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