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_SUCESS_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
62
LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */
63
LED_BLINK_StartToBlink = 8,/* Customzied for Sercomm Printer
65
LED_BLINK_WPS = 9, /* LED is blinkg during WPS communication */
67
LED_BLINK_WPS_STOP = 11, /*for ALPHA */
68
LED_BLINK_WPS_STOP_OVERLAP = 12, /*for BELKIN */
71
/*===========================================================================
72
* Prototype of protected function.
73
*===========================================================================
75
static void BlinkTimerCallback(unsigned long data);
77
static void BlinkWorkItemCallback(struct work_struct *work);
78
/*===========================================================================
79
* LED_819xUsb routines.
80
*===========================================================================
85
* Initialize an LED_871x object.
87
static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed,
88
enum LED_PIN_871x LedPin)
90
struct net_device *nic;
92
nic = padapter->pnetdev;
93
pLed->padapter = padapter;
94
pLed->LedPin = LedPin;
95
pLed->CurrLedState = LED_OFF;
97
pLed->bLedBlinkInProgress = false;
99
pLed->BlinkingLedState = LED_UNKNOWN;
100
_init_timer(&(pLed->BlinkTimer), nic, BlinkTimerCallback, pLed);
101
_init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
106
* DeInitialize an LED_871x object.
108
static void DeInitLed871x(struct LED_871x *pLed)
110
_cancel_timer_ex(&(pLed->BlinkTimer));
111
/* We should reset bLedBlinkInProgress if we cancel
112
* 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 == true) ||
125
(padapter->bDriverStopped == true))
127
LedCfg = r8712_read8(padapter, LEDCFG);
128
switch (pLed->LedPin) {
132
/* SW control led0 on.*/
133
r8712_write8(padapter, LEDCFG, LedCfg&0xf0);
136
/* SW control led1 on.*/
137
r8712_write8(padapter, LEDCFG, LedCfg&0x0f);
147
* Turn off LED according to LedPin specified.
149
static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
153
if ((padapter->bSurpriseRemoved == true) ||
154
(padapter->bDriverStopped == true))
156
LedCfg = r8712_read8(padapter, LEDCFG);
157
switch (pLed->LedPin) {
161
LedCfg &= 0xf0; /* Set to software control.*/
162
r8712_write8(padapter, LEDCFG, (LedCfg|BIT(3)));
165
LedCfg &= 0x0f; /* Set to software control.*/
166
r8712_write8(padapter, LEDCFG, (LedCfg|BIT(7)));
171
pLed->bLedOn = false;
174
/*===========================================================================
175
* Interface to manipulate LED objects.
176
*===========================================================================
179
* Initialize all LED_871x objects.
181
void r8712_InitSwLeds(struct _adapter *padapter)
183
struct led_priv *pledpriv = &(padapter->ledpriv);
185
pledpriv->LedControlHandler = LedControl871x;
186
InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
187
InitLed871x(padapter, &(pledpriv->SwLed1), LED_PIN_LED1);
191
* DeInitialize all LED_819xUsb objects.
193
void r8712_DeInitSwLeds(struct _adapter *padapter)
195
struct led_priv *ledpriv = &(padapter->ledpriv);
197
DeInitLed871x(&(ledpriv->SwLed0));
198
DeInitLed871x(&(ledpriv->SwLed1));
202
* Implementation of LED blinking behavior.
203
* It toggle off LED and schedule corresponding timer if necessary.
205
static void SwLedBlink(struct LED_871x *pLed)
207
struct _adapter *padapter = pLed->padapter;
208
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
209
u8 bStopBlinking = false;
211
/* Change LED according to BlinkingLedState specified. */
212
if (pLed->BlinkingLedState == LED_ON)
213
SwLedOn(padapter, pLed);
215
SwLedOff(padapter, pLed);
216
/* Determine if we shall change LED state again. */
218
switch (pLed->CurrLedState) {
219
case LED_BLINK_NORMAL:
220
if (pLed->BlinkTimes == 0)
221
bStopBlinking = true;
223
case LED_BLINK_StartToBlink:
224
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) &&
225
(pmlmepriv->fw_state & WIFI_STATION_STATE))
226
bStopBlinking = true;
227
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) &&
228
((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
229
(pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
230
bStopBlinking = true;
231
else if (pLed->BlinkTimes == 0)
232
bStopBlinking = true;
235
if (pLed->BlinkTimes == 0)
236
bStopBlinking = true;
239
bStopBlinking = true;
243
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) &&
244
(pLed->bLedOn == false))
245
SwLedOn(padapter, pLed);
246
else if ((check_fwstate(pmlmepriv, _FW_LINKED) ==
247
true) && pLed->bLedOn == true)
248
SwLedOff(padapter, pLed);
249
pLed->BlinkTimes = 0;
250
pLed->bLedBlinkInProgress = false;
252
/* Assign LED state to toggle. */
253
if (pLed->BlinkingLedState == LED_ON)
254
pLed->BlinkingLedState = LED_OFF;
256
pLed->BlinkingLedState = LED_ON;
258
/* Schedule a timer to toggle LED state. */
259
switch (pLed->CurrLedState) {
260
case LED_BLINK_NORMAL:
261
_set_timer(&(pLed->BlinkTimer),
262
LED_BLINK_NORMAL_INTERVAL);
264
case LED_BLINK_SLOWLY:
265
case LED_BLINK_StartToBlink:
266
_set_timer(&(pLed->BlinkTimer),
267
LED_BLINK_SLOWLY_INTERVAL);
270
if (pLed->BlinkingLedState == LED_ON)
271
_set_timer(&(pLed->BlinkTimer),
272
LED_BLINK_LONG_INTERVAL);
274
_set_timer(&(pLed->BlinkTimer),
275
LED_BLINK_LONG_INTERVAL);
278
_set_timer(&(pLed->BlinkTimer),
279
LED_BLINK_SLOWLY_INTERVAL);
285
static void SwLedBlink1(struct LED_871x *pLed)
287
struct _adapter *padapter = pLed->padapter;
288
struct led_priv *ledpriv = &(padapter->ledpriv);
289
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
290
struct eeprom_priv *peeprompriv = &(padapter->eeprompriv);
291
struct LED_871x *pLed1 = &(ledpriv->SwLed1);
292
u8 bStopBlinking = false;
294
if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
295
pLed = &(ledpriv->SwLed1);
296
/* Change LED according to BlinkingLedState specified. */
297
if (pLed->BlinkingLedState == LED_ON)
298
SwLedOn(padapter, pLed);
300
SwLedOff(padapter, pLed);
301
if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
302
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
303
if (!pLed1->bSWLedCtrl) {
304
SwLedOn(padapter, pLed1);
305
pLed1->bSWLedCtrl = true;
306
} else if (!pLed1->bLedOn)
307
SwLedOn(padapter, pLed1);
309
if (!pLed1->bSWLedCtrl) {
310
SwLedOff(padapter, pLed1);
311
pLed1->bSWLedCtrl = true;
312
} else if (pLed1->bLedOn)
313
SwLedOff(padapter, pLed1);
316
switch (pLed->CurrLedState) {
317
case LED_BLINK_SLOWLY:
319
pLed->BlinkingLedState = LED_OFF;
321
pLed->BlinkingLedState = LED_ON;
322
_set_timer(&(pLed->BlinkTimer),
323
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
325
case LED_BLINK_NORMAL:
327
pLed->BlinkingLedState = LED_OFF;
329
pLed->BlinkingLedState = LED_ON;
330
_set_timer(&(pLed->BlinkTimer),
331
LED_BLINK_LINK_INTERVAL_ALPHA);
335
if (pLed->BlinkTimes == 0)
336
bStopBlinking = true;
338
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
339
pLed->bLedLinkBlinkInProgress = true;
340
pLed->CurrLedState = LED_BLINK_NORMAL;
342
pLed->BlinkingLedState = LED_OFF;
344
pLed->BlinkingLedState = LED_ON;
345
_set_timer(&(pLed->BlinkTimer),
346
LED_BLINK_LINK_INTERVAL_ALPHA);
347
} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
348
pLed->bLedNoLinkBlinkInProgress = true;
349
pLed->CurrLedState = LED_BLINK_SLOWLY;
351
pLed->BlinkingLedState = LED_OFF;
353
pLed->BlinkingLedState = LED_ON;
354
_set_timer(&(pLed->BlinkTimer),
355
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
357
pLed->bLedScanBlinkInProgress = false;
360
pLed->BlinkingLedState = LED_OFF;
362
pLed->BlinkingLedState = LED_ON;
363
_set_timer(&(pLed->BlinkTimer),
364
LED_BLINK_SCAN_INTERVAL_ALPHA);
369
if (pLed->BlinkTimes == 0)
370
bStopBlinking = true;
372
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
373
pLed->bLedLinkBlinkInProgress = true;
374
pLed->CurrLedState = LED_BLINK_NORMAL;
376
pLed->BlinkingLedState = LED_OFF;
378
pLed->BlinkingLedState = LED_ON;
379
_set_timer(&(pLed->BlinkTimer),
380
LED_BLINK_LINK_INTERVAL_ALPHA);
381
} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
382
pLed->bLedNoLinkBlinkInProgress = true;
383
pLed->CurrLedState = LED_BLINK_SLOWLY;
385
pLed->BlinkingLedState = LED_OFF;
387
pLed->BlinkingLedState = LED_ON;
388
_set_timer(&(pLed->BlinkTimer),
389
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
391
pLed->BlinkTimes = 0;
392
pLed->bLedBlinkInProgress = false;
395
pLed->BlinkingLedState = LED_OFF;
397
pLed->BlinkingLedState = LED_ON;
398
_set_timer(&(pLed->BlinkTimer),
399
LED_BLINK_FASTER_INTERVAL_ALPHA);
404
pLed->BlinkingLedState = LED_OFF;
406
pLed->BlinkingLedState = LED_ON;
407
_set_timer(&(pLed->BlinkTimer),
408
LED_BLINK_SCAN_INTERVAL_ALPHA);
410
case LED_BLINK_WPS_STOP: /* WPS success */
411
if (pLed->BlinkingLedState == LED_ON) {
412
pLed->BlinkingLedState = LED_OFF;
413
_set_timer(&(pLed->BlinkTimer),
414
LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
415
bStopBlinking = false;
417
bStopBlinking = true;
419
pLed->bLedLinkBlinkInProgress = true;
420
pLed->CurrLedState = LED_BLINK_NORMAL;
422
pLed->BlinkingLedState = LED_OFF;
424
pLed->BlinkingLedState = LED_ON;
425
_set_timer(&(pLed->BlinkTimer),
426
LED_BLINK_LINK_INTERVAL_ALPHA);
428
pLed->bLedWPSBlinkInProgress = false;
435
static void SwLedBlink2(struct LED_871x *pLed)
437
struct _adapter *padapter = pLed->padapter;
438
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
439
u8 bStopBlinking = false;
441
/* Change LED according to BlinkingLedState specified. */
442
if (pLed->BlinkingLedState == LED_ON)
443
SwLedOn(padapter, pLed);
445
SwLedOff(padapter, pLed);
446
switch (pLed->CurrLedState) {
449
if (pLed->BlinkTimes == 0)
450
bStopBlinking = true;
452
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
453
pLed->CurrLedState = LED_ON;
454
pLed->BlinkingLedState = LED_ON;
455
SwLedOn(padapter, pLed);
456
} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
457
pLed->CurrLedState = LED_OFF;
458
pLed->BlinkingLedState = LED_OFF;
459
SwLedOff(padapter, pLed);
461
pLed->bLedScanBlinkInProgress = false;
464
pLed->BlinkingLedState = LED_OFF;
466
pLed->BlinkingLedState = LED_ON;
467
_set_timer(&(pLed->BlinkTimer),
468
LED_BLINK_SCAN_INTERVAL_ALPHA);
473
if (pLed->BlinkTimes == 0)
474
bStopBlinking = true;
476
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
477
pLed->CurrLedState = LED_ON;
478
pLed->BlinkingLedState = LED_ON;
479
SwLedOn(padapter, pLed);
480
} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
481
pLed->CurrLedState = LED_OFF;
482
pLed->BlinkingLedState = LED_OFF;
483
SwLedOff(padapter, pLed);
485
pLed->bLedBlinkInProgress = false;
488
pLed->BlinkingLedState = LED_OFF;
490
pLed->BlinkingLedState = LED_ON;
491
_set_timer(&(pLed->BlinkTimer),
492
LED_BLINK_FASTER_INTERVAL_ALPHA);
500
static void SwLedBlink3(struct LED_871x *pLed)
502
struct _adapter *padapter = pLed->padapter;
503
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
504
u8 bStopBlinking = false;
506
/* Change LED according to BlinkingLedState specified. */
507
if (pLed->BlinkingLedState == LED_ON)
508
SwLedOn(padapter, pLed);
510
if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
511
SwLedOff(padapter, pLed);
512
switch (pLed->CurrLedState) {
515
if (pLed->BlinkTimes == 0)
516
bStopBlinking = true;
518
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
519
pLed->CurrLedState = LED_ON;
520
pLed->BlinkingLedState = LED_ON;
522
SwLedOn(padapter, pLed);
523
} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
524
pLed->CurrLedState = LED_OFF;
525
pLed->BlinkingLedState = LED_OFF;
527
SwLedOff(padapter, pLed);
529
pLed->bLedScanBlinkInProgress = false;
532
pLed->BlinkingLedState = LED_OFF;
534
pLed->BlinkingLedState = LED_ON;
535
_set_timer(&(pLed->BlinkTimer),
536
LED_BLINK_SCAN_INTERVAL_ALPHA);
541
if (pLed->BlinkTimes == 0)
542
bStopBlinking = true;
544
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
545
pLed->CurrLedState = LED_ON;
546
pLed->BlinkingLedState = LED_ON;
548
SwLedOn(padapter, pLed);
549
} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
550
pLed->CurrLedState = LED_OFF;
551
pLed->BlinkingLedState = LED_OFF;
553
SwLedOff(padapter, pLed);
555
pLed->bLedBlinkInProgress = false;
558
pLed->BlinkingLedState = LED_OFF;
560
pLed->BlinkingLedState = LED_ON;
561
_set_timer(&(pLed->BlinkTimer),
562
LED_BLINK_FASTER_INTERVAL_ALPHA);
567
pLed->BlinkingLedState = LED_OFF;
569
pLed->BlinkingLedState = LED_ON;
570
_set_timer(&(pLed->BlinkTimer),
571
LED_BLINK_SCAN_INTERVAL_ALPHA);
573
case LED_BLINK_WPS_STOP: /*WPS success*/
574
if (pLed->BlinkingLedState == LED_ON) {
575
pLed->BlinkingLedState = LED_OFF;
576
_set_timer(&(pLed->BlinkTimer),
577
LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
578
bStopBlinking = false;
580
bStopBlinking = true;
582
pLed->CurrLedState = LED_ON;
583
pLed->BlinkingLedState = LED_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_ON)
602
SwLedOn(padapter, pLed);
604
SwLedOff(padapter, pLed);
605
if (!pLed1->bLedWPSBlinkInProgress &&
606
pLed1->BlinkingLedState == LED_UNKNOWN) {
607
pLed1->BlinkingLedState = LED_OFF;
608
pLed1->CurrLedState = LED_OFF;
609
SwLedOff(padapter, pLed1);
611
switch (pLed->CurrLedState) {
612
case LED_BLINK_SLOWLY:
614
pLed->BlinkingLedState = LED_OFF;
616
pLed->BlinkingLedState = LED_ON;
617
_set_timer(&(pLed->BlinkTimer),
618
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
620
case LED_BLINK_StartToBlink:
622
pLed->BlinkingLedState = LED_OFF;
623
_set_timer(&(pLed->BlinkTimer),
624
LED_BLINK_SLOWLY_INTERVAL);
626
pLed->BlinkingLedState = LED_ON;
627
_set_timer(&(pLed->BlinkTimer),
628
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_OFF;
641
pLed->BlinkingLedState = LED_ON;
642
_set_timer(&(pLed->BlinkTimer),
643
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
644
pLed->bLedScanBlinkInProgress = false;
647
pLed->BlinkingLedState = LED_OFF;
649
pLed->BlinkingLedState = LED_ON;
650
_set_timer(&(pLed->BlinkTimer),
651
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_OFF;
664
pLed->BlinkingLedState = LED_ON;
665
_set_timer(&(pLed->BlinkTimer),
666
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
667
pLed->bLedBlinkInProgress = false;
670
pLed->BlinkingLedState = LED_OFF;
672
pLed->BlinkingLedState = LED_ON;
673
_set_timer(&(pLed->BlinkTimer),
674
LED_BLINK_FASTER_INTERVAL_ALPHA);
679
pLed->BlinkingLedState = LED_OFF;
680
_set_timer(&(pLed->BlinkTimer),
681
LED_BLINK_SLOWLY_INTERVAL);
683
pLed->BlinkingLedState = LED_ON;
684
_set_timer(&(pLed->BlinkTimer),
685
LED_BLINK_NORMAL_INTERVAL);
688
case LED_BLINK_WPS_STOP: /*WPS authentication fail*/
690
pLed->BlinkingLedState = LED_OFF;
692
pLed->BlinkingLedState = LED_ON;
693
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
695
case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */
697
if (pLed->BlinkTimes == 0) {
699
pLed->BlinkTimes = 1;
701
bStopBlinking = true;
704
pLed->BlinkTimes = 10;
705
pLed->BlinkingLedState = LED_ON;
706
_set_timer(&(pLed->BlinkTimer),
707
LED_BLINK_LINK_INTERVAL_ALPHA);
710
pLed->BlinkingLedState = LED_OFF;
712
pLed->BlinkingLedState = LED_ON;
713
_set_timer(&(pLed->BlinkTimer),
714
LED_BLINK_NORMAL_INTERVAL);
722
static void SwLedBlink5(struct LED_871x *pLed)
724
struct _adapter *padapter = pLed->padapter;
725
u8 bStopBlinking = false;
727
/* Change LED according to BlinkingLedState specified. */
728
if (pLed->BlinkingLedState == LED_ON)
729
SwLedOn(padapter, pLed);
731
SwLedOff(padapter, pLed);
732
switch (pLed->CurrLedState) {
735
if (pLed->BlinkTimes == 0)
736
bStopBlinking = true;
738
pLed->CurrLedState = LED_ON;
739
pLed->BlinkingLedState = LED_ON;
741
_set_timer(&(pLed->BlinkTimer),
742
LED_BLINK_FASTER_INTERVAL_ALPHA);
743
pLed->bLedScanBlinkInProgress = false;
746
pLed->BlinkingLedState = LED_OFF;
748
pLed->BlinkingLedState = LED_ON;
749
_set_timer(&(pLed->BlinkTimer),
750
LED_BLINK_SCAN_INTERVAL_ALPHA);
755
if (pLed->BlinkTimes == 0)
756
bStopBlinking = true;
758
pLed->CurrLedState = LED_ON;
759
pLed->BlinkingLedState = LED_ON;
761
_set_timer(&(pLed->BlinkTimer),
762
LED_BLINK_FASTER_INTERVAL_ALPHA);
763
pLed->bLedBlinkInProgress = false;
766
pLed->BlinkingLedState = LED_OFF;
768
pLed->BlinkingLedState = LED_ON;
769
_set_timer(&(pLed->BlinkTimer),
770
LED_BLINK_FASTER_INTERVAL_ALPHA);
778
static void SwLedBlink6(struct LED_871x *pLed)
780
struct _adapter *padapter = pLed->padapter;
781
u8 bStopBlinking = false;
783
/* Change LED according to BlinkingLedState specified. */
784
if (pLed->BlinkingLedState == LED_ON)
785
SwLedOn(padapter, pLed);
787
SwLedOff(padapter, pLed);
788
switch (pLed->CurrLedState) {
791
if (pLed->BlinkTimes == 0)
792
bStopBlinking = true;
794
pLed->CurrLedState = LED_ON;
795
pLed->BlinkingLedState = LED_ON;
797
SwLedOn(padapter, pLed);
798
pLed->bLedBlinkInProgress = false;
801
pLed->BlinkingLedState = LED_OFF;
803
pLed->BlinkingLedState = LED_ON;
804
_set_timer(&(pLed->BlinkTimer),
805
LED_BLINK_FASTER_INTERVAL_ALPHA);
810
pLed->BlinkingLedState = LED_OFF;
812
pLed->BlinkingLedState = LED_ON;
813
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
822
* Callback function of LED BlinkTimer,
823
* it just schedules to corresponding BlinkWorkItem.
825
static void BlinkTimerCallback(unsigned long data)
827
struct LED_871x *pLed = (struct LED_871x *)data;
829
/* This fixed the crash problem on Fedora 12 when trying to do thei
830
* insmod;ifconfig up;rmmod commands. */
831
if ((pLed->padapter->bSurpriseRemoved == true) ||
832
(pLed->padapter->bDriverStopped == true))
834
_set_workitem(&(pLed->BlinkWorkItem));
838
* Callback function of LED BlinkWorkItem.
839
* We dispatch acture LED blink action according to LedStrategy.
841
static void BlinkWorkItemCallback(struct work_struct *work)
843
struct LED_871x *pLed = container_of(work, struct LED_871x,
845
struct led_priv *ledpriv = &(pLed->padapter->ledpriv);
847
switch (ledpriv->LedStrategy) {
875
/*============================================================================
876
* Default LED behavior.
877
*============================================================================
880
* Implement each led action for SW_LED_MODE0.
881
* This is default strategy.
884
static void SwLedControlMode1(struct _adapter *padapter,
885
enum LED_CTL_MODE LedAction)
887
struct led_priv *ledpriv = &(padapter->ledpriv);
888
struct LED_871x *pLed = &(ledpriv->SwLed0);
889
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
890
struct sitesurvey_ctrl *psitesurveyctrl = &(pmlmepriv->sitesurveyctrl);
892
if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
893
pLed = &(ledpriv->SwLed1);
895
case LED_CTL_START_TO_LINK:
896
case LED_CTL_NO_LINK:
897
if (pLed->bLedNoLinkBlinkInProgress == false) {
898
if (pLed->CurrLedState == LED_SCAN_BLINK ||
899
IS_LED_WPS_BLINKING(pLed))
901
if (pLed->bLedLinkBlinkInProgress == true) {
902
_cancel_timer_ex(&(pLed->BlinkTimer));
903
pLed->bLedLinkBlinkInProgress = false;
905
if (pLed->bLedBlinkInProgress == true) {
906
_cancel_timer_ex(&(pLed->BlinkTimer));
907
pLed->bLedBlinkInProgress = false;
909
pLed->bLedNoLinkBlinkInProgress = true;
910
pLed->CurrLedState = LED_BLINK_SLOWLY;
912
pLed->BlinkingLedState = LED_OFF;
914
pLed->BlinkingLedState = LED_ON;
915
_set_timer(&(pLed->BlinkTimer),
916
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
920
if (pLed->bLedLinkBlinkInProgress == false) {
921
if (pLed->CurrLedState == LED_SCAN_BLINK ||
922
IS_LED_WPS_BLINKING(pLed))
924
if (pLed->bLedNoLinkBlinkInProgress == true) {
925
_cancel_timer_ex(&(pLed->BlinkTimer));
926
pLed->bLedNoLinkBlinkInProgress = false;
928
if (pLed->bLedBlinkInProgress == true) {
929
_cancel_timer_ex(&(pLed->BlinkTimer));
930
pLed->bLedBlinkInProgress = false;
932
pLed->bLedLinkBlinkInProgress = true;
933
pLed->CurrLedState = LED_BLINK_NORMAL;
935
pLed->BlinkingLedState = LED_OFF;
937
pLed->BlinkingLedState = LED_ON;
938
_set_timer(&(pLed->BlinkTimer),
939
LED_BLINK_LINK_INTERVAL_ALPHA);
942
case LED_CTL_SITE_SURVEY:
943
if ((psitesurveyctrl->traffic_busy) &&
944
(check_fwstate(pmlmepriv, _FW_LINKED) == true))
946
else if (pLed->bLedScanBlinkInProgress == false) {
947
if (IS_LED_WPS_BLINKING(pLed))
949
if (pLed->bLedNoLinkBlinkInProgress == true) {
950
_cancel_timer_ex(&(pLed->BlinkTimer));
951
pLed->bLedNoLinkBlinkInProgress = false;
953
if (pLed->bLedLinkBlinkInProgress == true) {
954
_cancel_timer_ex(&(pLed->BlinkTimer));
955
pLed->bLedLinkBlinkInProgress = false;
957
if (pLed->bLedBlinkInProgress == true) {
958
_cancel_timer_ex(&(pLed->BlinkTimer));
959
pLed->bLedBlinkInProgress = false;
961
pLed->bLedScanBlinkInProgress = true;
962
pLed->CurrLedState = LED_SCAN_BLINK;
963
pLed->BlinkTimes = 24;
965
pLed->BlinkingLedState = LED_OFF;
967
pLed->BlinkingLedState = LED_ON;
968
_set_timer(&(pLed->BlinkTimer),
969
LED_BLINK_SCAN_INTERVAL_ALPHA);
974
if (pLed->bLedBlinkInProgress == false) {
975
if (pLed->CurrLedState == LED_SCAN_BLINK ||
976
IS_LED_WPS_BLINKING(pLed))
978
if (pLed->bLedNoLinkBlinkInProgress == true) {
979
_cancel_timer_ex(&(pLed->BlinkTimer));
980
pLed->bLedNoLinkBlinkInProgress = false;
982
if (pLed->bLedLinkBlinkInProgress == true) {
983
_cancel_timer_ex(&(pLed->BlinkTimer));
984
pLed->bLedLinkBlinkInProgress = false;
986
pLed->bLedBlinkInProgress = true;
987
pLed->CurrLedState = LED_TXRX_BLINK;
988
pLed->BlinkTimes = 2;
990
pLed->BlinkingLedState = LED_OFF;
992
pLed->BlinkingLedState = LED_ON;
993
_set_timer(&(pLed->BlinkTimer),
994
LED_BLINK_FASTER_INTERVAL_ALPHA);
998
case LED_CTL_START_WPS: /*wait until xinpin finish */
999
case LED_CTL_START_WPS_BOTTON:
1000
if (pLed->bLedWPSBlinkInProgress == false) {
1001
if (pLed->bLedNoLinkBlinkInProgress == true) {
1002
_cancel_timer_ex(&(pLed->BlinkTimer));
1003
pLed->bLedNoLinkBlinkInProgress = false;
1005
if (pLed->bLedLinkBlinkInProgress == true) {
1006
_cancel_timer_ex(&(pLed->BlinkTimer));
1007
pLed->bLedLinkBlinkInProgress = false;
1009
if (pLed->bLedBlinkInProgress == true) {
1010
_cancel_timer_ex(&(pLed->BlinkTimer));
1011
pLed->bLedBlinkInProgress = false;
1013
if (pLed->bLedScanBlinkInProgress == true) {
1014
_cancel_timer_ex(&(pLed->BlinkTimer));
1015
pLed->bLedScanBlinkInProgress = false;
1017
pLed->bLedWPSBlinkInProgress = true;
1018
pLed->CurrLedState = LED_BLINK_WPS;
1020
pLed->BlinkingLedState = LED_OFF;
1022
pLed->BlinkingLedState = LED_ON;
1023
_set_timer(&(pLed->BlinkTimer),
1024
LED_BLINK_SCAN_INTERVAL_ALPHA);
1027
case LED_CTL_STOP_WPS:
1028
if (pLed->bLedNoLinkBlinkInProgress == true) {
1029
_cancel_timer_ex(&(pLed->BlinkTimer));
1030
pLed->bLedNoLinkBlinkInProgress = false;
1032
if (pLed->bLedLinkBlinkInProgress == true) {
1033
_cancel_timer_ex(&(pLed->BlinkTimer));
1034
pLed->bLedLinkBlinkInProgress = false;
1036
if (pLed->bLedBlinkInProgress == true) {
1037
_cancel_timer_ex(&(pLed->BlinkTimer));
1038
pLed->bLedBlinkInProgress = false;
1040
if (pLed->bLedScanBlinkInProgress == true) {
1041
_cancel_timer_ex(&(pLed->BlinkTimer));
1042
pLed->bLedScanBlinkInProgress = false;
1044
if (pLed->bLedWPSBlinkInProgress)
1045
_cancel_timer_ex(&(pLed->BlinkTimer));
1047
pLed->bLedWPSBlinkInProgress = true;
1048
pLed->CurrLedState = LED_BLINK_WPS_STOP;
1050
pLed->BlinkingLedState = LED_OFF;
1051
_set_timer(&(pLed->BlinkTimer),
1052
LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1054
pLed->BlinkingLedState = LED_ON;
1055
_set_timer(&(pLed->BlinkTimer), 0);
1058
case LED_CTL_STOP_WPS_FAIL:
1059
if (pLed->bLedWPSBlinkInProgress) {
1060
_cancel_timer_ex(&(pLed->BlinkTimer));
1061
pLed->bLedWPSBlinkInProgress = false;
1063
pLed->bLedNoLinkBlinkInProgress = true;
1064
pLed->CurrLedState = LED_BLINK_SLOWLY;
1066
pLed->BlinkingLedState = LED_OFF;
1068
pLed->BlinkingLedState = LED_ON;
1069
_set_timer(&(pLed->BlinkTimer),
1070
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1072
case LED_CTL_POWER_OFF:
1073
pLed->CurrLedState = LED_OFF;
1074
pLed->BlinkingLedState = LED_OFF;
1075
if (pLed->bLedNoLinkBlinkInProgress) {
1076
_cancel_timer_ex(&(pLed->BlinkTimer));
1077
pLed->bLedNoLinkBlinkInProgress = false;
1079
if (pLed->bLedLinkBlinkInProgress) {
1080
_cancel_timer_ex(&(pLed->BlinkTimer));
1081
pLed->bLedLinkBlinkInProgress = false;
1083
if (pLed->bLedBlinkInProgress) {
1084
_cancel_timer_ex(&(pLed->BlinkTimer));
1085
pLed->bLedBlinkInProgress = false;
1087
if (pLed->bLedWPSBlinkInProgress) {
1088
_cancel_timer_ex(&(pLed->BlinkTimer));
1089
pLed->bLedWPSBlinkInProgress = false;
1091
if (pLed->bLedScanBlinkInProgress) {
1092
_cancel_timer_ex(&(pLed->BlinkTimer));
1093
pLed->bLedScanBlinkInProgress = false;
1095
_set_timer(&(pLed->BlinkTimer), 0);
1102
static void SwLedControlMode2(struct _adapter *padapter,
1103
enum LED_CTL_MODE LedAction)
1105
struct led_priv *ledpriv = &(padapter->ledpriv);
1106
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1107
struct LED_871x *pLed = &(ledpriv->SwLed0);
1109
switch (LedAction) {
1110
case LED_CTL_SITE_SURVEY:
1111
if (pmlmepriv->sitesurveyctrl.traffic_busy)
1112
; /* dummy branch */
1113
else if (pLed->bLedScanBlinkInProgress == false) {
1114
if (IS_LED_WPS_BLINKING(pLed))
1117
if (pLed->bLedBlinkInProgress == true) {
1118
_cancel_timer_ex(&(pLed->BlinkTimer));
1119
pLed->bLedBlinkInProgress = false;
1121
pLed->bLedScanBlinkInProgress = true;
1122
pLed->CurrLedState = LED_SCAN_BLINK;
1123
pLed->BlinkTimes = 24;
1125
pLed->BlinkingLedState = LED_OFF;
1127
pLed->BlinkingLedState = LED_ON;
1128
_set_timer(&(pLed->BlinkTimer),
1129
LED_BLINK_SCAN_INTERVAL_ALPHA);
1135
if ((pLed->bLedBlinkInProgress == false) &&
1136
(check_fwstate(pmlmepriv, _FW_LINKED) == true)) {
1137
if (pLed->CurrLedState == LED_SCAN_BLINK ||
1138
IS_LED_WPS_BLINKING(pLed))
1140
pLed->bLedBlinkInProgress = true;
1141
pLed->CurrLedState = LED_TXRX_BLINK;
1142
pLed->BlinkTimes = 2;
1144
pLed->BlinkingLedState = LED_OFF;
1146
pLed->BlinkingLedState = LED_ON;
1147
_set_timer(&(pLed->BlinkTimer),
1148
LED_BLINK_FASTER_INTERVAL_ALPHA);
1153
pLed->CurrLedState = LED_ON;
1154
pLed->BlinkingLedState = LED_ON;
1155
if (pLed->bLedBlinkInProgress) {
1156
_cancel_timer_ex(&(pLed->BlinkTimer));
1157
pLed->bLedBlinkInProgress = false;
1159
if (pLed->bLedScanBlinkInProgress) {
1160
_cancel_timer_ex(&(pLed->BlinkTimer));
1161
pLed->bLedScanBlinkInProgress = false;
1164
_set_timer(&(pLed->BlinkTimer), 0);
1167
case LED_CTL_START_WPS: /*wait until xinpin finish*/
1168
case LED_CTL_START_WPS_BOTTON:
1169
if (pLed->bLedWPSBlinkInProgress == false) {
1170
if (pLed->bLedBlinkInProgress == true) {
1171
_cancel_timer_ex(&(pLed->BlinkTimer));
1172
pLed->bLedBlinkInProgress = false;
1174
if (pLed->bLedScanBlinkInProgress == true) {
1175
_cancel_timer_ex(&(pLed->BlinkTimer));
1176
pLed->bLedScanBlinkInProgress = false;
1178
pLed->bLedWPSBlinkInProgress = true;
1179
pLed->CurrLedState = LED_ON;
1180
pLed->BlinkingLedState = LED_ON;
1181
_set_timer(&(pLed->BlinkTimer), 0);
1185
case LED_CTL_STOP_WPS:
1186
pLed->bLedWPSBlinkInProgress = false;
1187
pLed->CurrLedState = LED_ON;
1188
pLed->BlinkingLedState = LED_ON;
1189
_set_timer(&(pLed->BlinkTimer), 0);
1192
case LED_CTL_STOP_WPS_FAIL:
1193
pLed->bLedWPSBlinkInProgress = false;
1194
pLed->CurrLedState = LED_OFF;
1195
pLed->BlinkingLedState = LED_OFF;
1196
_set_timer(&(pLed->BlinkTimer), 0);
1199
case LED_CTL_START_TO_LINK:
1200
case LED_CTL_NO_LINK:
1201
if (!IS_LED_BLINKING(pLed)) {
1202
pLed->CurrLedState = LED_OFF;
1203
pLed->BlinkingLedState = LED_OFF;
1204
_set_timer(&(pLed->BlinkTimer), 0);
1207
case LED_CTL_POWER_OFF:
1208
pLed->CurrLedState = LED_OFF;
1209
pLed->BlinkingLedState = LED_OFF;
1210
if (pLed->bLedBlinkInProgress) {
1211
_cancel_timer_ex(&(pLed->BlinkTimer));
1212
pLed->bLedBlinkInProgress = false;
1214
if (pLed->bLedScanBlinkInProgress) {
1215
_cancel_timer_ex(&(pLed->BlinkTimer));
1216
pLed->bLedScanBlinkInProgress = false;
1218
if (pLed->bLedWPSBlinkInProgress) {
1219
_cancel_timer_ex(&(pLed->BlinkTimer));
1220
pLed->bLedWPSBlinkInProgress = false;
1222
_set_timer(&(pLed->BlinkTimer), 0);
1229
static void SwLedControlMode3(struct _adapter *padapter,
1230
enum LED_CTL_MODE LedAction)
1232
struct led_priv *ledpriv = &(padapter->ledpriv);
1233
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1234
struct LED_871x *pLed = &(ledpriv->SwLed0);
1236
switch (LedAction) {
1237
case LED_CTL_SITE_SURVEY:
1238
if (pmlmepriv->sitesurveyctrl.traffic_busy)
1239
; /* dummy branch */
1240
else if (pLed->bLedScanBlinkInProgress == false) {
1241
if (IS_LED_WPS_BLINKING(pLed))
1243
if (pLed->bLedBlinkInProgress == true) {
1244
_cancel_timer_ex(&(pLed->BlinkTimer));
1245
pLed->bLedBlinkInProgress = false;
1247
pLed->bLedScanBlinkInProgress = true;
1248
pLed->CurrLedState = LED_SCAN_BLINK;
1249
pLed->BlinkTimes = 24;
1251
pLed->BlinkingLedState = LED_OFF;
1253
pLed->BlinkingLedState = LED_ON;
1254
_set_timer(&(pLed->BlinkTimer),
1255
LED_BLINK_SCAN_INTERVAL_ALPHA);
1260
if ((pLed->bLedBlinkInProgress == false) &&
1261
(check_fwstate(pmlmepriv, _FW_LINKED) == true)) {
1262
if (pLed->CurrLedState == LED_SCAN_BLINK ||
1263
IS_LED_WPS_BLINKING(pLed))
1265
pLed->bLedBlinkInProgress = true;
1266
pLed->CurrLedState = LED_TXRX_BLINK;
1267
pLed->BlinkTimes = 2;
1269
pLed->BlinkingLedState = LED_OFF;
1271
pLed->BlinkingLedState = LED_ON;
1272
_set_timer(&(pLed->BlinkTimer),
1273
LED_BLINK_FASTER_INTERVAL_ALPHA);
1277
if (IS_LED_WPS_BLINKING(pLed))
1279
pLed->CurrLedState = LED_ON;
1280
pLed->BlinkingLedState = LED_ON;
1281
if (pLed->bLedBlinkInProgress) {
1282
_cancel_timer_ex(&(pLed->BlinkTimer));
1283
pLed->bLedBlinkInProgress = false;
1285
if (pLed->bLedScanBlinkInProgress) {
1286
_cancel_timer_ex(&(pLed->BlinkTimer));
1287
pLed->bLedScanBlinkInProgress = false;
1289
_set_timer(&(pLed->BlinkTimer), 0);
1291
case LED_CTL_START_WPS: /* wait until xinpin finish */
1292
case LED_CTL_START_WPS_BOTTON:
1293
if (pLed->bLedWPSBlinkInProgress == false) {
1294
if (pLed->bLedBlinkInProgress == true) {
1295
_cancel_timer_ex(&(pLed->BlinkTimer));
1296
pLed->bLedBlinkInProgress = false;
1298
if (pLed->bLedScanBlinkInProgress == true) {
1299
_cancel_timer_ex(&(pLed->BlinkTimer));
1300
pLed->bLedScanBlinkInProgress = false;
1302
pLed->bLedWPSBlinkInProgress = true;
1303
pLed->CurrLedState = LED_BLINK_WPS;
1305
pLed->BlinkingLedState = LED_OFF;
1307
pLed->BlinkingLedState = LED_ON;
1308
_set_timer(&(pLed->BlinkTimer),
1309
LED_BLINK_SCAN_INTERVAL_ALPHA);
1312
case LED_CTL_STOP_WPS:
1313
if (pLed->bLedWPSBlinkInProgress) {
1314
_cancel_timer_ex(&(pLed->BlinkTimer));
1315
pLed->bLedWPSBlinkInProgress = false;
1317
pLed->bLedWPSBlinkInProgress = true;
1318
pLed->CurrLedState = LED_BLINK_WPS_STOP;
1320
pLed->BlinkingLedState = LED_OFF;
1321
_set_timer(&(pLed->BlinkTimer),
1322
LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1324
pLed->BlinkingLedState = LED_ON;
1325
_set_timer(&(pLed->BlinkTimer), 0);
1328
case LED_CTL_STOP_WPS_FAIL:
1329
if (pLed->bLedWPSBlinkInProgress) {
1330
_cancel_timer_ex(&(pLed->BlinkTimer));
1331
pLed->bLedWPSBlinkInProgress = false;
1333
pLed->CurrLedState = LED_OFF;
1334
pLed->BlinkingLedState = LED_OFF;
1335
_set_timer(&(pLed->BlinkTimer), 0);
1337
case LED_CTL_START_TO_LINK:
1338
case LED_CTL_NO_LINK:
1339
if (!IS_LED_BLINKING(pLed)) {
1340
pLed->CurrLedState = LED_OFF;
1341
pLed->BlinkingLedState = LED_OFF;
1342
_set_timer(&(pLed->BlinkTimer), 0);
1345
case LED_CTL_POWER_OFF:
1346
pLed->CurrLedState = LED_OFF;
1347
pLed->BlinkingLedState = LED_OFF;
1348
if (pLed->bLedBlinkInProgress) {
1349
_cancel_timer_ex(&(pLed->BlinkTimer));
1350
pLed->bLedBlinkInProgress = false;
1352
if (pLed->bLedScanBlinkInProgress) {
1353
_cancel_timer_ex(&(pLed->BlinkTimer));
1354
pLed->bLedScanBlinkInProgress = false;
1356
if (pLed->bLedWPSBlinkInProgress) {
1357
_cancel_timer_ex(&(pLed->BlinkTimer));
1358
pLed->bLedWPSBlinkInProgress = false;
1360
_set_timer(&(pLed->BlinkTimer), 0);
1367
static void SwLedControlMode4(struct _adapter *padapter,
1368
enum LED_CTL_MODE LedAction)
1370
struct led_priv *ledpriv = &(padapter->ledpriv);
1371
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1372
struct LED_871x *pLed = &(ledpriv->SwLed0);
1373
struct LED_871x *pLed1 = &(ledpriv->SwLed1);
1375
switch (LedAction) {
1376
case LED_CTL_START_TO_LINK:
1377
if (pLed1->bLedWPSBlinkInProgress) {
1378
pLed1->bLedWPSBlinkInProgress = false;
1379
_cancel_timer_ex(&(pLed1->BlinkTimer));
1380
pLed1->BlinkingLedState = LED_OFF;
1381
pLed1->CurrLedState = LED_OFF;
1383
_set_timer(&(pLed->BlinkTimer), 0);
1385
if (pLed->bLedStartToLinkBlinkInProgress == false) {
1386
if (pLed->CurrLedState == LED_SCAN_BLINK ||
1387
IS_LED_WPS_BLINKING(pLed))
1389
if (pLed->bLedBlinkInProgress == true) {
1390
_cancel_timer_ex(&(pLed->BlinkTimer));
1391
pLed->bLedBlinkInProgress = false;
1393
if (pLed->bLedNoLinkBlinkInProgress == true) {
1394
_cancel_timer_ex(&(pLed->BlinkTimer));
1395
pLed->bLedNoLinkBlinkInProgress = false;
1397
pLed->bLedStartToLinkBlinkInProgress = true;
1398
pLed->CurrLedState = LED_BLINK_StartToBlink;
1400
pLed->BlinkingLedState = LED_OFF;
1401
_set_timer(&(pLed->BlinkTimer),
1402
LED_BLINK_SLOWLY_INTERVAL);
1404
pLed->BlinkingLedState = LED_ON;
1405
_set_timer(&(pLed->BlinkTimer),
1406
LED_BLINK_NORMAL_INTERVAL);
1411
case LED_CTL_NO_LINK:
1413
if (LedAction == LED_CTL_LINK) {
1414
if (pLed1->bLedWPSBlinkInProgress) {
1415
pLed1->bLedWPSBlinkInProgress = false;
1416
_cancel_timer_ex(&(pLed1->BlinkTimer));
1417
pLed1->BlinkingLedState = LED_OFF;
1418
pLed1->CurrLedState = LED_OFF;
1420
_set_timer(&(pLed->BlinkTimer), 0);
1423
if (pLed->bLedNoLinkBlinkInProgress == false) {
1424
if (pLed->CurrLedState == LED_SCAN_BLINK ||
1425
IS_LED_WPS_BLINKING(pLed))
1427
if (pLed->bLedBlinkInProgress == true) {
1428
_cancel_timer_ex(&(pLed->BlinkTimer));
1429
pLed->bLedBlinkInProgress = false;
1431
pLed->bLedNoLinkBlinkInProgress = true;
1432
pLed->CurrLedState = LED_BLINK_SLOWLY;
1434
pLed->BlinkingLedState = LED_OFF;
1436
pLed->BlinkingLedState = LED_ON;
1437
_set_timer(&(pLed->BlinkTimer),
1438
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1441
case LED_CTL_SITE_SURVEY:
1442
if ((pmlmepriv->sitesurveyctrl.traffic_busy) &&
1443
(check_fwstate(pmlmepriv, _FW_LINKED) == true))
1445
else if (pLed->bLedScanBlinkInProgress == false) {
1446
if (IS_LED_WPS_BLINKING(pLed))
1448
if (pLed->bLedNoLinkBlinkInProgress == true) {
1449
_cancel_timer_ex(&(pLed->BlinkTimer));
1450
pLed->bLedNoLinkBlinkInProgress = false;
1452
if (pLed->bLedBlinkInProgress == true) {
1453
_cancel_timer_ex(&(pLed->BlinkTimer));
1454
pLed->bLedBlinkInProgress = false;
1456
pLed->bLedScanBlinkInProgress = true;
1457
pLed->CurrLedState = LED_SCAN_BLINK;
1458
pLed->BlinkTimes = 24;
1460
pLed->BlinkingLedState = LED_OFF;
1462
pLed->BlinkingLedState = LED_ON;
1463
_set_timer(&(pLed->BlinkTimer),
1464
LED_BLINK_SCAN_INTERVAL_ALPHA);
1469
if (pLed->bLedBlinkInProgress == false) {
1470
if (pLed->CurrLedState == LED_SCAN_BLINK ||
1471
IS_LED_WPS_BLINKING(pLed))
1473
if (pLed->bLedNoLinkBlinkInProgress == true) {
1474
_cancel_timer_ex(&(pLed->BlinkTimer));
1475
pLed->bLedNoLinkBlinkInProgress = false;
1477
pLed->bLedBlinkInProgress = true;
1478
pLed->CurrLedState = LED_TXRX_BLINK;
1479
pLed->BlinkTimes = 2;
1481
pLed->BlinkingLedState = LED_OFF;
1483
pLed->BlinkingLedState = LED_ON;
1484
_set_timer(&(pLed->BlinkTimer),
1485
LED_BLINK_FASTER_INTERVAL_ALPHA);
1488
case LED_CTL_START_WPS: /*wait until xinpin finish*/
1489
case LED_CTL_START_WPS_BOTTON:
1490
if (pLed1->bLedWPSBlinkInProgress) {
1491
pLed1->bLedWPSBlinkInProgress = false;
1492
_cancel_timer_ex(&(pLed1->BlinkTimer));
1493
pLed1->BlinkingLedState = LED_OFF;
1494
pLed1->CurrLedState = LED_OFF;
1496
_set_timer(&(pLed->BlinkTimer), 0);
1498
if (pLed->bLedWPSBlinkInProgress == false) {
1499
if (pLed->bLedNoLinkBlinkInProgress == true) {
1500
_cancel_timer_ex(&(pLed->BlinkTimer));
1501
pLed->bLedNoLinkBlinkInProgress = false;
1503
if (pLed->bLedBlinkInProgress == true) {
1504
_cancel_timer_ex(&(pLed->BlinkTimer));
1505
pLed->bLedBlinkInProgress = false;
1507
if (pLed->bLedScanBlinkInProgress == true) {
1508
_cancel_timer_ex(&(pLed->BlinkTimer));
1509
pLed->bLedScanBlinkInProgress = false;
1511
pLed->bLedWPSBlinkInProgress = true;
1512
pLed->CurrLedState = LED_BLINK_WPS;
1514
pLed->BlinkingLedState = LED_OFF;
1515
_set_timer(&(pLed->BlinkTimer),
1516
LED_BLINK_SLOWLY_INTERVAL);
1518
pLed->BlinkingLedState = LED_ON;
1519
_set_timer(&(pLed->BlinkTimer),
1520
LED_BLINK_NORMAL_INTERVAL);
1524
case LED_CTL_STOP_WPS: /*WPS connect success*/
1525
if (pLed->bLedWPSBlinkInProgress) {
1526
_cancel_timer_ex(&(pLed->BlinkTimer));
1527
pLed->bLedWPSBlinkInProgress = false;
1529
pLed->bLedNoLinkBlinkInProgress = true;
1530
pLed->CurrLedState = LED_BLINK_SLOWLY;
1532
pLed->BlinkingLedState = LED_OFF;
1534
pLed->BlinkingLedState = LED_ON;
1535
_set_timer(&(pLed->BlinkTimer),
1536
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1538
case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/
1539
if (pLed->bLedWPSBlinkInProgress) {
1540
_cancel_timer_ex(&(pLed->BlinkTimer));
1541
pLed->bLedWPSBlinkInProgress = false;
1543
pLed->bLedNoLinkBlinkInProgress = true;
1544
pLed->CurrLedState = LED_BLINK_SLOWLY;
1546
pLed->BlinkingLedState = LED_OFF;
1548
pLed->BlinkingLedState = LED_ON;
1549
_set_timer(&(pLed->BlinkTimer),
1550
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1552
if (pLed1->bLedWPSBlinkInProgress)
1553
_cancel_timer_ex(&(pLed1->BlinkTimer));
1555
pLed1->bLedWPSBlinkInProgress = true;
1556
pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1558
pLed1->BlinkingLedState = LED_OFF;
1560
pLed1->BlinkingLedState = LED_ON;
1561
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1563
case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/
1564
if (pLed->bLedWPSBlinkInProgress) {
1565
_cancel_timer_ex(&(pLed->BlinkTimer));
1566
pLed->bLedWPSBlinkInProgress = false;
1568
pLed->bLedNoLinkBlinkInProgress = true;
1569
pLed->CurrLedState = LED_BLINK_SLOWLY;
1571
pLed->BlinkingLedState = LED_OFF;
1573
pLed->BlinkingLedState = LED_ON;
1574
_set_timer(&(pLed->BlinkTimer),
1575
LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1577
if (pLed1->bLedWPSBlinkInProgress)
1578
_cancel_timer_ex(&(pLed1->BlinkTimer));
1580
pLed1->bLedWPSBlinkInProgress = true;
1581
pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1582
pLed1->BlinkTimes = 10;
1584
pLed1->BlinkingLedState = LED_OFF;
1586
pLed1->BlinkingLedState = LED_ON;
1587
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1589
case LED_CTL_POWER_OFF:
1590
pLed->CurrLedState = LED_OFF;
1591
pLed->BlinkingLedState = LED_OFF;
1592
if (pLed->bLedNoLinkBlinkInProgress) {
1593
_cancel_timer_ex(&(pLed->BlinkTimer));
1594
pLed->bLedNoLinkBlinkInProgress = false;
1596
if (pLed->bLedLinkBlinkInProgress) {
1597
_cancel_timer_ex(&(pLed->BlinkTimer));
1598
pLed->bLedLinkBlinkInProgress = false;
1600
if (pLed->bLedBlinkInProgress) {
1601
_cancel_timer_ex(&(pLed->BlinkTimer));
1602
pLed->bLedBlinkInProgress = false;
1604
if (pLed->bLedWPSBlinkInProgress) {
1605
_cancel_timer_ex(&(pLed->BlinkTimer));
1606
pLed->bLedWPSBlinkInProgress = false;
1608
if (pLed->bLedScanBlinkInProgress) {
1609
_cancel_timer_ex(&(pLed->BlinkTimer));
1610
pLed->bLedScanBlinkInProgress = false;
1612
if (pLed->bLedStartToLinkBlinkInProgress) {
1613
_cancel_timer_ex(&(pLed->BlinkTimer));
1614
pLed->bLedStartToLinkBlinkInProgress = false;
1616
if (pLed1->bLedWPSBlinkInProgress) {
1617
_cancel_timer_ex(&(pLed1->BlinkTimer));
1618
pLed1->bLedWPSBlinkInProgress = false;
1620
pLed1->BlinkingLedState = LED_UNKNOWN;
1621
SwLedOff(padapter, pLed);
1622
SwLedOff(padapter, pLed1);
1629
static void SwLedControlMode5(struct _adapter *padapter,
1630
enum LED_CTL_MODE LedAction)
1632
struct led_priv *ledpriv = &(padapter->ledpriv);
1633
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1634
struct LED_871x *pLed = &(ledpriv->SwLed0);
1636
if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1637
pLed = &(ledpriv->SwLed1);
1639
switch (LedAction) {
1640
case LED_CTL_POWER_ON:
1641
case LED_CTL_NO_LINK:
1642
case LED_CTL_LINK: /* solid blue */
1643
if (pLed->CurrLedState == LED_SCAN_BLINK)
1645
pLed->CurrLedState = LED_ON;
1646
pLed->BlinkingLedState = LED_ON;
1647
pLed->bLedBlinkInProgress = false;
1648
_set_timer(&(pLed->BlinkTimer), 0);
1650
case LED_CTL_SITE_SURVEY:
1651
if ((pmlmepriv->sitesurveyctrl.traffic_busy) &&
1652
(check_fwstate(pmlmepriv, _FW_LINKED) == true))
1653
; /* dummy branch */
1654
else if (pLed->bLedScanBlinkInProgress == false) {
1655
if (pLed->bLedBlinkInProgress == true) {
1656
_cancel_timer_ex(&(pLed->BlinkTimer));
1657
pLed->bLedBlinkInProgress = false;
1659
pLed->bLedScanBlinkInProgress = true;
1660
pLed->CurrLedState = LED_SCAN_BLINK;
1661
pLed->BlinkTimes = 24;
1663
pLed->BlinkingLedState = LED_OFF;
1665
pLed->BlinkingLedState = LED_ON;
1666
_set_timer(&(pLed->BlinkTimer),
1667
LED_BLINK_SCAN_INTERVAL_ALPHA);
1672
if (pLed->bLedBlinkInProgress == false) {
1673
if (pLed->CurrLedState == LED_SCAN_BLINK)
1675
pLed->bLedBlinkInProgress = true;
1676
pLed->CurrLedState = LED_TXRX_BLINK;
1677
pLed->BlinkTimes = 2;
1679
pLed->BlinkingLedState = LED_OFF;
1681
pLed->BlinkingLedState = LED_ON;
1682
_set_timer(&(pLed->BlinkTimer),
1683
LED_BLINK_FASTER_INTERVAL_ALPHA);
1686
case LED_CTL_POWER_OFF:
1687
pLed->CurrLedState = LED_OFF;
1688
pLed->BlinkingLedState = LED_OFF;
1689
if (pLed->bLedBlinkInProgress) {
1690
_cancel_timer_ex(&(pLed->BlinkTimer));
1691
pLed->bLedBlinkInProgress = false;
1693
SwLedOff(padapter, pLed);
1701
static void SwLedControlMode6(struct _adapter *padapter,
1702
enum LED_CTL_MODE LedAction)
1704
struct led_priv *ledpriv = &(padapter->ledpriv);
1705
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1706
struct LED_871x *pLed = &(ledpriv->SwLed0);
1708
switch (LedAction) {
1709
case LED_CTL_POWER_ON:
1710
case LED_CTL_NO_LINK:
1711
case LED_CTL_LINK: /*solid blue*/
1712
case LED_CTL_SITE_SURVEY:
1713
if (IS_LED_WPS_BLINKING(pLed))
1715
pLed->CurrLedState = LED_ON;
1716
pLed->BlinkingLedState = LED_ON;
1717
pLed->bLedBlinkInProgress = false;
1718
_set_timer(&(pLed->BlinkTimer), 0);
1722
if (pLed->bLedBlinkInProgress == false &&
1723
(check_fwstate(pmlmepriv, _FW_LINKED) == true)) {
1724
if (IS_LED_WPS_BLINKING(pLed))
1726
pLed->bLedBlinkInProgress = true;
1727
pLed->CurrLedState = LED_TXRX_BLINK;
1728
pLed->BlinkTimes = 2;
1730
pLed->BlinkingLedState = LED_OFF;
1732
pLed->BlinkingLedState = LED_ON;
1733
_set_timer(&(pLed->BlinkTimer),
1734
LED_BLINK_FASTER_INTERVAL_ALPHA);
1737
case LED_CTL_START_WPS: /*wait until xinpin finish*/
1738
case LED_CTL_START_WPS_BOTTON:
1739
if (pLed->bLedWPSBlinkInProgress == false) {
1740
if (pLed->bLedBlinkInProgress == true) {
1741
_cancel_timer_ex(&(pLed->BlinkTimer));
1742
pLed->bLedBlinkInProgress = false;
1744
pLed->bLedWPSBlinkInProgress = true;
1745
pLed->CurrLedState = LED_BLINK_WPS;
1747
pLed->BlinkingLedState = LED_OFF;
1749
pLed->BlinkingLedState = LED_ON;
1750
_set_timer(&(pLed->BlinkTimer),
1751
LED_BLINK_SCAN_INTERVAL_ALPHA);
1754
case LED_CTL_STOP_WPS_FAIL:
1755
case LED_CTL_STOP_WPS:
1756
if (pLed->bLedWPSBlinkInProgress) {
1757
_cancel_timer_ex(&(pLed->BlinkTimer));
1758
pLed->bLedWPSBlinkInProgress = false;
1760
pLed->CurrLedState = LED_ON;
1761
pLed->BlinkingLedState = LED_ON;
1762
_set_timer(&(pLed->BlinkTimer), 0);
1764
case LED_CTL_POWER_OFF:
1765
pLed->CurrLedState = LED_OFF;
1766
pLed->BlinkingLedState = LED_OFF;
1767
if (pLed->bLedBlinkInProgress) {
1768
_cancel_timer_ex(&(pLed->BlinkTimer));
1769
pLed->bLedBlinkInProgress = false;
1771
if (pLed->bLedWPSBlinkInProgress) {
1772
_cancel_timer_ex(&(pLed->BlinkTimer));
1773
pLed->bLedWPSBlinkInProgress = false;
1775
SwLedOff(padapter, pLed);
1783
* Dispatch LED action according to pHalData->LedStrategy.
1785
void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1787
struct led_priv *ledpriv = &(padapter->ledpriv);
1789
if (ledpriv->bRegUseLed == false)
1791
switch (ledpriv->LedStrategy) {
1795
SwLedControlMode1(padapter, LedAction);
1798
SwLedControlMode2(padapter, LedAction);
1801
SwLedControlMode3(padapter, LedAction);
1804
SwLedControlMode4(padapter, LedAction);
1807
SwLedControlMode5(padapter, LedAction);
1810
SwLedControlMode6(padapter, LedAction);