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_SUCCESS_INTERVAL_ALPHA 5000 47 48 /*=========================================================================== 49 * LED object. 50 *=========================================================================== 51 */ 52 enum _LED_STATE_871x { 53 LED_UNKNOWN = 0, 54 LED_STATE_ON = 1, 55 LED_STATE_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 */ 63 LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */ 64 LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer 65 * Server case 66 */ 67 LED_BLINK_WPS = 9, /* LED is blinkg during WPS communication */ 68 LED_TXRX_BLINK = 10, 69 LED_BLINK_WPS_STOP = 11, /*for ALPHA */ 70 LED_BLINK_WPS_STOP_OVERLAP = 12, /*for BELKIN */ 71 }; 72 73 /*=========================================================================== 74 * Prototype of protected function. 75 *=========================================================================== 76 */ 77 static void BlinkTimerCallback(struct timer_list *t); 78 79 static void BlinkWorkItemCallback(struct work_struct *work); 80 /*=========================================================================== 81 * LED_819xUsb routines. 82 *=========================================================================== 83 * 84 * 85 * 86 * Description: 87 * Initialize an LED_871x object. 88 */ 89 static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed, 90 enum LED_PIN_871x LedPin) 91 { 92 pLed->padapter = padapter; 93 pLed->LedPin = LedPin; 94 pLed->CurrLedState = LED_STATE_OFF; 95 pLed->bLedOn = false; 96 pLed->bLedBlinkInProgress = false; 97 pLed->BlinkTimes = 0; 98 pLed->BlinkingLedState = LED_UNKNOWN; 99 timer_setup(&pLed->BlinkTimer, BlinkTimerCallback, 0); 100 INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback); 101 } 102 103 /* 104 * Description: 105 * DeInitialize an LED_871x object. 106 */ 107 static void DeInitLed871x(struct LED_871x *pLed) 108 { 109 del_timer_sync(&pLed->BlinkTimer); 110 /* We should reset bLedBlinkInProgress if we cancel 111 * the LedControlTimer, 112 */ 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 || padapter->bDriverStopped) 125 return; 126 LedCfg = r8712_read8(padapter, LEDCFG); 127 switch (pLed->LedPin) { 128 case LED_PIN_GPIO0: 129 break; 130 case LED_PIN_LED0: 131 /* SW control led0 on.*/ 132 r8712_write8(padapter, LEDCFG, LedCfg & 0xf0); 133 break; 134 case LED_PIN_LED1: 135 /* SW control led1 on.*/ 136 r8712_write8(padapter, LEDCFG, LedCfg & 0x0f); 137 break; 138 default: 139 break; 140 } 141 pLed->bLedOn = true; 142 } 143 144 /* 145 * Description: 146 * Turn off LED according to LedPin specified. 147 */ 148 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed) 149 { 150 u8 LedCfg; 151 152 if (padapter->bSurpriseRemoved || padapter->bDriverStopped) 153 return; 154 LedCfg = r8712_read8(padapter, LEDCFG); 155 switch (pLed->LedPin) { 156 case LED_PIN_GPIO0: 157 break; 158 case LED_PIN_LED0: 159 LedCfg &= 0xf0; /* Set to software control.*/ 160 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3))); 161 break; 162 case LED_PIN_LED1: 163 LedCfg &= 0x0f; /* Set to software control.*/ 164 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7))); 165 break; 166 default: 167 break; 168 } 169 pLed->bLedOn = false; 170 } 171 172 /*=========================================================================== 173 * Interface to manipulate LED objects. 174 *=========================================================================== 175 * 176 * Description: 177 * Initialize all LED_871x objects. 178 */ 179 void r8712_InitSwLeds(struct _adapter *padapter) 180 { 181 struct led_priv *pledpriv = &padapter->ledpriv; 182 183 pledpriv->LedControlHandler = LedControl871x; 184 InitLed871x(padapter, &pledpriv->SwLed0, LED_PIN_LED0); 185 InitLed871x(padapter, &pledpriv->SwLed1, LED_PIN_LED1); 186 } 187 188 /* Description: 189 * DeInitialize all LED_819xUsb objects. 190 */ 191 void r8712_DeInitSwLeds(struct _adapter *padapter) 192 { 193 struct led_priv *ledpriv = &padapter->ledpriv; 194 195 DeInitLed871x(&ledpriv->SwLed0); 196 DeInitLed871x(&ledpriv->SwLed1); 197 } 198 199 /* Description: 200 * Implementation of LED blinking behavior. 201 * It toggle off LED and schedule corresponding timer if necessary. 202 */ 203 static void SwLedBlink(struct LED_871x *pLed) 204 { 205 struct _adapter *padapter = pLed->padapter; 206 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 207 u8 bStopBlinking = false; 208 209 /* Change LED according to BlinkingLedState specified. */ 210 if (pLed->BlinkingLedState == LED_STATE_ON) 211 SwLedOn(padapter, pLed); 212 else 213 SwLedOff(padapter, pLed); 214 /* Determine if we shall change LED state again. */ 215 pLed->BlinkTimes--; 216 switch (pLed->CurrLedState) { 217 case LED_BLINK_NORMAL: 218 if (pLed->BlinkTimes == 0) 219 bStopBlinking = true; 220 break; 221 case LED_BLINK_StartToBlink: 222 if (check_fwstate(pmlmepriv, _FW_LINKED) && 223 (pmlmepriv->fw_state & WIFI_STATION_STATE)) 224 bStopBlinking = true; 225 if (check_fwstate(pmlmepriv, _FW_LINKED) && 226 ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) || 227 (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE))) 228 bStopBlinking = true; 229 else if (pLed->BlinkTimes == 0) 230 bStopBlinking = true; 231 break; 232 case LED_BLINK_WPS: 233 if (pLed->BlinkTimes == 0) 234 bStopBlinking = true; 235 break; 236 default: 237 bStopBlinking = true; 238 break; 239 } 240 if (bStopBlinking) { 241 if (check_fwstate(pmlmepriv, _FW_LINKED) && 242 !pLed->bLedOn) 243 SwLedOn(padapter, pLed); 244 else if (check_fwstate(pmlmepriv, _FW_LINKED) && pLed->bLedOn) 245 SwLedOff(padapter, pLed); 246 pLed->BlinkTimes = 0; 247 pLed->bLedBlinkInProgress = false; 248 } else { 249 /* Assign LED state to toggle. */ 250 if (pLed->BlinkingLedState == LED_STATE_ON) 251 pLed->BlinkingLedState = LED_STATE_OFF; 252 else 253 pLed->BlinkingLedState = LED_STATE_ON; 254 255 /* Schedule a timer to toggle LED state. */ 256 switch (pLed->CurrLedState) { 257 case LED_BLINK_NORMAL: 258 mod_timer(&pLed->BlinkTimer, jiffies + 259 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL)); 260 break; 261 case LED_BLINK_SLOWLY: 262 case LED_BLINK_StartToBlink: 263 mod_timer(&pLed->BlinkTimer, jiffies + 264 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL)); 265 break; 266 case LED_BLINK_WPS: 267 mod_timer(&pLed->BlinkTimer, jiffies + 268 msecs_to_jiffies(LED_BLINK_LONG_INTERVAL)); 269 break; 270 default: 271 mod_timer(&pLed->BlinkTimer, jiffies + 272 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL)); 273 break; 274 } 275 } 276 } 277 278 static void SwLedBlink1(struct LED_871x *pLed) 279 { 280 struct _adapter *padapter = pLed->padapter; 281 struct led_priv *ledpriv = &padapter->ledpriv; 282 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 283 struct eeprom_priv *peeprompriv = &padapter->eeprompriv; 284 struct LED_871x *pLed1 = &ledpriv->SwLed1; 285 u8 bStopBlinking = false; 286 287 if (peeprompriv->CustomerID == RT_CID_819x_CAMEO) 288 pLed = &ledpriv->SwLed1; 289 /* Change LED according to BlinkingLedState specified. */ 290 if (pLed->BlinkingLedState == LED_STATE_ON) 291 SwLedOn(padapter, pLed); 292 else 293 SwLedOff(padapter, pLed); 294 if (peeprompriv->CustomerID == RT_CID_DEFAULT) { 295 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 296 if (!pLed1->bSWLedCtrl) { 297 SwLedOn(padapter, pLed1); 298 pLed1->bSWLedCtrl = true; 299 } else if (!pLed1->bLedOn) { 300 SwLedOn(padapter, pLed1); 301 } 302 } else { 303 if (!pLed1->bSWLedCtrl) { 304 SwLedOff(padapter, pLed1); 305 pLed1->bSWLedCtrl = true; 306 } else if (pLed1->bLedOn) { 307 SwLedOff(padapter, pLed1); 308 } 309 } 310 } 311 switch (pLed->CurrLedState) { 312 case LED_BLINK_SLOWLY: 313 if (pLed->bLedOn) 314 pLed->BlinkingLedState = LED_STATE_OFF; 315 else 316 pLed->BlinkingLedState = LED_STATE_ON; 317 mod_timer(&pLed->BlinkTimer, jiffies + 318 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 319 break; 320 case LED_BLINK_NORMAL: 321 if (pLed->bLedOn) 322 pLed->BlinkingLedState = LED_STATE_OFF; 323 else 324 pLed->BlinkingLedState = LED_STATE_ON; 325 mod_timer(&pLed->BlinkTimer, jiffies + 326 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA)); 327 break; 328 case LED_SCAN_BLINK: 329 pLed->BlinkTimes--; 330 if (pLed->BlinkTimes == 0) 331 bStopBlinking = true; 332 if (bStopBlinking) { 333 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 334 pLed->bLedLinkBlinkInProgress = true; 335 pLed->CurrLedState = LED_BLINK_NORMAL; 336 if (pLed->bLedOn) 337 pLed->BlinkingLedState = LED_STATE_OFF; 338 else 339 pLed->BlinkingLedState = LED_STATE_ON; 340 mod_timer(&pLed->BlinkTimer, jiffies + 341 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA)); 342 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 343 pLed->bLedNoLinkBlinkInProgress = true; 344 pLed->CurrLedState = LED_BLINK_SLOWLY; 345 if (pLed->bLedOn) 346 pLed->BlinkingLedState = LED_STATE_OFF; 347 else 348 pLed->BlinkingLedState = LED_STATE_ON; 349 mod_timer(&pLed->BlinkTimer, jiffies + 350 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 351 } 352 pLed->bLedScanBlinkInProgress = false; 353 } else { 354 if (pLed->bLedOn) 355 pLed->BlinkingLedState = LED_STATE_OFF; 356 else 357 pLed->BlinkingLedState = LED_STATE_ON; 358 mod_timer(&pLed->BlinkTimer, jiffies + 359 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA)); 360 } 361 break; 362 case LED_TXRX_BLINK: 363 pLed->BlinkTimes--; 364 if (pLed->BlinkTimes == 0) 365 bStopBlinking = true; 366 if (bStopBlinking) { 367 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 368 pLed->bLedLinkBlinkInProgress = true; 369 pLed->CurrLedState = LED_BLINK_NORMAL; 370 if (pLed->bLedOn) 371 pLed->BlinkingLedState = LED_STATE_OFF; 372 else 373 pLed->BlinkingLedState = LED_STATE_ON; 374 mod_timer(&pLed->BlinkTimer, jiffies + 375 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA)); 376 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 377 pLed->bLedNoLinkBlinkInProgress = true; 378 pLed->CurrLedState = LED_BLINK_SLOWLY; 379 if (pLed->bLedOn) 380 pLed->BlinkingLedState = LED_STATE_OFF; 381 else 382 pLed->BlinkingLedState = LED_STATE_ON; 383 mod_timer(&pLed->BlinkTimer, jiffies + 384 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 385 } 386 pLed->BlinkTimes = 0; 387 pLed->bLedBlinkInProgress = false; 388 } else { 389 if (pLed->bLedOn) 390 pLed->BlinkingLedState = LED_STATE_OFF; 391 else 392 pLed->BlinkingLedState = LED_STATE_ON; 393 mod_timer(&pLed->BlinkTimer, jiffies + 394 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 395 } 396 break; 397 case LED_BLINK_WPS: 398 if (pLed->bLedOn) 399 pLed->BlinkingLedState = LED_STATE_OFF; 400 else 401 pLed->BlinkingLedState = LED_STATE_ON; 402 mod_timer(&pLed->BlinkTimer, jiffies + 403 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA)); 404 break; 405 case LED_BLINK_WPS_STOP: /* WPS success */ 406 if (pLed->BlinkingLedState == LED_STATE_ON) { 407 pLed->BlinkingLedState = LED_STATE_OFF; 408 mod_timer(&pLed->BlinkTimer, jiffies + 409 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA)); 410 bStopBlinking = false; 411 } else { 412 bStopBlinking = true; 413 } 414 if (bStopBlinking) { 415 pLed->bLedLinkBlinkInProgress = true; 416 pLed->CurrLedState = LED_BLINK_NORMAL; 417 if (pLed->bLedOn) 418 pLed->BlinkingLedState = LED_STATE_OFF; 419 else 420 pLed->BlinkingLedState = LED_STATE_ON; 421 mod_timer(&pLed->BlinkTimer, jiffies + 422 msecs_to_jiffies(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_STATE_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)) { 449 pLed->CurrLedState = LED_STATE_ON; 450 pLed->BlinkingLedState = LED_STATE_ON; 451 SwLedOn(padapter, pLed); 452 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 453 pLed->CurrLedState = LED_STATE_OFF; 454 pLed->BlinkingLedState = LED_STATE_OFF; 455 SwLedOff(padapter, pLed); 456 } 457 pLed->bLedScanBlinkInProgress = false; 458 } else { 459 if (pLed->bLedOn) 460 pLed->BlinkingLedState = LED_STATE_OFF; 461 else 462 pLed->BlinkingLedState = LED_STATE_ON; 463 mod_timer(&pLed->BlinkTimer, jiffies + 464 msecs_to_jiffies(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)) { 473 pLed->CurrLedState = LED_STATE_ON; 474 pLed->BlinkingLedState = LED_STATE_ON; 475 SwLedOn(padapter, pLed); 476 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 477 pLed->CurrLedState = LED_STATE_OFF; 478 pLed->BlinkingLedState = LED_STATE_OFF; 479 SwLedOff(padapter, pLed); 480 } 481 pLed->bLedBlinkInProgress = false; 482 } else { 483 if (pLed->bLedOn) 484 pLed->BlinkingLedState = LED_STATE_OFF; 485 else 486 pLed->BlinkingLedState = LED_STATE_ON; 487 mod_timer(&pLed->BlinkTimer, jiffies + 488 msecs_to_jiffies(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_STATE_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)) { 515 pLed->CurrLedState = LED_STATE_ON; 516 pLed->BlinkingLedState = LED_STATE_ON; 517 if (!pLed->bLedOn) 518 SwLedOn(padapter, pLed); 519 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 520 pLed->CurrLedState = LED_STATE_OFF; 521 pLed->BlinkingLedState = LED_STATE_OFF; 522 if (pLed->bLedOn) 523 SwLedOff(padapter, pLed); 524 } 525 pLed->bLedScanBlinkInProgress = false; 526 } else { 527 if (pLed->bLedOn) 528 pLed->BlinkingLedState = LED_STATE_OFF; 529 else 530 pLed->BlinkingLedState = LED_STATE_ON; 531 mod_timer(&pLed->BlinkTimer, jiffies + 532 msecs_to_jiffies(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)) { 541 pLed->CurrLedState = LED_STATE_ON; 542 pLed->BlinkingLedState = LED_STATE_ON; 543 if (!pLed->bLedOn) 544 SwLedOn(padapter, pLed); 545 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 546 pLed->CurrLedState = LED_STATE_OFF; 547 pLed->BlinkingLedState = LED_STATE_OFF; 548 if (pLed->bLedOn) 549 SwLedOff(padapter, pLed); 550 } 551 pLed->bLedBlinkInProgress = false; 552 } else { 553 if (pLed->bLedOn) 554 pLed->BlinkingLedState = LED_STATE_OFF; 555 else 556 pLed->BlinkingLedState = LED_STATE_ON; 557 mod_timer(&pLed->BlinkTimer, jiffies + 558 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 559 } 560 break; 561 case LED_BLINK_WPS: 562 if (pLed->bLedOn) 563 pLed->BlinkingLedState = LED_STATE_OFF; 564 else 565 pLed->BlinkingLedState = LED_STATE_ON; 566 mod_timer(&pLed->BlinkTimer, jiffies + 567 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA)); 568 break; 569 case LED_BLINK_WPS_STOP: /*WPS success*/ 570 if (pLed->BlinkingLedState == LED_STATE_ON) { 571 pLed->BlinkingLedState = LED_STATE_OFF; 572 mod_timer(&pLed->BlinkTimer, jiffies + 573 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA)); 574 bStopBlinking = false; 575 } else { 576 bStopBlinking = true; 577 } 578 if (bStopBlinking) { 579 pLed->CurrLedState = LED_STATE_ON; 580 pLed->BlinkingLedState = LED_STATE_ON; 581 SwLedOn(padapter, pLed); 582 pLed->bLedWPSBlinkInProgress = false; 583 } 584 break; 585 default: 586 break; 587 } 588 } 589 590 static void SwLedBlink4(struct LED_871x *pLed) 591 { 592 struct _adapter *padapter = pLed->padapter; 593 struct led_priv *ledpriv = &padapter->ledpriv; 594 struct LED_871x *pLed1 = &ledpriv->SwLed1; 595 u8 bStopBlinking = false; 596 597 /* Change LED according to BlinkingLedState specified. */ 598 if (pLed->BlinkingLedState == LED_STATE_ON) 599 SwLedOn(padapter, pLed); 600 else 601 SwLedOff(padapter, pLed); 602 if (!pLed1->bLedWPSBlinkInProgress && 603 pLed1->BlinkingLedState == LED_UNKNOWN) { 604 pLed1->BlinkingLedState = LED_STATE_OFF; 605 pLed1->CurrLedState = LED_STATE_OFF; 606 SwLedOff(padapter, pLed1); 607 } 608 switch (pLed->CurrLedState) { 609 case LED_BLINK_SLOWLY: 610 if (pLed->bLedOn) 611 pLed->BlinkingLedState = LED_STATE_OFF; 612 else 613 pLed->BlinkingLedState = LED_STATE_ON; 614 mod_timer(&pLed->BlinkTimer, jiffies + 615 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 616 break; 617 case LED_BLINK_StartToBlink: 618 if (pLed->bLedOn) { 619 pLed->BlinkingLedState = LED_STATE_OFF; 620 mod_timer(&pLed->BlinkTimer, jiffies + 621 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL)); 622 } else { 623 pLed->BlinkingLedState = LED_STATE_ON; 624 mod_timer(&pLed->BlinkTimer, jiffies + 625 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL)); 626 } 627 break; 628 case LED_SCAN_BLINK: 629 pLed->BlinkTimes--; 630 if (pLed->BlinkTimes == 0) 631 bStopBlinking = true; 632 if (bStopBlinking) { 633 pLed->bLedNoLinkBlinkInProgress = true; 634 pLed->CurrLedState = LED_BLINK_SLOWLY; 635 if (pLed->bLedOn) 636 pLed->BlinkingLedState = LED_STATE_OFF; 637 else 638 pLed->BlinkingLedState = LED_STATE_ON; 639 mod_timer(&pLed->BlinkTimer, jiffies + 640 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 641 pLed->bLedScanBlinkInProgress = false; 642 } else { 643 if (pLed->bLedOn) 644 pLed->BlinkingLedState = LED_STATE_OFF; 645 else 646 pLed->BlinkingLedState = LED_STATE_ON; 647 mod_timer(&pLed->BlinkTimer, jiffies + 648 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA)); 649 } 650 break; 651 case LED_TXRX_BLINK: 652 pLed->BlinkTimes--; 653 if (pLed->BlinkTimes == 0) 654 bStopBlinking = true; 655 if (bStopBlinking) { 656 pLed->bLedNoLinkBlinkInProgress = true; 657 pLed->CurrLedState = LED_BLINK_SLOWLY; 658 if (pLed->bLedOn) 659 pLed->BlinkingLedState = LED_STATE_OFF; 660 else 661 pLed->BlinkingLedState = LED_STATE_ON; 662 mod_timer(&pLed->BlinkTimer, jiffies + 663 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); 664 pLed->bLedBlinkInProgress = false; 665 } else { 666 if (pLed->bLedOn) 667 pLed->BlinkingLedState = LED_STATE_OFF; 668 else 669 pLed->BlinkingLedState = LED_STATE_ON; 670 mod_timer(&pLed->BlinkTimer, jiffies + 671 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 672 } 673 break; 674 case LED_BLINK_WPS: 675 if (pLed->bLedOn) { 676 pLed->BlinkingLedState = LED_STATE_OFF; 677 mod_timer(&pLed->BlinkTimer, jiffies + 678 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL)); 679 } else { 680 pLed->BlinkingLedState = LED_STATE_ON; 681 mod_timer(&pLed->BlinkTimer, jiffies + 682 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL)); 683 } 684 break; 685 case LED_BLINK_WPS_STOP: /*WPS authentication fail*/ 686 if (pLed->bLedOn) 687 pLed->BlinkingLedState = LED_STATE_OFF; 688 else 689 pLed->BlinkingLedState = LED_STATE_ON; 690 mod_timer(&pLed->BlinkTimer, jiffies + 691 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL)); 692 break; 693 case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */ 694 pLed->BlinkTimes--; 695 if (pLed->BlinkTimes == 0) { 696 if (pLed->bLedOn) 697 pLed->BlinkTimes = 1; 698 else 699 bStopBlinking = true; 700 } 701 if (bStopBlinking) { 702 pLed->BlinkTimes = 10; 703 pLed->BlinkingLedState = LED_STATE_ON; 704 mod_timer(&pLed->BlinkTimer, jiffies + 705 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA)); 706 } else { 707 if (pLed->bLedOn) 708 pLed->BlinkingLedState = LED_STATE_OFF; 709 else 710 pLed->BlinkingLedState = LED_STATE_ON; 711 mod_timer(&pLed->BlinkTimer, jiffies + 712 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL)); 713 } 714 break; 715 default: 716 break; 717 } 718 } 719 720 static void SwLedBlink5(struct LED_871x *pLed) 721 { 722 struct _adapter *padapter = pLed->padapter; 723 u8 bStopBlinking = false; 724 725 /* Change LED according to BlinkingLedState specified. */ 726 if (pLed->BlinkingLedState == LED_STATE_ON) 727 SwLedOn(padapter, pLed); 728 else 729 SwLedOff(padapter, pLed); 730 switch (pLed->CurrLedState) { 731 case LED_SCAN_BLINK: 732 pLed->BlinkTimes--; 733 if (pLed->BlinkTimes == 0) 734 bStopBlinking = true; 735 if (bStopBlinking) { 736 pLed->CurrLedState = LED_STATE_ON; 737 pLed->BlinkingLedState = LED_STATE_ON; 738 if (!pLed->bLedOn) 739 mod_timer(&pLed->BlinkTimer, jiffies + 740 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 741 pLed->bLedScanBlinkInProgress = false; 742 } else { 743 if (pLed->bLedOn) 744 pLed->BlinkingLedState = LED_STATE_OFF; 745 else 746 pLed->BlinkingLedState = LED_STATE_ON; 747 mod_timer(&pLed->BlinkTimer, jiffies + 748 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA)); 749 } 750 break; 751 case LED_TXRX_BLINK: 752 pLed->BlinkTimes--; 753 if (pLed->BlinkTimes == 0) 754 bStopBlinking = true; 755 if (bStopBlinking) { 756 pLed->CurrLedState = LED_STATE_ON; 757 pLed->BlinkingLedState = LED_STATE_ON; 758 if (!pLed->bLedOn) 759 mod_timer(&pLed->BlinkTimer, jiffies + 760 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 761 pLed->bLedBlinkInProgress = false; 762 } else { 763 if (pLed->bLedOn) 764 pLed->BlinkingLedState = LED_STATE_OFF; 765 else 766 pLed->BlinkingLedState = LED_STATE_ON; 767 mod_timer(&pLed->BlinkTimer, jiffies + 768 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 769 } 770 break; 771 default: 772 break; 773 } 774 } 775 776 static void SwLedBlink6(struct LED_871x *pLed) 777 { 778 struct _adapter *padapter = pLed->padapter; 779 u8 bStopBlinking = false; 780 781 /* Change LED according to BlinkingLedState specified. */ 782 if (pLed->BlinkingLedState == LED_STATE_ON) 783 SwLedOn(padapter, pLed); 784 else 785 SwLedOff(padapter, pLed); 786 switch (pLed->CurrLedState) { 787 case LED_TXRX_BLINK: 788 pLed->BlinkTimes--; 789 if (pLed->BlinkTimes == 0) 790 bStopBlinking = true; 791 if (bStopBlinking) { 792 pLed->CurrLedState = LED_STATE_ON; 793 pLed->BlinkingLedState = LED_STATE_ON; 794 if (!pLed->bLedOn) 795 SwLedOn(padapter, pLed); 796 pLed->bLedBlinkInProgress = false; 797 } else { 798 if (pLed->bLedOn) 799 pLed->BlinkingLedState = LED_STATE_OFF; 800 else 801 pLed->BlinkingLedState = LED_STATE_ON; 802 mod_timer(&pLed->BlinkTimer, jiffies + 803 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA)); 804 } 805 break; 806 case LED_BLINK_WPS: 807 if (pLed->bLedOn) 808 pLed->BlinkingLedState = LED_STATE_OFF; 809 else 810 pLed->BlinkingLedState = LED_STATE_ON; 811 mod_timer(&pLed->BlinkTimer, jiffies + 812 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA)); 813 break; 814 815 default: 816 break; 817 } 818 } 819 820 /* Description: 821 * Callback function of LED BlinkTimer, 822 * it just schedules to corresponding BlinkWorkItem. 823 */ 824 static void BlinkTimerCallback(struct timer_list *t) 825 { 826 struct LED_871x *pLed = from_timer(pLed, t, BlinkTimer); 827 828 /* This fixed the crash problem on Fedora 12 when trying to do the 829 * insmod;ifconfig up;rmmod commands. 830 */ 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_STATE_OFF; 912 else 913 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 935 else 936 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 965 else 966 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 990 else 991 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1020 else 1021 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1050 mod_timer(&pLed->BlinkTimer, jiffies + 1051 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA)); 1052 } else { 1053 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1067 else 1068 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1074 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1127 else 1128 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1146 else 1147 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1155 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1182 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1191 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1199 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1208 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1215 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1259 else 1260 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1277 else 1278 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1287 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1314 else 1315 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1330 mod_timer(&pLed->BlinkTimer, jiffies + 1331 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA)); 1332 } else { 1333 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1344 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1352 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1359 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1394 pLed1->CurrLedState = LED_STATE_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_STATE_OFF; 1415 mod_timer(&pLed->BlinkTimer, jiffies + 1416 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL)); 1417 } else { 1418 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1432 pLed1->CurrLedState = LED_STATE_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_STATE_OFF; 1450 else 1451 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1476 else 1477 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1497 else 1498 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1509 pLed1->CurrLedState = LED_STATE_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_STATE_OFF; 1531 mod_timer(&pLed->BlinkTimer, jiffies + 1532 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL)); 1533 } else { 1534 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1549 else 1550 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1563 else 1564 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1575 else 1576 pLed1->BlinkingLedState = LED_STATE_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_STATE_OFF; 1589 else 1590 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1602 else 1603 pLed1->BlinkingLedState = LED_STATE_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_STATE_OFF; 1609 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1664 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1683 else 1684 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1699 else 1700 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1707 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1735 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1750 else 1751 pLed->BlinkingLedState = LED_STATE_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_STATE_OFF; 1767 else 1768 pLed->BlinkingLedState = LED_STATE_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_STATE_ON; 1780 pLed->BlinkingLedState = LED_STATE_ON; 1781 mod_timer(&pLed->BlinkTimer, 1782 jiffies + msecs_to_jiffies(0)); 1783 break; 1784 case LED_CTL_POWER_OFF: 1785 pLed->CurrLedState = LED_STATE_OFF; 1786 pLed->BlinkingLedState = LED_STATE_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