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(struct timer_list *t);
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 timer_setup(&pLed->BlinkTimer, BlinkTimerCallback, 0);
103 INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback);
108 * DeInitialize an LED_871x object.
110 static void DeInitLed871x(struct LED_871x *pLed)
112 del_timer_sync(&pLed->BlinkTimer);
113 /* We should reset bLedBlinkInProgress if we cancel
114 * the LedControlTimer,
116 pLed->bLedBlinkInProgress = false;
121 * Turn on LED according to LedPin specified.
123 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
127 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
129 LedCfg = r8712_read8(padapter, LEDCFG);
130 switch (pLed->LedPin) {
134 /* SW control led0 on.*/
135 r8712_write8(padapter, LEDCFG, LedCfg & 0xf0);
138 /* SW control led1 on.*/
139 r8712_write8(padapter, LEDCFG, LedCfg & 0x0f);
149 * Turn off LED according to LedPin specified.
151 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
155 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
157 LedCfg = r8712_read8(padapter, LEDCFG);
158 switch (pLed->LedPin) {
162 LedCfg &= 0xf0; /* Set to software control.*/
163 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3)));
166 LedCfg &= 0x0f; /* Set to software control.*/
167 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7)));
172 pLed->bLedOn = false;
175 /*===========================================================================
176 * Interface to manipulate LED objects.
177 *===========================================================================
180 * Initialize all LED_871x objects.
182 void r8712_InitSwLeds(struct _adapter *padapter)
184 struct led_priv *pledpriv = &(padapter->ledpriv);
186 pledpriv->LedControlHandler = LedControl871x;
187 InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
188 InitLed871x(padapter, &(pledpriv->SwLed1), LED_PIN_LED1);
192 * DeInitialize all LED_819xUsb objects.
194 void r8712_DeInitSwLeds(struct _adapter *padapter)
196 struct led_priv *ledpriv = &(padapter->ledpriv);
198 DeInitLed871x(&(ledpriv->SwLed0));
199 DeInitLed871x(&(ledpriv->SwLed1));
203 * Implementation of LED blinking behavior.
204 * It toggle off LED and schedule corresponding timer if necessary.
206 static void SwLedBlink(struct LED_871x *pLed)
208 struct _adapter *padapter = pLed->padapter;
209 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
210 u8 bStopBlinking = false;
212 /* Change LED according to BlinkingLedState specified. */
213 if (pLed->BlinkingLedState == LED_STATE_ON)
214 SwLedOn(padapter, pLed);
216 SwLedOff(padapter, pLed);
217 /* Determine if we shall change LED state again. */
219 switch (pLed->CurrLedState) {
220 case LED_BLINK_NORMAL:
221 if (pLed->BlinkTimes == 0)
222 bStopBlinking = true;
224 case LED_BLINK_StartToBlink:
225 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
226 (pmlmepriv->fw_state & WIFI_STATION_STATE))
227 bStopBlinking = true;
228 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
229 ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
230 (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
231 bStopBlinking = true;
232 else if (pLed->BlinkTimes == 0)
233 bStopBlinking = true;
236 if (pLed->BlinkTimes == 0)
237 bStopBlinking = true;
240 bStopBlinking = true;
244 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
246 SwLedOn(padapter, pLed);
247 else if (check_fwstate(pmlmepriv, _FW_LINKED) && pLed->bLedOn)
248 SwLedOff(padapter, pLed);
249 pLed->BlinkTimes = 0;
250 pLed->bLedBlinkInProgress = false;
252 /* Assign LED state to toggle. */
253 if (pLed->BlinkingLedState == LED_STATE_ON)
254 pLed->BlinkingLedState = LED_STATE_OFF;
256 pLed->BlinkingLedState = LED_STATE_ON;
258 /* Schedule a timer to toggle LED state. */
259 switch (pLed->CurrLedState) {
260 case LED_BLINK_NORMAL:
261 mod_timer(&pLed->BlinkTimer, jiffies +
262 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
264 case LED_BLINK_SLOWLY:
265 case LED_BLINK_StartToBlink:
266 mod_timer(&pLed->BlinkTimer, jiffies +
267 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
270 mod_timer(&pLed->BlinkTimer, jiffies +
271 msecs_to_jiffies(LED_BLINK_LONG_INTERVAL));
274 mod_timer(&pLed->BlinkTimer, jiffies +
275 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
281 static void SwLedBlink1(struct LED_871x *pLed)
283 struct _adapter *padapter = pLed->padapter;
284 struct led_priv *ledpriv = &(padapter->ledpriv);
285 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
286 struct eeprom_priv *peeprompriv = &(padapter->eeprompriv);
287 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
288 u8 bStopBlinking = false;
290 if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
291 pLed = &(ledpriv->SwLed1);
292 /* Change LED according to BlinkingLedState specified. */
293 if (pLed->BlinkingLedState == LED_STATE_ON)
294 SwLedOn(padapter, pLed);
296 SwLedOff(padapter, pLed);
297 if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
298 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
299 if (!pLed1->bSWLedCtrl) {
300 SwLedOn(padapter, pLed1);
301 pLed1->bSWLedCtrl = true;
302 } else if (!pLed1->bLedOn) {
303 SwLedOn(padapter, pLed1);
306 if (!pLed1->bSWLedCtrl) {
307 SwLedOff(padapter, pLed1);
308 pLed1->bSWLedCtrl = true;
309 } else if (pLed1->bLedOn) {
310 SwLedOff(padapter, pLed1);
314 switch (pLed->CurrLedState) {
315 case LED_BLINK_SLOWLY:
317 pLed->BlinkingLedState = LED_STATE_OFF;
319 pLed->BlinkingLedState = LED_STATE_ON;
320 mod_timer(&pLed->BlinkTimer, jiffies +
321 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
323 case LED_BLINK_NORMAL:
325 pLed->BlinkingLedState = LED_STATE_OFF;
327 pLed->BlinkingLedState = LED_STATE_ON;
328 mod_timer(&pLed->BlinkTimer, jiffies +
329 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
333 if (pLed->BlinkTimes == 0)
334 bStopBlinking = true;
336 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
337 pLed->bLedLinkBlinkInProgress = true;
338 pLed->CurrLedState = LED_BLINK_NORMAL;
340 pLed->BlinkingLedState = LED_STATE_OFF;
342 pLed->BlinkingLedState = LED_STATE_ON;
343 mod_timer(&pLed->BlinkTimer, jiffies +
344 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
345 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
346 pLed->bLedNoLinkBlinkInProgress = true;
347 pLed->CurrLedState = LED_BLINK_SLOWLY;
349 pLed->BlinkingLedState = LED_STATE_OFF;
351 pLed->BlinkingLedState = LED_STATE_ON;
352 mod_timer(&pLed->BlinkTimer, jiffies +
353 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
355 pLed->bLedScanBlinkInProgress = false;
358 pLed->BlinkingLedState = LED_STATE_OFF;
360 pLed->BlinkingLedState = LED_STATE_ON;
361 mod_timer(&pLed->BlinkTimer, jiffies +
362 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
367 if (pLed->BlinkTimes == 0)
368 bStopBlinking = true;
370 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
371 pLed->bLedLinkBlinkInProgress = true;
372 pLed->CurrLedState = LED_BLINK_NORMAL;
374 pLed->BlinkingLedState = LED_STATE_OFF;
376 pLed->BlinkingLedState = LED_STATE_ON;
377 mod_timer(&pLed->BlinkTimer, jiffies +
378 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
379 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
380 pLed->bLedNoLinkBlinkInProgress = true;
381 pLed->CurrLedState = LED_BLINK_SLOWLY;
383 pLed->BlinkingLedState = LED_STATE_OFF;
385 pLed->BlinkingLedState = LED_STATE_ON;
386 mod_timer(&pLed->BlinkTimer, jiffies +
387 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
389 pLed->BlinkTimes = 0;
390 pLed->bLedBlinkInProgress = false;
393 pLed->BlinkingLedState = LED_STATE_OFF;
395 pLed->BlinkingLedState = LED_STATE_ON;
396 mod_timer(&pLed->BlinkTimer, jiffies +
397 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
402 pLed->BlinkingLedState = LED_STATE_OFF;
404 pLed->BlinkingLedState = LED_STATE_ON;
405 mod_timer(&pLed->BlinkTimer, jiffies +
406 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
408 case LED_BLINK_WPS_STOP: /* WPS success */
409 if (pLed->BlinkingLedState == LED_STATE_ON) {
410 pLed->BlinkingLedState = LED_STATE_OFF;
411 mod_timer(&pLed->BlinkTimer, jiffies +
412 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
413 bStopBlinking = false;
415 bStopBlinking = true;
418 pLed->bLedLinkBlinkInProgress = true;
419 pLed->CurrLedState = LED_BLINK_NORMAL;
421 pLed->BlinkingLedState = LED_STATE_OFF;
423 pLed->BlinkingLedState = LED_STATE_ON;
424 mod_timer(&pLed->BlinkTimer, jiffies +
425 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
427 pLed->bLedWPSBlinkInProgress = false;
434 static void SwLedBlink2(struct LED_871x *pLed)
436 struct _adapter *padapter = pLed->padapter;
437 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
438 u8 bStopBlinking = false;
440 /* Change LED according to BlinkingLedState specified. */
441 if (pLed->BlinkingLedState == LED_STATE_ON)
442 SwLedOn(padapter, pLed);
444 SwLedOff(padapter, pLed);
445 switch (pLed->CurrLedState) {
448 if (pLed->BlinkTimes == 0)
449 bStopBlinking = true;
451 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
452 pLed->CurrLedState = LED_STATE_ON;
453 pLed->BlinkingLedState = LED_STATE_ON;
454 SwLedOn(padapter, pLed);
455 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
456 pLed->CurrLedState = LED_STATE_OFF;
457 pLed->BlinkingLedState = LED_STATE_OFF;
458 SwLedOff(padapter, pLed);
460 pLed->bLedScanBlinkInProgress = false;
463 pLed->BlinkingLedState = LED_STATE_OFF;
465 pLed->BlinkingLedState = LED_STATE_ON;
466 mod_timer(&pLed->BlinkTimer, jiffies +
467 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
472 if (pLed->BlinkTimes == 0)
473 bStopBlinking = true;
475 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
476 pLed->CurrLedState = LED_STATE_ON;
477 pLed->BlinkingLedState = LED_STATE_ON;
478 SwLedOn(padapter, pLed);
479 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
480 pLed->CurrLedState = LED_STATE_OFF;
481 pLed->BlinkingLedState = LED_STATE_OFF;
482 SwLedOff(padapter, pLed);
484 pLed->bLedBlinkInProgress = false;
487 pLed->BlinkingLedState = LED_STATE_OFF;
489 pLed->BlinkingLedState = LED_STATE_ON;
490 mod_timer(&pLed->BlinkTimer, jiffies +
491 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
499 static void SwLedBlink3(struct LED_871x *pLed)
501 struct _adapter *padapter = pLed->padapter;
502 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
503 u8 bStopBlinking = false;
505 /* Change LED according to BlinkingLedState specified. */
506 if (pLed->BlinkingLedState == LED_STATE_ON)
507 SwLedOn(padapter, pLed);
509 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
510 SwLedOff(padapter, pLed);
511 switch (pLed->CurrLedState) {
514 if (pLed->BlinkTimes == 0)
515 bStopBlinking = true;
517 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
518 pLed->CurrLedState = LED_STATE_ON;
519 pLed->BlinkingLedState = LED_STATE_ON;
521 SwLedOn(padapter, pLed);
522 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
523 pLed->CurrLedState = LED_STATE_OFF;
524 pLed->BlinkingLedState = LED_STATE_OFF;
526 SwLedOff(padapter, pLed);
528 pLed->bLedScanBlinkInProgress = false;
531 pLed->BlinkingLedState = LED_STATE_OFF;
533 pLed->BlinkingLedState = LED_STATE_ON;
534 mod_timer(&pLed->BlinkTimer, jiffies +
535 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
540 if (pLed->BlinkTimes == 0)
541 bStopBlinking = true;
543 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
544 pLed->CurrLedState = LED_STATE_ON;
545 pLed->BlinkingLedState = LED_STATE_ON;
547 SwLedOn(padapter, pLed);
548 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
549 pLed->CurrLedState = LED_STATE_OFF;
550 pLed->BlinkingLedState = LED_STATE_OFF;
552 SwLedOff(padapter, pLed);
554 pLed->bLedBlinkInProgress = false;
557 pLed->BlinkingLedState = LED_STATE_OFF;
559 pLed->BlinkingLedState = LED_STATE_ON;
560 mod_timer(&pLed->BlinkTimer, jiffies +
561 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
566 pLed->BlinkingLedState = LED_STATE_OFF;
568 pLed->BlinkingLedState = LED_STATE_ON;
569 mod_timer(&pLed->BlinkTimer, jiffies +
570 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
572 case LED_BLINK_WPS_STOP: /*WPS success*/
573 if (pLed->BlinkingLedState == LED_STATE_ON) {
574 pLed->BlinkingLedState = LED_STATE_OFF;
575 mod_timer(&pLed->BlinkTimer, jiffies +
576 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
577 bStopBlinking = false;
579 bStopBlinking = true;
582 pLed->CurrLedState = LED_STATE_ON;
583 pLed->BlinkingLedState = LED_STATE_ON;
584 SwLedOn(padapter, pLed);
585 pLed->bLedWPSBlinkInProgress = false;
593 static void SwLedBlink4(struct LED_871x *pLed)
595 struct _adapter *padapter = pLed->padapter;
596 struct led_priv *ledpriv = &(padapter->ledpriv);
597 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
598 u8 bStopBlinking = false;
600 /* Change LED according to BlinkingLedState specified. */
601 if (pLed->BlinkingLedState == LED_STATE_ON)
602 SwLedOn(padapter, pLed);
604 SwLedOff(padapter, pLed);
605 if (!pLed1->bLedWPSBlinkInProgress &&
606 pLed1->BlinkingLedState == LED_UNKNOWN) {
607 pLed1->BlinkingLedState = LED_STATE_OFF;
608 pLed1->CurrLedState = LED_STATE_OFF;
609 SwLedOff(padapter, pLed1);
611 switch (pLed->CurrLedState) {
612 case LED_BLINK_SLOWLY:
614 pLed->BlinkingLedState = LED_STATE_OFF;
616 pLed->BlinkingLedState = LED_STATE_ON;
617 mod_timer(&pLed->BlinkTimer, jiffies +
618 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
620 case LED_BLINK_StartToBlink:
622 pLed->BlinkingLedState = LED_STATE_OFF;
623 mod_timer(&pLed->BlinkTimer, jiffies +
624 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
626 pLed->BlinkingLedState = LED_STATE_ON;
627 mod_timer(&pLed->BlinkTimer, jiffies +
628 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
633 if (pLed->BlinkTimes == 0)
634 bStopBlinking = true;
636 pLed->bLedNoLinkBlinkInProgress = true;
637 pLed->CurrLedState = LED_BLINK_SLOWLY;
639 pLed->BlinkingLedState = LED_STATE_OFF;
641 pLed->BlinkingLedState = LED_STATE_ON;
642 mod_timer(&pLed->BlinkTimer, jiffies +
643 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
644 pLed->bLedScanBlinkInProgress = false;
647 pLed->BlinkingLedState = LED_STATE_OFF;
649 pLed->BlinkingLedState = LED_STATE_ON;
650 mod_timer(&pLed->BlinkTimer, jiffies +
651 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
656 if (pLed->BlinkTimes == 0)
657 bStopBlinking = true;
659 pLed->bLedNoLinkBlinkInProgress = true;
660 pLed->CurrLedState = LED_BLINK_SLOWLY;
662 pLed->BlinkingLedState = LED_STATE_OFF;
664 pLed->BlinkingLedState = LED_STATE_ON;
665 mod_timer(&pLed->BlinkTimer, jiffies +
666 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
667 pLed->bLedBlinkInProgress = false;
670 pLed->BlinkingLedState = LED_STATE_OFF;
672 pLed->BlinkingLedState = LED_STATE_ON;
673 mod_timer(&pLed->BlinkTimer, jiffies +
674 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
679 pLed->BlinkingLedState = LED_STATE_OFF;
680 mod_timer(&pLed->BlinkTimer, jiffies +
681 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
683 pLed->BlinkingLedState = LED_STATE_ON;
684 mod_timer(&pLed->BlinkTimer, jiffies +
685 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
688 case LED_BLINK_WPS_STOP: /*WPS authentication fail*/
690 pLed->BlinkingLedState = LED_STATE_OFF;
692 pLed->BlinkingLedState = LED_STATE_ON;
693 mod_timer(&pLed->BlinkTimer, jiffies +
694 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
696 case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */
698 if (pLed->BlinkTimes == 0) {
700 pLed->BlinkTimes = 1;
702 bStopBlinking = true;
705 pLed->BlinkTimes = 10;
706 pLed->BlinkingLedState = LED_STATE_ON;
707 mod_timer(&pLed->BlinkTimer, jiffies +
708 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
711 pLed->BlinkingLedState = LED_STATE_OFF;
713 pLed->BlinkingLedState = LED_STATE_ON;
714 mod_timer(&pLed->BlinkTimer, jiffies +
715 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
723 static void SwLedBlink5(struct LED_871x *pLed)
725 struct _adapter *padapter = pLed->padapter;
726 u8 bStopBlinking = false;
728 /* Change LED according to BlinkingLedState specified. */
729 if (pLed->BlinkingLedState == LED_STATE_ON)
730 SwLedOn(padapter, pLed);
732 SwLedOff(padapter, pLed);
733 switch (pLed->CurrLedState) {
736 if (pLed->BlinkTimes == 0)
737 bStopBlinking = true;
739 pLed->CurrLedState = LED_STATE_ON;
740 pLed->BlinkingLedState = LED_STATE_ON;
742 mod_timer(&pLed->BlinkTimer, jiffies +
743 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
744 pLed->bLedScanBlinkInProgress = false;
747 pLed->BlinkingLedState = LED_STATE_OFF;
749 pLed->BlinkingLedState = LED_STATE_ON;
750 mod_timer(&pLed->BlinkTimer, jiffies +
751 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
756 if (pLed->BlinkTimes == 0)
757 bStopBlinking = true;
759 pLed->CurrLedState = LED_STATE_ON;
760 pLed->BlinkingLedState = LED_STATE_ON;
762 mod_timer(&pLed->BlinkTimer, jiffies +
763 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
764 pLed->bLedBlinkInProgress = false;
767 pLed->BlinkingLedState = LED_STATE_OFF;
769 pLed->BlinkingLedState = LED_STATE_ON;
770 mod_timer(&pLed->BlinkTimer, jiffies +
771 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
779 static void SwLedBlink6(struct LED_871x *pLed)
781 struct _adapter *padapter = pLed->padapter;
782 u8 bStopBlinking = false;
784 /* Change LED according to BlinkingLedState specified. */
785 if (pLed->BlinkingLedState == LED_STATE_ON)
786 SwLedOn(padapter, pLed);
788 SwLedOff(padapter, pLed);
789 switch (pLed->CurrLedState) {
792 if (pLed->BlinkTimes == 0)
793 bStopBlinking = true;
795 pLed->CurrLedState = LED_STATE_ON;
796 pLed->BlinkingLedState = LED_STATE_ON;
798 SwLedOn(padapter, pLed);
799 pLed->bLedBlinkInProgress = false;
802 pLed->BlinkingLedState = LED_STATE_OFF;
804 pLed->BlinkingLedState = LED_STATE_ON;
805 mod_timer(&pLed->BlinkTimer, jiffies +
806 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
811 pLed->BlinkingLedState = LED_STATE_OFF;
813 pLed->BlinkingLedState = LED_STATE_ON;
814 mod_timer(&pLed->BlinkTimer, jiffies +
815 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
824 * Callback function of LED BlinkTimer,
825 * it just schedules to corresponding BlinkWorkItem.
827 static void BlinkTimerCallback(struct timer_list *t)
829 struct LED_871x *pLed = from_timer(pLed, t, BlinkTimer);
831 /* This fixed the crash problem on Fedora 12 when trying to do the
832 * insmod;ifconfig up;rmmod commands.
834 if (pLed->padapter->bSurpriseRemoved || pLed->padapter->bDriverStopped)
836 schedule_work(&pLed->BlinkWorkItem);
840 * Callback function of LED BlinkWorkItem.
841 * We dispatch actual LED blink action according to LedStrategy.
843 static void BlinkWorkItemCallback(struct work_struct *work)
845 struct LED_871x *pLed = container_of(work, struct LED_871x,
847 struct led_priv *ledpriv = &(pLed->padapter->ledpriv);
849 switch (ledpriv->LedStrategy) {
877 /*============================================================================
878 * Default LED behavior.
879 *============================================================================
882 * Implement each led action for SW_LED_MODE0.
883 * This is default strategy.
886 static void SwLedControlMode1(struct _adapter *padapter,
887 enum LED_CTL_MODE LedAction)
889 struct led_priv *ledpriv = &(padapter->ledpriv);
890 struct LED_871x *pLed = &(ledpriv->SwLed0);
891 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
892 struct sitesurvey_ctrl *psitesurveyctrl = &(pmlmepriv->sitesurveyctrl);
894 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
895 pLed = &(ledpriv->SwLed1);
897 case LED_CTL_START_TO_LINK:
898 case LED_CTL_NO_LINK:
899 if (!pLed->bLedNoLinkBlinkInProgress) {
900 if (pLed->CurrLedState == LED_SCAN_BLINK ||
901 IS_LED_WPS_BLINKING(pLed))
903 if (pLed->bLedLinkBlinkInProgress) {
904 del_timer(&pLed->BlinkTimer);
905 pLed->bLedLinkBlinkInProgress = false;
907 if (pLed->bLedBlinkInProgress) {
908 del_timer(&pLed->BlinkTimer);
909 pLed->bLedBlinkInProgress = false;
911 pLed->bLedNoLinkBlinkInProgress = true;
912 pLed->CurrLedState = LED_BLINK_SLOWLY;
914 pLed->BlinkingLedState = LED_STATE_OFF;
916 pLed->BlinkingLedState = LED_STATE_ON;
917 mod_timer(&pLed->BlinkTimer, jiffies +
918 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
922 if (!pLed->bLedLinkBlinkInProgress) {
923 if (pLed->CurrLedState == LED_SCAN_BLINK ||
924 IS_LED_WPS_BLINKING(pLed))
926 if (pLed->bLedNoLinkBlinkInProgress) {
927 del_timer(&pLed->BlinkTimer);
928 pLed->bLedNoLinkBlinkInProgress = false;
930 if (pLed->bLedBlinkInProgress) {
931 del_timer(&pLed->BlinkTimer);
932 pLed->bLedBlinkInProgress = false;
934 pLed->bLedLinkBlinkInProgress = true;
935 pLed->CurrLedState = LED_BLINK_NORMAL;
937 pLed->BlinkingLedState = LED_STATE_OFF;
939 pLed->BlinkingLedState = LED_STATE_ON;
940 mod_timer(&pLed->BlinkTimer, jiffies +
941 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
944 case LED_CTL_SITE_SURVEY:
945 if (psitesurveyctrl->traffic_busy &&
946 check_fwstate(pmlmepriv, _FW_LINKED))
948 else if (!pLed->bLedScanBlinkInProgress) {
949 if (IS_LED_WPS_BLINKING(pLed))
951 if (pLed->bLedNoLinkBlinkInProgress) {
952 del_timer(&pLed->BlinkTimer);
953 pLed->bLedNoLinkBlinkInProgress = false;
955 if (pLed->bLedLinkBlinkInProgress) {
956 del_timer(&pLed->BlinkTimer);
957 pLed->bLedLinkBlinkInProgress = false;
959 if (pLed->bLedBlinkInProgress) {
960 del_timer(&pLed->BlinkTimer);
961 pLed->bLedBlinkInProgress = false;
963 pLed->bLedScanBlinkInProgress = true;
964 pLed->CurrLedState = LED_SCAN_BLINK;
965 pLed->BlinkTimes = 24;
967 pLed->BlinkingLedState = LED_STATE_OFF;
969 pLed->BlinkingLedState = LED_STATE_ON;
970 mod_timer(&pLed->BlinkTimer, jiffies +
971 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
976 if (!pLed->bLedBlinkInProgress) {
977 if (pLed->CurrLedState == LED_SCAN_BLINK ||
978 IS_LED_WPS_BLINKING(pLed))
980 if (pLed->bLedNoLinkBlinkInProgress) {
981 del_timer(&pLed->BlinkTimer);
982 pLed->bLedNoLinkBlinkInProgress = false;
984 if (pLed->bLedLinkBlinkInProgress) {
985 del_timer(&pLed->BlinkTimer);
986 pLed->bLedLinkBlinkInProgress = false;
988 pLed->bLedBlinkInProgress = true;
989 pLed->CurrLedState = LED_TXRX_BLINK;
990 pLed->BlinkTimes = 2;
992 pLed->BlinkingLedState = LED_STATE_OFF;
994 pLed->BlinkingLedState = LED_STATE_ON;
995 mod_timer(&pLed->BlinkTimer, jiffies +
996 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1000 case LED_CTL_START_WPS: /*wait until xinpin finish */
1001 case LED_CTL_START_WPS_BOTTON:
1002 if (!pLed->bLedWPSBlinkInProgress) {
1003 if (pLed->bLedNoLinkBlinkInProgress) {
1004 del_timer(&pLed->BlinkTimer);
1005 pLed->bLedNoLinkBlinkInProgress = false;
1007 if (pLed->bLedLinkBlinkInProgress) {
1008 del_timer(&pLed->BlinkTimer);
1009 pLed->bLedLinkBlinkInProgress = false;
1011 if (pLed->bLedBlinkInProgress) {
1012 del_timer(&pLed->BlinkTimer);
1013 pLed->bLedBlinkInProgress = false;
1015 if (pLed->bLedScanBlinkInProgress) {
1016 del_timer(&pLed->BlinkTimer);
1017 pLed->bLedScanBlinkInProgress = false;
1019 pLed->bLedWPSBlinkInProgress = true;
1020 pLed->CurrLedState = LED_BLINK_WPS;
1022 pLed->BlinkingLedState = LED_STATE_OFF;
1024 pLed->BlinkingLedState = LED_STATE_ON;
1025 mod_timer(&pLed->BlinkTimer, jiffies +
1026 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1029 case LED_CTL_STOP_WPS:
1030 if (pLed->bLedNoLinkBlinkInProgress) {
1031 del_timer(&pLed->BlinkTimer);
1032 pLed->bLedNoLinkBlinkInProgress = false;
1034 if (pLed->bLedLinkBlinkInProgress) {
1035 del_timer(&pLed->BlinkTimer);
1036 pLed->bLedLinkBlinkInProgress = false;
1038 if (pLed->bLedBlinkInProgress) {
1039 del_timer(&pLed->BlinkTimer);
1040 pLed->bLedBlinkInProgress = false;
1042 if (pLed->bLedScanBlinkInProgress) {
1043 del_timer(&pLed->BlinkTimer);
1044 pLed->bLedScanBlinkInProgress = false;
1046 if (pLed->bLedWPSBlinkInProgress)
1047 del_timer(&pLed->BlinkTimer);
1049 pLed->bLedWPSBlinkInProgress = true;
1050 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1052 pLed->BlinkingLedState = LED_STATE_OFF;
1053 mod_timer(&pLed->BlinkTimer, jiffies +
1054 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1056 pLed->BlinkingLedState = LED_STATE_ON;
1057 mod_timer(&pLed->BlinkTimer,
1058 jiffies + msecs_to_jiffies(0));
1061 case LED_CTL_STOP_WPS_FAIL:
1062 if (pLed->bLedWPSBlinkInProgress) {
1063 del_timer(&pLed->BlinkTimer);
1064 pLed->bLedWPSBlinkInProgress = false;
1066 pLed->bLedNoLinkBlinkInProgress = true;
1067 pLed->CurrLedState = LED_BLINK_SLOWLY;
1069 pLed->BlinkingLedState = LED_STATE_OFF;
1071 pLed->BlinkingLedState = LED_STATE_ON;
1072 mod_timer(&pLed->BlinkTimer, jiffies +
1073 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1075 case LED_CTL_POWER_OFF:
1076 pLed->CurrLedState = LED_STATE_OFF;
1077 pLed->BlinkingLedState = LED_STATE_OFF;
1078 if (pLed->bLedNoLinkBlinkInProgress) {
1079 del_timer(&pLed->BlinkTimer);
1080 pLed->bLedNoLinkBlinkInProgress = false;
1082 if (pLed->bLedLinkBlinkInProgress) {
1083 del_timer(&pLed->BlinkTimer);
1084 pLed->bLedLinkBlinkInProgress = false;
1086 if (pLed->bLedBlinkInProgress) {
1087 del_timer(&pLed->BlinkTimer);
1088 pLed->bLedBlinkInProgress = false;
1090 if (pLed->bLedWPSBlinkInProgress) {
1091 del_timer(&pLed->BlinkTimer);
1092 pLed->bLedWPSBlinkInProgress = false;
1094 if (pLed->bLedScanBlinkInProgress) {
1095 del_timer(&pLed->BlinkTimer);
1096 pLed->bLedScanBlinkInProgress = false;
1098 mod_timer(&pLed->BlinkTimer,
1099 jiffies + msecs_to_jiffies(0));
1106 static void SwLedControlMode2(struct _adapter *padapter,
1107 enum LED_CTL_MODE LedAction)
1109 struct led_priv *ledpriv = &(padapter->ledpriv);
1110 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1111 struct LED_871x *pLed = &(ledpriv->SwLed0);
1113 switch (LedAction) {
1114 case LED_CTL_SITE_SURVEY:
1115 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1116 ; /* dummy branch */
1117 else if (!pLed->bLedScanBlinkInProgress) {
1118 if (IS_LED_WPS_BLINKING(pLed))
1121 if (pLed->bLedBlinkInProgress) {
1122 del_timer(&pLed->BlinkTimer);
1123 pLed->bLedBlinkInProgress = false;
1125 pLed->bLedScanBlinkInProgress = true;
1126 pLed->CurrLedState = LED_SCAN_BLINK;
1127 pLed->BlinkTimes = 24;
1129 pLed->BlinkingLedState = LED_STATE_OFF;
1131 pLed->BlinkingLedState = LED_STATE_ON;
1132 mod_timer(&pLed->BlinkTimer, jiffies +
1133 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1139 if (!pLed->bLedBlinkInProgress &&
1140 check_fwstate(pmlmepriv, _FW_LINKED)) {
1141 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1142 IS_LED_WPS_BLINKING(pLed))
1144 pLed->bLedBlinkInProgress = true;
1145 pLed->CurrLedState = LED_TXRX_BLINK;
1146 pLed->BlinkTimes = 2;
1148 pLed->BlinkingLedState = LED_STATE_OFF;
1150 pLed->BlinkingLedState = LED_STATE_ON;
1151 mod_timer(&pLed->BlinkTimer, jiffies +
1152 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1157 pLed->CurrLedState = LED_STATE_ON;
1158 pLed->BlinkingLedState = LED_STATE_ON;
1159 if (pLed->bLedBlinkInProgress) {
1160 del_timer(&pLed->BlinkTimer);
1161 pLed->bLedBlinkInProgress = false;
1163 if (pLed->bLedScanBlinkInProgress) {
1164 del_timer(&pLed->BlinkTimer);
1165 pLed->bLedScanBlinkInProgress = false;
1168 mod_timer(&pLed->BlinkTimer,
1169 jiffies + msecs_to_jiffies(0));
1172 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1173 case LED_CTL_START_WPS_BOTTON:
1174 if (!pLed->bLedWPSBlinkInProgress) {
1175 if (pLed->bLedBlinkInProgress) {
1176 del_timer(&pLed->BlinkTimer);
1177 pLed->bLedBlinkInProgress = false;
1179 if (pLed->bLedScanBlinkInProgress) {
1180 del_timer(&pLed->BlinkTimer);
1181 pLed->bLedScanBlinkInProgress = false;
1183 pLed->bLedWPSBlinkInProgress = true;
1184 pLed->CurrLedState = LED_STATE_ON;
1185 pLed->BlinkingLedState = LED_STATE_ON;
1186 mod_timer(&pLed->BlinkTimer,
1187 jiffies + msecs_to_jiffies(0));
1191 case LED_CTL_STOP_WPS:
1192 pLed->bLedWPSBlinkInProgress = false;
1193 pLed->CurrLedState = LED_STATE_ON;
1194 pLed->BlinkingLedState = LED_STATE_ON;
1195 mod_timer(&pLed->BlinkTimer,
1196 jiffies + msecs_to_jiffies(0));
1199 case LED_CTL_STOP_WPS_FAIL:
1200 pLed->bLedWPSBlinkInProgress = false;
1201 pLed->CurrLedState = LED_STATE_OFF;
1202 pLed->BlinkingLedState = LED_STATE_OFF;
1203 mod_timer(&pLed->BlinkTimer,
1204 jiffies + msecs_to_jiffies(0));
1207 case LED_CTL_START_TO_LINK:
1208 case LED_CTL_NO_LINK:
1209 if (!IS_LED_BLINKING(pLed)) {
1210 pLed->CurrLedState = LED_STATE_OFF;
1211 pLed->BlinkingLedState = LED_STATE_OFF;
1212 mod_timer(&pLed->BlinkTimer,
1213 jiffies + msecs_to_jiffies(0));
1216 case LED_CTL_POWER_OFF:
1217 pLed->CurrLedState = LED_STATE_OFF;
1218 pLed->BlinkingLedState = LED_STATE_OFF;
1219 if (pLed->bLedBlinkInProgress) {
1220 del_timer(&pLed->BlinkTimer);
1221 pLed->bLedBlinkInProgress = false;
1223 if (pLed->bLedScanBlinkInProgress) {
1224 del_timer(&pLed->BlinkTimer);
1225 pLed->bLedScanBlinkInProgress = false;
1227 if (pLed->bLedWPSBlinkInProgress) {
1228 del_timer(&pLed->BlinkTimer);
1229 pLed->bLedWPSBlinkInProgress = false;
1231 mod_timer(&pLed->BlinkTimer,
1232 jiffies + msecs_to_jiffies(0));
1239 static void SwLedControlMode3(struct _adapter *padapter,
1240 enum LED_CTL_MODE LedAction)
1242 struct led_priv *ledpriv = &(padapter->ledpriv);
1243 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1244 struct LED_871x *pLed = &(ledpriv->SwLed0);
1246 switch (LedAction) {
1247 case LED_CTL_SITE_SURVEY:
1248 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1249 ; /* dummy branch */
1250 else if (!pLed->bLedScanBlinkInProgress) {
1251 if (IS_LED_WPS_BLINKING(pLed))
1253 if (pLed->bLedBlinkInProgress) {
1254 del_timer(&pLed->BlinkTimer);
1255 pLed->bLedBlinkInProgress = false;
1257 pLed->bLedScanBlinkInProgress = true;
1258 pLed->CurrLedState = LED_SCAN_BLINK;
1259 pLed->BlinkTimes = 24;
1261 pLed->BlinkingLedState = LED_STATE_OFF;
1263 pLed->BlinkingLedState = LED_STATE_ON;
1264 mod_timer(&pLed->BlinkTimer, jiffies +
1265 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1270 if (!pLed->bLedBlinkInProgress &&
1271 check_fwstate(pmlmepriv, _FW_LINKED)) {
1272 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1273 IS_LED_WPS_BLINKING(pLed))
1275 pLed->bLedBlinkInProgress = true;
1276 pLed->CurrLedState = LED_TXRX_BLINK;
1277 pLed->BlinkTimes = 2;
1279 pLed->BlinkingLedState = LED_STATE_OFF;
1281 pLed->BlinkingLedState = LED_STATE_ON;
1282 mod_timer(&pLed->BlinkTimer, jiffies +
1283 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1287 if (IS_LED_WPS_BLINKING(pLed))
1289 pLed->CurrLedState = LED_STATE_ON;
1290 pLed->BlinkingLedState = LED_STATE_ON;
1291 if (pLed->bLedBlinkInProgress) {
1292 del_timer(&pLed->BlinkTimer);
1293 pLed->bLedBlinkInProgress = false;
1295 if (pLed->bLedScanBlinkInProgress) {
1296 del_timer(&pLed->BlinkTimer);
1297 pLed->bLedScanBlinkInProgress = false;
1299 mod_timer(&pLed->BlinkTimer,
1300 jiffies + msecs_to_jiffies(0));
1302 case LED_CTL_START_WPS: /* wait until xinpin finish */
1303 case LED_CTL_START_WPS_BOTTON:
1304 if (!pLed->bLedWPSBlinkInProgress) {
1305 if (pLed->bLedBlinkInProgress) {
1306 del_timer(&pLed->BlinkTimer);
1307 pLed->bLedBlinkInProgress = false;
1309 if (pLed->bLedScanBlinkInProgress) {
1310 del_timer(&pLed->BlinkTimer);
1311 pLed->bLedScanBlinkInProgress = false;
1313 pLed->bLedWPSBlinkInProgress = true;
1314 pLed->CurrLedState = LED_BLINK_WPS;
1316 pLed->BlinkingLedState = LED_STATE_OFF;
1318 pLed->BlinkingLedState = LED_STATE_ON;
1319 mod_timer(&pLed->BlinkTimer, jiffies +
1320 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1323 case LED_CTL_STOP_WPS:
1324 if (pLed->bLedWPSBlinkInProgress) {
1325 del_timer(&pLed->BlinkTimer);
1326 pLed->bLedWPSBlinkInProgress = false;
1328 pLed->bLedWPSBlinkInProgress = true;
1330 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1332 pLed->BlinkingLedState = LED_STATE_OFF;
1333 mod_timer(&pLed->BlinkTimer, jiffies +
1334 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1336 pLed->BlinkingLedState = LED_STATE_ON;
1337 mod_timer(&pLed->BlinkTimer,
1338 jiffies + msecs_to_jiffies(0));
1341 case LED_CTL_STOP_WPS_FAIL:
1342 if (pLed->bLedWPSBlinkInProgress) {
1343 del_timer(&pLed->BlinkTimer);
1344 pLed->bLedWPSBlinkInProgress = false;
1346 pLed->CurrLedState = LED_STATE_OFF;
1347 pLed->BlinkingLedState = LED_STATE_OFF;
1348 mod_timer(&pLed->BlinkTimer,
1349 jiffies + msecs_to_jiffies(0));
1351 case LED_CTL_START_TO_LINK:
1352 case LED_CTL_NO_LINK:
1353 if (!IS_LED_BLINKING(pLed)) {
1354 pLed->CurrLedState = LED_STATE_OFF;
1355 pLed->BlinkingLedState = LED_STATE_OFF;
1356 mod_timer(&pLed->BlinkTimer,
1357 jiffies + msecs_to_jiffies(0));
1360 case LED_CTL_POWER_OFF:
1361 pLed->CurrLedState = LED_STATE_OFF;
1362 pLed->BlinkingLedState = LED_STATE_OFF;
1363 if (pLed->bLedBlinkInProgress) {
1364 del_timer(&pLed->BlinkTimer);
1365 pLed->bLedBlinkInProgress = false;
1367 if (pLed->bLedScanBlinkInProgress) {
1368 del_timer(&pLed->BlinkTimer);
1369 pLed->bLedScanBlinkInProgress = false;
1371 if (pLed->bLedWPSBlinkInProgress) {
1372 del_timer(&pLed->BlinkTimer);
1373 pLed->bLedWPSBlinkInProgress = false;
1375 mod_timer(&pLed->BlinkTimer,
1376 jiffies + msecs_to_jiffies(0));
1383 static void SwLedControlMode4(struct _adapter *padapter,
1384 enum LED_CTL_MODE LedAction)
1386 struct led_priv *ledpriv = &(padapter->ledpriv);
1387 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1388 struct LED_871x *pLed = &(ledpriv->SwLed0);
1389 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
1391 switch (LedAction) {
1392 case LED_CTL_START_TO_LINK:
1393 if (pLed1->bLedWPSBlinkInProgress) {
1394 pLed1->bLedWPSBlinkInProgress = false;
1395 del_timer(&pLed1->BlinkTimer);
1396 pLed1->BlinkingLedState = LED_STATE_OFF;
1397 pLed1->CurrLedState = LED_STATE_OFF;
1399 mod_timer(&pLed->BlinkTimer,
1400 jiffies + msecs_to_jiffies(0));
1402 if (!pLed->bLedStartToLinkBlinkInProgress) {
1403 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1404 IS_LED_WPS_BLINKING(pLed))
1406 if (pLed->bLedBlinkInProgress) {
1407 del_timer(&pLed->BlinkTimer);
1408 pLed->bLedBlinkInProgress = false;
1410 if (pLed->bLedNoLinkBlinkInProgress) {
1411 del_timer(&pLed->BlinkTimer);
1412 pLed->bLedNoLinkBlinkInProgress = false;
1414 pLed->bLedStartToLinkBlinkInProgress = true;
1415 pLed->CurrLedState = LED_BLINK_StartToBlink;
1417 pLed->BlinkingLedState = LED_STATE_OFF;
1418 mod_timer(&pLed->BlinkTimer, jiffies +
1419 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1421 pLed->BlinkingLedState = LED_STATE_ON;
1422 mod_timer(&pLed->BlinkTimer, jiffies +
1423 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1428 case LED_CTL_NO_LINK:
1430 if (LedAction == LED_CTL_LINK) {
1431 if (pLed1->bLedWPSBlinkInProgress) {
1432 pLed1->bLedWPSBlinkInProgress = false;
1433 del_timer(&pLed1->BlinkTimer);
1434 pLed1->BlinkingLedState = LED_STATE_OFF;
1435 pLed1->CurrLedState = LED_STATE_OFF;
1437 mod_timer(&pLed->BlinkTimer,
1438 jiffies + msecs_to_jiffies(0));
1441 if (!pLed->bLedNoLinkBlinkInProgress) {
1442 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1443 IS_LED_WPS_BLINKING(pLed))
1445 if (pLed->bLedBlinkInProgress) {
1446 del_timer(&pLed->BlinkTimer);
1447 pLed->bLedBlinkInProgress = false;
1449 pLed->bLedNoLinkBlinkInProgress = true;
1450 pLed->CurrLedState = LED_BLINK_SLOWLY;
1452 pLed->BlinkingLedState = LED_STATE_OFF;
1454 pLed->BlinkingLedState = LED_STATE_ON;
1455 mod_timer(&pLed->BlinkTimer, jiffies +
1456 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1459 case LED_CTL_SITE_SURVEY:
1460 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1461 check_fwstate(pmlmepriv, _FW_LINKED))
1463 else if (!pLed->bLedScanBlinkInProgress) {
1464 if (IS_LED_WPS_BLINKING(pLed))
1466 if (pLed->bLedNoLinkBlinkInProgress) {
1467 del_timer(&pLed->BlinkTimer);
1468 pLed->bLedNoLinkBlinkInProgress = false;
1470 if (pLed->bLedBlinkInProgress) {
1471 del_timer(&pLed->BlinkTimer);
1472 pLed->bLedBlinkInProgress = false;
1474 pLed->bLedScanBlinkInProgress = true;
1475 pLed->CurrLedState = LED_SCAN_BLINK;
1476 pLed->BlinkTimes = 24;
1478 pLed->BlinkingLedState = LED_STATE_OFF;
1480 pLed->BlinkingLedState = LED_STATE_ON;
1481 mod_timer(&pLed->BlinkTimer, jiffies +
1482 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1487 if (!pLed->bLedBlinkInProgress) {
1488 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1489 IS_LED_WPS_BLINKING(pLed))
1491 if (pLed->bLedNoLinkBlinkInProgress) {
1492 del_timer(&pLed->BlinkTimer);
1493 pLed->bLedNoLinkBlinkInProgress = false;
1495 pLed->bLedBlinkInProgress = true;
1496 pLed->CurrLedState = LED_TXRX_BLINK;
1497 pLed->BlinkTimes = 2;
1499 pLed->BlinkingLedState = LED_STATE_OFF;
1501 pLed->BlinkingLedState = LED_STATE_ON;
1502 mod_timer(&pLed->BlinkTimer, jiffies +
1503 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1506 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1507 case LED_CTL_START_WPS_BOTTON:
1508 if (pLed1->bLedWPSBlinkInProgress) {
1509 pLed1->bLedWPSBlinkInProgress = false;
1510 del_timer(&pLed1->BlinkTimer);
1511 pLed1->BlinkingLedState = LED_STATE_OFF;
1512 pLed1->CurrLedState = LED_STATE_OFF;
1514 mod_timer(&pLed->BlinkTimer,
1515 jiffies + msecs_to_jiffies(0));
1517 if (!pLed->bLedWPSBlinkInProgress) {
1518 if (pLed->bLedNoLinkBlinkInProgress) {
1519 del_timer(&pLed->BlinkTimer);
1520 pLed->bLedNoLinkBlinkInProgress = false;
1522 if (pLed->bLedBlinkInProgress) {
1523 del_timer(&pLed->BlinkTimer);
1524 pLed->bLedBlinkInProgress = false;
1526 if (pLed->bLedScanBlinkInProgress) {
1527 del_timer(&pLed->BlinkTimer);
1528 pLed->bLedScanBlinkInProgress = false;
1530 pLed->bLedWPSBlinkInProgress = true;
1531 pLed->CurrLedState = LED_BLINK_WPS;
1533 pLed->BlinkingLedState = LED_STATE_OFF;
1534 mod_timer(&pLed->BlinkTimer, jiffies +
1535 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1537 pLed->BlinkingLedState = LED_STATE_ON;
1538 mod_timer(&pLed->BlinkTimer, jiffies +
1539 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1543 case LED_CTL_STOP_WPS: /*WPS connect success*/
1544 if (pLed->bLedWPSBlinkInProgress) {
1545 del_timer(&pLed->BlinkTimer);
1546 pLed->bLedWPSBlinkInProgress = false;
1548 pLed->bLedNoLinkBlinkInProgress = true;
1549 pLed->CurrLedState = LED_BLINK_SLOWLY;
1551 pLed->BlinkingLedState = LED_STATE_OFF;
1553 pLed->BlinkingLedState = LED_STATE_ON;
1554 mod_timer(&pLed->BlinkTimer, jiffies +
1555 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1557 case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/
1558 if (pLed->bLedWPSBlinkInProgress) {
1559 del_timer(&pLed->BlinkTimer);
1560 pLed->bLedWPSBlinkInProgress = false;
1562 pLed->bLedNoLinkBlinkInProgress = true;
1563 pLed->CurrLedState = LED_BLINK_SLOWLY;
1565 pLed->BlinkingLedState = LED_STATE_OFF;
1567 pLed->BlinkingLedState = LED_STATE_ON;
1568 mod_timer(&pLed->BlinkTimer, jiffies +
1569 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1571 if (pLed1->bLedWPSBlinkInProgress)
1572 del_timer(&pLed1->BlinkTimer);
1574 pLed1->bLedWPSBlinkInProgress = true;
1575 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1577 pLed1->BlinkingLedState = LED_STATE_OFF;
1579 pLed1->BlinkingLedState = LED_STATE_ON;
1580 mod_timer(&pLed->BlinkTimer, jiffies +
1581 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1583 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/
1584 if (pLed->bLedWPSBlinkInProgress) {
1585 del_timer(&pLed->BlinkTimer);
1586 pLed->bLedWPSBlinkInProgress = false;
1588 pLed->bLedNoLinkBlinkInProgress = true;
1589 pLed->CurrLedState = LED_BLINK_SLOWLY;
1591 pLed->BlinkingLedState = LED_STATE_OFF;
1593 pLed->BlinkingLedState = LED_STATE_ON;
1594 mod_timer(&pLed->BlinkTimer, jiffies +
1595 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1597 if (pLed1->bLedWPSBlinkInProgress)
1598 del_timer(&pLed1->BlinkTimer);
1600 pLed1->bLedWPSBlinkInProgress = true;
1601 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1602 pLed1->BlinkTimes = 10;
1604 pLed1->BlinkingLedState = LED_STATE_OFF;
1606 pLed1->BlinkingLedState = LED_STATE_ON;
1607 mod_timer(&pLed->BlinkTimer, jiffies +
1608 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1610 case LED_CTL_POWER_OFF:
1611 pLed->CurrLedState = LED_STATE_OFF;
1612 pLed->BlinkingLedState = LED_STATE_OFF;
1613 if (pLed->bLedNoLinkBlinkInProgress) {
1614 del_timer(&pLed->BlinkTimer);
1615 pLed->bLedNoLinkBlinkInProgress = false;
1617 if (pLed->bLedLinkBlinkInProgress) {
1618 del_timer(&pLed->BlinkTimer);
1619 pLed->bLedLinkBlinkInProgress = false;
1621 if (pLed->bLedBlinkInProgress) {
1622 del_timer(&pLed->BlinkTimer);
1623 pLed->bLedBlinkInProgress = false;
1625 if (pLed->bLedWPSBlinkInProgress) {
1626 del_timer(&pLed->BlinkTimer);
1627 pLed->bLedWPSBlinkInProgress = false;
1629 if (pLed->bLedScanBlinkInProgress) {
1630 del_timer(&pLed->BlinkTimer);
1631 pLed->bLedScanBlinkInProgress = false;
1633 if (pLed->bLedStartToLinkBlinkInProgress) {
1634 del_timer(&pLed->BlinkTimer);
1635 pLed->bLedStartToLinkBlinkInProgress = false;
1637 if (pLed1->bLedWPSBlinkInProgress) {
1638 del_timer(&pLed1->BlinkTimer);
1639 pLed1->bLedWPSBlinkInProgress = false;
1641 pLed1->BlinkingLedState = LED_UNKNOWN;
1642 SwLedOff(padapter, pLed);
1643 SwLedOff(padapter, pLed1);
1650 static void SwLedControlMode5(struct _adapter *padapter,
1651 enum LED_CTL_MODE LedAction)
1653 struct led_priv *ledpriv = &(padapter->ledpriv);
1654 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1655 struct LED_871x *pLed = &(ledpriv->SwLed0);
1657 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1658 pLed = &(ledpriv->SwLed1);
1660 switch (LedAction) {
1661 case LED_CTL_POWER_ON:
1662 case LED_CTL_NO_LINK:
1663 case LED_CTL_LINK: /* solid blue */
1664 if (pLed->CurrLedState == LED_SCAN_BLINK)
1666 pLed->CurrLedState = LED_STATE_ON;
1667 pLed->BlinkingLedState = LED_STATE_ON;
1668 pLed->bLedBlinkInProgress = false;
1669 mod_timer(&pLed->BlinkTimer,
1670 jiffies + msecs_to_jiffies(0));
1672 case LED_CTL_SITE_SURVEY:
1673 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1674 check_fwstate(pmlmepriv, _FW_LINKED))
1675 ; /* dummy branch */
1676 else if (!pLed->bLedScanBlinkInProgress) {
1677 if (pLed->bLedBlinkInProgress) {
1678 del_timer(&pLed->BlinkTimer);
1679 pLed->bLedBlinkInProgress = false;
1681 pLed->bLedScanBlinkInProgress = true;
1682 pLed->CurrLedState = LED_SCAN_BLINK;
1683 pLed->BlinkTimes = 24;
1685 pLed->BlinkingLedState = LED_STATE_OFF;
1687 pLed->BlinkingLedState = LED_STATE_ON;
1688 mod_timer(&pLed->BlinkTimer, jiffies +
1689 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1694 if (!pLed->bLedBlinkInProgress) {
1695 if (pLed->CurrLedState == LED_SCAN_BLINK)
1697 pLed->bLedBlinkInProgress = true;
1698 pLed->CurrLedState = LED_TXRX_BLINK;
1699 pLed->BlinkTimes = 2;
1701 pLed->BlinkingLedState = LED_STATE_OFF;
1703 pLed->BlinkingLedState = LED_STATE_ON;
1704 mod_timer(&pLed->BlinkTimer, jiffies +
1705 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1708 case LED_CTL_POWER_OFF:
1709 pLed->CurrLedState = LED_STATE_OFF;
1710 pLed->BlinkingLedState = LED_STATE_OFF;
1711 if (pLed->bLedBlinkInProgress) {
1712 del_timer(&pLed->BlinkTimer);
1713 pLed->bLedBlinkInProgress = false;
1715 SwLedOff(padapter, pLed);
1723 static void SwLedControlMode6(struct _adapter *padapter,
1724 enum LED_CTL_MODE LedAction)
1726 struct led_priv *ledpriv = &(padapter->ledpriv);
1727 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1728 struct LED_871x *pLed = &(ledpriv->SwLed0);
1730 switch (LedAction) {
1731 case LED_CTL_POWER_ON:
1732 case LED_CTL_NO_LINK:
1733 case LED_CTL_LINK: /*solid blue*/
1734 case LED_CTL_SITE_SURVEY:
1735 if (IS_LED_WPS_BLINKING(pLed))
1737 pLed->CurrLedState = LED_STATE_ON;
1738 pLed->BlinkingLedState = LED_STATE_ON;
1739 pLed->bLedBlinkInProgress = false;
1740 mod_timer(&(pLed->BlinkTimer), jiffies + msecs_to_jiffies(0));
1744 if (!pLed->bLedBlinkInProgress &&
1745 check_fwstate(pmlmepriv, _FW_LINKED)) {
1746 if (IS_LED_WPS_BLINKING(pLed))
1748 pLed->bLedBlinkInProgress = true;
1749 pLed->CurrLedState = LED_TXRX_BLINK;
1750 pLed->BlinkTimes = 2;
1752 pLed->BlinkingLedState = LED_STATE_OFF;
1754 pLed->BlinkingLedState = LED_STATE_ON;
1755 mod_timer(&pLed->BlinkTimer, jiffies +
1756 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1759 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1760 case LED_CTL_START_WPS_BOTTON:
1761 if (!pLed->bLedWPSBlinkInProgress) {
1762 if (pLed->bLedBlinkInProgress) {
1763 del_timer(&pLed->BlinkTimer);
1764 pLed->bLedBlinkInProgress = false;
1766 pLed->bLedWPSBlinkInProgress = true;
1767 pLed->CurrLedState = LED_BLINK_WPS;
1769 pLed->BlinkingLedState = LED_STATE_OFF;
1771 pLed->BlinkingLedState = LED_STATE_ON;
1772 mod_timer(&pLed->BlinkTimer, jiffies +
1773 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1776 case LED_CTL_STOP_WPS_FAIL:
1777 case LED_CTL_STOP_WPS:
1778 if (pLed->bLedWPSBlinkInProgress) {
1779 del_timer(&pLed->BlinkTimer);
1780 pLed->bLedWPSBlinkInProgress = false;
1782 pLed->CurrLedState = LED_STATE_ON;
1783 pLed->BlinkingLedState = LED_STATE_ON;
1784 mod_timer(&pLed->BlinkTimer,
1785 jiffies + msecs_to_jiffies(0));
1787 case LED_CTL_POWER_OFF:
1788 pLed->CurrLedState = LED_STATE_OFF;
1789 pLed->BlinkingLedState = LED_STATE_OFF;
1790 if (pLed->bLedBlinkInProgress) {
1791 del_timer(&pLed->BlinkTimer);
1792 pLed->bLedBlinkInProgress = false;
1794 if (pLed->bLedWPSBlinkInProgress) {
1795 del_timer(&pLed->BlinkTimer);
1796 pLed->bLedWPSBlinkInProgress = false;
1798 SwLedOff(padapter, pLed);
1806 * Dispatch LED action according to pHalData->LedStrategy.
1808 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1810 struct led_priv *ledpriv = &(padapter->ledpriv);
1812 if (!ledpriv->bRegUseLed)
1814 switch (ledpriv->LedStrategy) {
1818 SwLedControlMode1(padapter, LedAction);
1821 SwLedControlMode2(padapter, LedAction);
1824 SwLedControlMode3(padapter, LedAction);
1827 SwLedControlMode4(padapter, LedAction);
1830 SwLedControlMode5(padapter, LedAction);
1833 SwLedControlMode6(padapter, LedAction);