1 /******************************************************************************
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
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.
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
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
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
27 ******************************************************************************/
29 #include "drv_types.h"
31 /*===========================================================================
33 *===========================================================================
36 * Default LED behavior.
38 #define LED_BLINK_NORMAL_INTERVAL 100
39 #define LED_BLINK_SLOWLY_INTERVAL 200
40 #define LED_BLINK_LONG_INTERVAL 400
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
48 /*===========================================================================
50 *===========================================================================
52 enum _LED_STATE_871x {
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
63 LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */
64 LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer
67 LED_BLINK_WPS = 9, /* LED is blinkg during WPS communication */
69 LED_BLINK_WPS_STOP = 11, /*for ALPHA */
70 LED_BLINK_WPS_STOP_OVERLAP = 12, /*for BELKIN */
73 /*===========================================================================
74 * Prototype of protected function.
75 *===========================================================================
77 static void BlinkTimerCallback(unsigned long data);
79 static void BlinkWorkItemCallback(struct work_struct *work);
80 /*===========================================================================
81 * LED_819xUsb routines.
82 *===========================================================================
87 * Initialize an LED_871x object.
89 static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed,
90 enum LED_PIN_871x LedPin)
92 struct net_device *nic;
94 nic = padapter->pnetdev;
95 pLed->padapter = padapter;
96 pLed->LedPin = LedPin;
97 pLed->CurrLedState = LED_STATE_OFF;
99 pLed->bLedBlinkInProgress = false;
100 pLed->BlinkTimes = 0;
101 pLed->BlinkingLedState = LED_UNKNOWN;
102 setup_timer(&pLed->BlinkTimer, BlinkTimerCallback,
103 (unsigned long)pLed);
104 INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback);
109 * DeInitialize an LED_871x object.
111 static void DeInitLed871x(struct LED_871x *pLed)
113 del_timer_sync(&pLed->BlinkTimer);
114 /* We should reset bLedBlinkInProgress if we cancel
115 * the LedControlTimer,
117 pLed->bLedBlinkInProgress = false;
122 * Turn on LED according to LedPin specified.
124 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
128 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
130 LedCfg = r8712_read8(padapter, LEDCFG);
131 switch (pLed->LedPin) {
135 /* SW control led0 on.*/
136 r8712_write8(padapter, LEDCFG, LedCfg & 0xf0);
139 /* SW control led1 on.*/
140 r8712_write8(padapter, LEDCFG, LedCfg & 0x0f);
150 * Turn off LED according to LedPin specified.
152 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
156 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
158 LedCfg = r8712_read8(padapter, LEDCFG);
159 switch (pLed->LedPin) {
163 LedCfg &= 0xf0; /* Set to software control.*/
164 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3)));
167 LedCfg &= 0x0f; /* Set to software control.*/
168 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7)));
173 pLed->bLedOn = false;
176 /*===========================================================================
177 * Interface to manipulate LED objects.
178 *===========================================================================
181 * Initialize all LED_871x objects.
183 void r8712_InitSwLeds(struct _adapter *padapter)
185 struct led_priv *pledpriv = &(padapter->ledpriv);
187 pledpriv->LedControlHandler = LedControl871x;
188 InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
189 InitLed871x(padapter, &(pledpriv->SwLed1), LED_PIN_LED1);
193 * DeInitialize all LED_819xUsb objects.
195 void r8712_DeInitSwLeds(struct _adapter *padapter)
197 struct led_priv *ledpriv = &(padapter->ledpriv);
199 DeInitLed871x(&(ledpriv->SwLed0));
200 DeInitLed871x(&(ledpriv->SwLed1));
204 * Implementation of LED blinking behavior.
205 * It toggle off LED and schedule corresponding timer if necessary.
207 static void SwLedBlink(struct LED_871x *pLed)
209 struct _adapter *padapter = pLed->padapter;
210 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
211 u8 bStopBlinking = false;
213 /* Change LED according to BlinkingLedState specified. */
214 if (pLed->BlinkingLedState == LED_STATE_ON)
215 SwLedOn(padapter, pLed);
217 SwLedOff(padapter, pLed);
218 /* Determine if we shall change LED state again. */
220 switch (pLed->CurrLedState) {
221 case LED_BLINK_NORMAL:
222 if (pLed->BlinkTimes == 0)
223 bStopBlinking = true;
225 case LED_BLINK_StartToBlink:
226 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
227 (pmlmepriv->fw_state & WIFI_STATION_STATE))
228 bStopBlinking = true;
229 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
230 ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
231 (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
232 bStopBlinking = true;
233 else if (pLed->BlinkTimes == 0)
234 bStopBlinking = true;
237 if (pLed->BlinkTimes == 0)
238 bStopBlinking = true;
241 bStopBlinking = true;
245 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
247 SwLedOn(padapter, pLed);
248 else if (check_fwstate(pmlmepriv, _FW_LINKED) && pLed->bLedOn)
249 SwLedOff(padapter, pLed);
250 pLed->BlinkTimes = 0;
251 pLed->bLedBlinkInProgress = false;
253 /* Assign LED state to toggle. */
254 if (pLed->BlinkingLedState == LED_STATE_ON)
255 pLed->BlinkingLedState = LED_STATE_OFF;
257 pLed->BlinkingLedState = LED_STATE_ON;
259 /* Schedule a timer to toggle LED state. */
260 switch (pLed->CurrLedState) {
261 case LED_BLINK_NORMAL:
262 mod_timer(&pLed->BlinkTimer, jiffies +
263 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
265 case LED_BLINK_SLOWLY:
266 case LED_BLINK_StartToBlink:
267 mod_timer(&pLed->BlinkTimer, jiffies +
268 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
271 mod_timer(&pLed->BlinkTimer, jiffies +
272 msecs_to_jiffies(LED_BLINK_LONG_INTERVAL));
275 mod_timer(&pLed->BlinkTimer, jiffies +
276 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
282 static void SwLedBlink1(struct LED_871x *pLed)
284 struct _adapter *padapter = pLed->padapter;
285 struct led_priv *ledpriv = &(padapter->ledpriv);
286 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
287 struct eeprom_priv *peeprompriv = &(padapter->eeprompriv);
288 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
289 u8 bStopBlinking = false;
291 if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
292 pLed = &(ledpriv->SwLed1);
293 /* Change LED according to BlinkingLedState specified. */
294 if (pLed->BlinkingLedState == LED_STATE_ON)
295 SwLedOn(padapter, pLed);
297 SwLedOff(padapter, pLed);
298 if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
299 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
300 if (!pLed1->bSWLedCtrl) {
301 SwLedOn(padapter, pLed1);
302 pLed1->bSWLedCtrl = true;
303 } else if (!pLed1->bLedOn) {
304 SwLedOn(padapter, pLed1);
307 if (!pLed1->bSWLedCtrl) {
308 SwLedOff(padapter, pLed1);
309 pLed1->bSWLedCtrl = true;
310 } else if (pLed1->bLedOn) {
311 SwLedOff(padapter, pLed1);
315 switch (pLed->CurrLedState) {
316 case LED_BLINK_SLOWLY:
318 pLed->BlinkingLedState = LED_STATE_OFF;
320 pLed->BlinkingLedState = LED_STATE_ON;
321 mod_timer(&pLed->BlinkTimer, jiffies +
322 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
324 case LED_BLINK_NORMAL:
326 pLed->BlinkingLedState = LED_STATE_OFF;
328 pLed->BlinkingLedState = LED_STATE_ON;
329 mod_timer(&pLed->BlinkTimer, jiffies +
330 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
334 if (pLed->BlinkTimes == 0)
335 bStopBlinking = true;
337 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
338 pLed->bLedLinkBlinkInProgress = true;
339 pLed->CurrLedState = LED_BLINK_NORMAL;
341 pLed->BlinkingLedState = LED_STATE_OFF;
343 pLed->BlinkingLedState = LED_STATE_ON;
344 mod_timer(&pLed->BlinkTimer, jiffies +
345 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
346 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
347 pLed->bLedNoLinkBlinkInProgress = true;
348 pLed->CurrLedState = LED_BLINK_SLOWLY;
350 pLed->BlinkingLedState = LED_STATE_OFF;
352 pLed->BlinkingLedState = LED_STATE_ON;
353 mod_timer(&pLed->BlinkTimer, jiffies +
354 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
356 pLed->bLedScanBlinkInProgress = false;
359 pLed->BlinkingLedState = LED_STATE_OFF;
361 pLed->BlinkingLedState = LED_STATE_ON;
362 mod_timer(&pLed->BlinkTimer, jiffies +
363 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
368 if (pLed->BlinkTimes == 0)
369 bStopBlinking = true;
371 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
372 pLed->bLedLinkBlinkInProgress = true;
373 pLed->CurrLedState = LED_BLINK_NORMAL;
375 pLed->BlinkingLedState = LED_STATE_OFF;
377 pLed->BlinkingLedState = LED_STATE_ON;
378 mod_timer(&pLed->BlinkTimer, jiffies +
379 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
380 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
381 pLed->bLedNoLinkBlinkInProgress = true;
382 pLed->CurrLedState = LED_BLINK_SLOWLY;
384 pLed->BlinkingLedState = LED_STATE_OFF;
386 pLed->BlinkingLedState = LED_STATE_ON;
387 mod_timer(&pLed->BlinkTimer, jiffies +
388 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
390 pLed->BlinkTimes = 0;
391 pLed->bLedBlinkInProgress = false;
394 pLed->BlinkingLedState = LED_STATE_OFF;
396 pLed->BlinkingLedState = LED_STATE_ON;
397 mod_timer(&pLed->BlinkTimer, jiffies +
398 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
403 pLed->BlinkingLedState = LED_STATE_OFF;
405 pLed->BlinkingLedState = LED_STATE_ON;
406 mod_timer(&pLed->BlinkTimer, jiffies +
407 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
409 case LED_BLINK_WPS_STOP: /* WPS success */
410 if (pLed->BlinkingLedState == LED_STATE_ON) {
411 pLed->BlinkingLedState = LED_STATE_OFF;
412 mod_timer(&pLed->BlinkTimer, jiffies +
413 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
414 bStopBlinking = false;
416 bStopBlinking = true;
419 pLed->bLedLinkBlinkInProgress = true;
420 pLed->CurrLedState = LED_BLINK_NORMAL;
422 pLed->BlinkingLedState = LED_STATE_OFF;
424 pLed->BlinkingLedState = LED_STATE_ON;
425 mod_timer(&pLed->BlinkTimer, jiffies +
426 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
428 pLed->bLedWPSBlinkInProgress = false;
435 static void SwLedBlink2(struct LED_871x *pLed)
437 struct _adapter *padapter = pLed->padapter;
438 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
439 u8 bStopBlinking = false;
441 /* Change LED according to BlinkingLedState specified. */
442 if (pLed->BlinkingLedState == LED_STATE_ON)
443 SwLedOn(padapter, pLed);
445 SwLedOff(padapter, pLed);
446 switch (pLed->CurrLedState) {
449 if (pLed->BlinkTimes == 0)
450 bStopBlinking = true;
452 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
453 pLed->CurrLedState = LED_STATE_ON;
454 pLed->BlinkingLedState = LED_STATE_ON;
455 SwLedOn(padapter, pLed);
456 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
457 pLed->CurrLedState = LED_STATE_OFF;
458 pLed->BlinkingLedState = LED_STATE_OFF;
459 SwLedOff(padapter, pLed);
461 pLed->bLedScanBlinkInProgress = false;
464 pLed->BlinkingLedState = LED_STATE_OFF;
466 pLed->BlinkingLedState = LED_STATE_ON;
467 mod_timer(&pLed->BlinkTimer, jiffies +
468 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
473 if (pLed->BlinkTimes == 0)
474 bStopBlinking = true;
476 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
477 pLed->CurrLedState = LED_STATE_ON;
478 pLed->BlinkingLedState = LED_STATE_ON;
479 SwLedOn(padapter, pLed);
480 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
481 pLed->CurrLedState = LED_STATE_OFF;
482 pLed->BlinkingLedState = LED_STATE_OFF;
483 SwLedOff(padapter, pLed);
485 pLed->bLedBlinkInProgress = false;
488 pLed->BlinkingLedState = LED_STATE_OFF;
490 pLed->BlinkingLedState = LED_STATE_ON;
491 mod_timer(&pLed->BlinkTimer, jiffies +
492 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
500 static void SwLedBlink3(struct LED_871x *pLed)
502 struct _adapter *padapter = pLed->padapter;
503 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
504 u8 bStopBlinking = false;
506 /* Change LED according to BlinkingLedState specified. */
507 if (pLed->BlinkingLedState == LED_STATE_ON)
508 SwLedOn(padapter, pLed);
510 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
511 SwLedOff(padapter, pLed);
512 switch (pLed->CurrLedState) {
515 if (pLed->BlinkTimes == 0)
516 bStopBlinking = true;
518 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
519 pLed->CurrLedState = LED_STATE_ON;
520 pLed->BlinkingLedState = LED_STATE_ON;
522 SwLedOn(padapter, pLed);
523 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
524 pLed->CurrLedState = LED_STATE_OFF;
525 pLed->BlinkingLedState = LED_STATE_OFF;
527 SwLedOff(padapter, pLed);
529 pLed->bLedScanBlinkInProgress = false;
532 pLed->BlinkingLedState = LED_STATE_OFF;
534 pLed->BlinkingLedState = LED_STATE_ON;
535 mod_timer(&pLed->BlinkTimer, jiffies +
536 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
541 if (pLed->BlinkTimes == 0)
542 bStopBlinking = true;
544 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
545 pLed->CurrLedState = LED_STATE_ON;
546 pLed->BlinkingLedState = LED_STATE_ON;
548 SwLedOn(padapter, pLed);
549 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
550 pLed->CurrLedState = LED_STATE_OFF;
551 pLed->BlinkingLedState = LED_STATE_OFF;
553 SwLedOff(padapter, pLed);
555 pLed->bLedBlinkInProgress = false;
558 pLed->BlinkingLedState = LED_STATE_OFF;
560 pLed->BlinkingLedState = LED_STATE_ON;
561 mod_timer(&pLed->BlinkTimer, jiffies +
562 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
567 pLed->BlinkingLedState = LED_STATE_OFF;
569 pLed->BlinkingLedState = LED_STATE_ON;
570 mod_timer(&pLed->BlinkTimer, jiffies +
571 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
573 case LED_BLINK_WPS_STOP: /*WPS success*/
574 if (pLed->BlinkingLedState == LED_STATE_ON) {
575 pLed->BlinkingLedState = LED_STATE_OFF;
576 mod_timer(&pLed->BlinkTimer, jiffies +
577 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
578 bStopBlinking = false;
580 bStopBlinking = true;
583 pLed->CurrLedState = LED_STATE_ON;
584 pLed->BlinkingLedState = LED_STATE_ON;
585 SwLedOn(padapter, pLed);
586 pLed->bLedWPSBlinkInProgress = false;
594 static void SwLedBlink4(struct LED_871x *pLed)
596 struct _adapter *padapter = pLed->padapter;
597 struct led_priv *ledpriv = &(padapter->ledpriv);
598 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
599 u8 bStopBlinking = false;
601 /* Change LED according to BlinkingLedState specified. */
602 if (pLed->BlinkingLedState == LED_STATE_ON)
603 SwLedOn(padapter, pLed);
605 SwLedOff(padapter, pLed);
606 if (!pLed1->bLedWPSBlinkInProgress &&
607 pLed1->BlinkingLedState == LED_UNKNOWN) {
608 pLed1->BlinkingLedState = LED_STATE_OFF;
609 pLed1->CurrLedState = LED_STATE_OFF;
610 SwLedOff(padapter, pLed1);
612 switch (pLed->CurrLedState) {
613 case LED_BLINK_SLOWLY:
615 pLed->BlinkingLedState = LED_STATE_OFF;
617 pLed->BlinkingLedState = LED_STATE_ON;
618 mod_timer(&pLed->BlinkTimer, jiffies +
619 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
621 case LED_BLINK_StartToBlink:
623 pLed->BlinkingLedState = LED_STATE_OFF;
624 mod_timer(&pLed->BlinkTimer, jiffies +
625 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
627 pLed->BlinkingLedState = LED_STATE_ON;
628 mod_timer(&pLed->BlinkTimer, jiffies +
629 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
634 if (pLed->BlinkTimes == 0)
635 bStopBlinking = true;
637 pLed->bLedNoLinkBlinkInProgress = true;
638 pLed->CurrLedState = LED_BLINK_SLOWLY;
640 pLed->BlinkingLedState = LED_STATE_OFF;
642 pLed->BlinkingLedState = LED_STATE_ON;
643 mod_timer(&pLed->BlinkTimer, jiffies +
644 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
645 pLed->bLedScanBlinkInProgress = false;
648 pLed->BlinkingLedState = LED_STATE_OFF;
650 pLed->BlinkingLedState = LED_STATE_ON;
651 mod_timer(&pLed->BlinkTimer, jiffies +
652 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
657 if (pLed->BlinkTimes == 0)
658 bStopBlinking = true;
660 pLed->bLedNoLinkBlinkInProgress = true;
661 pLed->CurrLedState = LED_BLINK_SLOWLY;
663 pLed->BlinkingLedState = LED_STATE_OFF;
665 pLed->BlinkingLedState = LED_STATE_ON;
666 mod_timer(&pLed->BlinkTimer, jiffies +
667 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
668 pLed->bLedBlinkInProgress = false;
671 pLed->BlinkingLedState = LED_STATE_OFF;
673 pLed->BlinkingLedState = LED_STATE_ON;
674 mod_timer(&pLed->BlinkTimer, jiffies +
675 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
680 pLed->BlinkingLedState = LED_STATE_OFF;
681 mod_timer(&pLed->BlinkTimer, jiffies +
682 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
684 pLed->BlinkingLedState = LED_STATE_ON;
685 mod_timer(&pLed->BlinkTimer, jiffies +
686 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
689 case LED_BLINK_WPS_STOP: /*WPS authentication fail*/
691 pLed->BlinkingLedState = LED_STATE_OFF;
693 pLed->BlinkingLedState = LED_STATE_ON;
694 mod_timer(&pLed->BlinkTimer, jiffies +
695 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
697 case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */
699 if (pLed->BlinkTimes == 0) {
701 pLed->BlinkTimes = 1;
703 bStopBlinking = true;
706 pLed->BlinkTimes = 10;
707 pLed->BlinkingLedState = LED_STATE_ON;
708 mod_timer(&pLed->BlinkTimer, jiffies +
709 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
712 pLed->BlinkingLedState = LED_STATE_OFF;
714 pLed->BlinkingLedState = LED_STATE_ON;
715 mod_timer(&pLed->BlinkTimer, jiffies +
716 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
724 static void SwLedBlink5(struct LED_871x *pLed)
726 struct _adapter *padapter = pLed->padapter;
727 u8 bStopBlinking = false;
729 /* Change LED according to BlinkingLedState specified. */
730 if (pLed->BlinkingLedState == LED_STATE_ON)
731 SwLedOn(padapter, pLed);
733 SwLedOff(padapter, pLed);
734 switch (pLed->CurrLedState) {
737 if (pLed->BlinkTimes == 0)
738 bStopBlinking = true;
740 pLed->CurrLedState = LED_STATE_ON;
741 pLed->BlinkingLedState = LED_STATE_ON;
743 mod_timer(&pLed->BlinkTimer, jiffies +
744 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
745 pLed->bLedScanBlinkInProgress = false;
748 pLed->BlinkingLedState = LED_STATE_OFF;
750 pLed->BlinkingLedState = LED_STATE_ON;
751 mod_timer(&pLed->BlinkTimer, jiffies +
752 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
757 if (pLed->BlinkTimes == 0)
758 bStopBlinking = true;
760 pLed->CurrLedState = LED_STATE_ON;
761 pLed->BlinkingLedState = LED_STATE_ON;
763 mod_timer(&pLed->BlinkTimer, jiffies +
764 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
765 pLed->bLedBlinkInProgress = false;
768 pLed->BlinkingLedState = LED_STATE_OFF;
770 pLed->BlinkingLedState = LED_STATE_ON;
771 mod_timer(&pLed->BlinkTimer, jiffies +
772 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
780 static void SwLedBlink6(struct LED_871x *pLed)
782 struct _adapter *padapter = pLed->padapter;
783 u8 bStopBlinking = false;
785 /* Change LED according to BlinkingLedState specified. */
786 if (pLed->BlinkingLedState == LED_STATE_ON)
787 SwLedOn(padapter, pLed);
789 SwLedOff(padapter, pLed);
790 switch (pLed->CurrLedState) {
793 if (pLed->BlinkTimes == 0)
794 bStopBlinking = true;
796 pLed->CurrLedState = LED_STATE_ON;
797 pLed->BlinkingLedState = LED_STATE_ON;
799 SwLedOn(padapter, pLed);
800 pLed->bLedBlinkInProgress = false;
803 pLed->BlinkingLedState = LED_STATE_OFF;
805 pLed->BlinkingLedState = LED_STATE_ON;
806 mod_timer(&pLed->BlinkTimer, jiffies +
807 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
812 pLed->BlinkingLedState = LED_STATE_OFF;
814 pLed->BlinkingLedState = LED_STATE_ON;
815 mod_timer(&pLed->BlinkTimer, jiffies +
816 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
825 * Callback function of LED BlinkTimer,
826 * it just schedules to corresponding BlinkWorkItem.
828 static void BlinkTimerCallback(unsigned long data)
830 struct LED_871x *pLed = (struct LED_871x *)data;
832 /* This fixed the crash problem on Fedora 12 when trying to do the
833 * insmod;ifconfig up;rmmod commands.
835 if (pLed->padapter->bSurpriseRemoved || pLed->padapter->bDriverStopped)
837 schedule_work(&pLed->BlinkWorkItem);
841 * Callback function of LED BlinkWorkItem.
842 * We dispatch actual LED blink action according to LedStrategy.
844 static void BlinkWorkItemCallback(struct work_struct *work)
846 struct LED_871x *pLed = container_of(work, struct LED_871x,
848 struct led_priv *ledpriv = &(pLed->padapter->ledpriv);
850 switch (ledpriv->LedStrategy) {
878 /*============================================================================
879 * Default LED behavior.
880 *============================================================================
883 * Implement each led action for SW_LED_MODE0.
884 * This is default strategy.
887 static void SwLedControlMode1(struct _adapter *padapter,
888 enum LED_CTL_MODE LedAction)
890 struct led_priv *ledpriv = &(padapter->ledpriv);
891 struct LED_871x *pLed = &(ledpriv->SwLed0);
892 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
893 struct sitesurvey_ctrl *psitesurveyctrl = &(pmlmepriv->sitesurveyctrl);
895 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
896 pLed = &(ledpriv->SwLed1);
898 case LED_CTL_START_TO_LINK:
899 case LED_CTL_NO_LINK:
900 if (!pLed->bLedNoLinkBlinkInProgress) {
901 if (pLed->CurrLedState == LED_SCAN_BLINK ||
902 IS_LED_WPS_BLINKING(pLed))
904 if (pLed->bLedLinkBlinkInProgress) {
905 del_timer(&pLed->BlinkTimer);
906 pLed->bLedLinkBlinkInProgress = false;
908 if (pLed->bLedBlinkInProgress) {
909 del_timer(&pLed->BlinkTimer);
910 pLed->bLedBlinkInProgress = false;
912 pLed->bLedNoLinkBlinkInProgress = true;
913 pLed->CurrLedState = LED_BLINK_SLOWLY;
915 pLed->BlinkingLedState = LED_STATE_OFF;
917 pLed->BlinkingLedState = LED_STATE_ON;
918 mod_timer(&pLed->BlinkTimer, jiffies +
919 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
923 if (!pLed->bLedLinkBlinkInProgress) {
924 if (pLed->CurrLedState == LED_SCAN_BLINK ||
925 IS_LED_WPS_BLINKING(pLed))
927 if (pLed->bLedNoLinkBlinkInProgress) {
928 del_timer(&pLed->BlinkTimer);
929 pLed->bLedNoLinkBlinkInProgress = false;
931 if (pLed->bLedBlinkInProgress) {
932 del_timer(&pLed->BlinkTimer);
933 pLed->bLedBlinkInProgress = false;
935 pLed->bLedLinkBlinkInProgress = true;
936 pLed->CurrLedState = LED_BLINK_NORMAL;
938 pLed->BlinkingLedState = LED_STATE_OFF;
940 pLed->BlinkingLedState = LED_STATE_ON;
941 mod_timer(&pLed->BlinkTimer, jiffies +
942 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
945 case LED_CTL_SITE_SURVEY:
946 if (psitesurveyctrl->traffic_busy &&
947 check_fwstate(pmlmepriv, _FW_LINKED))
949 else if (!pLed->bLedScanBlinkInProgress) {
950 if (IS_LED_WPS_BLINKING(pLed))
952 if (pLed->bLedNoLinkBlinkInProgress) {
953 del_timer(&pLed->BlinkTimer);
954 pLed->bLedNoLinkBlinkInProgress = false;
956 if (pLed->bLedLinkBlinkInProgress) {
957 del_timer(&pLed->BlinkTimer);
958 pLed->bLedLinkBlinkInProgress = false;
960 if (pLed->bLedBlinkInProgress) {
961 del_timer(&pLed->BlinkTimer);
962 pLed->bLedBlinkInProgress = false;
964 pLed->bLedScanBlinkInProgress = true;
965 pLed->CurrLedState = LED_SCAN_BLINK;
966 pLed->BlinkTimes = 24;
968 pLed->BlinkingLedState = LED_STATE_OFF;
970 pLed->BlinkingLedState = LED_STATE_ON;
971 mod_timer(&pLed->BlinkTimer, jiffies +
972 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
977 if (!pLed->bLedBlinkInProgress) {
978 if (pLed->CurrLedState == LED_SCAN_BLINK ||
979 IS_LED_WPS_BLINKING(pLed))
981 if (pLed->bLedNoLinkBlinkInProgress) {
982 del_timer(&pLed->BlinkTimer);
983 pLed->bLedNoLinkBlinkInProgress = false;
985 if (pLed->bLedLinkBlinkInProgress) {
986 del_timer(&pLed->BlinkTimer);
987 pLed->bLedLinkBlinkInProgress = false;
989 pLed->bLedBlinkInProgress = true;
990 pLed->CurrLedState = LED_TXRX_BLINK;
991 pLed->BlinkTimes = 2;
993 pLed->BlinkingLedState = LED_STATE_OFF;
995 pLed->BlinkingLedState = LED_STATE_ON;
996 mod_timer(&pLed->BlinkTimer, jiffies +
997 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1001 case LED_CTL_START_WPS: /*wait until xinpin finish */
1002 case LED_CTL_START_WPS_BOTTON:
1003 if (!pLed->bLedWPSBlinkInProgress) {
1004 if (pLed->bLedNoLinkBlinkInProgress) {
1005 del_timer(&pLed->BlinkTimer);
1006 pLed->bLedNoLinkBlinkInProgress = false;
1008 if (pLed->bLedLinkBlinkInProgress) {
1009 del_timer(&pLed->BlinkTimer);
1010 pLed->bLedLinkBlinkInProgress = false;
1012 if (pLed->bLedBlinkInProgress) {
1013 del_timer(&pLed->BlinkTimer);
1014 pLed->bLedBlinkInProgress = false;
1016 if (pLed->bLedScanBlinkInProgress) {
1017 del_timer(&pLed->BlinkTimer);
1018 pLed->bLedScanBlinkInProgress = false;
1020 pLed->bLedWPSBlinkInProgress = true;
1021 pLed->CurrLedState = LED_BLINK_WPS;
1023 pLed->BlinkingLedState = LED_STATE_OFF;
1025 pLed->BlinkingLedState = LED_STATE_ON;
1026 mod_timer(&pLed->BlinkTimer, jiffies +
1027 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1030 case LED_CTL_STOP_WPS:
1031 if (pLed->bLedNoLinkBlinkInProgress) {
1032 del_timer(&pLed->BlinkTimer);
1033 pLed->bLedNoLinkBlinkInProgress = false;
1035 if (pLed->bLedLinkBlinkInProgress) {
1036 del_timer(&pLed->BlinkTimer);
1037 pLed->bLedLinkBlinkInProgress = false;
1039 if (pLed->bLedBlinkInProgress) {
1040 del_timer(&pLed->BlinkTimer);
1041 pLed->bLedBlinkInProgress = false;
1043 if (pLed->bLedScanBlinkInProgress) {
1044 del_timer(&pLed->BlinkTimer);
1045 pLed->bLedScanBlinkInProgress = false;
1047 if (pLed->bLedWPSBlinkInProgress)
1048 del_timer(&pLed->BlinkTimer);
1050 pLed->bLedWPSBlinkInProgress = true;
1051 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1053 pLed->BlinkingLedState = LED_STATE_OFF;
1054 mod_timer(&pLed->BlinkTimer, jiffies +
1055 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1057 pLed->BlinkingLedState = LED_STATE_ON;
1058 mod_timer(&pLed->BlinkTimer,
1059 jiffies + msecs_to_jiffies(0));
1062 case LED_CTL_STOP_WPS_FAIL:
1063 if (pLed->bLedWPSBlinkInProgress) {
1064 del_timer(&pLed->BlinkTimer);
1065 pLed->bLedWPSBlinkInProgress = false;
1067 pLed->bLedNoLinkBlinkInProgress = true;
1068 pLed->CurrLedState = LED_BLINK_SLOWLY;
1070 pLed->BlinkingLedState = LED_STATE_OFF;
1072 pLed->BlinkingLedState = LED_STATE_ON;
1073 mod_timer(&pLed->BlinkTimer, jiffies +
1074 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1076 case LED_CTL_POWER_OFF:
1077 pLed->CurrLedState = LED_STATE_OFF;
1078 pLed->BlinkingLedState = LED_STATE_OFF;
1079 if (pLed->bLedNoLinkBlinkInProgress) {
1080 del_timer(&pLed->BlinkTimer);
1081 pLed->bLedNoLinkBlinkInProgress = false;
1083 if (pLed->bLedLinkBlinkInProgress) {
1084 del_timer(&pLed->BlinkTimer);
1085 pLed->bLedLinkBlinkInProgress = false;
1087 if (pLed->bLedBlinkInProgress) {
1088 del_timer(&pLed->BlinkTimer);
1089 pLed->bLedBlinkInProgress = false;
1091 if (pLed->bLedWPSBlinkInProgress) {
1092 del_timer(&pLed->BlinkTimer);
1093 pLed->bLedWPSBlinkInProgress = false;
1095 if (pLed->bLedScanBlinkInProgress) {
1096 del_timer(&pLed->BlinkTimer);
1097 pLed->bLedScanBlinkInProgress = false;
1099 mod_timer(&pLed->BlinkTimer,
1100 jiffies + msecs_to_jiffies(0));
1107 static void SwLedControlMode2(struct _adapter *padapter,
1108 enum LED_CTL_MODE LedAction)
1110 struct led_priv *ledpriv = &(padapter->ledpriv);
1111 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1112 struct LED_871x *pLed = &(ledpriv->SwLed0);
1114 switch (LedAction) {
1115 case LED_CTL_SITE_SURVEY:
1116 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1117 ; /* dummy branch */
1118 else if (!pLed->bLedScanBlinkInProgress) {
1119 if (IS_LED_WPS_BLINKING(pLed))
1122 if (pLed->bLedBlinkInProgress) {
1123 del_timer(&pLed->BlinkTimer);
1124 pLed->bLedBlinkInProgress = false;
1126 pLed->bLedScanBlinkInProgress = true;
1127 pLed->CurrLedState = LED_SCAN_BLINK;
1128 pLed->BlinkTimes = 24;
1130 pLed->BlinkingLedState = LED_STATE_OFF;
1132 pLed->BlinkingLedState = LED_STATE_ON;
1133 mod_timer(&pLed->BlinkTimer, jiffies +
1134 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1140 if (!pLed->bLedBlinkInProgress &&
1141 check_fwstate(pmlmepriv, _FW_LINKED)) {
1142 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1143 IS_LED_WPS_BLINKING(pLed))
1145 pLed->bLedBlinkInProgress = true;
1146 pLed->CurrLedState = LED_TXRX_BLINK;
1147 pLed->BlinkTimes = 2;
1149 pLed->BlinkingLedState = LED_STATE_OFF;
1151 pLed->BlinkingLedState = LED_STATE_ON;
1152 mod_timer(&pLed->BlinkTimer, jiffies +
1153 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1158 pLed->CurrLedState = LED_STATE_ON;
1159 pLed->BlinkingLedState = LED_STATE_ON;
1160 if (pLed->bLedBlinkInProgress) {
1161 del_timer(&pLed->BlinkTimer);
1162 pLed->bLedBlinkInProgress = false;
1164 if (pLed->bLedScanBlinkInProgress) {
1165 del_timer(&pLed->BlinkTimer);
1166 pLed->bLedScanBlinkInProgress = false;
1169 mod_timer(&pLed->BlinkTimer,
1170 jiffies + msecs_to_jiffies(0));
1173 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1174 case LED_CTL_START_WPS_BOTTON:
1175 if (!pLed->bLedWPSBlinkInProgress) {
1176 if (pLed->bLedBlinkInProgress) {
1177 del_timer(&pLed->BlinkTimer);
1178 pLed->bLedBlinkInProgress = false;
1180 if (pLed->bLedScanBlinkInProgress) {
1181 del_timer(&pLed->BlinkTimer);
1182 pLed->bLedScanBlinkInProgress = false;
1184 pLed->bLedWPSBlinkInProgress = true;
1185 pLed->CurrLedState = LED_STATE_ON;
1186 pLed->BlinkingLedState = LED_STATE_ON;
1187 mod_timer(&pLed->BlinkTimer,
1188 jiffies + msecs_to_jiffies(0));
1192 case LED_CTL_STOP_WPS:
1193 pLed->bLedWPSBlinkInProgress = false;
1194 pLed->CurrLedState = LED_STATE_ON;
1195 pLed->BlinkingLedState = LED_STATE_ON;
1196 mod_timer(&pLed->BlinkTimer,
1197 jiffies + msecs_to_jiffies(0));
1200 case LED_CTL_STOP_WPS_FAIL:
1201 pLed->bLedWPSBlinkInProgress = false;
1202 pLed->CurrLedState = LED_STATE_OFF;
1203 pLed->BlinkingLedState = LED_STATE_OFF;
1204 mod_timer(&pLed->BlinkTimer,
1205 jiffies + msecs_to_jiffies(0));
1208 case LED_CTL_START_TO_LINK:
1209 case LED_CTL_NO_LINK:
1210 if (!IS_LED_BLINKING(pLed)) {
1211 pLed->CurrLedState = LED_STATE_OFF;
1212 pLed->BlinkingLedState = LED_STATE_OFF;
1213 mod_timer(&pLed->BlinkTimer,
1214 jiffies + msecs_to_jiffies(0));
1217 case LED_CTL_POWER_OFF:
1218 pLed->CurrLedState = LED_STATE_OFF;
1219 pLed->BlinkingLedState = LED_STATE_OFF;
1220 if (pLed->bLedBlinkInProgress) {
1221 del_timer(&pLed->BlinkTimer);
1222 pLed->bLedBlinkInProgress = false;
1224 if (pLed->bLedScanBlinkInProgress) {
1225 del_timer(&pLed->BlinkTimer);
1226 pLed->bLedScanBlinkInProgress = false;
1228 if (pLed->bLedWPSBlinkInProgress) {
1229 del_timer(&pLed->BlinkTimer);
1230 pLed->bLedWPSBlinkInProgress = false;
1232 mod_timer(&pLed->BlinkTimer,
1233 jiffies + msecs_to_jiffies(0));
1240 static void SwLedControlMode3(struct _adapter *padapter,
1241 enum LED_CTL_MODE LedAction)
1243 struct led_priv *ledpriv = &(padapter->ledpriv);
1244 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1245 struct LED_871x *pLed = &(ledpriv->SwLed0);
1247 switch (LedAction) {
1248 case LED_CTL_SITE_SURVEY:
1249 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1250 ; /* dummy branch */
1251 else if (!pLed->bLedScanBlinkInProgress) {
1252 if (IS_LED_WPS_BLINKING(pLed))
1254 if (pLed->bLedBlinkInProgress) {
1255 del_timer(&pLed->BlinkTimer);
1256 pLed->bLedBlinkInProgress = false;
1258 pLed->bLedScanBlinkInProgress = true;
1259 pLed->CurrLedState = LED_SCAN_BLINK;
1260 pLed->BlinkTimes = 24;
1262 pLed->BlinkingLedState = LED_STATE_OFF;
1264 pLed->BlinkingLedState = LED_STATE_ON;
1265 mod_timer(&pLed->BlinkTimer, jiffies +
1266 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1271 if (!pLed->bLedBlinkInProgress &&
1272 check_fwstate(pmlmepriv, _FW_LINKED)) {
1273 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1274 IS_LED_WPS_BLINKING(pLed))
1276 pLed->bLedBlinkInProgress = true;
1277 pLed->CurrLedState = LED_TXRX_BLINK;
1278 pLed->BlinkTimes = 2;
1280 pLed->BlinkingLedState = LED_STATE_OFF;
1282 pLed->BlinkingLedState = LED_STATE_ON;
1283 mod_timer(&pLed->BlinkTimer, jiffies +
1284 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1288 if (IS_LED_WPS_BLINKING(pLed))
1290 pLed->CurrLedState = LED_STATE_ON;
1291 pLed->BlinkingLedState = LED_STATE_ON;
1292 if (pLed->bLedBlinkInProgress) {
1293 del_timer(&pLed->BlinkTimer);
1294 pLed->bLedBlinkInProgress = false;
1296 if (pLed->bLedScanBlinkInProgress) {
1297 del_timer(&pLed->BlinkTimer);
1298 pLed->bLedScanBlinkInProgress = false;
1300 mod_timer(&pLed->BlinkTimer,
1301 jiffies + msecs_to_jiffies(0));
1303 case LED_CTL_START_WPS: /* wait until xinpin finish */
1304 case LED_CTL_START_WPS_BOTTON:
1305 if (!pLed->bLedWPSBlinkInProgress) {
1306 if (pLed->bLedBlinkInProgress) {
1307 del_timer(&pLed->BlinkTimer);
1308 pLed->bLedBlinkInProgress = false;
1310 if (pLed->bLedScanBlinkInProgress) {
1311 del_timer(&pLed->BlinkTimer);
1312 pLed->bLedScanBlinkInProgress = false;
1314 pLed->bLedWPSBlinkInProgress = true;
1315 pLed->CurrLedState = LED_BLINK_WPS;
1317 pLed->BlinkingLedState = LED_STATE_OFF;
1319 pLed->BlinkingLedState = LED_STATE_ON;
1320 mod_timer(&pLed->BlinkTimer, jiffies +
1321 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1324 case LED_CTL_STOP_WPS:
1325 if (pLed->bLedWPSBlinkInProgress) {
1326 del_timer(&pLed->BlinkTimer);
1327 pLed->bLedWPSBlinkInProgress = false;
1329 pLed->bLedWPSBlinkInProgress = true;
1331 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1333 pLed->BlinkingLedState = LED_STATE_OFF;
1334 mod_timer(&pLed->BlinkTimer, jiffies +
1335 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1337 pLed->BlinkingLedState = LED_STATE_ON;
1338 mod_timer(&pLed->BlinkTimer,
1339 jiffies + msecs_to_jiffies(0));
1342 case LED_CTL_STOP_WPS_FAIL:
1343 if (pLed->bLedWPSBlinkInProgress) {
1344 del_timer(&pLed->BlinkTimer);
1345 pLed->bLedWPSBlinkInProgress = false;
1347 pLed->CurrLedState = LED_STATE_OFF;
1348 pLed->BlinkingLedState = LED_STATE_OFF;
1349 mod_timer(&pLed->BlinkTimer,
1350 jiffies + msecs_to_jiffies(0));
1352 case LED_CTL_START_TO_LINK:
1353 case LED_CTL_NO_LINK:
1354 if (!IS_LED_BLINKING(pLed)) {
1355 pLed->CurrLedState = LED_STATE_OFF;
1356 pLed->BlinkingLedState = LED_STATE_OFF;
1357 mod_timer(&pLed->BlinkTimer,
1358 jiffies + msecs_to_jiffies(0));
1361 case LED_CTL_POWER_OFF:
1362 pLed->CurrLedState = LED_STATE_OFF;
1363 pLed->BlinkingLedState = LED_STATE_OFF;
1364 if (pLed->bLedBlinkInProgress) {
1365 del_timer(&pLed->BlinkTimer);
1366 pLed->bLedBlinkInProgress = false;
1368 if (pLed->bLedScanBlinkInProgress) {
1369 del_timer(&pLed->BlinkTimer);
1370 pLed->bLedScanBlinkInProgress = false;
1372 if (pLed->bLedWPSBlinkInProgress) {
1373 del_timer(&pLed->BlinkTimer);
1374 pLed->bLedWPSBlinkInProgress = false;
1376 mod_timer(&pLed->BlinkTimer,
1377 jiffies + msecs_to_jiffies(0));
1384 static void SwLedControlMode4(struct _adapter *padapter,
1385 enum LED_CTL_MODE LedAction)
1387 struct led_priv *ledpriv = &(padapter->ledpriv);
1388 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1389 struct LED_871x *pLed = &(ledpriv->SwLed0);
1390 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
1392 switch (LedAction) {
1393 case LED_CTL_START_TO_LINK:
1394 if (pLed1->bLedWPSBlinkInProgress) {
1395 pLed1->bLedWPSBlinkInProgress = false;
1396 del_timer(&pLed1->BlinkTimer);
1397 pLed1->BlinkingLedState = LED_STATE_OFF;
1398 pLed1->CurrLedState = LED_STATE_OFF;
1400 mod_timer(&pLed->BlinkTimer,
1401 jiffies + msecs_to_jiffies(0));
1403 if (!pLed->bLedStartToLinkBlinkInProgress) {
1404 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1405 IS_LED_WPS_BLINKING(pLed))
1407 if (pLed->bLedBlinkInProgress) {
1408 del_timer(&pLed->BlinkTimer);
1409 pLed->bLedBlinkInProgress = false;
1411 if (pLed->bLedNoLinkBlinkInProgress) {
1412 del_timer(&pLed->BlinkTimer);
1413 pLed->bLedNoLinkBlinkInProgress = false;
1415 pLed->bLedStartToLinkBlinkInProgress = true;
1416 pLed->CurrLedState = LED_BLINK_StartToBlink;
1418 pLed->BlinkingLedState = LED_STATE_OFF;
1419 mod_timer(&pLed->BlinkTimer, jiffies +
1420 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1422 pLed->BlinkingLedState = LED_STATE_ON;
1423 mod_timer(&pLed->BlinkTimer, jiffies +
1424 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1429 case LED_CTL_NO_LINK:
1431 if (LedAction == LED_CTL_LINK) {
1432 if (pLed1->bLedWPSBlinkInProgress) {
1433 pLed1->bLedWPSBlinkInProgress = false;
1434 del_timer(&pLed1->BlinkTimer);
1435 pLed1->BlinkingLedState = LED_STATE_OFF;
1436 pLed1->CurrLedState = LED_STATE_OFF;
1438 mod_timer(&pLed->BlinkTimer,
1439 jiffies + msecs_to_jiffies(0));
1442 if (!pLed->bLedNoLinkBlinkInProgress) {
1443 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1444 IS_LED_WPS_BLINKING(pLed))
1446 if (pLed->bLedBlinkInProgress) {
1447 del_timer(&pLed->BlinkTimer);
1448 pLed->bLedBlinkInProgress = false;
1450 pLed->bLedNoLinkBlinkInProgress = true;
1451 pLed->CurrLedState = LED_BLINK_SLOWLY;
1453 pLed->BlinkingLedState = LED_STATE_OFF;
1455 pLed->BlinkingLedState = LED_STATE_ON;
1456 mod_timer(&pLed->BlinkTimer, jiffies +
1457 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1460 case LED_CTL_SITE_SURVEY:
1461 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1462 check_fwstate(pmlmepriv, _FW_LINKED))
1464 else if (!pLed->bLedScanBlinkInProgress) {
1465 if (IS_LED_WPS_BLINKING(pLed))
1467 if (pLed->bLedNoLinkBlinkInProgress) {
1468 del_timer(&pLed->BlinkTimer);
1469 pLed->bLedNoLinkBlinkInProgress = false;
1471 if (pLed->bLedBlinkInProgress) {
1472 del_timer(&pLed->BlinkTimer);
1473 pLed->bLedBlinkInProgress = false;
1475 pLed->bLedScanBlinkInProgress = true;
1476 pLed->CurrLedState = LED_SCAN_BLINK;
1477 pLed->BlinkTimes = 24;
1479 pLed->BlinkingLedState = LED_STATE_OFF;
1481 pLed->BlinkingLedState = LED_STATE_ON;
1482 mod_timer(&pLed->BlinkTimer, jiffies +
1483 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1488 if (!pLed->bLedBlinkInProgress) {
1489 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1490 IS_LED_WPS_BLINKING(pLed))
1492 if (pLed->bLedNoLinkBlinkInProgress) {
1493 del_timer(&pLed->BlinkTimer);
1494 pLed->bLedNoLinkBlinkInProgress = false;
1496 pLed->bLedBlinkInProgress = true;
1497 pLed->CurrLedState = LED_TXRX_BLINK;
1498 pLed->BlinkTimes = 2;
1500 pLed->BlinkingLedState = LED_STATE_OFF;
1502 pLed->BlinkingLedState = LED_STATE_ON;
1503 mod_timer(&pLed->BlinkTimer, jiffies +
1504 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1507 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1508 case LED_CTL_START_WPS_BOTTON:
1509 if (pLed1->bLedWPSBlinkInProgress) {
1510 pLed1->bLedWPSBlinkInProgress = false;
1511 del_timer(&pLed1->BlinkTimer);
1512 pLed1->BlinkingLedState = LED_STATE_OFF;
1513 pLed1->CurrLedState = LED_STATE_OFF;
1515 mod_timer(&pLed->BlinkTimer,
1516 jiffies + msecs_to_jiffies(0));
1518 if (!pLed->bLedWPSBlinkInProgress) {
1519 if (pLed->bLedNoLinkBlinkInProgress) {
1520 del_timer(&pLed->BlinkTimer);
1521 pLed->bLedNoLinkBlinkInProgress = false;
1523 if (pLed->bLedBlinkInProgress) {
1524 del_timer(&pLed->BlinkTimer);
1525 pLed->bLedBlinkInProgress = false;
1527 if (pLed->bLedScanBlinkInProgress) {
1528 del_timer(&pLed->BlinkTimer);
1529 pLed->bLedScanBlinkInProgress = false;
1531 pLed->bLedWPSBlinkInProgress = true;
1532 pLed->CurrLedState = LED_BLINK_WPS;
1534 pLed->BlinkingLedState = LED_STATE_OFF;
1535 mod_timer(&pLed->BlinkTimer, jiffies +
1536 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1538 pLed->BlinkingLedState = LED_STATE_ON;
1539 mod_timer(&pLed->BlinkTimer, jiffies +
1540 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1544 case LED_CTL_STOP_WPS: /*WPS connect success*/
1545 if (pLed->bLedWPSBlinkInProgress) {
1546 del_timer(&pLed->BlinkTimer);
1547 pLed->bLedWPSBlinkInProgress = false;
1549 pLed->bLedNoLinkBlinkInProgress = true;
1550 pLed->CurrLedState = LED_BLINK_SLOWLY;
1552 pLed->BlinkingLedState = LED_STATE_OFF;
1554 pLed->BlinkingLedState = LED_STATE_ON;
1555 mod_timer(&pLed->BlinkTimer, jiffies +
1556 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1558 case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/
1559 if (pLed->bLedWPSBlinkInProgress) {
1560 del_timer(&pLed->BlinkTimer);
1561 pLed->bLedWPSBlinkInProgress = false;
1563 pLed->bLedNoLinkBlinkInProgress = true;
1564 pLed->CurrLedState = LED_BLINK_SLOWLY;
1566 pLed->BlinkingLedState = LED_STATE_OFF;
1568 pLed->BlinkingLedState = LED_STATE_ON;
1569 mod_timer(&pLed->BlinkTimer, jiffies +
1570 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1572 if (pLed1->bLedWPSBlinkInProgress)
1573 del_timer(&pLed1->BlinkTimer);
1575 pLed1->bLedWPSBlinkInProgress = true;
1576 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1578 pLed1->BlinkingLedState = LED_STATE_OFF;
1580 pLed1->BlinkingLedState = LED_STATE_ON;
1581 mod_timer(&pLed->BlinkTimer, jiffies +
1582 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1584 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/
1585 if (pLed->bLedWPSBlinkInProgress) {
1586 del_timer(&pLed->BlinkTimer);
1587 pLed->bLedWPSBlinkInProgress = false;
1589 pLed->bLedNoLinkBlinkInProgress = true;
1590 pLed->CurrLedState = LED_BLINK_SLOWLY;
1592 pLed->BlinkingLedState = LED_STATE_OFF;
1594 pLed->BlinkingLedState = LED_STATE_ON;
1595 mod_timer(&pLed->BlinkTimer, jiffies +
1596 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1598 if (pLed1->bLedWPSBlinkInProgress)
1599 del_timer(&pLed1->BlinkTimer);
1601 pLed1->bLedWPSBlinkInProgress = true;
1602 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1603 pLed1->BlinkTimes = 10;
1605 pLed1->BlinkingLedState = LED_STATE_OFF;
1607 pLed1->BlinkingLedState = LED_STATE_ON;
1608 mod_timer(&pLed->BlinkTimer, jiffies +
1609 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1611 case LED_CTL_POWER_OFF:
1612 pLed->CurrLedState = LED_STATE_OFF;
1613 pLed->BlinkingLedState = LED_STATE_OFF;
1614 if (pLed->bLedNoLinkBlinkInProgress) {
1615 del_timer(&pLed->BlinkTimer);
1616 pLed->bLedNoLinkBlinkInProgress = false;
1618 if (pLed->bLedLinkBlinkInProgress) {
1619 del_timer(&pLed->BlinkTimer);
1620 pLed->bLedLinkBlinkInProgress = false;
1622 if (pLed->bLedBlinkInProgress) {
1623 del_timer(&pLed->BlinkTimer);
1624 pLed->bLedBlinkInProgress = false;
1626 if (pLed->bLedWPSBlinkInProgress) {
1627 del_timer(&pLed->BlinkTimer);
1628 pLed->bLedWPSBlinkInProgress = false;
1630 if (pLed->bLedScanBlinkInProgress) {
1631 del_timer(&pLed->BlinkTimer);
1632 pLed->bLedScanBlinkInProgress = false;
1634 if (pLed->bLedStartToLinkBlinkInProgress) {
1635 del_timer(&pLed->BlinkTimer);
1636 pLed->bLedStartToLinkBlinkInProgress = false;
1638 if (pLed1->bLedWPSBlinkInProgress) {
1639 del_timer(&pLed1->BlinkTimer);
1640 pLed1->bLedWPSBlinkInProgress = false;
1642 pLed1->BlinkingLedState = LED_UNKNOWN;
1643 SwLedOff(padapter, pLed);
1644 SwLedOff(padapter, pLed1);
1651 static void SwLedControlMode5(struct _adapter *padapter,
1652 enum LED_CTL_MODE LedAction)
1654 struct led_priv *ledpriv = &(padapter->ledpriv);
1655 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1656 struct LED_871x *pLed = &(ledpriv->SwLed0);
1658 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1659 pLed = &(ledpriv->SwLed1);
1661 switch (LedAction) {
1662 case LED_CTL_POWER_ON:
1663 case LED_CTL_NO_LINK:
1664 case LED_CTL_LINK: /* solid blue */
1665 if (pLed->CurrLedState == LED_SCAN_BLINK)
1667 pLed->CurrLedState = LED_STATE_ON;
1668 pLed->BlinkingLedState = LED_STATE_ON;
1669 pLed->bLedBlinkInProgress = false;
1670 mod_timer(&pLed->BlinkTimer,
1671 jiffies + msecs_to_jiffies(0));
1673 case LED_CTL_SITE_SURVEY:
1674 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1675 check_fwstate(pmlmepriv, _FW_LINKED))
1676 ; /* dummy branch */
1677 else if (!pLed->bLedScanBlinkInProgress) {
1678 if (pLed->bLedBlinkInProgress) {
1679 del_timer(&pLed->BlinkTimer);
1680 pLed->bLedBlinkInProgress = false;
1682 pLed->bLedScanBlinkInProgress = true;
1683 pLed->CurrLedState = LED_SCAN_BLINK;
1684 pLed->BlinkTimes = 24;
1686 pLed->BlinkingLedState = LED_STATE_OFF;
1688 pLed->BlinkingLedState = LED_STATE_ON;
1689 mod_timer(&pLed->BlinkTimer, jiffies +
1690 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1695 if (!pLed->bLedBlinkInProgress) {
1696 if (pLed->CurrLedState == LED_SCAN_BLINK)
1698 pLed->bLedBlinkInProgress = true;
1699 pLed->CurrLedState = LED_TXRX_BLINK;
1700 pLed->BlinkTimes = 2;
1702 pLed->BlinkingLedState = LED_STATE_OFF;
1704 pLed->BlinkingLedState = LED_STATE_ON;
1705 mod_timer(&pLed->BlinkTimer, jiffies +
1706 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1709 case LED_CTL_POWER_OFF:
1710 pLed->CurrLedState = LED_STATE_OFF;
1711 pLed->BlinkingLedState = LED_STATE_OFF;
1712 if (pLed->bLedBlinkInProgress) {
1713 del_timer(&pLed->BlinkTimer);
1714 pLed->bLedBlinkInProgress = false;
1716 SwLedOff(padapter, pLed);
1724 static void SwLedControlMode6(struct _adapter *padapter,
1725 enum LED_CTL_MODE LedAction)
1727 struct led_priv *ledpriv = &(padapter->ledpriv);
1728 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1729 struct LED_871x *pLed = &(ledpriv->SwLed0);
1731 switch (LedAction) {
1732 case LED_CTL_POWER_ON:
1733 case LED_CTL_NO_LINK:
1734 case LED_CTL_LINK: /*solid blue*/
1735 case LED_CTL_SITE_SURVEY:
1736 if (IS_LED_WPS_BLINKING(pLed))
1738 pLed->CurrLedState = LED_STATE_ON;
1739 pLed->BlinkingLedState = LED_STATE_ON;
1740 pLed->bLedBlinkInProgress = false;
1741 mod_timer(&(pLed->BlinkTimer), jiffies + msecs_to_jiffies(0));
1745 if (!pLed->bLedBlinkInProgress &&
1746 check_fwstate(pmlmepriv, _FW_LINKED)) {
1747 if (IS_LED_WPS_BLINKING(pLed))
1749 pLed->bLedBlinkInProgress = true;
1750 pLed->CurrLedState = LED_TXRX_BLINK;
1751 pLed->BlinkTimes = 2;
1753 pLed->BlinkingLedState = LED_STATE_OFF;
1755 pLed->BlinkingLedState = LED_STATE_ON;
1756 mod_timer(&pLed->BlinkTimer, jiffies +
1757 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1760 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1761 case LED_CTL_START_WPS_BOTTON:
1762 if (!pLed->bLedWPSBlinkInProgress) {
1763 if (pLed->bLedBlinkInProgress) {
1764 del_timer(&pLed->BlinkTimer);
1765 pLed->bLedBlinkInProgress = false;
1767 pLed->bLedWPSBlinkInProgress = true;
1768 pLed->CurrLedState = LED_BLINK_WPS;
1770 pLed->BlinkingLedState = LED_STATE_OFF;
1772 pLed->BlinkingLedState = LED_STATE_ON;
1773 mod_timer(&pLed->BlinkTimer, jiffies +
1774 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1777 case LED_CTL_STOP_WPS_FAIL:
1778 case LED_CTL_STOP_WPS:
1779 if (pLed->bLedWPSBlinkInProgress) {
1780 del_timer(&pLed->BlinkTimer);
1781 pLed->bLedWPSBlinkInProgress = false;
1783 pLed->CurrLedState = LED_STATE_ON;
1784 pLed->BlinkingLedState = LED_STATE_ON;
1785 mod_timer(&pLed->BlinkTimer,
1786 jiffies + msecs_to_jiffies(0));
1788 case LED_CTL_POWER_OFF:
1789 pLed->CurrLedState = LED_STATE_OFF;
1790 pLed->BlinkingLedState = LED_STATE_OFF;
1791 if (pLed->bLedBlinkInProgress) {
1792 del_timer(&pLed->BlinkTimer);
1793 pLed->bLedBlinkInProgress = false;
1795 if (pLed->bLedWPSBlinkInProgress) {
1796 del_timer(&pLed->BlinkTimer);
1797 pLed->bLedWPSBlinkInProgress = false;
1799 SwLedOff(padapter, pLed);
1807 * Dispatch LED action according to pHalData->LedStrategy.
1809 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1811 struct led_priv *ledpriv = &(padapter->ledpriv);
1813 if (!ledpriv->bRegUseLed)
1815 switch (ledpriv->LedStrategy) {
1819 SwLedControlMode1(padapter, LedAction);
1822 SwLedControlMode2(padapter, LedAction);
1825 SwLedControlMode3(padapter, LedAction);
1828 SwLedControlMode4(padapter, LedAction);
1831 SwLedControlMode5(padapter, LedAction);
1834 SwLedControlMode6(padapter, LedAction);