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 pLed->padapter = padapter;
93 pLed->LedPin = LedPin;
94 pLed->CurrLedState = LED_STATE_OFF;
96 pLed->bLedBlinkInProgress = false;
98 pLed->BlinkingLedState = LED_UNKNOWN;
99 timer_setup(&pLed->BlinkTimer, BlinkTimerCallback, 0);
100 INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback);
105 * DeInitialize an LED_871x object.
107 static void DeInitLed871x(struct LED_871x *pLed)
109 del_timer_sync(&pLed->BlinkTimer);
110 /* We should reset bLedBlinkInProgress if we cancel
111 * the LedControlTimer,
113 pLed->bLedBlinkInProgress = false;
118 * Turn on LED according to LedPin specified.
120 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
124 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
126 LedCfg = r8712_read8(padapter, LEDCFG);
127 switch (pLed->LedPin) {
131 /* SW control led0 on.*/
132 r8712_write8(padapter, LEDCFG, LedCfg & 0xf0);
135 /* SW control led1 on.*/
136 r8712_write8(padapter, LEDCFG, LedCfg & 0x0f);
146 * Turn off LED according to LedPin specified.
148 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
152 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
154 LedCfg = r8712_read8(padapter, LEDCFG);
155 switch (pLed->LedPin) {
159 LedCfg &= 0xf0; /* Set to software control.*/
160 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3)));
163 LedCfg &= 0x0f; /* Set to software control.*/
164 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7)));
169 pLed->bLedOn = false;
172 /*===========================================================================
173 * Interface to manipulate LED objects.
174 *===========================================================================
177 * Initialize all LED_871x objects.
179 void r8712_InitSwLeds(struct _adapter *padapter)
181 struct led_priv *pledpriv = &padapter->ledpriv;
183 pledpriv->LedControlHandler = LedControl871x;
184 InitLed871x(padapter, &pledpriv->SwLed0, LED_PIN_LED0);
185 InitLed871x(padapter, &pledpriv->SwLed1, LED_PIN_LED1);
189 * DeInitialize all LED_819xUsb objects.
191 void r8712_DeInitSwLeds(struct _adapter *padapter)
193 struct led_priv *ledpriv = &padapter->ledpriv;
195 DeInitLed871x(&ledpriv->SwLed0);
196 DeInitLed871x(&ledpriv->SwLed1);
200 * Implementation of LED blinking behavior.
201 * It toggle off LED and schedule corresponding timer if necessary.
203 static void SwLedBlink(struct LED_871x *pLed)
205 struct _adapter *padapter = pLed->padapter;
206 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
207 u8 bStopBlinking = false;
209 /* Change LED according to BlinkingLedState specified. */
210 if (pLed->BlinkingLedState == LED_STATE_ON)
211 SwLedOn(padapter, pLed);
213 SwLedOff(padapter, pLed);
214 /* Determine if we shall change LED state again. */
216 switch (pLed->CurrLedState) {
217 case LED_BLINK_NORMAL:
218 if (pLed->BlinkTimes == 0)
219 bStopBlinking = true;
221 case LED_BLINK_StartToBlink:
222 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
223 (pmlmepriv->fw_state & WIFI_STATION_STATE))
224 bStopBlinking = true;
225 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
226 ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
227 (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
228 bStopBlinking = true;
229 else if (pLed->BlinkTimes == 0)
230 bStopBlinking = true;
233 if (pLed->BlinkTimes == 0)
234 bStopBlinking = true;
237 bStopBlinking = true;
241 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
243 SwLedOn(padapter, pLed);
244 else if (check_fwstate(pmlmepriv, _FW_LINKED) && pLed->bLedOn)
245 SwLedOff(padapter, pLed);
246 pLed->BlinkTimes = 0;
247 pLed->bLedBlinkInProgress = false;
249 /* Assign LED state to toggle. */
250 if (pLed->BlinkingLedState == LED_STATE_ON)
251 pLed->BlinkingLedState = LED_STATE_OFF;
253 pLed->BlinkingLedState = LED_STATE_ON;
255 /* Schedule a timer to toggle LED state. */
256 switch (pLed->CurrLedState) {
257 case LED_BLINK_NORMAL:
258 mod_timer(&pLed->BlinkTimer, jiffies +
259 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
261 case LED_BLINK_SLOWLY:
262 case LED_BLINK_StartToBlink:
263 mod_timer(&pLed->BlinkTimer, jiffies +
264 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
267 mod_timer(&pLed->BlinkTimer, jiffies +
268 msecs_to_jiffies(LED_BLINK_LONG_INTERVAL));
271 mod_timer(&pLed->BlinkTimer, jiffies +
272 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
278 static void SwLedBlink1(struct LED_871x *pLed)
280 struct _adapter *padapter = pLed->padapter;
281 struct led_priv *ledpriv = &padapter->ledpriv;
282 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
283 struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
284 struct LED_871x *pLed1 = &ledpriv->SwLed1;
285 u8 bStopBlinking = false;
287 if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
288 pLed = &ledpriv->SwLed1;
289 /* Change LED according to BlinkingLedState specified. */
290 if (pLed->BlinkingLedState == LED_STATE_ON)
291 SwLedOn(padapter, pLed);
293 SwLedOff(padapter, pLed);
294 if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
295 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
296 if (!pLed1->bSWLedCtrl) {
297 SwLedOn(padapter, pLed1);
298 pLed1->bSWLedCtrl = true;
299 } else if (!pLed1->bLedOn) {
300 SwLedOn(padapter, pLed1);
303 if (!pLed1->bSWLedCtrl) {
304 SwLedOff(padapter, pLed1);
305 pLed1->bSWLedCtrl = true;
306 } else if (pLed1->bLedOn) {
307 SwLedOff(padapter, pLed1);
311 switch (pLed->CurrLedState) {
312 case LED_BLINK_SLOWLY:
314 pLed->BlinkingLedState = LED_STATE_OFF;
316 pLed->BlinkingLedState = LED_STATE_ON;
317 mod_timer(&pLed->BlinkTimer, jiffies +
318 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
320 case LED_BLINK_NORMAL:
322 pLed->BlinkingLedState = LED_STATE_OFF;
324 pLed->BlinkingLedState = LED_STATE_ON;
325 mod_timer(&pLed->BlinkTimer, jiffies +
326 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
330 if (pLed->BlinkTimes == 0)
331 bStopBlinking = true;
333 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
334 pLed->bLedLinkBlinkInProgress = true;
335 pLed->CurrLedState = LED_BLINK_NORMAL;
337 pLed->BlinkingLedState = LED_STATE_OFF;
339 pLed->BlinkingLedState = LED_STATE_ON;
340 mod_timer(&pLed->BlinkTimer, jiffies +
341 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
342 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
343 pLed->bLedNoLinkBlinkInProgress = true;
344 pLed->CurrLedState = LED_BLINK_SLOWLY;
346 pLed->BlinkingLedState = LED_STATE_OFF;
348 pLed->BlinkingLedState = LED_STATE_ON;
349 mod_timer(&pLed->BlinkTimer, jiffies +
350 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
352 pLed->bLedScanBlinkInProgress = false;
355 pLed->BlinkingLedState = LED_STATE_OFF;
357 pLed->BlinkingLedState = LED_STATE_ON;
358 mod_timer(&pLed->BlinkTimer, jiffies +
359 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
364 if (pLed->BlinkTimes == 0)
365 bStopBlinking = true;
367 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
368 pLed->bLedLinkBlinkInProgress = true;
369 pLed->CurrLedState = LED_BLINK_NORMAL;
371 pLed->BlinkingLedState = LED_STATE_OFF;
373 pLed->BlinkingLedState = LED_STATE_ON;
374 mod_timer(&pLed->BlinkTimer, jiffies +
375 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
376 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
377 pLed->bLedNoLinkBlinkInProgress = true;
378 pLed->CurrLedState = LED_BLINK_SLOWLY;
380 pLed->BlinkingLedState = LED_STATE_OFF;
382 pLed->BlinkingLedState = LED_STATE_ON;
383 mod_timer(&pLed->BlinkTimer, jiffies +
384 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
386 pLed->BlinkTimes = 0;
387 pLed->bLedBlinkInProgress = false;
390 pLed->BlinkingLedState = LED_STATE_OFF;
392 pLed->BlinkingLedState = LED_STATE_ON;
393 mod_timer(&pLed->BlinkTimer, jiffies +
394 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
399 pLed->BlinkingLedState = LED_STATE_OFF;
401 pLed->BlinkingLedState = LED_STATE_ON;
402 mod_timer(&pLed->BlinkTimer, jiffies +
403 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
405 case LED_BLINK_WPS_STOP: /* WPS success */
406 if (pLed->BlinkingLedState == LED_STATE_ON) {
407 pLed->BlinkingLedState = LED_STATE_OFF;
408 mod_timer(&pLed->BlinkTimer, jiffies +
409 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
410 bStopBlinking = false;
412 bStopBlinking = true;
415 pLed->bLedLinkBlinkInProgress = true;
416 pLed->CurrLedState = LED_BLINK_NORMAL;
418 pLed->BlinkingLedState = LED_STATE_OFF;
420 pLed->BlinkingLedState = LED_STATE_ON;
421 mod_timer(&pLed->BlinkTimer, jiffies +
422 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
424 pLed->bLedWPSBlinkInProgress = false;
431 static void SwLedBlink2(struct LED_871x *pLed)
433 struct _adapter *padapter = pLed->padapter;
434 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
435 u8 bStopBlinking = false;
437 /* Change LED according to BlinkingLedState specified. */
438 if (pLed->BlinkingLedState == LED_STATE_ON)
439 SwLedOn(padapter, pLed);
441 SwLedOff(padapter, pLed);
442 switch (pLed->CurrLedState) {
445 if (pLed->BlinkTimes == 0)
446 bStopBlinking = true;
448 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
449 pLed->CurrLedState = LED_STATE_ON;
450 pLed->BlinkingLedState = LED_STATE_ON;
451 SwLedOn(padapter, pLed);
452 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
453 pLed->CurrLedState = LED_STATE_OFF;
454 pLed->BlinkingLedState = LED_STATE_OFF;
455 SwLedOff(padapter, pLed);
457 pLed->bLedScanBlinkInProgress = false;
460 pLed->BlinkingLedState = LED_STATE_OFF;
462 pLed->BlinkingLedState = LED_STATE_ON;
463 mod_timer(&pLed->BlinkTimer, jiffies +
464 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
469 if (pLed->BlinkTimes == 0)
470 bStopBlinking = true;
472 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
473 pLed->CurrLedState = LED_STATE_ON;
474 pLed->BlinkingLedState = LED_STATE_ON;
475 SwLedOn(padapter, pLed);
476 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
477 pLed->CurrLedState = LED_STATE_OFF;
478 pLed->BlinkingLedState = LED_STATE_OFF;
479 SwLedOff(padapter, pLed);
481 pLed->bLedBlinkInProgress = false;
484 pLed->BlinkingLedState = LED_STATE_OFF;
486 pLed->BlinkingLedState = LED_STATE_ON;
487 mod_timer(&pLed->BlinkTimer, jiffies +
488 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
496 static void SwLedBlink3(struct LED_871x *pLed)
498 struct _adapter *padapter = pLed->padapter;
499 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
500 u8 bStopBlinking = false;
502 /* Change LED according to BlinkingLedState specified. */
503 if (pLed->BlinkingLedState == LED_STATE_ON)
504 SwLedOn(padapter, pLed);
506 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
507 SwLedOff(padapter, pLed);
508 switch (pLed->CurrLedState) {
511 if (pLed->BlinkTimes == 0)
512 bStopBlinking = true;
514 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
515 pLed->CurrLedState = LED_STATE_ON;
516 pLed->BlinkingLedState = LED_STATE_ON;
518 SwLedOn(padapter, pLed);
519 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
520 pLed->CurrLedState = LED_STATE_OFF;
521 pLed->BlinkingLedState = LED_STATE_OFF;
523 SwLedOff(padapter, pLed);
525 pLed->bLedScanBlinkInProgress = false;
528 pLed->BlinkingLedState = LED_STATE_OFF;
530 pLed->BlinkingLedState = LED_STATE_ON;
531 mod_timer(&pLed->BlinkTimer, jiffies +
532 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
537 if (pLed->BlinkTimes == 0)
538 bStopBlinking = true;
540 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
541 pLed->CurrLedState = LED_STATE_ON;
542 pLed->BlinkingLedState = LED_STATE_ON;
544 SwLedOn(padapter, pLed);
545 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
546 pLed->CurrLedState = LED_STATE_OFF;
547 pLed->BlinkingLedState = LED_STATE_OFF;
549 SwLedOff(padapter, pLed);
551 pLed->bLedBlinkInProgress = false;
554 pLed->BlinkingLedState = LED_STATE_OFF;
556 pLed->BlinkingLedState = LED_STATE_ON;
557 mod_timer(&pLed->BlinkTimer, jiffies +
558 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
563 pLed->BlinkingLedState = LED_STATE_OFF;
565 pLed->BlinkingLedState = LED_STATE_ON;
566 mod_timer(&pLed->BlinkTimer, jiffies +
567 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
569 case LED_BLINK_WPS_STOP: /*WPS success*/
570 if (pLed->BlinkingLedState == LED_STATE_ON) {
571 pLed->BlinkingLedState = LED_STATE_OFF;
572 mod_timer(&pLed->BlinkTimer, jiffies +
573 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
574 bStopBlinking = false;
576 bStopBlinking = true;
579 pLed->CurrLedState = LED_STATE_ON;
580 pLed->BlinkingLedState = LED_STATE_ON;
581 SwLedOn(padapter, pLed);
582 pLed->bLedWPSBlinkInProgress = false;
590 static void SwLedBlink4(struct LED_871x *pLed)
592 struct _adapter *padapter = pLed->padapter;
593 struct led_priv *ledpriv = &padapter->ledpriv;
594 struct LED_871x *pLed1 = &ledpriv->SwLed1;
595 u8 bStopBlinking = false;
597 /* Change LED according to BlinkingLedState specified. */
598 if (pLed->BlinkingLedState == LED_STATE_ON)
599 SwLedOn(padapter, pLed);
601 SwLedOff(padapter, pLed);
602 if (!pLed1->bLedWPSBlinkInProgress &&
603 pLed1->BlinkingLedState == LED_UNKNOWN) {
604 pLed1->BlinkingLedState = LED_STATE_OFF;
605 pLed1->CurrLedState = LED_STATE_OFF;
606 SwLedOff(padapter, pLed1);
608 switch (pLed->CurrLedState) {
609 case LED_BLINK_SLOWLY:
611 pLed->BlinkingLedState = LED_STATE_OFF;
613 pLed->BlinkingLedState = LED_STATE_ON;
614 mod_timer(&pLed->BlinkTimer, jiffies +
615 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
617 case LED_BLINK_StartToBlink:
619 pLed->BlinkingLedState = LED_STATE_OFF;
620 mod_timer(&pLed->BlinkTimer, jiffies +
621 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
623 pLed->BlinkingLedState = LED_STATE_ON;
624 mod_timer(&pLed->BlinkTimer, jiffies +
625 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
630 if (pLed->BlinkTimes == 0)
631 bStopBlinking = true;
633 pLed->bLedNoLinkBlinkInProgress = true;
634 pLed->CurrLedState = LED_BLINK_SLOWLY;
636 pLed->BlinkingLedState = LED_STATE_OFF;
638 pLed->BlinkingLedState = LED_STATE_ON;
639 mod_timer(&pLed->BlinkTimer, jiffies +
640 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
641 pLed->bLedScanBlinkInProgress = false;
644 pLed->BlinkingLedState = LED_STATE_OFF;
646 pLed->BlinkingLedState = LED_STATE_ON;
647 mod_timer(&pLed->BlinkTimer, jiffies +
648 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
653 if (pLed->BlinkTimes == 0)
654 bStopBlinking = true;
656 pLed->bLedNoLinkBlinkInProgress = true;
657 pLed->CurrLedState = LED_BLINK_SLOWLY;
659 pLed->BlinkingLedState = LED_STATE_OFF;
661 pLed->BlinkingLedState = LED_STATE_ON;
662 mod_timer(&pLed->BlinkTimer, jiffies +
663 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
664 pLed->bLedBlinkInProgress = false;
667 pLed->BlinkingLedState = LED_STATE_OFF;
669 pLed->BlinkingLedState = LED_STATE_ON;
670 mod_timer(&pLed->BlinkTimer, jiffies +
671 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
676 pLed->BlinkingLedState = LED_STATE_OFF;
677 mod_timer(&pLed->BlinkTimer, jiffies +
678 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
680 pLed->BlinkingLedState = LED_STATE_ON;
681 mod_timer(&pLed->BlinkTimer, jiffies +
682 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
685 case LED_BLINK_WPS_STOP: /*WPS authentication fail*/
687 pLed->BlinkingLedState = LED_STATE_OFF;
689 pLed->BlinkingLedState = LED_STATE_ON;
690 mod_timer(&pLed->BlinkTimer, jiffies +
691 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
693 case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */
695 if (pLed->BlinkTimes == 0) {
697 pLed->BlinkTimes = 1;
699 bStopBlinking = true;
702 pLed->BlinkTimes = 10;
703 pLed->BlinkingLedState = LED_STATE_ON;
704 mod_timer(&pLed->BlinkTimer, jiffies +
705 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
708 pLed->BlinkingLedState = LED_STATE_OFF;
710 pLed->BlinkingLedState = LED_STATE_ON;
711 mod_timer(&pLed->BlinkTimer, jiffies +
712 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
720 static void SwLedBlink5(struct LED_871x *pLed)
722 struct _adapter *padapter = pLed->padapter;
723 u8 bStopBlinking = false;
725 /* Change LED according to BlinkingLedState specified. */
726 if (pLed->BlinkingLedState == LED_STATE_ON)
727 SwLedOn(padapter, pLed);
729 SwLedOff(padapter, pLed);
730 switch (pLed->CurrLedState) {
733 if (pLed->BlinkTimes == 0)
734 bStopBlinking = true;
736 pLed->CurrLedState = LED_STATE_ON;
737 pLed->BlinkingLedState = LED_STATE_ON;
739 mod_timer(&pLed->BlinkTimer, jiffies +
740 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
741 pLed->bLedScanBlinkInProgress = false;
744 pLed->BlinkingLedState = LED_STATE_OFF;
746 pLed->BlinkingLedState = LED_STATE_ON;
747 mod_timer(&pLed->BlinkTimer, jiffies +
748 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
753 if (pLed->BlinkTimes == 0)
754 bStopBlinking = true;
756 pLed->CurrLedState = LED_STATE_ON;
757 pLed->BlinkingLedState = LED_STATE_ON;
759 mod_timer(&pLed->BlinkTimer, jiffies +
760 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
761 pLed->bLedBlinkInProgress = false;
764 pLed->BlinkingLedState = LED_STATE_OFF;
766 pLed->BlinkingLedState = LED_STATE_ON;
767 mod_timer(&pLed->BlinkTimer, jiffies +
768 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
776 static void SwLedBlink6(struct LED_871x *pLed)
778 struct _adapter *padapter = pLed->padapter;
779 u8 bStopBlinking = false;
781 /* Change LED according to BlinkingLedState specified. */
782 if (pLed->BlinkingLedState == LED_STATE_ON)
783 SwLedOn(padapter, pLed);
785 SwLedOff(padapter, pLed);
786 switch (pLed->CurrLedState) {
789 if (pLed->BlinkTimes == 0)
790 bStopBlinking = true;
792 pLed->CurrLedState = LED_STATE_ON;
793 pLed->BlinkingLedState = LED_STATE_ON;
795 SwLedOn(padapter, pLed);
796 pLed->bLedBlinkInProgress = false;
799 pLed->BlinkingLedState = LED_STATE_OFF;
801 pLed->BlinkingLedState = LED_STATE_ON;
802 mod_timer(&pLed->BlinkTimer, jiffies +
803 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
808 pLed->BlinkingLedState = LED_STATE_OFF;
810 pLed->BlinkingLedState = LED_STATE_ON;
811 mod_timer(&pLed->BlinkTimer, jiffies +
812 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
821 * Callback function of LED BlinkTimer,
822 * it just schedules to corresponding BlinkWorkItem.
824 static void BlinkTimerCallback(struct timer_list *t)
826 struct LED_871x *pLed = from_timer(pLed, t, BlinkTimer);
828 /* This fixed the crash problem on Fedora 12 when trying to do the
829 * insmod;ifconfig up;rmmod commands.
831 if (pLed->padapter->bSurpriseRemoved || pLed->padapter->bDriverStopped)
833 schedule_work(&pLed->BlinkWorkItem);
837 * Callback function of LED BlinkWorkItem.
838 * We dispatch actual LED blink action according to LedStrategy.
840 static void BlinkWorkItemCallback(struct work_struct *work)
842 struct LED_871x *pLed = container_of(work, struct LED_871x,
844 struct led_priv *ledpriv = &pLed->padapter->ledpriv;
846 switch (ledpriv->LedStrategy) {
874 /*============================================================================
875 * Default LED behavior.
876 *============================================================================
879 * Implement each led action for SW_LED_MODE0.
880 * This is default strategy.
883 static void SwLedControlMode1(struct _adapter *padapter,
884 enum LED_CTL_MODE LedAction)
886 struct led_priv *ledpriv = &padapter->ledpriv;
887 struct LED_871x *pLed = &ledpriv->SwLed0;
888 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
889 struct sitesurvey_ctrl *psitesurveyctrl = &pmlmepriv->sitesurveyctrl;
891 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
892 pLed = &ledpriv->SwLed1;
894 case LED_CTL_START_TO_LINK:
895 case LED_CTL_NO_LINK:
896 if (!pLed->bLedNoLinkBlinkInProgress) {
897 if (pLed->CurrLedState == LED_SCAN_BLINK ||
898 IS_LED_WPS_BLINKING(pLed))
900 if (pLed->bLedLinkBlinkInProgress) {
901 del_timer(&pLed->BlinkTimer);
902 pLed->bLedLinkBlinkInProgress = false;
904 if (pLed->bLedBlinkInProgress) {
905 del_timer(&pLed->BlinkTimer);
906 pLed->bLedBlinkInProgress = false;
908 pLed->bLedNoLinkBlinkInProgress = true;
909 pLed->CurrLedState = LED_BLINK_SLOWLY;
911 pLed->BlinkingLedState = LED_STATE_OFF;
913 pLed->BlinkingLedState = LED_STATE_ON;
914 mod_timer(&pLed->BlinkTimer, jiffies +
915 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
919 if (!pLed->bLedLinkBlinkInProgress) {
920 if (pLed->CurrLedState == LED_SCAN_BLINK ||
921 IS_LED_WPS_BLINKING(pLed))
923 if (pLed->bLedNoLinkBlinkInProgress) {
924 del_timer(&pLed->BlinkTimer);
925 pLed->bLedNoLinkBlinkInProgress = false;
927 if (pLed->bLedBlinkInProgress) {
928 del_timer(&pLed->BlinkTimer);
929 pLed->bLedBlinkInProgress = false;
931 pLed->bLedLinkBlinkInProgress = true;
932 pLed->CurrLedState = LED_BLINK_NORMAL;
934 pLed->BlinkingLedState = LED_STATE_OFF;
936 pLed->BlinkingLedState = LED_STATE_ON;
937 mod_timer(&pLed->BlinkTimer, jiffies +
938 msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
941 case LED_CTL_SITE_SURVEY:
942 if (psitesurveyctrl->traffic_busy &&
943 check_fwstate(pmlmepriv, _FW_LINKED))
945 else if (!pLed->bLedScanBlinkInProgress) {
946 if (IS_LED_WPS_BLINKING(pLed))
948 if (pLed->bLedNoLinkBlinkInProgress) {
949 del_timer(&pLed->BlinkTimer);
950 pLed->bLedNoLinkBlinkInProgress = false;
952 if (pLed->bLedLinkBlinkInProgress) {
953 del_timer(&pLed->BlinkTimer);
954 pLed->bLedLinkBlinkInProgress = false;
956 if (pLed->bLedBlinkInProgress) {
957 del_timer(&pLed->BlinkTimer);
958 pLed->bLedBlinkInProgress = false;
960 pLed->bLedScanBlinkInProgress = true;
961 pLed->CurrLedState = LED_SCAN_BLINK;
962 pLed->BlinkTimes = 24;
964 pLed->BlinkingLedState = LED_STATE_OFF;
966 pLed->BlinkingLedState = LED_STATE_ON;
967 mod_timer(&pLed->BlinkTimer, jiffies +
968 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
973 if (!pLed->bLedBlinkInProgress) {
974 if (pLed->CurrLedState == LED_SCAN_BLINK ||
975 IS_LED_WPS_BLINKING(pLed))
977 if (pLed->bLedNoLinkBlinkInProgress) {
978 del_timer(&pLed->BlinkTimer);
979 pLed->bLedNoLinkBlinkInProgress = false;
981 if (pLed->bLedLinkBlinkInProgress) {
982 del_timer(&pLed->BlinkTimer);
983 pLed->bLedLinkBlinkInProgress = false;
985 pLed->bLedBlinkInProgress = true;
986 pLed->CurrLedState = LED_TXRX_BLINK;
987 pLed->BlinkTimes = 2;
989 pLed->BlinkingLedState = LED_STATE_OFF;
991 pLed->BlinkingLedState = LED_STATE_ON;
992 mod_timer(&pLed->BlinkTimer, jiffies +
993 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
997 case LED_CTL_START_WPS: /*wait until xinpin finish */
998 case LED_CTL_START_WPS_BOTTON:
999 if (!pLed->bLedWPSBlinkInProgress) {
1000 if (pLed->bLedNoLinkBlinkInProgress) {
1001 del_timer(&pLed->BlinkTimer);
1002 pLed->bLedNoLinkBlinkInProgress = false;
1004 if (pLed->bLedLinkBlinkInProgress) {
1005 del_timer(&pLed->BlinkTimer);
1006 pLed->bLedLinkBlinkInProgress = false;
1008 if (pLed->bLedBlinkInProgress) {
1009 del_timer(&pLed->BlinkTimer);
1010 pLed->bLedBlinkInProgress = false;
1012 if (pLed->bLedScanBlinkInProgress) {
1013 del_timer(&pLed->BlinkTimer);
1014 pLed->bLedScanBlinkInProgress = false;
1016 pLed->bLedWPSBlinkInProgress = true;
1017 pLed->CurrLedState = LED_BLINK_WPS;
1019 pLed->BlinkingLedState = LED_STATE_OFF;
1021 pLed->BlinkingLedState = LED_STATE_ON;
1022 mod_timer(&pLed->BlinkTimer, jiffies +
1023 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1026 case LED_CTL_STOP_WPS:
1027 if (pLed->bLedNoLinkBlinkInProgress) {
1028 del_timer(&pLed->BlinkTimer);
1029 pLed->bLedNoLinkBlinkInProgress = false;
1031 if (pLed->bLedLinkBlinkInProgress) {
1032 del_timer(&pLed->BlinkTimer);
1033 pLed->bLedLinkBlinkInProgress = false;
1035 if (pLed->bLedBlinkInProgress) {
1036 del_timer(&pLed->BlinkTimer);
1037 pLed->bLedBlinkInProgress = false;
1039 if (pLed->bLedScanBlinkInProgress) {
1040 del_timer(&pLed->BlinkTimer);
1041 pLed->bLedScanBlinkInProgress = false;
1043 if (pLed->bLedWPSBlinkInProgress)
1044 del_timer(&pLed->BlinkTimer);
1046 pLed->bLedWPSBlinkInProgress = true;
1047 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1049 pLed->BlinkingLedState = LED_STATE_OFF;
1050 mod_timer(&pLed->BlinkTimer, jiffies +
1051 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1053 pLed->BlinkingLedState = LED_STATE_ON;
1054 mod_timer(&pLed->BlinkTimer,
1055 jiffies + msecs_to_jiffies(0));
1058 case LED_CTL_STOP_WPS_FAIL:
1059 if (pLed->bLedWPSBlinkInProgress) {
1060 del_timer(&pLed->BlinkTimer);
1061 pLed->bLedWPSBlinkInProgress = false;
1063 pLed->bLedNoLinkBlinkInProgress = true;
1064 pLed->CurrLedState = LED_BLINK_SLOWLY;
1066 pLed->BlinkingLedState = LED_STATE_OFF;
1068 pLed->BlinkingLedState = LED_STATE_ON;
1069 mod_timer(&pLed->BlinkTimer, jiffies +
1070 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1072 case LED_CTL_POWER_OFF:
1073 pLed->CurrLedState = LED_STATE_OFF;
1074 pLed->BlinkingLedState = LED_STATE_OFF;
1075 if (pLed->bLedNoLinkBlinkInProgress) {
1076 del_timer(&pLed->BlinkTimer);
1077 pLed->bLedNoLinkBlinkInProgress = false;
1079 if (pLed->bLedLinkBlinkInProgress) {
1080 del_timer(&pLed->BlinkTimer);
1081 pLed->bLedLinkBlinkInProgress = false;
1083 if (pLed->bLedBlinkInProgress) {
1084 del_timer(&pLed->BlinkTimer);
1085 pLed->bLedBlinkInProgress = false;
1087 if (pLed->bLedWPSBlinkInProgress) {
1088 del_timer(&pLed->BlinkTimer);
1089 pLed->bLedWPSBlinkInProgress = false;
1091 if (pLed->bLedScanBlinkInProgress) {
1092 del_timer(&pLed->BlinkTimer);
1093 pLed->bLedScanBlinkInProgress = false;
1095 mod_timer(&pLed->BlinkTimer,
1096 jiffies + msecs_to_jiffies(0));
1103 static void SwLedControlMode2(struct _adapter *padapter,
1104 enum LED_CTL_MODE LedAction)
1106 struct led_priv *ledpriv = &padapter->ledpriv;
1107 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1108 struct LED_871x *pLed = &ledpriv->SwLed0;
1110 switch (LedAction) {
1111 case LED_CTL_SITE_SURVEY:
1112 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1113 ; /* dummy branch */
1114 else if (!pLed->bLedScanBlinkInProgress) {
1115 if (IS_LED_WPS_BLINKING(pLed))
1118 if (pLed->bLedBlinkInProgress) {
1119 del_timer(&pLed->BlinkTimer);
1120 pLed->bLedBlinkInProgress = false;
1122 pLed->bLedScanBlinkInProgress = true;
1123 pLed->CurrLedState = LED_SCAN_BLINK;
1124 pLed->BlinkTimes = 24;
1126 pLed->BlinkingLedState = LED_STATE_OFF;
1128 pLed->BlinkingLedState = LED_STATE_ON;
1129 mod_timer(&pLed->BlinkTimer, jiffies +
1130 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1136 if (!pLed->bLedBlinkInProgress &&
1137 check_fwstate(pmlmepriv, _FW_LINKED)) {
1138 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1139 IS_LED_WPS_BLINKING(pLed))
1141 pLed->bLedBlinkInProgress = true;
1142 pLed->CurrLedState = LED_TXRX_BLINK;
1143 pLed->BlinkTimes = 2;
1145 pLed->BlinkingLedState = LED_STATE_OFF;
1147 pLed->BlinkingLedState = LED_STATE_ON;
1148 mod_timer(&pLed->BlinkTimer, jiffies +
1149 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1154 pLed->CurrLedState = LED_STATE_ON;
1155 pLed->BlinkingLedState = LED_STATE_ON;
1156 if (pLed->bLedBlinkInProgress) {
1157 del_timer(&pLed->BlinkTimer);
1158 pLed->bLedBlinkInProgress = false;
1160 if (pLed->bLedScanBlinkInProgress) {
1161 del_timer(&pLed->BlinkTimer);
1162 pLed->bLedScanBlinkInProgress = false;
1165 mod_timer(&pLed->BlinkTimer,
1166 jiffies + msecs_to_jiffies(0));
1169 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1170 case LED_CTL_START_WPS_BOTTON:
1171 if (!pLed->bLedWPSBlinkInProgress) {
1172 if (pLed->bLedBlinkInProgress) {
1173 del_timer(&pLed->BlinkTimer);
1174 pLed->bLedBlinkInProgress = false;
1176 if (pLed->bLedScanBlinkInProgress) {
1177 del_timer(&pLed->BlinkTimer);
1178 pLed->bLedScanBlinkInProgress = false;
1180 pLed->bLedWPSBlinkInProgress = true;
1181 pLed->CurrLedState = LED_STATE_ON;
1182 pLed->BlinkingLedState = LED_STATE_ON;
1183 mod_timer(&pLed->BlinkTimer,
1184 jiffies + msecs_to_jiffies(0));
1188 case LED_CTL_STOP_WPS:
1189 pLed->bLedWPSBlinkInProgress = false;
1190 pLed->CurrLedState = LED_STATE_ON;
1191 pLed->BlinkingLedState = LED_STATE_ON;
1192 mod_timer(&pLed->BlinkTimer,
1193 jiffies + msecs_to_jiffies(0));
1196 case LED_CTL_STOP_WPS_FAIL:
1197 pLed->bLedWPSBlinkInProgress = false;
1198 pLed->CurrLedState = LED_STATE_OFF;
1199 pLed->BlinkingLedState = LED_STATE_OFF;
1200 mod_timer(&pLed->BlinkTimer,
1201 jiffies + msecs_to_jiffies(0));
1204 case LED_CTL_START_TO_LINK:
1205 case LED_CTL_NO_LINK:
1206 if (!IS_LED_BLINKING(pLed)) {
1207 pLed->CurrLedState = LED_STATE_OFF;
1208 pLed->BlinkingLedState = LED_STATE_OFF;
1209 mod_timer(&pLed->BlinkTimer,
1210 jiffies + msecs_to_jiffies(0));
1213 case LED_CTL_POWER_OFF:
1214 pLed->CurrLedState = LED_STATE_OFF;
1215 pLed->BlinkingLedState = LED_STATE_OFF;
1216 if (pLed->bLedBlinkInProgress) {
1217 del_timer(&pLed->BlinkTimer);
1218 pLed->bLedBlinkInProgress = false;
1220 if (pLed->bLedScanBlinkInProgress) {
1221 del_timer(&pLed->BlinkTimer);
1222 pLed->bLedScanBlinkInProgress = false;
1224 if (pLed->bLedWPSBlinkInProgress) {
1225 del_timer(&pLed->BlinkTimer);
1226 pLed->bLedWPSBlinkInProgress = false;
1228 mod_timer(&pLed->BlinkTimer,
1229 jiffies + msecs_to_jiffies(0));
1236 static void SwLedControlMode3(struct _adapter *padapter,
1237 enum LED_CTL_MODE LedAction)
1239 struct led_priv *ledpriv = &padapter->ledpriv;
1240 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1241 struct LED_871x *pLed = &ledpriv->SwLed0;
1243 switch (LedAction) {
1244 case LED_CTL_SITE_SURVEY:
1245 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1246 ; /* dummy branch */
1247 else if (!pLed->bLedScanBlinkInProgress) {
1248 if (IS_LED_WPS_BLINKING(pLed))
1250 if (pLed->bLedBlinkInProgress) {
1251 del_timer(&pLed->BlinkTimer);
1252 pLed->bLedBlinkInProgress = false;
1254 pLed->bLedScanBlinkInProgress = true;
1255 pLed->CurrLedState = LED_SCAN_BLINK;
1256 pLed->BlinkTimes = 24;
1258 pLed->BlinkingLedState = LED_STATE_OFF;
1260 pLed->BlinkingLedState = LED_STATE_ON;
1261 mod_timer(&pLed->BlinkTimer, jiffies +
1262 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1267 if (!pLed->bLedBlinkInProgress &&
1268 check_fwstate(pmlmepriv, _FW_LINKED)) {
1269 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1270 IS_LED_WPS_BLINKING(pLed))
1272 pLed->bLedBlinkInProgress = true;
1273 pLed->CurrLedState = LED_TXRX_BLINK;
1274 pLed->BlinkTimes = 2;
1276 pLed->BlinkingLedState = LED_STATE_OFF;
1278 pLed->BlinkingLedState = LED_STATE_ON;
1279 mod_timer(&pLed->BlinkTimer, jiffies +
1280 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1284 if (IS_LED_WPS_BLINKING(pLed))
1286 pLed->CurrLedState = LED_STATE_ON;
1287 pLed->BlinkingLedState = LED_STATE_ON;
1288 if (pLed->bLedBlinkInProgress) {
1289 del_timer(&pLed->BlinkTimer);
1290 pLed->bLedBlinkInProgress = false;
1292 if (pLed->bLedScanBlinkInProgress) {
1293 del_timer(&pLed->BlinkTimer);
1294 pLed->bLedScanBlinkInProgress = false;
1296 mod_timer(&pLed->BlinkTimer,
1297 jiffies + msecs_to_jiffies(0));
1299 case LED_CTL_START_WPS: /* wait until xinpin finish */
1300 case LED_CTL_START_WPS_BOTTON:
1301 if (!pLed->bLedWPSBlinkInProgress) {
1302 if (pLed->bLedBlinkInProgress) {
1303 del_timer(&pLed->BlinkTimer);
1304 pLed->bLedBlinkInProgress = false;
1306 if (pLed->bLedScanBlinkInProgress) {
1307 del_timer(&pLed->BlinkTimer);
1308 pLed->bLedScanBlinkInProgress = false;
1310 pLed->bLedWPSBlinkInProgress = true;
1311 pLed->CurrLedState = LED_BLINK_WPS;
1313 pLed->BlinkingLedState = LED_STATE_OFF;
1315 pLed->BlinkingLedState = LED_STATE_ON;
1316 mod_timer(&pLed->BlinkTimer, jiffies +
1317 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1320 case LED_CTL_STOP_WPS:
1321 if (pLed->bLedWPSBlinkInProgress) {
1322 del_timer(&pLed->BlinkTimer);
1323 pLed->bLedWPSBlinkInProgress = false;
1325 pLed->bLedWPSBlinkInProgress = true;
1327 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1329 pLed->BlinkingLedState = LED_STATE_OFF;
1330 mod_timer(&pLed->BlinkTimer, jiffies +
1331 msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1333 pLed->BlinkingLedState = LED_STATE_ON;
1334 mod_timer(&pLed->BlinkTimer,
1335 jiffies + msecs_to_jiffies(0));
1338 case LED_CTL_STOP_WPS_FAIL:
1339 if (pLed->bLedWPSBlinkInProgress) {
1340 del_timer(&pLed->BlinkTimer);
1341 pLed->bLedWPSBlinkInProgress = false;
1343 pLed->CurrLedState = LED_STATE_OFF;
1344 pLed->BlinkingLedState = LED_STATE_OFF;
1345 mod_timer(&pLed->BlinkTimer,
1346 jiffies + msecs_to_jiffies(0));
1348 case LED_CTL_START_TO_LINK:
1349 case LED_CTL_NO_LINK:
1350 if (!IS_LED_BLINKING(pLed)) {
1351 pLed->CurrLedState = LED_STATE_OFF;
1352 pLed->BlinkingLedState = LED_STATE_OFF;
1353 mod_timer(&pLed->BlinkTimer,
1354 jiffies + msecs_to_jiffies(0));
1357 case LED_CTL_POWER_OFF:
1358 pLed->CurrLedState = LED_STATE_OFF;
1359 pLed->BlinkingLedState = LED_STATE_OFF;
1360 if (pLed->bLedBlinkInProgress) {
1361 del_timer(&pLed->BlinkTimer);
1362 pLed->bLedBlinkInProgress = false;
1364 if (pLed->bLedScanBlinkInProgress) {
1365 del_timer(&pLed->BlinkTimer);
1366 pLed->bLedScanBlinkInProgress = false;
1368 if (pLed->bLedWPSBlinkInProgress) {
1369 del_timer(&pLed->BlinkTimer);
1370 pLed->bLedWPSBlinkInProgress = false;
1372 mod_timer(&pLed->BlinkTimer,
1373 jiffies + msecs_to_jiffies(0));
1380 static void SwLedControlMode4(struct _adapter *padapter,
1381 enum LED_CTL_MODE LedAction)
1383 struct led_priv *ledpriv = &padapter->ledpriv;
1384 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1385 struct LED_871x *pLed = &ledpriv->SwLed0;
1386 struct LED_871x *pLed1 = &ledpriv->SwLed1;
1388 switch (LedAction) {
1389 case LED_CTL_START_TO_LINK:
1390 if (pLed1->bLedWPSBlinkInProgress) {
1391 pLed1->bLedWPSBlinkInProgress = false;
1392 del_timer(&pLed1->BlinkTimer);
1393 pLed1->BlinkingLedState = LED_STATE_OFF;
1394 pLed1->CurrLedState = LED_STATE_OFF;
1396 mod_timer(&pLed->BlinkTimer,
1397 jiffies + msecs_to_jiffies(0));
1399 if (!pLed->bLedStartToLinkBlinkInProgress) {
1400 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1401 IS_LED_WPS_BLINKING(pLed))
1403 if (pLed->bLedBlinkInProgress) {
1404 del_timer(&pLed->BlinkTimer);
1405 pLed->bLedBlinkInProgress = false;
1407 if (pLed->bLedNoLinkBlinkInProgress) {
1408 del_timer(&pLed->BlinkTimer);
1409 pLed->bLedNoLinkBlinkInProgress = false;
1411 pLed->bLedStartToLinkBlinkInProgress = true;
1412 pLed->CurrLedState = LED_BLINK_StartToBlink;
1414 pLed->BlinkingLedState = LED_STATE_OFF;
1415 mod_timer(&pLed->BlinkTimer, jiffies +
1416 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1418 pLed->BlinkingLedState = LED_STATE_ON;
1419 mod_timer(&pLed->BlinkTimer, jiffies +
1420 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1425 case LED_CTL_NO_LINK:
1427 if (LedAction == LED_CTL_LINK) {
1428 if (pLed1->bLedWPSBlinkInProgress) {
1429 pLed1->bLedWPSBlinkInProgress = false;
1430 del_timer(&pLed1->BlinkTimer);
1431 pLed1->BlinkingLedState = LED_STATE_OFF;
1432 pLed1->CurrLedState = LED_STATE_OFF;
1434 mod_timer(&pLed->BlinkTimer,
1435 jiffies + msecs_to_jiffies(0));
1438 if (!pLed->bLedNoLinkBlinkInProgress) {
1439 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1440 IS_LED_WPS_BLINKING(pLed))
1442 if (pLed->bLedBlinkInProgress) {
1443 del_timer(&pLed->BlinkTimer);
1444 pLed->bLedBlinkInProgress = false;
1446 pLed->bLedNoLinkBlinkInProgress = true;
1447 pLed->CurrLedState = LED_BLINK_SLOWLY;
1449 pLed->BlinkingLedState = LED_STATE_OFF;
1451 pLed->BlinkingLedState = LED_STATE_ON;
1452 mod_timer(&pLed->BlinkTimer, jiffies +
1453 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1456 case LED_CTL_SITE_SURVEY:
1457 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1458 check_fwstate(pmlmepriv, _FW_LINKED))
1460 else if (!pLed->bLedScanBlinkInProgress) {
1461 if (IS_LED_WPS_BLINKING(pLed))
1463 if (pLed->bLedNoLinkBlinkInProgress) {
1464 del_timer(&pLed->BlinkTimer);
1465 pLed->bLedNoLinkBlinkInProgress = false;
1467 if (pLed->bLedBlinkInProgress) {
1468 del_timer(&pLed->BlinkTimer);
1469 pLed->bLedBlinkInProgress = false;
1471 pLed->bLedScanBlinkInProgress = true;
1472 pLed->CurrLedState = LED_SCAN_BLINK;
1473 pLed->BlinkTimes = 24;
1475 pLed->BlinkingLedState = LED_STATE_OFF;
1477 pLed->BlinkingLedState = LED_STATE_ON;
1478 mod_timer(&pLed->BlinkTimer, jiffies +
1479 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1484 if (!pLed->bLedBlinkInProgress) {
1485 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1486 IS_LED_WPS_BLINKING(pLed))
1488 if (pLed->bLedNoLinkBlinkInProgress) {
1489 del_timer(&pLed->BlinkTimer);
1490 pLed->bLedNoLinkBlinkInProgress = false;
1492 pLed->bLedBlinkInProgress = true;
1493 pLed->CurrLedState = LED_TXRX_BLINK;
1494 pLed->BlinkTimes = 2;
1496 pLed->BlinkingLedState = LED_STATE_OFF;
1498 pLed->BlinkingLedState = LED_STATE_ON;
1499 mod_timer(&pLed->BlinkTimer, jiffies +
1500 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1503 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1504 case LED_CTL_START_WPS_BOTTON:
1505 if (pLed1->bLedWPSBlinkInProgress) {
1506 pLed1->bLedWPSBlinkInProgress = false;
1507 del_timer(&pLed1->BlinkTimer);
1508 pLed1->BlinkingLedState = LED_STATE_OFF;
1509 pLed1->CurrLedState = LED_STATE_OFF;
1511 mod_timer(&pLed->BlinkTimer,
1512 jiffies + msecs_to_jiffies(0));
1514 if (!pLed->bLedWPSBlinkInProgress) {
1515 if (pLed->bLedNoLinkBlinkInProgress) {
1516 del_timer(&pLed->BlinkTimer);
1517 pLed->bLedNoLinkBlinkInProgress = false;
1519 if (pLed->bLedBlinkInProgress) {
1520 del_timer(&pLed->BlinkTimer);
1521 pLed->bLedBlinkInProgress = false;
1523 if (pLed->bLedScanBlinkInProgress) {
1524 del_timer(&pLed->BlinkTimer);
1525 pLed->bLedScanBlinkInProgress = false;
1527 pLed->bLedWPSBlinkInProgress = true;
1528 pLed->CurrLedState = LED_BLINK_WPS;
1530 pLed->BlinkingLedState = LED_STATE_OFF;
1531 mod_timer(&pLed->BlinkTimer, jiffies +
1532 msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1534 pLed->BlinkingLedState = LED_STATE_ON;
1535 mod_timer(&pLed->BlinkTimer, jiffies +
1536 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1540 case LED_CTL_STOP_WPS: /*WPS connect success*/
1541 if (pLed->bLedWPSBlinkInProgress) {
1542 del_timer(&pLed->BlinkTimer);
1543 pLed->bLedWPSBlinkInProgress = false;
1545 pLed->bLedNoLinkBlinkInProgress = true;
1546 pLed->CurrLedState = LED_BLINK_SLOWLY;
1548 pLed->BlinkingLedState = LED_STATE_OFF;
1550 pLed->BlinkingLedState = LED_STATE_ON;
1551 mod_timer(&pLed->BlinkTimer, jiffies +
1552 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1554 case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/
1555 if (pLed->bLedWPSBlinkInProgress) {
1556 del_timer(&pLed->BlinkTimer);
1557 pLed->bLedWPSBlinkInProgress = false;
1559 pLed->bLedNoLinkBlinkInProgress = true;
1560 pLed->CurrLedState = LED_BLINK_SLOWLY;
1562 pLed->BlinkingLedState = LED_STATE_OFF;
1564 pLed->BlinkingLedState = LED_STATE_ON;
1565 mod_timer(&pLed->BlinkTimer, jiffies +
1566 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1568 if (pLed1->bLedWPSBlinkInProgress)
1569 del_timer(&pLed1->BlinkTimer);
1571 pLed1->bLedWPSBlinkInProgress = true;
1572 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1574 pLed1->BlinkingLedState = LED_STATE_OFF;
1576 pLed1->BlinkingLedState = LED_STATE_ON;
1577 mod_timer(&pLed->BlinkTimer, jiffies +
1578 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1580 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/
1581 if (pLed->bLedWPSBlinkInProgress) {
1582 del_timer(&pLed->BlinkTimer);
1583 pLed->bLedWPSBlinkInProgress = false;
1585 pLed->bLedNoLinkBlinkInProgress = true;
1586 pLed->CurrLedState = LED_BLINK_SLOWLY;
1588 pLed->BlinkingLedState = LED_STATE_OFF;
1590 pLed->BlinkingLedState = LED_STATE_ON;
1591 mod_timer(&pLed->BlinkTimer, jiffies +
1592 msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1594 if (pLed1->bLedWPSBlinkInProgress)
1595 del_timer(&pLed1->BlinkTimer);
1597 pLed1->bLedWPSBlinkInProgress = true;
1598 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1599 pLed1->BlinkTimes = 10;
1601 pLed1->BlinkingLedState = LED_STATE_OFF;
1603 pLed1->BlinkingLedState = LED_STATE_ON;
1604 mod_timer(&pLed->BlinkTimer, jiffies +
1605 msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1607 case LED_CTL_POWER_OFF:
1608 pLed->CurrLedState = LED_STATE_OFF;
1609 pLed->BlinkingLedState = LED_STATE_OFF;
1610 if (pLed->bLedNoLinkBlinkInProgress) {
1611 del_timer(&pLed->BlinkTimer);
1612 pLed->bLedNoLinkBlinkInProgress = false;
1614 if (pLed->bLedLinkBlinkInProgress) {
1615 del_timer(&pLed->BlinkTimer);
1616 pLed->bLedLinkBlinkInProgress = false;
1618 if (pLed->bLedBlinkInProgress) {
1619 del_timer(&pLed->BlinkTimer);
1620 pLed->bLedBlinkInProgress = false;
1622 if (pLed->bLedWPSBlinkInProgress) {
1623 del_timer(&pLed->BlinkTimer);
1624 pLed->bLedWPSBlinkInProgress = false;
1626 if (pLed->bLedScanBlinkInProgress) {
1627 del_timer(&pLed->BlinkTimer);
1628 pLed->bLedScanBlinkInProgress = false;
1630 if (pLed->bLedStartToLinkBlinkInProgress) {
1631 del_timer(&pLed->BlinkTimer);
1632 pLed->bLedStartToLinkBlinkInProgress = false;
1634 if (pLed1->bLedWPSBlinkInProgress) {
1635 del_timer(&pLed1->BlinkTimer);
1636 pLed1->bLedWPSBlinkInProgress = false;
1638 pLed1->BlinkingLedState = LED_UNKNOWN;
1639 SwLedOff(padapter, pLed);
1640 SwLedOff(padapter, pLed1);
1647 static void SwLedControlMode5(struct _adapter *padapter,
1648 enum LED_CTL_MODE LedAction)
1650 struct led_priv *ledpriv = &padapter->ledpriv;
1651 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1652 struct LED_871x *pLed = &ledpriv->SwLed0;
1654 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1655 pLed = &ledpriv->SwLed1;
1657 switch (LedAction) {
1658 case LED_CTL_POWER_ON:
1659 case LED_CTL_NO_LINK:
1660 case LED_CTL_LINK: /* solid blue */
1661 if (pLed->CurrLedState == LED_SCAN_BLINK)
1663 pLed->CurrLedState = LED_STATE_ON;
1664 pLed->BlinkingLedState = LED_STATE_ON;
1665 pLed->bLedBlinkInProgress = false;
1666 mod_timer(&pLed->BlinkTimer,
1667 jiffies + msecs_to_jiffies(0));
1669 case LED_CTL_SITE_SURVEY:
1670 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1671 check_fwstate(pmlmepriv, _FW_LINKED))
1672 ; /* dummy branch */
1673 else if (!pLed->bLedScanBlinkInProgress) {
1674 if (pLed->bLedBlinkInProgress) {
1675 del_timer(&pLed->BlinkTimer);
1676 pLed->bLedBlinkInProgress = false;
1678 pLed->bLedScanBlinkInProgress = true;
1679 pLed->CurrLedState = LED_SCAN_BLINK;
1680 pLed->BlinkTimes = 24;
1682 pLed->BlinkingLedState = LED_STATE_OFF;
1684 pLed->BlinkingLedState = LED_STATE_ON;
1685 mod_timer(&pLed->BlinkTimer, jiffies +
1686 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1691 if (!pLed->bLedBlinkInProgress) {
1692 if (pLed->CurrLedState == LED_SCAN_BLINK)
1694 pLed->bLedBlinkInProgress = true;
1695 pLed->CurrLedState = LED_TXRX_BLINK;
1696 pLed->BlinkTimes = 2;
1698 pLed->BlinkingLedState = LED_STATE_OFF;
1700 pLed->BlinkingLedState = LED_STATE_ON;
1701 mod_timer(&pLed->BlinkTimer, jiffies +
1702 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1705 case LED_CTL_POWER_OFF:
1706 pLed->CurrLedState = LED_STATE_OFF;
1707 pLed->BlinkingLedState = LED_STATE_OFF;
1708 if (pLed->bLedBlinkInProgress) {
1709 del_timer(&pLed->BlinkTimer);
1710 pLed->bLedBlinkInProgress = false;
1712 SwLedOff(padapter, pLed);
1720 static void SwLedControlMode6(struct _adapter *padapter,
1721 enum LED_CTL_MODE LedAction)
1723 struct led_priv *ledpriv = &padapter->ledpriv;
1724 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1725 struct LED_871x *pLed = &ledpriv->SwLed0;
1727 switch (LedAction) {
1728 case LED_CTL_POWER_ON:
1729 case LED_CTL_NO_LINK:
1730 case LED_CTL_LINK: /*solid blue*/
1731 case LED_CTL_SITE_SURVEY:
1732 if (IS_LED_WPS_BLINKING(pLed))
1734 pLed->CurrLedState = LED_STATE_ON;
1735 pLed->BlinkingLedState = LED_STATE_ON;
1736 pLed->bLedBlinkInProgress = false;
1737 mod_timer(&pLed->BlinkTimer, jiffies + msecs_to_jiffies(0));
1741 if (!pLed->bLedBlinkInProgress &&
1742 check_fwstate(pmlmepriv, _FW_LINKED)) {
1743 if (IS_LED_WPS_BLINKING(pLed))
1745 pLed->bLedBlinkInProgress = true;
1746 pLed->CurrLedState = LED_TXRX_BLINK;
1747 pLed->BlinkTimes = 2;
1749 pLed->BlinkingLedState = LED_STATE_OFF;
1751 pLed->BlinkingLedState = LED_STATE_ON;
1752 mod_timer(&pLed->BlinkTimer, jiffies +
1753 msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1756 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1757 case LED_CTL_START_WPS_BOTTON:
1758 if (!pLed->bLedWPSBlinkInProgress) {
1759 if (pLed->bLedBlinkInProgress) {
1760 del_timer(&pLed->BlinkTimer);
1761 pLed->bLedBlinkInProgress = false;
1763 pLed->bLedWPSBlinkInProgress = true;
1764 pLed->CurrLedState = LED_BLINK_WPS;
1766 pLed->BlinkingLedState = LED_STATE_OFF;
1768 pLed->BlinkingLedState = LED_STATE_ON;
1769 mod_timer(&pLed->BlinkTimer, jiffies +
1770 msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1773 case LED_CTL_STOP_WPS_FAIL:
1774 case LED_CTL_STOP_WPS:
1775 if (pLed->bLedWPSBlinkInProgress) {
1776 del_timer(&pLed->BlinkTimer);
1777 pLed->bLedWPSBlinkInProgress = false;
1779 pLed->CurrLedState = LED_STATE_ON;
1780 pLed->BlinkingLedState = LED_STATE_ON;
1781 mod_timer(&pLed->BlinkTimer,
1782 jiffies + msecs_to_jiffies(0));
1784 case LED_CTL_POWER_OFF:
1785 pLed->CurrLedState = LED_STATE_OFF;
1786 pLed->BlinkingLedState = LED_STATE_OFF;
1787 if (pLed->bLedBlinkInProgress) {
1788 del_timer(&pLed->BlinkTimer);
1789 pLed->bLedBlinkInProgress = false;
1791 if (pLed->bLedWPSBlinkInProgress) {
1792 del_timer(&pLed->BlinkTimer);
1793 pLed->bLedWPSBlinkInProgress = false;
1795 SwLedOff(padapter, pLed);
1803 * Dispatch LED action according to pHalData->LedStrategy.
1805 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1807 struct led_priv *ledpriv = &padapter->ledpriv;
1809 if (!ledpriv->bRegUseLed)
1811 switch (ledpriv->LedStrategy) {
1815 SwLedControlMode1(padapter, LedAction);
1818 SwLedControlMode2(padapter, LedAction);
1821 SwLedControlMode3(padapter, LedAction);
1824 SwLedControlMode4(padapter, LedAction);
1827 SwLedControlMode5(padapter, LedAction);
1830 SwLedControlMode6(padapter, LedAction);