1 /****************************************************************************** 2 * rtl8712_led.c 3 * 4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. 5 * Linux device driver for RTL8192SU 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of version 2 of the GNU General Public License as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program; if not, write to the Free Software Foundation, Inc., 18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 19 * 20 * Modifications for inclusion into the Linux staging tree are 21 * Copyright(c) 2010 Larry Finger. All rights reserved. 22 * 23 * Contact information: 24 * WLAN FAE <wlanfae@realtek.com> 25 * Larry Finger <Larry.Finger@lwfinger.net> 26 * 27 ******************************************************************************/ 28 29 #include "drv_types.h" 30 31 /*=========================================================================== 32 * Constant. 33 *=========================================================================== 34 35 * 36 * Default LED behavior. 37 */ 38 #define LED_BLINK_NORMAL_INTERVAL 100 39 #define LED_BLINK_SLOWLY_INTERVAL 200 40 #define LED_BLINK_LONG_INTERVAL 400 41 42 #define LED_BLINK_NO_LINK_INTERVAL_ALPHA 1000 43 #define LED_BLINK_LINK_INTERVAL_ALPHA 500 44 #define LED_BLINK_SCAN_INTERVAL_ALPHA 180 45 #define LED_BLINK_FASTER_INTERVAL_ALPHA 50 46 #define LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA 5000 47 48 /*=========================================================================== 49 * LED object. 50 *=========================================================================== 51 */ 52 enum _LED_STATE_871x { 53 LED_UNKNOWN = 0, 54 LED_ON = 1, 55 LED_OFF = 2, 56 LED_BLINK_NORMAL = 3, 57 LED_BLINK_SLOWLY = 4, 58 LED_POWER_ON_BLINK = 5, 59 LED_SCAN_BLINK = 6, /* LED is blinking during scanning period, 60 * the # of times to blink is depend on time 61 * for scanning. */ 62 LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */ 63 LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer 64 * Server case */ 65 LED_BLINK_WPS = 9, /* LED is blinkg during WPS communication */ 66 LED_TXRX_BLINK = 10, 67 LED_BLINK_WPS_STOP = 11, /*for ALPHA */ 68 LED_BLINK_WPS_STOP_OVERLAP = 12, /*for BELKIN */ 69 }; 70 71 /*=========================================================================== 72 * Prototype of protected function. 73 *=========================================================================== 74 */ 75 static void BlinkTimerCallback(unsigned long data); 76 77 static void BlinkWorkItemCallback(struct work_struct *work); 78 /*=========================================================================== 79 * LED_819xUsb routines. 80 *=========================================================================== 81 * 82 * 83 * 84 * Description: 85 * Initialize an LED_871x object. 86 */ 87 static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed, 88 enum LED_PIN_871x LedPin) 89 { 90 struct net_device *nic; 91 92 nic = padapter->pnetdev; 93 pLed->padapter = padapter; 94 pLed->LedPin = LedPin; 95 pLed->CurrLedState = LED_OFF; 96 pLed->bLedOn = false; 97 pLed->bLedBlinkInProgress = false; 98 pLed->BlinkTimes = 0; 99 pLed->BlinkingLedState = LED_UNKNOWN; 100 _init_timer(&(pLed->BlinkTimer), nic, BlinkTimerCallback, pLed); 101 INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback); 102 } 103 104 /* 105 * Description: 106 * DeInitialize an LED_871x object. 107 */ 108 static void DeInitLed871x(struct LED_871x *pLed) 109 { 110 _cancel_timer_ex(&(pLed->BlinkTimer)); 111 /* We should reset bLedBlinkInProgress if we cancel 112 * the LedControlTimer, */ 113 pLed->bLedBlinkInProgress = false; 114 } 115 116 /* 117 * Description: 118 * Turn on LED according to LedPin specified. 119 */ 120 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed) 121 { 122 u8 LedCfg; 123 124 if ((padapter->bSurpriseRemoved == true) || 125 (padapter->bDriverStopped == true)) 126 return; 127 LedCfg = r8712_read8(padapter, LEDCFG); 128 switch (pLed->LedPin) { 129 case LED_PIN_GPIO0: 130 break; 131 case LED_PIN_LED0: 132 /* SW control led0 on.*/ 133 r8712_write8(padapter, LEDCFG, LedCfg&0xf0); 134 break; 135 case LED_PIN_LED1: 136 /* SW control led1 on.*/ 137 r8712_write8(padapter, LEDCFG, LedCfg&0x0f); 138 break; 139 default: 140 break; 141 } 142 pLed->bLedOn = true; 143 } 144 145 /* 146 * Description: 147 * Turn off LED according to LedPin specified. 148 */ 149 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed) 150 { 151 u8 LedCfg; 152 153 if ((padapter->bSurpriseRemoved == true) || 154 (padapter->bDriverStopped == true)) 155 return; 156 LedCfg = r8712_read8(padapter, LEDCFG); 157 switch (pLed->LedPin) { 158 case LED_PIN_GPIO0: 159 break; 160 case LED_PIN_LED0: 161 LedCfg &= 0xf0; /* Set to software control.*/ 162 r8712_write8(padapter, LEDCFG, (LedCfg|BIT(3))); 163 break; 164 case LED_PIN_LED1: 165 LedCfg &= 0x0f; /* Set to software control.*/ 166 r8712_write8(padapter, LEDCFG, (LedCfg|BIT(7))); 167 break; 168 default: 169 break; 170 } 171 pLed->bLedOn = false; 172 } 173 174 /*=========================================================================== 175 * Interface to manipulate LED objects. 176 *=========================================================================== 177 * 178 * Description: 179 * Initialize all LED_871x objects. 180 */ 181 void r8712_InitSwLeds(struct _adapter *padapter) 182 { 183 struct led_priv *pledpriv = &(padapter->ledpriv); 184 185 pledpriv->LedControlHandler = LedControl871x; 186 InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0); 187 InitLed871x(padapter, &(pledpriv->SwLed1), LED_PIN_LED1); 188 } 189 190 /* Description: 191 * DeInitialize all LED_819xUsb objects. 192 */ 193 void r8712_DeInitSwLeds(struct _adapter *padapter) 194 { 195 struct led_priv *ledpriv = &(padapter->ledpriv); 196 197 DeInitLed871x(&(ledpriv->SwLed0)); 198 DeInitLed871x(&(ledpriv->SwLed1)); 199 } 200 201 /* Description: 202 * Implementation of LED blinking behavior. 203 * It toggle off LED and schedule corresponding timer if necessary. 204 */ 205 static void SwLedBlink(struct LED_871x *pLed) 206 { 207 struct _adapter *padapter = pLed->padapter; 208 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 209 u8 bStopBlinking = false; 210 211 /* Change LED according to BlinkingLedState specified. */ 212 if (pLed->BlinkingLedState == LED_ON) 213 SwLedOn(padapter, pLed); 214 else 215 SwLedOff(padapter, pLed); 216 /* Determine if we shall change LED state again. */ 217 pLed->BlinkTimes--; 218 switch (pLed->CurrLedState) { 219 case LED_BLINK_NORMAL: 220 if (pLed->BlinkTimes == 0) 221 bStopBlinking = true; 222 break; 223 case LED_BLINK_StartToBlink: 224 if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && 225 (pmlmepriv->fw_state & WIFI_STATION_STATE)) 226 bStopBlinking = true; 227 if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && 228 ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) || 229 (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE))) 230 bStopBlinking = true; 231 else if (pLed->BlinkTimes == 0) 232 bStopBlinking = true; 233 break; 234 case LED_BLINK_WPS: 235 if (pLed->BlinkTimes == 0) 236 bStopBlinking = true; 237 break; 238 default: 239 bStopBlinking = true; 240 break; 241 } 242 if (bStopBlinking) { 243 if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && 244 (pLed->bLedOn == false)) 245 SwLedOn(padapter, pLed); 246 else if ((check_fwstate(pmlmepriv, _FW_LINKED) == 247 true) && pLed->bLedOn == true) 248 SwLedOff(padapter, pLed); 249 pLed->BlinkTimes = 0; 250 pLed->bLedBlinkInProgress = false; 251 } else { 252 /* Assign LED state to toggle. */ 253 if (pLed->BlinkingLedState == LED_ON) 254 pLed->BlinkingLedState = LED_OFF; 255 else 256 pLed->BlinkingLedState = LED_ON; 257 258 /* Schedule a timer to toggle LED state. */ 259 switch (pLed->CurrLedState) { 260 case LED_BLINK_NORMAL: 261 _set_timer(&(pLed->BlinkTimer), 262 LED_BLINK_NORMAL_INTERVAL); 263 break; 264 case LED_BLINK_SLOWLY: 265 case LED_BLINK_StartToBlink: 266 _set_timer(&(pLed->BlinkTimer), 267 LED_BLINK_SLOWLY_INTERVAL); 268 break; 269 case LED_BLINK_WPS: 270 _set_timer(&(pLed->BlinkTimer), 271 LED_BLINK_LONG_INTERVAL); 272 break; 273 default: 274 _set_timer(&(pLed->BlinkTimer), 275 LED_BLINK_SLOWLY_INTERVAL); 276 break; 277 } 278 } 279 } 280 281 static void SwLedBlink1(struct LED_871x *pLed) 282 { 283 struct _adapter *padapter = pLed->padapter; 284 struct led_priv *ledpriv = &(padapter->ledpriv); 285 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 286 struct eeprom_priv *peeprompriv = &(padapter->eeprompriv); 287 struct LED_871x *pLed1 = &(ledpriv->SwLed1); 288 u8 bStopBlinking = false; 289 290 if (peeprompriv->CustomerID == RT_CID_819x_CAMEO) 291 pLed = &(ledpriv->SwLed1); 292 /* Change LED according to BlinkingLedState specified. */ 293 if (pLed->BlinkingLedState == LED_ON) 294 SwLedOn(padapter, pLed); 295 else 296 SwLedOff(padapter, pLed); 297 if (peeprompriv->CustomerID == RT_CID_DEFAULT) { 298 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 299 if (!pLed1->bSWLedCtrl) { 300 SwLedOn(padapter, pLed1); 301 pLed1->bSWLedCtrl = true; 302 } else if (!pLed1->bLedOn) 303 SwLedOn(padapter, pLed1); 304 } else { 305 if (!pLed1->bSWLedCtrl) { 306 SwLedOff(padapter, pLed1); 307 pLed1->bSWLedCtrl = true; 308 } else if (pLed1->bLedOn) 309 SwLedOff(padapter, pLed1); 310 } 311 } 312 switch (pLed->CurrLedState) { 313 case LED_BLINK_SLOWLY: 314 if (pLed->bLedOn) 315 pLed->BlinkingLedState = LED_OFF; 316 else 317 pLed->BlinkingLedState = LED_ON; 318 _set_timer(&(pLed->BlinkTimer), 319 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 320 break; 321 case LED_BLINK_NORMAL: 322 if (pLed->bLedOn) 323 pLed->BlinkingLedState = LED_OFF; 324 else 325 pLed->BlinkingLedState = LED_ON; 326 _set_timer(&(pLed->BlinkTimer), 327 LED_BLINK_LINK_INTERVAL_ALPHA); 328 break; 329 case LED_SCAN_BLINK: 330 pLed->BlinkTimes--; 331 if (pLed->BlinkTimes == 0) 332 bStopBlinking = true; 333 if (bStopBlinking) { 334 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 335 pLed->bLedLinkBlinkInProgress = true; 336 pLed->CurrLedState = LED_BLINK_NORMAL; 337 if (pLed->bLedOn) 338 pLed->BlinkingLedState = LED_OFF; 339 else 340 pLed->BlinkingLedState = LED_ON; 341 _set_timer(&(pLed->BlinkTimer), 342 LED_BLINK_LINK_INTERVAL_ALPHA); 343 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 344 pLed->bLedNoLinkBlinkInProgress = true; 345 pLed->CurrLedState = LED_BLINK_SLOWLY; 346 if (pLed->bLedOn) 347 pLed->BlinkingLedState = LED_OFF; 348 else 349 pLed->BlinkingLedState = LED_ON; 350 _set_timer(&(pLed->BlinkTimer), 351 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 352 } 353 pLed->bLedScanBlinkInProgress = false; 354 } else { 355 if (pLed->bLedOn) 356 pLed->BlinkingLedState = LED_OFF; 357 else 358 pLed->BlinkingLedState = LED_ON; 359 _set_timer(&(pLed->BlinkTimer), 360 LED_BLINK_SCAN_INTERVAL_ALPHA); 361 } 362 break; 363 case LED_TXRX_BLINK: 364 pLed->BlinkTimes--; 365 if (pLed->BlinkTimes == 0) 366 bStopBlinking = true; 367 if (bStopBlinking) { 368 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 369 pLed->bLedLinkBlinkInProgress = true; 370 pLed->CurrLedState = LED_BLINK_NORMAL; 371 if (pLed->bLedOn) 372 pLed->BlinkingLedState = LED_OFF; 373 else 374 pLed->BlinkingLedState = LED_ON; 375 _set_timer(&(pLed->BlinkTimer), 376 LED_BLINK_LINK_INTERVAL_ALPHA); 377 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 378 pLed->bLedNoLinkBlinkInProgress = true; 379 pLed->CurrLedState = LED_BLINK_SLOWLY; 380 if (pLed->bLedOn) 381 pLed->BlinkingLedState = LED_OFF; 382 else 383 pLed->BlinkingLedState = LED_ON; 384 _set_timer(&(pLed->BlinkTimer), 385 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 386 } 387 pLed->BlinkTimes = 0; 388 pLed->bLedBlinkInProgress = false; 389 } else { 390 if (pLed->bLedOn) 391 pLed->BlinkingLedState = LED_OFF; 392 else 393 pLed->BlinkingLedState = LED_ON; 394 _set_timer(&(pLed->BlinkTimer), 395 LED_BLINK_FASTER_INTERVAL_ALPHA); 396 } 397 break; 398 case LED_BLINK_WPS: 399 if (pLed->bLedOn) 400 pLed->BlinkingLedState = LED_OFF; 401 else 402 pLed->BlinkingLedState = LED_ON; 403 _set_timer(&(pLed->BlinkTimer), 404 LED_BLINK_SCAN_INTERVAL_ALPHA); 405 break; 406 case LED_BLINK_WPS_STOP: /* WPS success */ 407 if (pLed->BlinkingLedState == LED_ON) { 408 pLed->BlinkingLedState = LED_OFF; 409 _set_timer(&(pLed->BlinkTimer), 410 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA); 411 bStopBlinking = false; 412 } else 413 bStopBlinking = true; 414 if (bStopBlinking) { 415 pLed->bLedLinkBlinkInProgress = true; 416 pLed->CurrLedState = LED_BLINK_NORMAL; 417 if (pLed->bLedOn) 418 pLed->BlinkingLedState = LED_OFF; 419 else 420 pLed->BlinkingLedState = LED_ON; 421 _set_timer(&(pLed->BlinkTimer), 422 LED_BLINK_LINK_INTERVAL_ALPHA); 423 } 424 pLed->bLedWPSBlinkInProgress = false; 425 break; 426 default: 427 break; 428 } 429 } 430 431 static void SwLedBlink2(struct LED_871x *pLed) 432 { 433 struct _adapter *padapter = pLed->padapter; 434 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 435 u8 bStopBlinking = false; 436 437 /* Change LED according to BlinkingLedState specified. */ 438 if (pLed->BlinkingLedState == LED_ON) 439 SwLedOn(padapter, pLed); 440 else 441 SwLedOff(padapter, pLed); 442 switch (pLed->CurrLedState) { 443 case LED_SCAN_BLINK: 444 pLed->BlinkTimes--; 445 if (pLed->BlinkTimes == 0) 446 bStopBlinking = true; 447 if (bStopBlinking) { 448 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 449 pLed->CurrLedState = LED_ON; 450 pLed->BlinkingLedState = LED_ON; 451 SwLedOn(padapter, pLed); 452 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 453 pLed->CurrLedState = LED_OFF; 454 pLed->BlinkingLedState = LED_OFF; 455 SwLedOff(padapter, pLed); 456 } 457 pLed->bLedScanBlinkInProgress = false; 458 } else { 459 if (pLed->bLedOn) 460 pLed->BlinkingLedState = LED_OFF; 461 else 462 pLed->BlinkingLedState = LED_ON; 463 _set_timer(&(pLed->BlinkTimer), 464 LED_BLINK_SCAN_INTERVAL_ALPHA); 465 } 466 break; 467 case LED_TXRX_BLINK: 468 pLed->BlinkTimes--; 469 if (pLed->BlinkTimes == 0) 470 bStopBlinking = true; 471 if (bStopBlinking) { 472 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 473 pLed->CurrLedState = LED_ON; 474 pLed->BlinkingLedState = LED_ON; 475 SwLedOn(padapter, pLed); 476 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 477 pLed->CurrLedState = LED_OFF; 478 pLed->BlinkingLedState = LED_OFF; 479 SwLedOff(padapter, pLed); 480 } 481 pLed->bLedBlinkInProgress = false; 482 } else { 483 if (pLed->bLedOn) 484 pLed->BlinkingLedState = LED_OFF; 485 else 486 pLed->BlinkingLedState = LED_ON; 487 _set_timer(&(pLed->BlinkTimer), 488 LED_BLINK_FASTER_INTERVAL_ALPHA); 489 } 490 break; 491 default: 492 break; 493 } 494 } 495 496 static void SwLedBlink3(struct LED_871x *pLed) 497 { 498 struct _adapter *padapter = pLed->padapter; 499 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 500 u8 bStopBlinking = false; 501 502 /* Change LED according to BlinkingLedState specified. */ 503 if (pLed->BlinkingLedState == LED_ON) 504 SwLedOn(padapter, pLed); 505 else 506 if (pLed->CurrLedState != LED_BLINK_WPS_STOP) 507 SwLedOff(padapter, pLed); 508 switch (pLed->CurrLedState) { 509 case LED_SCAN_BLINK: 510 pLed->BlinkTimes--; 511 if (pLed->BlinkTimes == 0) 512 bStopBlinking = true; 513 if (bStopBlinking) { 514 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 515 pLed->CurrLedState = LED_ON; 516 pLed->BlinkingLedState = LED_ON; 517 if (!pLed->bLedOn) 518 SwLedOn(padapter, pLed); 519 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 520 pLed->CurrLedState = LED_OFF; 521 pLed->BlinkingLedState = LED_OFF; 522 if (pLed->bLedOn) 523 SwLedOff(padapter, pLed); 524 } 525 pLed->bLedScanBlinkInProgress = false; 526 } else { 527 if (pLed->bLedOn) 528 pLed->BlinkingLedState = LED_OFF; 529 else 530 pLed->BlinkingLedState = LED_ON; 531 _set_timer(&(pLed->BlinkTimer), 532 LED_BLINK_SCAN_INTERVAL_ALPHA); 533 } 534 break; 535 case LED_TXRX_BLINK: 536 pLed->BlinkTimes--; 537 if (pLed->BlinkTimes == 0) 538 bStopBlinking = true; 539 if (bStopBlinking) { 540 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 541 pLed->CurrLedState = LED_ON; 542 pLed->BlinkingLedState = LED_ON; 543 if (!pLed->bLedOn) 544 SwLedOn(padapter, pLed); 545 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 546 pLed->CurrLedState = LED_OFF; 547 pLed->BlinkingLedState = LED_OFF; 548 if (pLed->bLedOn) 549 SwLedOff(padapter, pLed); 550 } 551 pLed->bLedBlinkInProgress = false; 552 } else { 553 if (pLed->bLedOn) 554 pLed->BlinkingLedState = LED_OFF; 555 else 556 pLed->BlinkingLedState = LED_ON; 557 _set_timer(&(pLed->BlinkTimer), 558 LED_BLINK_FASTER_INTERVAL_ALPHA); 559 } 560 break; 561 case LED_BLINK_WPS: 562 if (pLed->bLedOn) 563 pLed->BlinkingLedState = LED_OFF; 564 else 565 pLed->BlinkingLedState = LED_ON; 566 _set_timer(&(pLed->BlinkTimer), 567 LED_BLINK_SCAN_INTERVAL_ALPHA); 568 break; 569 case LED_BLINK_WPS_STOP: /*WPS success*/ 570 if (pLed->BlinkingLedState == LED_ON) { 571 pLed->BlinkingLedState = LED_OFF; 572 _set_timer(&(pLed->BlinkTimer), 573 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA); 574 bStopBlinking = false; 575 } else 576 bStopBlinking = true; 577 if (bStopBlinking) { 578 pLed->CurrLedState = LED_ON; 579 pLed->BlinkingLedState = LED_ON; 580 SwLedOn(padapter, pLed); 581 pLed->bLedWPSBlinkInProgress = false; 582 } 583 break; 584 default: 585 break; 586 } 587 } 588 589 static void SwLedBlink4(struct LED_871x *pLed) 590 { 591 struct _adapter *padapter = pLed->padapter; 592 struct led_priv *ledpriv = &(padapter->ledpriv); 593 struct LED_871x *pLed1 = &(ledpriv->SwLed1); 594 u8 bStopBlinking = false; 595 596 /* Change LED according to BlinkingLedState specified. */ 597 if (pLed->BlinkingLedState == LED_ON) 598 SwLedOn(padapter, pLed); 599 else 600 SwLedOff(padapter, pLed); 601 if (!pLed1->bLedWPSBlinkInProgress && 602 pLed1->BlinkingLedState == LED_UNKNOWN) { 603 pLed1->BlinkingLedState = LED_OFF; 604 pLed1->CurrLedState = LED_OFF; 605 SwLedOff(padapter, pLed1); 606 } 607 switch (pLed->CurrLedState) { 608 case LED_BLINK_SLOWLY: 609 if (pLed->bLedOn) 610 pLed->BlinkingLedState = LED_OFF; 611 else 612 pLed->BlinkingLedState = LED_ON; 613 _set_timer(&(pLed->BlinkTimer), 614 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 615 break; 616 case LED_BLINK_StartToBlink: 617 if (pLed->bLedOn) { 618 pLed->BlinkingLedState = LED_OFF; 619 _set_timer(&(pLed->BlinkTimer), 620 LED_BLINK_SLOWLY_INTERVAL); 621 } else { 622 pLed->BlinkingLedState = LED_ON; 623 _set_timer(&(pLed->BlinkTimer), 624 LED_BLINK_NORMAL_INTERVAL); 625 } 626 break; 627 case LED_SCAN_BLINK: 628 pLed->BlinkTimes--; 629 if (pLed->BlinkTimes == 0) 630 bStopBlinking = true; 631 if (bStopBlinking) { 632 pLed->bLedNoLinkBlinkInProgress = true; 633 pLed->CurrLedState = LED_BLINK_SLOWLY; 634 if (pLed->bLedOn) 635 pLed->BlinkingLedState = LED_OFF; 636 else 637 pLed->BlinkingLedState = LED_ON; 638 _set_timer(&(pLed->BlinkTimer), 639 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 640 pLed->bLedScanBlinkInProgress = false; 641 } else { 642 if (pLed->bLedOn) 643 pLed->BlinkingLedState = LED_OFF; 644 else 645 pLed->BlinkingLedState = LED_ON; 646 _set_timer(&(pLed->BlinkTimer), 647 LED_BLINK_SCAN_INTERVAL_ALPHA); 648 } 649 break; 650 case LED_TXRX_BLINK: 651 pLed->BlinkTimes--; 652 if (pLed->BlinkTimes == 0) 653 bStopBlinking = true; 654 if (bStopBlinking) { 655 pLed->bLedNoLinkBlinkInProgress = true; 656 pLed->CurrLedState = LED_BLINK_SLOWLY; 657 if (pLed->bLedOn) 658 pLed->BlinkingLedState = LED_OFF; 659 else 660 pLed->BlinkingLedState = LED_ON; 661 _set_timer(&(pLed->BlinkTimer), 662 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 663 pLed->bLedBlinkInProgress = false; 664 } else { 665 if (pLed->bLedOn) 666 pLed->BlinkingLedState = LED_OFF; 667 else 668 pLed->BlinkingLedState = LED_ON; 669 _set_timer(&(pLed->BlinkTimer), 670 LED_BLINK_FASTER_INTERVAL_ALPHA); 671 } 672 break; 673 case LED_BLINK_WPS: 674 if (pLed->bLedOn) { 675 pLed->BlinkingLedState = LED_OFF; 676 _set_timer(&(pLed->BlinkTimer), 677 LED_BLINK_SLOWLY_INTERVAL); 678 } else { 679 pLed->BlinkingLedState = LED_ON; 680 _set_timer(&(pLed->BlinkTimer), 681 LED_BLINK_NORMAL_INTERVAL); 682 } 683 break; 684 case LED_BLINK_WPS_STOP: /*WPS authentication fail*/ 685 if (pLed->bLedOn) 686 pLed->BlinkingLedState = LED_OFF; 687 else 688 pLed->BlinkingLedState = LED_ON; 689 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL); 690 break; 691 case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */ 692 pLed->BlinkTimes--; 693 if (pLed->BlinkTimes == 0) { 694 if (pLed->bLedOn) 695 pLed->BlinkTimes = 1; 696 else 697 bStopBlinking = true; 698 } 699 if (bStopBlinking) { 700 pLed->BlinkTimes = 10; 701 pLed->BlinkingLedState = LED_ON; 702 _set_timer(&(pLed->BlinkTimer), 703 LED_BLINK_LINK_INTERVAL_ALPHA); 704 } else { 705 if (pLed->bLedOn) 706 pLed->BlinkingLedState = LED_OFF; 707 else 708 pLed->BlinkingLedState = LED_ON; 709 _set_timer(&(pLed->BlinkTimer), 710 LED_BLINK_NORMAL_INTERVAL); 711 } 712 break; 713 default: 714 break; 715 } 716 } 717 718 static void SwLedBlink5(struct LED_871x *pLed) 719 { 720 struct _adapter *padapter = pLed->padapter; 721 u8 bStopBlinking = false; 722 723 /* Change LED according to BlinkingLedState specified. */ 724 if (pLed->BlinkingLedState == LED_ON) 725 SwLedOn(padapter, pLed); 726 else 727 SwLedOff(padapter, pLed); 728 switch (pLed->CurrLedState) { 729 case LED_SCAN_BLINK: 730 pLed->BlinkTimes--; 731 if (pLed->BlinkTimes == 0) 732 bStopBlinking = true; 733 if (bStopBlinking) { 734 pLed->CurrLedState = LED_ON; 735 pLed->BlinkingLedState = LED_ON; 736 if (!pLed->bLedOn) 737 _set_timer(&(pLed->BlinkTimer), 738 LED_BLINK_FASTER_INTERVAL_ALPHA); 739 pLed->bLedScanBlinkInProgress = false; 740 } else { 741 if (pLed->bLedOn) 742 pLed->BlinkingLedState = LED_OFF; 743 else 744 pLed->BlinkingLedState = LED_ON; 745 _set_timer(&(pLed->BlinkTimer), 746 LED_BLINK_SCAN_INTERVAL_ALPHA); 747 } 748 break; 749 case LED_TXRX_BLINK: 750 pLed->BlinkTimes--; 751 if (pLed->BlinkTimes == 0) 752 bStopBlinking = true; 753 if (bStopBlinking) { 754 pLed->CurrLedState = LED_ON; 755 pLed->BlinkingLedState = LED_ON; 756 if (!pLed->bLedOn) 757 _set_timer(&(pLed->BlinkTimer), 758 LED_BLINK_FASTER_INTERVAL_ALPHA); 759 pLed->bLedBlinkInProgress = false; 760 } else { 761 if (pLed->bLedOn) 762 pLed->BlinkingLedState = LED_OFF; 763 else 764 pLed->BlinkingLedState = LED_ON; 765 _set_timer(&(pLed->BlinkTimer), 766 LED_BLINK_FASTER_INTERVAL_ALPHA); 767 } 768 break; 769 default: 770 break; 771 } 772 } 773 774 static void SwLedBlink6(struct LED_871x *pLed) 775 { 776 struct _adapter *padapter = pLed->padapter; 777 u8 bStopBlinking = false; 778 779 /* Change LED according to BlinkingLedState specified. */ 780 if (pLed->BlinkingLedState == LED_ON) 781 SwLedOn(padapter, pLed); 782 else 783 SwLedOff(padapter, pLed); 784 switch (pLed->CurrLedState) { 785 case LED_TXRX_BLINK: 786 pLed->BlinkTimes--; 787 if (pLed->BlinkTimes == 0) 788 bStopBlinking = true; 789 if (bStopBlinking) { 790 pLed->CurrLedState = LED_ON; 791 pLed->BlinkingLedState = LED_ON; 792 if (!pLed->bLedOn) 793 SwLedOn(padapter, pLed); 794 pLed->bLedBlinkInProgress = false; 795 } else { 796 if (pLed->bLedOn) 797 pLed->BlinkingLedState = LED_OFF; 798 else 799 pLed->BlinkingLedState = LED_ON; 800 _set_timer(&(pLed->BlinkTimer), 801 LED_BLINK_FASTER_INTERVAL_ALPHA); 802 } 803 break; 804 case LED_BLINK_WPS: 805 if (pLed->bLedOn) 806 pLed->BlinkingLedState = LED_OFF; 807 else 808 pLed->BlinkingLedState = LED_ON; 809 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA); 810 break; 811 812 default: 813 break; 814 } 815 } 816 817 /* Description: 818 * Callback function of LED BlinkTimer, 819 * it just schedules to corresponding BlinkWorkItem. 820 */ 821 static void BlinkTimerCallback(unsigned long data) 822 { 823 struct LED_871x *pLed = (struct LED_871x *)data; 824 825 /* This fixed the crash problem on Fedora 12 when trying to do the 826 * insmod;ifconfig up;rmmod commands. */ 827 if ((pLed->padapter->bSurpriseRemoved == true) || 828 (pLed->padapter->bDriverStopped == true)) 829 return; 830 schedule_work(&pLed->BlinkWorkItem); 831 } 832 833 /* Description: 834 * Callback function of LED BlinkWorkItem. 835 * We dispatch actual LED blink action according to LedStrategy. 836 */ 837 static void BlinkWorkItemCallback(struct work_struct *work) 838 { 839 struct LED_871x *pLed = container_of(work, struct LED_871x, 840 BlinkWorkItem); 841 struct led_priv *ledpriv = &(pLed->padapter->ledpriv); 842 843 switch (ledpriv->LedStrategy) { 844 case SW_LED_MODE0: 845 SwLedBlink(pLed); 846 break; 847 case SW_LED_MODE1: 848 SwLedBlink1(pLed); 849 break; 850 case SW_LED_MODE2: 851 SwLedBlink2(pLed); 852 break; 853 case SW_LED_MODE3: 854 SwLedBlink3(pLed); 855 break; 856 case SW_LED_MODE4: 857 SwLedBlink4(pLed); 858 break; 859 case SW_LED_MODE5: 860 SwLedBlink5(pLed); 861 break; 862 case SW_LED_MODE6: 863 SwLedBlink6(pLed); 864 break; 865 default: 866 SwLedBlink(pLed); 867 break; 868 } 869 } 870 871 /*============================================================================ 872 * Default LED behavior. 873 *============================================================================ 874 * 875 * Description: 876 * Implement each led action for SW_LED_MODE0. 877 * This is default strategy. 878 */ 879 880 static void SwLedControlMode1(struct _adapter *padapter, 881 enum LED_CTL_MODE LedAction) 882 { 883 struct led_priv *ledpriv = &(padapter->ledpriv); 884 struct LED_871x *pLed = &(ledpriv->SwLed0); 885 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 886 struct sitesurvey_ctrl *psitesurveyctrl = &(pmlmepriv->sitesurveyctrl); 887 888 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO) 889 pLed = &(ledpriv->SwLed1); 890 switch (LedAction) { 891 case LED_CTL_START_TO_LINK: 892 case LED_CTL_NO_LINK: 893 if (pLed->bLedNoLinkBlinkInProgress == false) { 894 if (pLed->CurrLedState == LED_SCAN_BLINK || 895 IS_LED_WPS_BLINKING(pLed)) 896 return; 897 if (pLed->bLedLinkBlinkInProgress == true) { 898 _cancel_timer_ex(&(pLed->BlinkTimer)); 899 pLed->bLedLinkBlinkInProgress = false; 900 } 901 if (pLed->bLedBlinkInProgress == true) { 902 _cancel_timer_ex(&(pLed->BlinkTimer)); 903 pLed->bLedBlinkInProgress = false; 904 } 905 pLed->bLedNoLinkBlinkInProgress = true; 906 pLed->CurrLedState = LED_BLINK_SLOWLY; 907 if (pLed->bLedOn) 908 pLed->BlinkingLedState = LED_OFF; 909 else 910 pLed->BlinkingLedState = LED_ON; 911 _set_timer(&(pLed->BlinkTimer), 912 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 913 } 914 break; 915 case LED_CTL_LINK: 916 if (pLed->bLedLinkBlinkInProgress == false) { 917 if (pLed->CurrLedState == LED_SCAN_BLINK || 918 IS_LED_WPS_BLINKING(pLed)) 919 return; 920 if (pLed->bLedNoLinkBlinkInProgress == true) { 921 _cancel_timer_ex(&(pLed->BlinkTimer)); 922 pLed->bLedNoLinkBlinkInProgress = false; 923 } 924 if (pLed->bLedBlinkInProgress == true) { 925 _cancel_timer_ex(&(pLed->BlinkTimer)); 926 pLed->bLedBlinkInProgress = false; 927 } 928 pLed->bLedLinkBlinkInProgress = true; 929 pLed->CurrLedState = LED_BLINK_NORMAL; 930 if (pLed->bLedOn) 931 pLed->BlinkingLedState = LED_OFF; 932 else 933 pLed->BlinkingLedState = LED_ON; 934 _set_timer(&(pLed->BlinkTimer), 935 LED_BLINK_LINK_INTERVAL_ALPHA); 936 } 937 break; 938 case LED_CTL_SITE_SURVEY: 939 if ((psitesurveyctrl->traffic_busy) && 940 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) 941 ; /* dummy branch */ 942 else if (pLed->bLedScanBlinkInProgress == false) { 943 if (IS_LED_WPS_BLINKING(pLed)) 944 return; 945 if (pLed->bLedNoLinkBlinkInProgress == true) { 946 _cancel_timer_ex(&(pLed->BlinkTimer)); 947 pLed->bLedNoLinkBlinkInProgress = false; 948 } 949 if (pLed->bLedLinkBlinkInProgress == true) { 950 _cancel_timer_ex(&(pLed->BlinkTimer)); 951 pLed->bLedLinkBlinkInProgress = false; 952 } 953 if (pLed->bLedBlinkInProgress == true) { 954 _cancel_timer_ex(&(pLed->BlinkTimer)); 955 pLed->bLedBlinkInProgress = false; 956 } 957 pLed->bLedScanBlinkInProgress = true; 958 pLed->CurrLedState = LED_SCAN_BLINK; 959 pLed->BlinkTimes = 24; 960 if (pLed->bLedOn) 961 pLed->BlinkingLedState = LED_OFF; 962 else 963 pLed->BlinkingLedState = LED_ON; 964 _set_timer(&(pLed->BlinkTimer), 965 LED_BLINK_SCAN_INTERVAL_ALPHA); 966 } 967 break; 968 case LED_CTL_TX: 969 case LED_CTL_RX: 970 if (pLed->bLedBlinkInProgress == false) { 971 if (pLed->CurrLedState == LED_SCAN_BLINK || 972 IS_LED_WPS_BLINKING(pLed)) 973 return; 974 if (pLed->bLedNoLinkBlinkInProgress == true) { 975 _cancel_timer_ex(&(pLed->BlinkTimer)); 976 pLed->bLedNoLinkBlinkInProgress = false; 977 } 978 if (pLed->bLedLinkBlinkInProgress == true) { 979 _cancel_timer_ex(&(pLed->BlinkTimer)); 980 pLed->bLedLinkBlinkInProgress = false; 981 } 982 pLed->bLedBlinkInProgress = true; 983 pLed->CurrLedState = LED_TXRX_BLINK; 984 pLed->BlinkTimes = 2; 985 if (pLed->bLedOn) 986 pLed->BlinkingLedState = LED_OFF; 987 else 988 pLed->BlinkingLedState = LED_ON; 989 _set_timer(&(pLed->BlinkTimer), 990 LED_BLINK_FASTER_INTERVAL_ALPHA); 991 } 992 break; 993 994 case LED_CTL_START_WPS: /*wait until xinpin finish */ 995 case LED_CTL_START_WPS_BOTTON: 996 if (pLed->bLedWPSBlinkInProgress == false) { 997 if (pLed->bLedNoLinkBlinkInProgress == true) { 998 _cancel_timer_ex(&(pLed->BlinkTimer)); 999 pLed->bLedNoLinkBlinkInProgress = false; 1000 } 1001 if (pLed->bLedLinkBlinkInProgress == true) { 1002 _cancel_timer_ex(&(pLed->BlinkTimer)); 1003 pLed->bLedLinkBlinkInProgress = false; 1004 } 1005 if (pLed->bLedBlinkInProgress == true) { 1006 _cancel_timer_ex(&(pLed->BlinkTimer)); 1007 pLed->bLedBlinkInProgress = false; 1008 } 1009 if (pLed->bLedScanBlinkInProgress == true) { 1010 _cancel_timer_ex(&(pLed->BlinkTimer)); 1011 pLed->bLedScanBlinkInProgress = false; 1012 } 1013 pLed->bLedWPSBlinkInProgress = true; 1014 pLed->CurrLedState = LED_BLINK_WPS; 1015 if (pLed->bLedOn) 1016 pLed->BlinkingLedState = LED_OFF; 1017 else 1018 pLed->BlinkingLedState = LED_ON; 1019 _set_timer(&(pLed->BlinkTimer), 1020 LED_BLINK_SCAN_INTERVAL_ALPHA); 1021 } 1022 break; 1023 case LED_CTL_STOP_WPS: 1024 if (pLed->bLedNoLinkBlinkInProgress == true) { 1025 _cancel_timer_ex(&(pLed->BlinkTimer)); 1026 pLed->bLedNoLinkBlinkInProgress = false; 1027 } 1028 if (pLed->bLedLinkBlinkInProgress == true) { 1029 _cancel_timer_ex(&(pLed->BlinkTimer)); 1030 pLed->bLedLinkBlinkInProgress = false; 1031 } 1032 if (pLed->bLedBlinkInProgress == true) { 1033 _cancel_timer_ex(&(pLed->BlinkTimer)); 1034 pLed->bLedBlinkInProgress = false; 1035 } 1036 if (pLed->bLedScanBlinkInProgress == true) { 1037 _cancel_timer_ex(&(pLed->BlinkTimer)); 1038 pLed->bLedScanBlinkInProgress = false; 1039 } 1040 if (pLed->bLedWPSBlinkInProgress) 1041 _cancel_timer_ex(&(pLed->BlinkTimer)); 1042 else 1043 pLed->bLedWPSBlinkInProgress = true; 1044 pLed->CurrLedState = LED_BLINK_WPS_STOP; 1045 if (pLed->bLedOn) { 1046 pLed->BlinkingLedState = LED_OFF; 1047 _set_timer(&(pLed->BlinkTimer), 1048 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA); 1049 } else { 1050 pLed->BlinkingLedState = LED_ON; 1051 _set_timer(&(pLed->BlinkTimer), 0); 1052 } 1053 break; 1054 case LED_CTL_STOP_WPS_FAIL: 1055 if (pLed->bLedWPSBlinkInProgress) { 1056 _cancel_timer_ex(&(pLed->BlinkTimer)); 1057 pLed->bLedWPSBlinkInProgress = false; 1058 } 1059 pLed->bLedNoLinkBlinkInProgress = true; 1060 pLed->CurrLedState = LED_BLINK_SLOWLY; 1061 if (pLed->bLedOn) 1062 pLed->BlinkingLedState = LED_OFF; 1063 else 1064 pLed->BlinkingLedState = LED_ON; 1065 _set_timer(&(pLed->BlinkTimer), 1066 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 1067 break; 1068 case LED_CTL_POWER_OFF: 1069 pLed->CurrLedState = LED_OFF; 1070 pLed->BlinkingLedState = LED_OFF; 1071 if (pLed->bLedNoLinkBlinkInProgress) { 1072 _cancel_timer_ex(&(pLed->BlinkTimer)); 1073 pLed->bLedNoLinkBlinkInProgress = false; 1074 } 1075 if (pLed->bLedLinkBlinkInProgress) { 1076 _cancel_timer_ex(&(pLed->BlinkTimer)); 1077 pLed->bLedLinkBlinkInProgress = false; 1078 } 1079 if (pLed->bLedBlinkInProgress) { 1080 _cancel_timer_ex(&(pLed->BlinkTimer)); 1081 pLed->bLedBlinkInProgress = false; 1082 } 1083 if (pLed->bLedWPSBlinkInProgress) { 1084 _cancel_timer_ex(&(pLed->BlinkTimer)); 1085 pLed->bLedWPSBlinkInProgress = false; 1086 } 1087 if (pLed->bLedScanBlinkInProgress) { 1088 _cancel_timer_ex(&(pLed->BlinkTimer)); 1089 pLed->bLedScanBlinkInProgress = false; 1090 } 1091 _set_timer(&(pLed->BlinkTimer), 0); 1092 break; 1093 default: 1094 break; 1095 } 1096 } 1097 1098 static void SwLedControlMode2(struct _adapter *padapter, 1099 enum LED_CTL_MODE LedAction) 1100 { 1101 struct led_priv *ledpriv = &(padapter->ledpriv); 1102 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1103 struct LED_871x *pLed = &(ledpriv->SwLed0); 1104 1105 switch (LedAction) { 1106 case LED_CTL_SITE_SURVEY: 1107 if (pmlmepriv->sitesurveyctrl.traffic_busy) 1108 ; /* dummy branch */ 1109 else if (pLed->bLedScanBlinkInProgress == false) { 1110 if (IS_LED_WPS_BLINKING(pLed)) 1111 return; 1112 1113 if (pLed->bLedBlinkInProgress == true) { 1114 _cancel_timer_ex(&(pLed->BlinkTimer)); 1115 pLed->bLedBlinkInProgress = false; 1116 } 1117 pLed->bLedScanBlinkInProgress = true; 1118 pLed->CurrLedState = LED_SCAN_BLINK; 1119 pLed->BlinkTimes = 24; 1120 if (pLed->bLedOn) 1121 pLed->BlinkingLedState = LED_OFF; 1122 else 1123 pLed->BlinkingLedState = LED_ON; 1124 _set_timer(&(pLed->BlinkTimer), 1125 LED_BLINK_SCAN_INTERVAL_ALPHA); 1126 } 1127 break; 1128 1129 case LED_CTL_TX: 1130 case LED_CTL_RX: 1131 if ((pLed->bLedBlinkInProgress == false) && 1132 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) { 1133 if (pLed->CurrLedState == LED_SCAN_BLINK || 1134 IS_LED_WPS_BLINKING(pLed)) 1135 return; 1136 pLed->bLedBlinkInProgress = true; 1137 pLed->CurrLedState = LED_TXRX_BLINK; 1138 pLed->BlinkTimes = 2; 1139 if (pLed->bLedOn) 1140 pLed->BlinkingLedState = LED_OFF; 1141 else 1142 pLed->BlinkingLedState = LED_ON; 1143 _set_timer(&(pLed->BlinkTimer), 1144 LED_BLINK_FASTER_INTERVAL_ALPHA); 1145 } 1146 break; 1147 1148 case LED_CTL_LINK: 1149 pLed->CurrLedState = LED_ON; 1150 pLed->BlinkingLedState = LED_ON; 1151 if (pLed->bLedBlinkInProgress) { 1152 _cancel_timer_ex(&(pLed->BlinkTimer)); 1153 pLed->bLedBlinkInProgress = false; 1154 } 1155 if (pLed->bLedScanBlinkInProgress) { 1156 _cancel_timer_ex(&(pLed->BlinkTimer)); 1157 pLed->bLedScanBlinkInProgress = false; 1158 } 1159 1160 _set_timer(&(pLed->BlinkTimer), 0); 1161 break; 1162 1163 case LED_CTL_START_WPS: /*wait until xinpin finish*/ 1164 case LED_CTL_START_WPS_BOTTON: 1165 if (pLed->bLedWPSBlinkInProgress == false) { 1166 if (pLed->bLedBlinkInProgress == true) { 1167 _cancel_timer_ex(&(pLed->BlinkTimer)); 1168 pLed->bLedBlinkInProgress = false; 1169 } 1170 if (pLed->bLedScanBlinkInProgress == true) { 1171 _cancel_timer_ex(&(pLed->BlinkTimer)); 1172 pLed->bLedScanBlinkInProgress = false; 1173 } 1174 pLed->bLedWPSBlinkInProgress = true; 1175 pLed->CurrLedState = LED_ON; 1176 pLed->BlinkingLedState = LED_ON; 1177 _set_timer(&(pLed->BlinkTimer), 0); 1178 } 1179 break; 1180 1181 case LED_CTL_STOP_WPS: 1182 pLed->bLedWPSBlinkInProgress = false; 1183 pLed->CurrLedState = LED_ON; 1184 pLed->BlinkingLedState = LED_ON; 1185 _set_timer(&(pLed->BlinkTimer), 0); 1186 break; 1187 1188 case LED_CTL_STOP_WPS_FAIL: 1189 pLed->bLedWPSBlinkInProgress = false; 1190 pLed->CurrLedState = LED_OFF; 1191 pLed->BlinkingLedState = LED_OFF; 1192 _set_timer(&(pLed->BlinkTimer), 0); 1193 break; 1194 1195 case LED_CTL_START_TO_LINK: 1196 case LED_CTL_NO_LINK: 1197 if (!IS_LED_BLINKING(pLed)) { 1198 pLed->CurrLedState = LED_OFF; 1199 pLed->BlinkingLedState = LED_OFF; 1200 _set_timer(&(pLed->BlinkTimer), 0); 1201 } 1202 break; 1203 case LED_CTL_POWER_OFF: 1204 pLed->CurrLedState = LED_OFF; 1205 pLed->BlinkingLedState = LED_OFF; 1206 if (pLed->bLedBlinkInProgress) { 1207 _cancel_timer_ex(&(pLed->BlinkTimer)); 1208 pLed->bLedBlinkInProgress = false; 1209 } 1210 if (pLed->bLedScanBlinkInProgress) { 1211 _cancel_timer_ex(&(pLed->BlinkTimer)); 1212 pLed->bLedScanBlinkInProgress = false; 1213 } 1214 if (pLed->bLedWPSBlinkInProgress) { 1215 _cancel_timer_ex(&(pLed->BlinkTimer)); 1216 pLed->bLedWPSBlinkInProgress = false; 1217 } 1218 _set_timer(&(pLed->BlinkTimer), 0); 1219 break; 1220 default: 1221 break; 1222 } 1223 } 1224 1225 static void SwLedControlMode3(struct _adapter *padapter, 1226 enum LED_CTL_MODE LedAction) 1227 { 1228 struct led_priv *ledpriv = &(padapter->ledpriv); 1229 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1230 struct LED_871x *pLed = &(ledpriv->SwLed0); 1231 1232 switch (LedAction) { 1233 case LED_CTL_SITE_SURVEY: 1234 if (pmlmepriv->sitesurveyctrl.traffic_busy) 1235 ; /* dummy branch */ 1236 else if (pLed->bLedScanBlinkInProgress == false) { 1237 if (IS_LED_WPS_BLINKING(pLed)) 1238 return; 1239 if (pLed->bLedBlinkInProgress == true) { 1240 _cancel_timer_ex(&(pLed->BlinkTimer)); 1241 pLed->bLedBlinkInProgress = false; 1242 } 1243 pLed->bLedScanBlinkInProgress = true; 1244 pLed->CurrLedState = LED_SCAN_BLINK; 1245 pLed->BlinkTimes = 24; 1246 if (pLed->bLedOn) 1247 pLed->BlinkingLedState = LED_OFF; 1248 else 1249 pLed->BlinkingLedState = LED_ON; 1250 _set_timer(&(pLed->BlinkTimer), 1251 LED_BLINK_SCAN_INTERVAL_ALPHA); 1252 } 1253 break; 1254 case LED_CTL_TX: 1255 case LED_CTL_RX: 1256 if ((pLed->bLedBlinkInProgress == false) && 1257 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) { 1258 if (pLed->CurrLedState == LED_SCAN_BLINK || 1259 IS_LED_WPS_BLINKING(pLed)) 1260 return; 1261 pLed->bLedBlinkInProgress = true; 1262 pLed->CurrLedState = LED_TXRX_BLINK; 1263 pLed->BlinkTimes = 2; 1264 if (pLed->bLedOn) 1265 pLed->BlinkingLedState = LED_OFF; 1266 else 1267 pLed->BlinkingLedState = LED_ON; 1268 _set_timer(&(pLed->BlinkTimer), 1269 LED_BLINK_FASTER_INTERVAL_ALPHA); 1270 } 1271 break; 1272 case LED_CTL_LINK: 1273 if (IS_LED_WPS_BLINKING(pLed)) 1274 return; 1275 pLed->CurrLedState = LED_ON; 1276 pLed->BlinkingLedState = LED_ON; 1277 if (pLed->bLedBlinkInProgress) { 1278 _cancel_timer_ex(&(pLed->BlinkTimer)); 1279 pLed->bLedBlinkInProgress = false; 1280 } 1281 if (pLed->bLedScanBlinkInProgress) { 1282 _cancel_timer_ex(&(pLed->BlinkTimer)); 1283 pLed->bLedScanBlinkInProgress = false; 1284 } 1285 _set_timer(&(pLed->BlinkTimer), 0); 1286 break; 1287 case LED_CTL_START_WPS: /* wait until xinpin finish */ 1288 case LED_CTL_START_WPS_BOTTON: 1289 if (pLed->bLedWPSBlinkInProgress == false) { 1290 if (pLed->bLedBlinkInProgress == true) { 1291 _cancel_timer_ex(&(pLed->BlinkTimer)); 1292 pLed->bLedBlinkInProgress = false; 1293 } 1294 if (pLed->bLedScanBlinkInProgress == true) { 1295 _cancel_timer_ex(&(pLed->BlinkTimer)); 1296 pLed->bLedScanBlinkInProgress = false; 1297 } 1298 pLed->bLedWPSBlinkInProgress = true; 1299 pLed->CurrLedState = LED_BLINK_WPS; 1300 if (pLed->bLedOn) 1301 pLed->BlinkingLedState = LED_OFF; 1302 else 1303 pLed->BlinkingLedState = LED_ON; 1304 _set_timer(&(pLed->BlinkTimer), 1305 LED_BLINK_SCAN_INTERVAL_ALPHA); 1306 } 1307 break; 1308 case LED_CTL_STOP_WPS: 1309 if (pLed->bLedWPSBlinkInProgress) { 1310 _cancel_timer_ex(&(pLed->BlinkTimer)); 1311 pLed->bLedWPSBlinkInProgress = false; 1312 } else 1313 pLed->bLedWPSBlinkInProgress = true; 1314 pLed->CurrLedState = LED_BLINK_WPS_STOP; 1315 if (pLed->bLedOn) { 1316 pLed->BlinkingLedState = LED_OFF; 1317 _set_timer(&(pLed->BlinkTimer), 1318 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA); 1319 } else { 1320 pLed->BlinkingLedState = LED_ON; 1321 _set_timer(&(pLed->BlinkTimer), 0); 1322 } 1323 break; 1324 case LED_CTL_STOP_WPS_FAIL: 1325 if (pLed->bLedWPSBlinkInProgress) { 1326 _cancel_timer_ex(&(pLed->BlinkTimer)); 1327 pLed->bLedWPSBlinkInProgress = false; 1328 } 1329 pLed->CurrLedState = LED_OFF; 1330 pLed->BlinkingLedState = LED_OFF; 1331 _set_timer(&(pLed->BlinkTimer), 0); 1332 break; 1333 case LED_CTL_START_TO_LINK: 1334 case LED_CTL_NO_LINK: 1335 if (!IS_LED_BLINKING(pLed)) { 1336 pLed->CurrLedState = LED_OFF; 1337 pLed->BlinkingLedState = LED_OFF; 1338 _set_timer(&(pLed->BlinkTimer), 0); 1339 } 1340 break; 1341 case LED_CTL_POWER_OFF: 1342 pLed->CurrLedState = LED_OFF; 1343 pLed->BlinkingLedState = LED_OFF; 1344 if (pLed->bLedBlinkInProgress) { 1345 _cancel_timer_ex(&(pLed->BlinkTimer)); 1346 pLed->bLedBlinkInProgress = false; 1347 } 1348 if (pLed->bLedScanBlinkInProgress) { 1349 _cancel_timer_ex(&(pLed->BlinkTimer)); 1350 pLed->bLedScanBlinkInProgress = false; 1351 } 1352 if (pLed->bLedWPSBlinkInProgress) { 1353 _cancel_timer_ex(&(pLed->BlinkTimer)); 1354 pLed->bLedWPSBlinkInProgress = false; 1355 } 1356 _set_timer(&(pLed->BlinkTimer), 0); 1357 break; 1358 default: 1359 break; 1360 } 1361 } 1362 1363 static void SwLedControlMode4(struct _adapter *padapter, 1364 enum LED_CTL_MODE LedAction) 1365 { 1366 struct led_priv *ledpriv = &(padapter->ledpriv); 1367 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1368 struct LED_871x *pLed = &(ledpriv->SwLed0); 1369 struct LED_871x *pLed1 = &(ledpriv->SwLed1); 1370 1371 switch (LedAction) { 1372 case LED_CTL_START_TO_LINK: 1373 if (pLed1->bLedWPSBlinkInProgress) { 1374 pLed1->bLedWPSBlinkInProgress = false; 1375 _cancel_timer_ex(&(pLed1->BlinkTimer)); 1376 pLed1->BlinkingLedState = LED_OFF; 1377 pLed1->CurrLedState = LED_OFF; 1378 if (pLed1->bLedOn) 1379 _set_timer(&(pLed->BlinkTimer), 0); 1380 } 1381 if (pLed->bLedStartToLinkBlinkInProgress == false) { 1382 if (pLed->CurrLedState == LED_SCAN_BLINK || 1383 IS_LED_WPS_BLINKING(pLed)) 1384 return; 1385 if (pLed->bLedBlinkInProgress == true) { 1386 _cancel_timer_ex(&(pLed->BlinkTimer)); 1387 pLed->bLedBlinkInProgress = false; 1388 } 1389 if (pLed->bLedNoLinkBlinkInProgress == true) { 1390 _cancel_timer_ex(&(pLed->BlinkTimer)); 1391 pLed->bLedNoLinkBlinkInProgress = false; 1392 } 1393 pLed->bLedStartToLinkBlinkInProgress = true; 1394 pLed->CurrLedState = LED_BLINK_StartToBlink; 1395 if (pLed->bLedOn) { 1396 pLed->BlinkingLedState = LED_OFF; 1397 _set_timer(&(pLed->BlinkTimer), 1398 LED_BLINK_SLOWLY_INTERVAL); 1399 } else { 1400 pLed->BlinkingLedState = LED_ON; 1401 _set_timer(&(pLed->BlinkTimer), 1402 LED_BLINK_NORMAL_INTERVAL); 1403 } 1404 } 1405 break; 1406 case LED_CTL_LINK: 1407 case LED_CTL_NO_LINK: 1408 /*LED1 settings*/ 1409 if (LedAction == LED_CTL_LINK) { 1410 if (pLed1->bLedWPSBlinkInProgress) { 1411 pLed1->bLedWPSBlinkInProgress = false; 1412 _cancel_timer_ex(&(pLed1->BlinkTimer)); 1413 pLed1->BlinkingLedState = LED_OFF; 1414 pLed1->CurrLedState = LED_OFF; 1415 if (pLed1->bLedOn) 1416 _set_timer(&(pLed->BlinkTimer), 0); 1417 } 1418 } 1419 if (pLed->bLedNoLinkBlinkInProgress == false) { 1420 if (pLed->CurrLedState == LED_SCAN_BLINK || 1421 IS_LED_WPS_BLINKING(pLed)) 1422 return; 1423 if (pLed->bLedBlinkInProgress == true) { 1424 _cancel_timer_ex(&(pLed->BlinkTimer)); 1425 pLed->bLedBlinkInProgress = false; 1426 } 1427 pLed->bLedNoLinkBlinkInProgress = true; 1428 pLed->CurrLedState = LED_BLINK_SLOWLY; 1429 if (pLed->bLedOn) 1430 pLed->BlinkingLedState = LED_OFF; 1431 else 1432 pLed->BlinkingLedState = LED_ON; 1433 _set_timer(&(pLed->BlinkTimer), 1434 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 1435 } 1436 break; 1437 case LED_CTL_SITE_SURVEY: 1438 if ((pmlmepriv->sitesurveyctrl.traffic_busy) && 1439 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) 1440 ; 1441 else if (pLed->bLedScanBlinkInProgress == false) { 1442 if (IS_LED_WPS_BLINKING(pLed)) 1443 return; 1444 if (pLed->bLedNoLinkBlinkInProgress == true) { 1445 _cancel_timer_ex(&(pLed->BlinkTimer)); 1446 pLed->bLedNoLinkBlinkInProgress = false; 1447 } 1448 if (pLed->bLedBlinkInProgress == true) { 1449 _cancel_timer_ex(&(pLed->BlinkTimer)); 1450 pLed->bLedBlinkInProgress = false; 1451 } 1452 pLed->bLedScanBlinkInProgress = true; 1453 pLed->CurrLedState = LED_SCAN_BLINK; 1454 pLed->BlinkTimes = 24; 1455 if (pLed->bLedOn) 1456 pLed->BlinkingLedState = LED_OFF; 1457 else 1458 pLed->BlinkingLedState = LED_ON; 1459 _set_timer(&(pLed->BlinkTimer), 1460 LED_BLINK_SCAN_INTERVAL_ALPHA); 1461 } 1462 break; 1463 case LED_CTL_TX: 1464 case LED_CTL_RX: 1465 if (pLed->bLedBlinkInProgress == false) { 1466 if (pLed->CurrLedState == LED_SCAN_BLINK || 1467 IS_LED_WPS_BLINKING(pLed)) 1468 return; 1469 if (pLed->bLedNoLinkBlinkInProgress == true) { 1470 _cancel_timer_ex(&(pLed->BlinkTimer)); 1471 pLed->bLedNoLinkBlinkInProgress = false; 1472 } 1473 pLed->bLedBlinkInProgress = true; 1474 pLed->CurrLedState = LED_TXRX_BLINK; 1475 pLed->BlinkTimes = 2; 1476 if (pLed->bLedOn) 1477 pLed->BlinkingLedState = LED_OFF; 1478 else 1479 pLed->BlinkingLedState = LED_ON; 1480 _set_timer(&(pLed->BlinkTimer), 1481 LED_BLINK_FASTER_INTERVAL_ALPHA); 1482 } 1483 break; 1484 case LED_CTL_START_WPS: /*wait until xinpin finish*/ 1485 case LED_CTL_START_WPS_BOTTON: 1486 if (pLed1->bLedWPSBlinkInProgress) { 1487 pLed1->bLedWPSBlinkInProgress = false; 1488 _cancel_timer_ex(&(pLed1->BlinkTimer)); 1489 pLed1->BlinkingLedState = LED_OFF; 1490 pLed1->CurrLedState = LED_OFF; 1491 if (pLed1->bLedOn) 1492 _set_timer(&(pLed->BlinkTimer), 0); 1493 } 1494 if (pLed->bLedWPSBlinkInProgress == false) { 1495 if (pLed->bLedNoLinkBlinkInProgress == true) { 1496 _cancel_timer_ex(&(pLed->BlinkTimer)); 1497 pLed->bLedNoLinkBlinkInProgress = false; 1498 } 1499 if (pLed->bLedBlinkInProgress == true) { 1500 _cancel_timer_ex(&(pLed->BlinkTimer)); 1501 pLed->bLedBlinkInProgress = false; 1502 } 1503 if (pLed->bLedScanBlinkInProgress == true) { 1504 _cancel_timer_ex(&(pLed->BlinkTimer)); 1505 pLed->bLedScanBlinkInProgress = false; 1506 } 1507 pLed->bLedWPSBlinkInProgress = true; 1508 pLed->CurrLedState = LED_BLINK_WPS; 1509 if (pLed->bLedOn) { 1510 pLed->BlinkingLedState = LED_OFF; 1511 _set_timer(&(pLed->BlinkTimer), 1512 LED_BLINK_SLOWLY_INTERVAL); 1513 } else { 1514 pLed->BlinkingLedState = LED_ON; 1515 _set_timer(&(pLed->BlinkTimer), 1516 LED_BLINK_NORMAL_INTERVAL); 1517 } 1518 } 1519 break; 1520 case LED_CTL_STOP_WPS: /*WPS connect success*/ 1521 if (pLed->bLedWPSBlinkInProgress) { 1522 _cancel_timer_ex(&(pLed->BlinkTimer)); 1523 pLed->bLedWPSBlinkInProgress = false; 1524 } 1525 pLed->bLedNoLinkBlinkInProgress = true; 1526 pLed->CurrLedState = LED_BLINK_SLOWLY; 1527 if (pLed->bLedOn) 1528 pLed->BlinkingLedState = LED_OFF; 1529 else 1530 pLed->BlinkingLedState = LED_ON; 1531 _set_timer(&(pLed->BlinkTimer), 1532 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 1533 break; 1534 case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/ 1535 if (pLed->bLedWPSBlinkInProgress) { 1536 _cancel_timer_ex(&(pLed->BlinkTimer)); 1537 pLed->bLedWPSBlinkInProgress = false; 1538 } 1539 pLed->bLedNoLinkBlinkInProgress = true; 1540 pLed->CurrLedState = LED_BLINK_SLOWLY; 1541 if (pLed->bLedOn) 1542 pLed->BlinkingLedState = LED_OFF; 1543 else 1544 pLed->BlinkingLedState = LED_ON; 1545 _set_timer(&(pLed->BlinkTimer), 1546 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 1547 /*LED1 settings*/ 1548 if (pLed1->bLedWPSBlinkInProgress) 1549 _cancel_timer_ex(&(pLed1->BlinkTimer)); 1550 else 1551 pLed1->bLedWPSBlinkInProgress = true; 1552 pLed1->CurrLedState = LED_BLINK_WPS_STOP; 1553 if (pLed1->bLedOn) 1554 pLed1->BlinkingLedState = LED_OFF; 1555 else 1556 pLed1->BlinkingLedState = LED_ON; 1557 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL); 1558 break; 1559 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/ 1560 if (pLed->bLedWPSBlinkInProgress) { 1561 _cancel_timer_ex(&(pLed->BlinkTimer)); 1562 pLed->bLedWPSBlinkInProgress = false; 1563 } 1564 pLed->bLedNoLinkBlinkInProgress = true; 1565 pLed->CurrLedState = LED_BLINK_SLOWLY; 1566 if (pLed->bLedOn) 1567 pLed->BlinkingLedState = LED_OFF; 1568 else 1569 pLed->BlinkingLedState = LED_ON; 1570 _set_timer(&(pLed->BlinkTimer), 1571 LED_BLINK_NO_LINK_INTERVAL_ALPHA); 1572 /*LED1 settings*/ 1573 if (pLed1->bLedWPSBlinkInProgress) 1574 _cancel_timer_ex(&(pLed1->BlinkTimer)); 1575 else 1576 pLed1->bLedWPSBlinkInProgress = true; 1577 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP; 1578 pLed1->BlinkTimes = 10; 1579 if (pLed1->bLedOn) 1580 pLed1->BlinkingLedState = LED_OFF; 1581 else 1582 pLed1->BlinkingLedState = LED_ON; 1583 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL); 1584 break; 1585 case LED_CTL_POWER_OFF: 1586 pLed->CurrLedState = LED_OFF; 1587 pLed->BlinkingLedState = LED_OFF; 1588 if (pLed->bLedNoLinkBlinkInProgress) { 1589 _cancel_timer_ex(&(pLed->BlinkTimer)); 1590 pLed->bLedNoLinkBlinkInProgress = false; 1591 } 1592 if (pLed->bLedLinkBlinkInProgress) { 1593 _cancel_timer_ex(&(pLed->BlinkTimer)); 1594 pLed->bLedLinkBlinkInProgress = false; 1595 } 1596 if (pLed->bLedBlinkInProgress) { 1597 _cancel_timer_ex(&(pLed->BlinkTimer)); 1598 pLed->bLedBlinkInProgress = false; 1599 } 1600 if (pLed->bLedWPSBlinkInProgress) { 1601 _cancel_timer_ex(&(pLed->BlinkTimer)); 1602 pLed->bLedWPSBlinkInProgress = false; 1603 } 1604 if (pLed->bLedScanBlinkInProgress) { 1605 _cancel_timer_ex(&(pLed->BlinkTimer)); 1606 pLed->bLedScanBlinkInProgress = false; 1607 } 1608 if (pLed->bLedStartToLinkBlinkInProgress) { 1609 _cancel_timer_ex(&(pLed->BlinkTimer)); 1610 pLed->bLedStartToLinkBlinkInProgress = false; 1611 } 1612 if (pLed1->bLedWPSBlinkInProgress) { 1613 _cancel_timer_ex(&(pLed1->BlinkTimer)); 1614 pLed1->bLedWPSBlinkInProgress = false; 1615 } 1616 pLed1->BlinkingLedState = LED_UNKNOWN; 1617 SwLedOff(padapter, pLed); 1618 SwLedOff(padapter, pLed1); 1619 break; 1620 default: 1621 break; 1622 } 1623 } 1624 1625 static void SwLedControlMode5(struct _adapter *padapter, 1626 enum LED_CTL_MODE LedAction) 1627 { 1628 struct led_priv *ledpriv = &(padapter->ledpriv); 1629 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1630 struct LED_871x *pLed = &(ledpriv->SwLed0); 1631 1632 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO) 1633 pLed = &(ledpriv->SwLed1); 1634 1635 switch (LedAction) { 1636 case LED_CTL_POWER_ON: 1637 case LED_CTL_NO_LINK: 1638 case LED_CTL_LINK: /* solid blue */ 1639 if (pLed->CurrLedState == LED_SCAN_BLINK) 1640 return; 1641 pLed->CurrLedState = LED_ON; 1642 pLed->BlinkingLedState = LED_ON; 1643 pLed->bLedBlinkInProgress = false; 1644 _set_timer(&(pLed->BlinkTimer), 0); 1645 break; 1646 case LED_CTL_SITE_SURVEY: 1647 if ((pmlmepriv->sitesurveyctrl.traffic_busy) && 1648 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) 1649 ; /* dummy branch */ 1650 else if (pLed->bLedScanBlinkInProgress == false) { 1651 if (pLed->bLedBlinkInProgress == true) { 1652 _cancel_timer_ex(&(pLed->BlinkTimer)); 1653 pLed->bLedBlinkInProgress = false; 1654 } 1655 pLed->bLedScanBlinkInProgress = true; 1656 pLed->CurrLedState = LED_SCAN_BLINK; 1657 pLed->BlinkTimes = 24; 1658 if (pLed->bLedOn) 1659 pLed->BlinkingLedState = LED_OFF; 1660 else 1661 pLed->BlinkingLedState = LED_ON; 1662 _set_timer(&(pLed->BlinkTimer), 1663 LED_BLINK_SCAN_INTERVAL_ALPHA); 1664 } 1665 break; 1666 case LED_CTL_TX: 1667 case LED_CTL_RX: 1668 if (pLed->bLedBlinkInProgress == false) { 1669 if (pLed->CurrLedState == LED_SCAN_BLINK) 1670 return; 1671 pLed->bLedBlinkInProgress = true; 1672 pLed->CurrLedState = LED_TXRX_BLINK; 1673 pLed->BlinkTimes = 2; 1674 if (pLed->bLedOn) 1675 pLed->BlinkingLedState = LED_OFF; 1676 else 1677 pLed->BlinkingLedState = LED_ON; 1678 _set_timer(&(pLed->BlinkTimer), 1679 LED_BLINK_FASTER_INTERVAL_ALPHA); 1680 } 1681 break; 1682 case LED_CTL_POWER_OFF: 1683 pLed->CurrLedState = LED_OFF; 1684 pLed->BlinkingLedState = LED_OFF; 1685 if (pLed->bLedBlinkInProgress) { 1686 _cancel_timer_ex(&(pLed->BlinkTimer)); 1687 pLed->bLedBlinkInProgress = false; 1688 } 1689 SwLedOff(padapter, pLed); 1690 break; 1691 default: 1692 break; 1693 } 1694 } 1695 1696 1697 static void SwLedControlMode6(struct _adapter *padapter, 1698 enum LED_CTL_MODE LedAction) 1699 { 1700 struct led_priv *ledpriv = &(padapter->ledpriv); 1701 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1702 struct LED_871x *pLed = &(ledpriv->SwLed0); 1703 1704 switch (LedAction) { 1705 case LED_CTL_POWER_ON: 1706 case LED_CTL_NO_LINK: 1707 case LED_CTL_LINK: /*solid blue*/ 1708 case LED_CTL_SITE_SURVEY: 1709 if (IS_LED_WPS_BLINKING(pLed)) 1710 return; 1711 pLed->CurrLedState = LED_ON; 1712 pLed->BlinkingLedState = LED_ON; 1713 pLed->bLedBlinkInProgress = false; 1714 _set_timer(&(pLed->BlinkTimer), 0); 1715 break; 1716 case LED_CTL_TX: 1717 case LED_CTL_RX: 1718 if (pLed->bLedBlinkInProgress == false && 1719 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) { 1720 if (IS_LED_WPS_BLINKING(pLed)) 1721 return; 1722 pLed->bLedBlinkInProgress = true; 1723 pLed->CurrLedState = LED_TXRX_BLINK; 1724 pLed->BlinkTimes = 2; 1725 if (pLed->bLedOn) 1726 pLed->BlinkingLedState = LED_OFF; 1727 else 1728 pLed->BlinkingLedState = LED_ON; 1729 _set_timer(&(pLed->BlinkTimer), 1730 LED_BLINK_FASTER_INTERVAL_ALPHA); 1731 } 1732 break; 1733 case LED_CTL_START_WPS: /*wait until xinpin finish*/ 1734 case LED_CTL_START_WPS_BOTTON: 1735 if (pLed->bLedWPSBlinkInProgress == false) { 1736 if (pLed->bLedBlinkInProgress == true) { 1737 _cancel_timer_ex(&(pLed->BlinkTimer)); 1738 pLed->bLedBlinkInProgress = false; 1739 } 1740 pLed->bLedWPSBlinkInProgress = true; 1741 pLed->CurrLedState = LED_BLINK_WPS; 1742 if (pLed->bLedOn) 1743 pLed->BlinkingLedState = LED_OFF; 1744 else 1745 pLed->BlinkingLedState = LED_ON; 1746 _set_timer(&(pLed->BlinkTimer), 1747 LED_BLINK_SCAN_INTERVAL_ALPHA); 1748 } 1749 break; 1750 case LED_CTL_STOP_WPS_FAIL: 1751 case LED_CTL_STOP_WPS: 1752 if (pLed->bLedWPSBlinkInProgress) { 1753 _cancel_timer_ex(&(pLed->BlinkTimer)); 1754 pLed->bLedWPSBlinkInProgress = false; 1755 } 1756 pLed->CurrLedState = LED_ON; 1757 pLed->BlinkingLedState = LED_ON; 1758 _set_timer(&(pLed->BlinkTimer), 0); 1759 break; 1760 case LED_CTL_POWER_OFF: 1761 pLed->CurrLedState = LED_OFF; 1762 pLed->BlinkingLedState = LED_OFF; 1763 if (pLed->bLedBlinkInProgress) { 1764 _cancel_timer_ex(&(pLed->BlinkTimer)); 1765 pLed->bLedBlinkInProgress = false; 1766 } 1767 if (pLed->bLedWPSBlinkInProgress) { 1768 _cancel_timer_ex(&(pLed->BlinkTimer)); 1769 pLed->bLedWPSBlinkInProgress = false; 1770 } 1771 SwLedOff(padapter, pLed); 1772 break; 1773 default: 1774 break; 1775 } 1776 } 1777 1778 /* Description: 1779 * Dispatch LED action according to pHalData->LedStrategy. 1780 */ 1781 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction) 1782 { 1783 struct led_priv *ledpriv = &(padapter->ledpriv); 1784 1785 if (ledpriv->bRegUseLed == false) 1786 return; 1787 switch (ledpriv->LedStrategy) { 1788 case SW_LED_MODE0: 1789 break; 1790 case SW_LED_MODE1: 1791 SwLedControlMode1(padapter, LedAction); 1792 break; 1793 case SW_LED_MODE2: 1794 SwLedControlMode2(padapter, LedAction); 1795 break; 1796 case SW_LED_MODE3: 1797 SwLedControlMode3(padapter, LedAction); 1798 break; 1799 case SW_LED_MODE4: 1800 SwLedControlMode4(padapter, LedAction); 1801 break; 1802 case SW_LED_MODE5: 1803 SwLedControlMode5(padapter, LedAction); 1804 break; 1805 case SW_LED_MODE6: 1806 SwLedControlMode6(padapter, LedAction); 1807 break; 1808 default: 1809 break; 1810 } 1811 } 1812