projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-3.16' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
[deliverable/linux.git] / drivers / staging / rtl8712 / rtl8712_led.c
1 /******************************************************************************
2 * rtl8712_led.c
3 *
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
22 *
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
26 *
27 ******************************************************************************/
28
29 #include "drv_types.h"
30
31 /*===========================================================================
32 * Constant.
33 *===========================================================================
34
35 *
36 * Default LED behavior.
37 */
38 #define LED_BLINK_NORMAL_INTERVAL 100
39 #define LED_BLINK_SLOWLY_INTERVAL 200
40 #define LED_BLINK_LONG_INTERVAL 400
41
42 #define LED_BLINK_NO_LINK_INTERVAL_ALPHA 1000
43 #define LED_BLINK_LINK_INTERVAL_ALPHA 500
44 #define LED_BLINK_SCAN_INTERVAL_ALPHA 180
45 #define LED_BLINK_FASTER_INTERVAL_ALPHA 50
46 #define LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA 5000
47
48 /*===========================================================================
49 * LED object.
50 *===========================================================================
51 */
52 enum _LED_STATE_871x {
53 LED_UNKNOWN = 0,
54 LED_ON = 1,
55 LED_OFF = 2,
56 LED_BLINK_NORMAL = 3,
57 LED_BLINK_SLOWLY = 4,
58 LED_POWER_ON_BLINK = 5,
59 LED_SCAN_BLINK = 6, /* LED is blinking during scanning period,
60 * the # of times to blink is depend on time
61 * for scanning. */
62 LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */
63 LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer
64 * Server case */
65 LED_BLINK_WPS = 9, /* LED is blinkg during WPS communication */
66 LED_TXRX_BLINK = 10,
67 LED_BLINK_WPS_STOP = 11, /*for ALPHA */
68 LED_BLINK_WPS_STOP_OVERLAP = 12, /*for BELKIN */
69 };
70
71 /*===========================================================================
72 * Prototype of protected function.
73 *===========================================================================
74 */
75 static void BlinkTimerCallback(unsigned long data);
76
77 static void BlinkWorkItemCallback(struct work_struct *work);
78 /*===========================================================================
79 * LED_819xUsb routines.
80 *===========================================================================
81 *
82 *
83 *
84 * Description:
85 * Initialize an LED_871x object.
86 */
87 static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed,
88 enum LED_PIN_871x LedPin)
89 {
90 struct net_device *nic;
91
92 nic = padapter->pnetdev;
93 pLed->padapter = padapter;
94 pLed->LedPin = LedPin;
95 pLed->CurrLedState = LED_OFF;
96 pLed->bLedOn = false;
97 pLed->bLedBlinkInProgress = false;
98 pLed->BlinkTimes = 0;
99 pLed->BlinkingLedState = LED_UNKNOWN;
100 _init_timer(&(pLed->BlinkTimer), nic, BlinkTimerCallback, pLed);
101 _init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
102 }
103
104 /*
105 * Description:
106 * DeInitialize an LED_871x object.
107 */
108 static void DeInitLed871x(struct LED_871x *pLed)
109 {
110 _cancel_timer_ex(&(pLed->BlinkTimer));
111 /* We should reset bLedBlinkInProgress if we cancel
112 * the LedControlTimer, */
113 pLed->bLedBlinkInProgress = false;
114 }
115
116 /*
117 * Description:
118 * Turn on LED according to LedPin specified.
119 */
120 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
121 {
122 u8 LedCfg;
123
124 if ((padapter->bSurpriseRemoved == true) ||
125 (padapter->bDriverStopped == true))
126 return;
127 LedCfg = r8712_read8(padapter, LEDCFG);
128 switch (pLed->LedPin) {
129 case LED_PIN_GPIO0:
130 break;
131 case LED_PIN_LED0:
132 /* SW control led0 on.*/
133 r8712_write8(padapter, LEDCFG, LedCfg&0xf0);
134 break;
135 case LED_PIN_LED1:
136 /* SW control led1 on.*/
137 r8712_write8(padapter, LEDCFG, LedCfg&0x0f);
138 break;
139 default:
140 break;
141 }
142 pLed->bLedOn = true;
143 }
144
145 /*
146 * Description:
147 * Turn off LED according to LedPin specified.
148 */
149 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
150 {
151 u8 LedCfg;
152
153 if ((padapter->bSurpriseRemoved == true) ||
154 (padapter->bDriverStopped == true))
155 return;
156 LedCfg = r8712_read8(padapter, LEDCFG);
157 switch (pLed->LedPin) {
158 case LED_PIN_GPIO0:
159 break;
160 case LED_PIN_LED0:
161 LedCfg &= 0xf0; /* Set to software control.*/
162 r8712_write8(padapter, LEDCFG, (LedCfg|BIT(3)));
163 break;
164 case LED_PIN_LED1:
165 LedCfg &= 0x0f; /* Set to software control.*/
166 r8712_write8(padapter, LEDCFG, (LedCfg|BIT(7)));
167 break;
168 default:
169 break;
170 }
171 pLed->bLedOn = false;
172 }
173
174 /*===========================================================================
175 * Interface to manipulate LED objects.
176 *===========================================================================
177 *
178 * Description:
179 * Initialize all LED_871x objects.
180 */
181 void r8712_InitSwLeds(struct _adapter *padapter)
182 {
183 struct led_priv *pledpriv = &(padapter->ledpriv);
184
185 pledpriv->LedControlHandler = LedControl871x;
186 InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
187 InitLed871x(padapter, &(pledpriv->SwLed1), LED_PIN_LED1);
188 }
189
190 /* Description:
191 * DeInitialize all LED_819xUsb objects.
192 */
193 void r8712_DeInitSwLeds(struct _adapter *padapter)
194 {
195 struct led_priv *ledpriv = &(padapter->ledpriv);
196
197 DeInitLed871x(&(ledpriv->SwLed0));
198 DeInitLed871x(&(ledpriv->SwLed1));
199 }
200
201 /* Description:
202 * Implementation of LED blinking behavior.
203 * It toggle off LED and schedule corresponding timer if necessary.
204 */
205 static void SwLedBlink(struct LED_871x *pLed)
206 {
207 struct _adapter *padapter = pLed->padapter;
208 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
209 u8 bStopBlinking = false;
210
211 /* Change LED according to BlinkingLedState specified. */
212 if (pLed->BlinkingLedState == LED_ON)
213 SwLedOn(padapter, pLed);
214 else
215 SwLedOff(padapter, pLed);
216 /* Determine if we shall change LED state again. */
217 pLed->BlinkTimes--;
218 switch (pLed->CurrLedState) {
219 case LED_BLINK_NORMAL:
220 if (pLed->BlinkTimes == 0)
221 bStopBlinking = true;
222 break;
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;
233 break;
234 case LED_BLINK_WPS:
235 if (pLed->BlinkTimes == 0)
236 bStopBlinking = true;
237 break;
238 default:
239 bStopBlinking = true;
240 break;
241 }
242 if (bStopBlinking) {
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;
251 } else {
252 /* Assign LED state to toggle. */
253 if (pLed->BlinkingLedState == LED_ON)
254 pLed->BlinkingLedState = LED_OFF;
255 else
256 pLed->BlinkingLedState = LED_ON;
257
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);
263 break;
264 case LED_BLINK_SLOWLY:
265 case LED_BLINK_StartToBlink:
266 _set_timer(&(pLed->BlinkTimer),
267 LED_BLINK_SLOWLY_INTERVAL);
268 break;
269 case LED_BLINK_WPS:
270 _set_timer(&(pLed->BlinkTimer),
271 LED_BLINK_LONG_INTERVAL);
272 break;
273 default:
274 _set_timer(&(pLed->BlinkTimer),
275 LED_BLINK_SLOWLY_INTERVAL);
276 break;
277 }
278 }
279 }
280
281 static void SwLedBlink1(struct LED_871x *pLed)
282 {
283 struct _adapter *padapter = pLed->padapter;
284 struct led_priv *ledpriv = &(padapter->ledpriv);
285 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
286 struct eeprom_priv *peeprompriv = &(padapter->eeprompriv);
287 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
288 u8 bStopBlinking = false;
289
290 if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
291 pLed = &(ledpriv->SwLed1);
292 /* Change LED according to BlinkingLedState specified. */
293 if (pLed->BlinkingLedState == LED_ON)
294 SwLedOn(padapter, pLed);
295 else
296 SwLedOff(padapter, pLed);
297 if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
298 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
299 if (!pLed1->bSWLedCtrl) {
300 SwLedOn(padapter, pLed1);
301 pLed1->bSWLedCtrl = true;
302 } else if (!pLed1->bLedOn)
303 SwLedOn(padapter, pLed1);
304 } else {
305 if (!pLed1->bSWLedCtrl) {
306 SwLedOff(padapter, pLed1);
307 pLed1->bSWLedCtrl = true;
308 } else if (pLed1->bLedOn)
309 SwLedOff(padapter, pLed1);
310 }
311 }
312 switch (pLed->CurrLedState) {
313 case LED_BLINK_SLOWLY:
314 if (pLed->bLedOn)
315 pLed->BlinkingLedState = LED_OFF;
316 else
317 pLed->BlinkingLedState = LED_ON;
318 _set_timer(&(pLed->BlinkTimer),
319 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
320 break;
321 case LED_BLINK_NORMAL:
322 if (pLed->bLedOn)
323 pLed->BlinkingLedState = LED_OFF;
324 else
325 pLed->BlinkingLedState = LED_ON;
326 _set_timer(&(pLed->BlinkTimer),
327 LED_BLINK_LINK_INTERVAL_ALPHA);
328 break;
329 case LED_SCAN_BLINK:
330 pLed->BlinkTimes--;
331 if (pLed->BlinkTimes == 0)
332 bStopBlinking = true;
333 if (bStopBlinking) {
334 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
335 pLed->bLedLinkBlinkInProgress = true;
336 pLed->CurrLedState = LED_BLINK_NORMAL;
337 if (pLed->bLedOn)
338 pLed->BlinkingLedState = LED_OFF;
339 else
340 pLed->BlinkingLedState = LED_ON;
341 _set_timer(&(pLed->BlinkTimer),
342 LED_BLINK_LINK_INTERVAL_ALPHA);
343 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
344 pLed->bLedNoLinkBlinkInProgress = true;
345 pLed->CurrLedState = LED_BLINK_SLOWLY;
346 if (pLed->bLedOn)
347 pLed->BlinkingLedState = LED_OFF;
348 else
349 pLed->BlinkingLedState = LED_ON;
350 _set_timer(&(pLed->BlinkTimer),
351 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
352 }
353 pLed->bLedScanBlinkInProgress = false;
354 } else {
355 if (pLed->bLedOn)
356 pLed->BlinkingLedState = LED_OFF;
357 else
358 pLed->BlinkingLedState = LED_ON;
359 _set_timer(&(pLed->BlinkTimer),
360 LED_BLINK_SCAN_INTERVAL_ALPHA);
361 }
362 break;
363 case LED_TXRX_BLINK:
364 pLed->BlinkTimes--;
365 if (pLed->BlinkTimes == 0)
366 bStopBlinking = true;
367 if (bStopBlinking) {
368 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
369 pLed->bLedLinkBlinkInProgress = true;
370 pLed->CurrLedState = LED_BLINK_NORMAL;
371 if (pLed->bLedOn)
372 pLed->BlinkingLedState = LED_OFF;
373 else
374 pLed->BlinkingLedState = LED_ON;
375 _set_timer(&(pLed->BlinkTimer),
376 LED_BLINK_LINK_INTERVAL_ALPHA);
377 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
378 pLed->bLedNoLinkBlinkInProgress = true;
379 pLed->CurrLedState = LED_BLINK_SLOWLY;
380 if (pLed->bLedOn)
381 pLed->BlinkingLedState = LED_OFF;
382 else
383 pLed->BlinkingLedState = LED_ON;
384 _set_timer(&(pLed->BlinkTimer),
385 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
386 }
387 pLed->BlinkTimes = 0;
388 pLed->bLedBlinkInProgress = false;
389 } else {
390 if (pLed->bLedOn)
391 pLed->BlinkingLedState = LED_OFF;
392 else
393 pLed->BlinkingLedState = LED_ON;
394 _set_timer(&(pLed->BlinkTimer),
395 LED_BLINK_FASTER_INTERVAL_ALPHA);
396 }
397 break;
398 case LED_BLINK_WPS:
399 if (pLed->bLedOn)
400 pLed->BlinkingLedState = LED_OFF;
401 else
402 pLed->BlinkingLedState = LED_ON;
403 _set_timer(&(pLed->BlinkTimer),
404 LED_BLINK_SCAN_INTERVAL_ALPHA);
405 break;
406 case LED_BLINK_WPS_STOP: /* WPS success */
407 if (pLed->BlinkingLedState == LED_ON) {
408 pLed->BlinkingLedState = LED_OFF;
409 _set_timer(&(pLed->BlinkTimer),
410 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
411 bStopBlinking = false;
412 } else
413 bStopBlinking = true;
414 if (bStopBlinking) {
415 pLed->bLedLinkBlinkInProgress = true;
416 pLed->CurrLedState = LED_BLINK_NORMAL;
417 if (pLed->bLedOn)
418 pLed->BlinkingLedState = LED_OFF;
419 else
420 pLed->BlinkingLedState = LED_ON;
421 _set_timer(&(pLed->BlinkTimer),
422 LED_BLINK_LINK_INTERVAL_ALPHA);
423 }
424 pLed->bLedWPSBlinkInProgress = false;
425 break;
426 default:
427 break;
428 }
429 }
430
431 static void SwLedBlink2(struct LED_871x *pLed)
432 {
433 struct _adapter *padapter = pLed->padapter;
434 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
435 u8 bStopBlinking = false;
436
437 /* Change LED according to BlinkingLedState specified. */
438 if (pLed->BlinkingLedState == LED_ON)
439 SwLedOn(padapter, pLed);
440 else
441 SwLedOff(padapter, pLed);
442 switch (pLed->CurrLedState) {
443 case LED_SCAN_BLINK:
444 pLed->BlinkTimes--;
445 if (pLed->BlinkTimes == 0)
446 bStopBlinking = true;
447 if (bStopBlinking) {
448 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
449 pLed->CurrLedState = LED_ON;
450 pLed->BlinkingLedState = LED_ON;
451 SwLedOn(padapter, pLed);
452 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
453 pLed->CurrLedState = LED_OFF;
454 pLed->BlinkingLedState = LED_OFF;
455 SwLedOff(padapter, pLed);
456 }
457 pLed->bLedScanBlinkInProgress = false;
458 } else {
459 if (pLed->bLedOn)
460 pLed->BlinkingLedState = LED_OFF;
461 else
462 pLed->BlinkingLedState = LED_ON;
463 _set_timer(&(pLed->BlinkTimer),
464 LED_BLINK_SCAN_INTERVAL_ALPHA);
465 }
466 break;
467 case LED_TXRX_BLINK:
468 pLed->BlinkTimes--;
469 if (pLed->BlinkTimes == 0)
470 bStopBlinking = true;
471 if (bStopBlinking) {
472 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
473 pLed->CurrLedState = LED_ON;
474 pLed->BlinkingLedState = LED_ON;
475 SwLedOn(padapter, pLed);
476 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
477 pLed->CurrLedState = LED_OFF;
478 pLed->BlinkingLedState = LED_OFF;
479 SwLedOff(padapter, pLed);
480 }
481 pLed->bLedBlinkInProgress = false;
482 } else {
483 if (pLed->bLedOn)
484 pLed->BlinkingLedState = LED_OFF;
485 else
486 pLed->BlinkingLedState = LED_ON;
487 _set_timer(&(pLed->BlinkTimer),
488 LED_BLINK_FASTER_INTERVAL_ALPHA);
489 }
490 break;
491 default:
492 break;
493 }
494 }
495
496 static void SwLedBlink3(struct LED_871x *pLed)
497 {
498 struct _adapter *padapter = pLed->padapter;
499 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
500 u8 bStopBlinking = false;
501
502 /* Change LED according to BlinkingLedState specified. */
503 if (pLed->BlinkingLedState == LED_ON)
504 SwLedOn(padapter, pLed);
505 else
506 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
507 SwLedOff(padapter, pLed);
508 switch (pLed->CurrLedState) {
509 case LED_SCAN_BLINK:
510 pLed->BlinkTimes--;
511 if (pLed->BlinkTimes == 0)
512 bStopBlinking = true;
513 if (bStopBlinking) {
514 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
515 pLed->CurrLedState = LED_ON;
516 pLed->BlinkingLedState = LED_ON;
517 if (!pLed->bLedOn)
518 SwLedOn(padapter, pLed);
519 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
520 pLed->CurrLedState = LED_OFF;
521 pLed->BlinkingLedState = LED_OFF;
522 if (pLed->bLedOn)
523 SwLedOff(padapter, pLed);
524 }
525 pLed->bLedScanBlinkInProgress = false;
526 } else {
527 if (pLed->bLedOn)
528 pLed->BlinkingLedState = LED_OFF;
529 else
530 pLed->BlinkingLedState = LED_ON;
531 _set_timer(&(pLed->BlinkTimer),
532 LED_BLINK_SCAN_INTERVAL_ALPHA);
533 }
534 break;
535 case LED_TXRX_BLINK:
536 pLed->BlinkTimes--;
537 if (pLed->BlinkTimes == 0)
538 bStopBlinking = true;
539 if (bStopBlinking) {
540 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
541 pLed->CurrLedState = LED_ON;
542 pLed->BlinkingLedState = LED_ON;
543 if (!pLed->bLedOn)
544 SwLedOn(padapter, pLed);
545 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
546 pLed->CurrLedState = LED_OFF;
547 pLed->BlinkingLedState = LED_OFF;
548 if (pLed->bLedOn)
549 SwLedOff(padapter, pLed);
550 }
551 pLed->bLedBlinkInProgress = false;
552 } else {
553 if (pLed->bLedOn)
554 pLed->BlinkingLedState = LED_OFF;
555 else
556 pLed->BlinkingLedState = LED_ON;
557 _set_timer(&(pLed->BlinkTimer),
558 LED_BLINK_FASTER_INTERVAL_ALPHA);
559 }
560 break;
561 case LED_BLINK_WPS:
562 if (pLed->bLedOn)
563 pLed->BlinkingLedState = LED_OFF;
564 else
565 pLed->BlinkingLedState = LED_ON;
566 _set_timer(&(pLed->BlinkTimer),
567 LED_BLINK_SCAN_INTERVAL_ALPHA);
568 break;
569 case LED_BLINK_WPS_STOP: /*WPS success*/
570 if (pLed->BlinkingLedState == LED_ON) {
571 pLed->BlinkingLedState = LED_OFF;
572 _set_timer(&(pLed->BlinkTimer),
573 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
574 bStopBlinking = false;
575 } else
576 bStopBlinking = true;
577 if (bStopBlinking) {
578 pLed->CurrLedState = LED_ON;
579 pLed->BlinkingLedState = LED_ON;
580 SwLedOn(padapter, pLed);
581 pLed->bLedWPSBlinkInProgress = false;
582 }
583 break;
584 default:
585 break;
586 }
587 }
588
589 static void SwLedBlink4(struct LED_871x *pLed)
590 {
591 struct _adapter *padapter = pLed->padapter;
592 struct led_priv *ledpriv = &(padapter->ledpriv);
593 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
594 u8 bStopBlinking = false;
595
596 /* Change LED according to BlinkingLedState specified. */
597 if (pLed->BlinkingLedState == LED_ON)
598 SwLedOn(padapter, pLed);
599 else
600 SwLedOff(padapter, pLed);
601 if (!pLed1->bLedWPSBlinkInProgress &&
602 pLed1->BlinkingLedState == LED_UNKNOWN) {
603 pLed1->BlinkingLedState = LED_OFF;
604 pLed1->CurrLedState = LED_OFF;
605 SwLedOff(padapter, pLed1);
606 }
607 switch (pLed->CurrLedState) {
608 case LED_BLINK_SLOWLY:
609 if (pLed->bLedOn)
610 pLed->BlinkingLedState = LED_OFF;
611 else
612 pLed->BlinkingLedState = LED_ON;
613 _set_timer(&(pLed->BlinkTimer),
614 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
615 break;
616 case LED_BLINK_StartToBlink:
617 if (pLed->bLedOn) {
618 pLed->BlinkingLedState = LED_OFF;
619 _set_timer(&(pLed->BlinkTimer),
620 LED_BLINK_SLOWLY_INTERVAL);
621 } else {
622 pLed->BlinkingLedState = LED_ON;
623 _set_timer(&(pLed->BlinkTimer),
624 LED_BLINK_NORMAL_INTERVAL);
625 }
626 break;
627 case LED_SCAN_BLINK:
628 pLed->BlinkTimes--;
629 if (pLed->BlinkTimes == 0)
630 bStopBlinking = true;
631 if (bStopBlinking) {
632 pLed->bLedNoLinkBlinkInProgress = true;
633 pLed->CurrLedState = LED_BLINK_SLOWLY;
634 if (pLed->bLedOn)
635 pLed->BlinkingLedState = LED_OFF;
636 else
637 pLed->BlinkingLedState = LED_ON;
638 _set_timer(&(pLed->BlinkTimer),
639 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
640 pLed->bLedScanBlinkInProgress = false;
641 } else {
642 if (pLed->bLedOn)
643 pLed->BlinkingLedState = LED_OFF;
644 else
645 pLed->BlinkingLedState = LED_ON;
646 _set_timer(&(pLed->BlinkTimer),
647 LED_BLINK_SCAN_INTERVAL_ALPHA);
648 }
649 break;
650 case LED_TXRX_BLINK:
651 pLed->BlinkTimes--;
652 if (pLed->BlinkTimes == 0)
653 bStopBlinking = true;
654 if (bStopBlinking) {
655 pLed->bLedNoLinkBlinkInProgress = true;
656 pLed->CurrLedState = LED_BLINK_SLOWLY;
657 if (pLed->bLedOn)
658 pLed->BlinkingLedState = LED_OFF;
659 else
660 pLed->BlinkingLedState = LED_ON;
661 _set_timer(&(pLed->BlinkTimer),
662 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
663 pLed->bLedBlinkInProgress = false;
664 } else {
665 if (pLed->bLedOn)
666 pLed->BlinkingLedState = LED_OFF;
667 else
668 pLed->BlinkingLedState = LED_ON;
669 _set_timer(&(pLed->BlinkTimer),
670 LED_BLINK_FASTER_INTERVAL_ALPHA);
671 }
672 break;
673 case LED_BLINK_WPS:
674 if (pLed->bLedOn) {
675 pLed->BlinkingLedState = LED_OFF;
676 _set_timer(&(pLed->BlinkTimer),
677 LED_BLINK_SLOWLY_INTERVAL);
678 } else {
679 pLed->BlinkingLedState = LED_ON;
680 _set_timer(&(pLed->BlinkTimer),
681 LED_BLINK_NORMAL_INTERVAL);
682 }
683 break;
684 case LED_BLINK_WPS_STOP: /*WPS authentication fail*/
685 if (pLed->bLedOn)
686 pLed->BlinkingLedState = LED_OFF;
687 else
688 pLed->BlinkingLedState = LED_ON;
689 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
690 break;
691 case LED_BLINK_WPS_STOP_OVERLAP: /*WPS session overlap */
692 pLed->BlinkTimes--;
693 if (pLed->BlinkTimes == 0) {
694 if (pLed->bLedOn)
695 pLed->BlinkTimes = 1;
696 else
697 bStopBlinking = true;
698 }
699 if (bStopBlinking) {
700 pLed->BlinkTimes = 10;
701 pLed->BlinkingLedState = LED_ON;
702 _set_timer(&(pLed->BlinkTimer),
703 LED_BLINK_LINK_INTERVAL_ALPHA);
704 } else {
705 if (pLed->bLedOn)
706 pLed->BlinkingLedState = LED_OFF;
707 else
708 pLed->BlinkingLedState = LED_ON;
709 _set_timer(&(pLed->BlinkTimer),
710 LED_BLINK_NORMAL_INTERVAL);
711 }
712 break;
713 default:
714 break;
715 }
716 }
717
718 static void SwLedBlink5(struct LED_871x *pLed)
719 {
720 struct _adapter *padapter = pLed->padapter;
721 u8 bStopBlinking = false;
722
723 /* Change LED according to BlinkingLedState specified. */
724 if (pLed->BlinkingLedState == LED_ON)
725 SwLedOn(padapter, pLed);
726 else
727 SwLedOff(padapter, pLed);
728 switch (pLed->CurrLedState) {
729 case LED_SCAN_BLINK:
730 pLed->BlinkTimes--;
731 if (pLed->BlinkTimes == 0)
732 bStopBlinking = true;
733 if (bStopBlinking) {
734 pLed->CurrLedState = LED_ON;
735 pLed->BlinkingLedState = LED_ON;
736 if (!pLed->bLedOn)
737 _set_timer(&(pLed->BlinkTimer),
738 LED_BLINK_FASTER_INTERVAL_ALPHA);
739 pLed->bLedScanBlinkInProgress = false;
740 } else {
741 if (pLed->bLedOn)
742 pLed->BlinkingLedState = LED_OFF;
743 else
744 pLed->BlinkingLedState = LED_ON;
745 _set_timer(&(pLed->BlinkTimer),
746 LED_BLINK_SCAN_INTERVAL_ALPHA);
747 }
748 break;
749 case LED_TXRX_BLINK:
750 pLed->BlinkTimes--;
751 if (pLed->BlinkTimes == 0)
752 bStopBlinking = true;
753 if (bStopBlinking) {
754 pLed->CurrLedState = LED_ON;
755 pLed->BlinkingLedState = LED_ON;
756 if (!pLed->bLedOn)
757 _set_timer(&(pLed->BlinkTimer),
758 LED_BLINK_FASTER_INTERVAL_ALPHA);
759 pLed->bLedBlinkInProgress = false;
760 } else {
761 if (pLed->bLedOn)
762 pLed->BlinkingLedState = LED_OFF;
763 else
764 pLed->BlinkingLedState = LED_ON;
765 _set_timer(&(pLed->BlinkTimer),
766 LED_BLINK_FASTER_INTERVAL_ALPHA);
767 }
768 break;
769 default:
770 break;
771 }
772 }
773
774 static void SwLedBlink6(struct LED_871x *pLed)
775 {
776 struct _adapter *padapter = pLed->padapter;
777 u8 bStopBlinking = false;
778
779 /* Change LED according to BlinkingLedState specified. */
780 if (pLed->BlinkingLedState == LED_ON)
781 SwLedOn(padapter, pLed);
782 else
783 SwLedOff(padapter, pLed);
784 switch (pLed->CurrLedState) {
785 case LED_TXRX_BLINK:
786 pLed->BlinkTimes--;
787 if (pLed->BlinkTimes == 0)
788 bStopBlinking = true;
789 if (bStopBlinking) {
790 pLed->CurrLedState = LED_ON;
791 pLed->BlinkingLedState = LED_ON;
792 if (!pLed->bLedOn)
793 SwLedOn(padapter, pLed);
794 pLed->bLedBlinkInProgress = false;
795 } else {
796 if (pLed->bLedOn)
797 pLed->BlinkingLedState = LED_OFF;
798 else
799 pLed->BlinkingLedState = LED_ON;
800 _set_timer(&(pLed->BlinkTimer),
801 LED_BLINK_FASTER_INTERVAL_ALPHA);
802 }
803 break;
804 case LED_BLINK_WPS:
805 if (pLed->bLedOn)
806 pLed->BlinkingLedState = LED_OFF;
807 else
808 pLed->BlinkingLedState = LED_ON;
809 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
810 break;
811
812 default:
813 break;
814 }
815 }
816
817 /* Description:
818 * Callback function of LED BlinkTimer,
819 * it just schedules to corresponding BlinkWorkItem.
820 */
821 static void BlinkTimerCallback(unsigned long data)
822 {
823 struct LED_871x *pLed = (struct LED_871x *)data;
824
825 /* This fixed the crash problem on Fedora 12 when trying to do the
826 * insmod;ifconfig up;rmmod commands. */
827 if ((pLed->padapter->bSurpriseRemoved == true) ||
828 (pLed->padapter->bDriverStopped == true))
829 return;
830 _set_workitem(&(pLed->BlinkWorkItem));
831 }
832
833 /* Description:
834 * Callback function of LED BlinkWorkItem.
835 * We dispatch actual LED blink action according to LedStrategy.
836 */
837 static void BlinkWorkItemCallback(struct work_struct *work)
838 {
839 struct LED_871x *pLed = container_of(work, struct LED_871x,
840 BlinkWorkItem);
841 struct led_priv *ledpriv = &(pLed->padapter->ledpriv);
842
843 switch (ledpriv->LedStrategy) {
844 case SW_LED_MODE0:
845 SwLedBlink(pLed);
846 break;
847 case SW_LED_MODE1:
848 SwLedBlink1(pLed);
849 break;
850 case SW_LED_MODE2:
851 SwLedBlink2(pLed);
852 break;
853 case SW_LED_MODE3:
854 SwLedBlink3(pLed);
855 break;
856 case SW_LED_MODE4:
857 SwLedBlink4(pLed);
858 break;
859 case SW_LED_MODE5:
860 SwLedBlink5(pLed);
861 break;
862 case SW_LED_MODE6:
863 SwLedBlink6(pLed);
864 break;
865 default:
866 SwLedBlink(pLed);
867 break;
868 }
869 }
870
871 /*============================================================================
872 * Default LED behavior.
873 *============================================================================
874 *
875 * Description:
876 * Implement each led action for SW_LED_MODE0.
877 * This is default strategy.
878 */
879
880 static void SwLedControlMode1(struct _adapter *padapter,
881 enum LED_CTL_MODE LedAction)
882 {
883 struct led_priv *ledpriv = &(padapter->ledpriv);
884 struct LED_871x *pLed = &(ledpriv->SwLed0);
885 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
886 struct sitesurvey_ctrl *psitesurveyctrl = &(pmlmepriv->sitesurveyctrl);
887
888 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
889 pLed = &(ledpriv->SwLed1);
890 switch (LedAction) {
891 case LED_CTL_START_TO_LINK:
892 case LED_CTL_NO_LINK:
893 if (pLed->bLedNoLinkBlinkInProgress == false) {
894 if (pLed->CurrLedState == LED_SCAN_BLINK ||
895 IS_LED_WPS_BLINKING(pLed))
896 return;
897 if (pLed->bLedLinkBlinkInProgress == true) {
898 _cancel_timer_ex(&(pLed->BlinkTimer));
899 pLed->bLedLinkBlinkInProgress = false;
900 }
901 if (pLed->bLedBlinkInProgress == true) {
902 _cancel_timer_ex(&(pLed->BlinkTimer));
903 pLed->bLedBlinkInProgress = false;
904 }
905 pLed->bLedNoLinkBlinkInProgress = true;
906 pLed->CurrLedState = LED_BLINK_SLOWLY;
907 if (pLed->bLedOn)
908 pLed->BlinkingLedState = LED_OFF;
909 else
910 pLed->BlinkingLedState = LED_ON;
911 _set_timer(&(pLed->BlinkTimer),
912 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
913 }
914 break;
915 case LED_CTL_LINK:
916 if (pLed->bLedLinkBlinkInProgress == false) {
917 if (pLed->CurrLedState == LED_SCAN_BLINK ||
918 IS_LED_WPS_BLINKING(pLed))
919 return;
920 if (pLed->bLedNoLinkBlinkInProgress == true) {
921 _cancel_timer_ex(&(pLed->BlinkTimer));
922 pLed->bLedNoLinkBlinkInProgress = false;
923 }
924 if (pLed->bLedBlinkInProgress == true) {
925 _cancel_timer_ex(&(pLed->BlinkTimer));
926 pLed->bLedBlinkInProgress = false;
927 }
928 pLed->bLedLinkBlinkInProgress = true;
929 pLed->CurrLedState = LED_BLINK_NORMAL;
930 if (pLed->bLedOn)
931 pLed->BlinkingLedState = LED_OFF;
932 else
933 pLed->BlinkingLedState = LED_ON;
934 _set_timer(&(pLed->BlinkTimer),
935 LED_BLINK_LINK_INTERVAL_ALPHA);
936 }
937 break;
938 case LED_CTL_SITE_SURVEY:
939 if ((psitesurveyctrl->traffic_busy) &&
940 (check_fwstate(pmlmepriv, _FW_LINKED) == true))
941 ; /* dummy branch */
942 else if (pLed->bLedScanBlinkInProgress == false) {
943 if (IS_LED_WPS_BLINKING(pLed))
944 return;
945 if (pLed->bLedNoLinkBlinkInProgress == true) {
946 _cancel_timer_ex(&(pLed->BlinkTimer));
947 pLed->bLedNoLinkBlinkInProgress = false;
948 }
949 if (pLed->bLedLinkBlinkInProgress == true) {
950 _cancel_timer_ex(&(pLed->BlinkTimer));
951 pLed->bLedLinkBlinkInProgress = false;
952 }
953 if (pLed->bLedBlinkInProgress == true) {
954 _cancel_timer_ex(&(pLed->BlinkTimer));
955 pLed->bLedBlinkInProgress = false;
956 }
957 pLed->bLedScanBlinkInProgress = true;
958 pLed->CurrLedState = LED_SCAN_BLINK;
959 pLed->BlinkTimes = 24;
960 if (pLed->bLedOn)
961 pLed->BlinkingLedState = LED_OFF;
962 else
963 pLed->BlinkingLedState = LED_ON;
964 _set_timer(&(pLed->BlinkTimer),
965 LED_BLINK_SCAN_INTERVAL_ALPHA);
966 }
967 break;
968 case LED_CTL_TX:
969 case LED_CTL_RX:
970 if (pLed->bLedBlinkInProgress == false) {
971 if (pLed->CurrLedState == LED_SCAN_BLINK ||
972 IS_LED_WPS_BLINKING(pLed))
973 return;
974 if (pLed->bLedNoLinkBlinkInProgress == true) {
975 _cancel_timer_ex(&(pLed->BlinkTimer));
976 pLed->bLedNoLinkBlinkInProgress = false;
977 }
978 if (pLed->bLedLinkBlinkInProgress == true) {
979 _cancel_timer_ex(&(pLed->BlinkTimer));
980 pLed->bLedLinkBlinkInProgress = false;
981 }
982 pLed->bLedBlinkInProgress = true;
983 pLed->CurrLedState = LED_TXRX_BLINK;
984 pLed->BlinkTimes = 2;
985 if (pLed->bLedOn)
986 pLed->BlinkingLedState = LED_OFF;
987 else
988 pLed->BlinkingLedState = LED_ON;
989 _set_timer(&(pLed->BlinkTimer),
990 LED_BLINK_FASTER_INTERVAL_ALPHA);
991 }
992 break;
993
994 case LED_CTL_START_WPS: /*wait until xinpin finish */
995 case LED_CTL_START_WPS_BOTTON:
996 if (pLed->bLedWPSBlinkInProgress == false) {
997 if (pLed->bLedNoLinkBlinkInProgress == true) {
998 _cancel_timer_ex(&(pLed->BlinkTimer));
999 pLed->bLedNoLinkBlinkInProgress = false;
1000 }
1001 if (pLed->bLedLinkBlinkInProgress == true) {
1002 _cancel_timer_ex(&(pLed->BlinkTimer));
1003 pLed->bLedLinkBlinkInProgress = false;
1004 }
1005 if (pLed->bLedBlinkInProgress == true) {
1006 _cancel_timer_ex(&(pLed->BlinkTimer));
1007 pLed->bLedBlinkInProgress = false;
1008 }
1009 if (pLed->bLedScanBlinkInProgress == true) {
1010 _cancel_timer_ex(&(pLed->BlinkTimer));
1011 pLed->bLedScanBlinkInProgress = false;
1012 }
1013 pLed->bLedWPSBlinkInProgress = true;
1014 pLed->CurrLedState = LED_BLINK_WPS;
1015 if (pLed->bLedOn)
1016 pLed->BlinkingLedState = LED_OFF;
1017 else
1018 pLed->BlinkingLedState = LED_ON;
1019 _set_timer(&(pLed->BlinkTimer),
1020 LED_BLINK_SCAN_INTERVAL_ALPHA);
1021 }
1022 break;
1023 case LED_CTL_STOP_WPS:
1024 if (pLed->bLedNoLinkBlinkInProgress == true) {
1025 _cancel_timer_ex(&(pLed->BlinkTimer));
1026 pLed->bLedNoLinkBlinkInProgress = false;
1027 }
1028 if (pLed->bLedLinkBlinkInProgress == true) {
1029 _cancel_timer_ex(&(pLed->BlinkTimer));
1030 pLed->bLedLinkBlinkInProgress = false;
1031 }
1032 if (pLed->bLedBlinkInProgress == true) {
1033 _cancel_timer_ex(&(pLed->BlinkTimer));
1034 pLed->bLedBlinkInProgress = false;
1035 }
1036 if (pLed->bLedScanBlinkInProgress == true) {
1037 _cancel_timer_ex(&(pLed->BlinkTimer));
1038 pLed->bLedScanBlinkInProgress = false;
1039 }
1040 if (pLed->bLedWPSBlinkInProgress)
1041 _cancel_timer_ex(&(pLed->BlinkTimer));
1042 else
1043 pLed->bLedWPSBlinkInProgress = true;
1044 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1045 if (pLed->bLedOn) {
1046 pLed->BlinkingLedState = LED_OFF;
1047 _set_timer(&(pLed->BlinkTimer),
1048 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1049 } else {
1050 pLed->BlinkingLedState = LED_ON;
1051 _set_timer(&(pLed->BlinkTimer), 0);
1052 }
1053 break;
1054 case LED_CTL_STOP_WPS_FAIL:
1055 if (pLed->bLedWPSBlinkInProgress) {
1056 _cancel_timer_ex(&(pLed->BlinkTimer));
1057 pLed->bLedWPSBlinkInProgress = false;
1058 }
1059 pLed->bLedNoLinkBlinkInProgress = true;
1060 pLed->CurrLedState = LED_BLINK_SLOWLY;
1061 if (pLed->bLedOn)
1062 pLed->BlinkingLedState = LED_OFF;
1063 else
1064 pLed->BlinkingLedState = LED_ON;
1065 _set_timer(&(pLed->BlinkTimer),
1066 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1067 break;
1068 case LED_CTL_POWER_OFF:
1069 pLed->CurrLedState = LED_OFF;
1070 pLed->BlinkingLedState = LED_OFF;
1071 if (pLed->bLedNoLinkBlinkInProgress) {
1072 _cancel_timer_ex(&(pLed->BlinkTimer));
1073 pLed->bLedNoLinkBlinkInProgress = false;
1074 }
1075 if (pLed->bLedLinkBlinkInProgress) {
1076 _cancel_timer_ex(&(pLed->BlinkTimer));
1077 pLed->bLedLinkBlinkInProgress = false;
1078 }
1079 if (pLed->bLedBlinkInProgress) {
1080 _cancel_timer_ex(&(pLed->BlinkTimer));
1081 pLed->bLedBlinkInProgress = false;
1082 }
1083 if (pLed->bLedWPSBlinkInProgress) {
1084 _cancel_timer_ex(&(pLed->BlinkTimer));
1085 pLed->bLedWPSBlinkInProgress = false;
1086 }
1087 if (pLed->bLedScanBlinkInProgress) {
1088 _cancel_timer_ex(&(pLed->BlinkTimer));
1089 pLed->bLedScanBlinkInProgress = false;
1090 }
1091 _set_timer(&(pLed->BlinkTimer), 0);
1092 break;
1093 default:
1094 break;
1095 }
1096 }
1097
1098 static void SwLedControlMode2(struct _adapter *padapter,
1099 enum LED_CTL_MODE LedAction)
1100 {
1101 struct led_priv *ledpriv = &(padapter->ledpriv);
1102 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1103 struct LED_871x *pLed = &(ledpriv->SwLed0);
1104
1105 switch (LedAction) {
1106 case LED_CTL_SITE_SURVEY:
1107 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1108 ; /* dummy branch */
1109 else if (pLed->bLedScanBlinkInProgress == false) {
1110 if (IS_LED_WPS_BLINKING(pLed))
1111 return;
1112
1113 if (pLed->bLedBlinkInProgress == true) {
1114 _cancel_timer_ex(&(pLed->BlinkTimer));
1115 pLed->bLedBlinkInProgress = false;
1116 }
1117 pLed->bLedScanBlinkInProgress = true;
1118 pLed->CurrLedState = LED_SCAN_BLINK;
1119 pLed->BlinkTimes = 24;
1120 if (pLed->bLedOn)
1121 pLed->BlinkingLedState = LED_OFF;
1122 else
1123 pLed->BlinkingLedState = LED_ON;
1124 _set_timer(&(pLed->BlinkTimer),
1125 LED_BLINK_SCAN_INTERVAL_ALPHA);
1126 }
1127 break;
1128
1129 case LED_CTL_TX:
1130 case LED_CTL_RX:
1131 if ((pLed->bLedBlinkInProgress == false) &&
1132 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) {
1133 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1134 IS_LED_WPS_BLINKING(pLed))
1135 return;
1136 pLed->bLedBlinkInProgress = true;
1137 pLed->CurrLedState = LED_TXRX_BLINK;
1138 pLed->BlinkTimes = 2;
1139 if (pLed->bLedOn)
1140 pLed->BlinkingLedState = LED_OFF;
1141 else
1142 pLed->BlinkingLedState = LED_ON;
1143 _set_timer(&(pLed->BlinkTimer),
1144 LED_BLINK_FASTER_INTERVAL_ALPHA);
1145 }
1146 break;
1147
1148 case LED_CTL_LINK:
1149 pLed->CurrLedState = LED_ON;
1150 pLed->BlinkingLedState = LED_ON;
1151 if (pLed->bLedBlinkInProgress) {
1152 _cancel_timer_ex(&(pLed->BlinkTimer));
1153 pLed->bLedBlinkInProgress = false;
1154 }
1155 if (pLed->bLedScanBlinkInProgress) {
1156 _cancel_timer_ex(&(pLed->BlinkTimer));
1157 pLed->bLedScanBlinkInProgress = false;
1158 }
1159
1160 _set_timer(&(pLed->BlinkTimer), 0);
1161 break;
1162
1163 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1164 case LED_CTL_START_WPS_BOTTON:
1165 if (pLed->bLedWPSBlinkInProgress == false) {
1166 if (pLed->bLedBlinkInProgress == true) {
1167 _cancel_timer_ex(&(pLed->BlinkTimer));
1168 pLed->bLedBlinkInProgress = false;
1169 }
1170 if (pLed->bLedScanBlinkInProgress == true) {
1171 _cancel_timer_ex(&(pLed->BlinkTimer));
1172 pLed->bLedScanBlinkInProgress = false;
1173 }
1174 pLed->bLedWPSBlinkInProgress = true;
1175 pLed->CurrLedState = LED_ON;
1176 pLed->BlinkingLedState = LED_ON;
1177 _set_timer(&(pLed->BlinkTimer), 0);
1178 }
1179 break;
1180
1181 case LED_CTL_STOP_WPS:
1182 pLed->bLedWPSBlinkInProgress = false;
1183 pLed->CurrLedState = LED_ON;
1184 pLed->BlinkingLedState = LED_ON;
1185 _set_timer(&(pLed->BlinkTimer), 0);
1186 break;
1187
1188 case LED_CTL_STOP_WPS_FAIL:
1189 pLed->bLedWPSBlinkInProgress = false;
1190 pLed->CurrLedState = LED_OFF;
1191 pLed->BlinkingLedState = LED_OFF;
1192 _set_timer(&(pLed->BlinkTimer), 0);
1193 break;
1194
1195 case LED_CTL_START_TO_LINK:
1196 case LED_CTL_NO_LINK:
1197 if (!IS_LED_BLINKING(pLed)) {
1198 pLed->CurrLedState = LED_OFF;
1199 pLed->BlinkingLedState = LED_OFF;
1200 _set_timer(&(pLed->BlinkTimer), 0);
1201 }
1202 break;
1203 case LED_CTL_POWER_OFF:
1204 pLed->CurrLedState = LED_OFF;
1205 pLed->BlinkingLedState = LED_OFF;
1206 if (pLed->bLedBlinkInProgress) {
1207 _cancel_timer_ex(&(pLed->BlinkTimer));
1208 pLed->bLedBlinkInProgress = false;
1209 }
1210 if (pLed->bLedScanBlinkInProgress) {
1211 _cancel_timer_ex(&(pLed->BlinkTimer));
1212 pLed->bLedScanBlinkInProgress = false;
1213 }
1214 if (pLed->bLedWPSBlinkInProgress) {
1215 _cancel_timer_ex(&(pLed->BlinkTimer));
1216 pLed->bLedWPSBlinkInProgress = false;
1217 }
1218 _set_timer(&(pLed->BlinkTimer), 0);
1219 break;
1220 default:
1221 break;
1222 }
1223 }
1224
1225 static void SwLedControlMode3(struct _adapter *padapter,
1226 enum LED_CTL_MODE LedAction)
1227 {
1228 struct led_priv *ledpriv = &(padapter->ledpriv);
1229 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1230 struct LED_871x *pLed = &(ledpriv->SwLed0);
1231
1232 switch (LedAction) {
1233 case LED_CTL_SITE_SURVEY:
1234 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1235 ; /* dummy branch */
1236 else if (pLed->bLedScanBlinkInProgress == false) {
1237 if (IS_LED_WPS_BLINKING(pLed))
1238 return;
1239 if (pLed->bLedBlinkInProgress == true) {
1240 _cancel_timer_ex(&(pLed->BlinkTimer));
1241 pLed->bLedBlinkInProgress = false;
1242 }
1243 pLed->bLedScanBlinkInProgress = true;
1244 pLed->CurrLedState = LED_SCAN_BLINK;
1245 pLed->BlinkTimes = 24;
1246 if (pLed->bLedOn)
1247 pLed->BlinkingLedState = LED_OFF;
1248 else
1249 pLed->BlinkingLedState = LED_ON;
1250 _set_timer(&(pLed->BlinkTimer),
1251 LED_BLINK_SCAN_INTERVAL_ALPHA);
1252 }
1253 break;
1254 case LED_CTL_TX:
1255 case LED_CTL_RX:
1256 if ((pLed->bLedBlinkInProgress == false) &&
1257 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) {
1258 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1259 IS_LED_WPS_BLINKING(pLed))
1260 return;
1261 pLed->bLedBlinkInProgress = true;
1262 pLed->CurrLedState = LED_TXRX_BLINK;
1263 pLed->BlinkTimes = 2;
1264 if (pLed->bLedOn)
1265 pLed->BlinkingLedState = LED_OFF;
1266 else
1267 pLed->BlinkingLedState = LED_ON;
1268 _set_timer(&(pLed->BlinkTimer),
1269 LED_BLINK_FASTER_INTERVAL_ALPHA);
1270 }
1271 break;
1272 case LED_CTL_LINK:
1273 if (IS_LED_WPS_BLINKING(pLed))
1274 return;
1275 pLed->CurrLedState = LED_ON;
1276 pLed->BlinkingLedState = LED_ON;
1277 if (pLed->bLedBlinkInProgress) {
1278 _cancel_timer_ex(&(pLed->BlinkTimer));
1279 pLed->bLedBlinkInProgress = false;
1280 }
1281 if (pLed->bLedScanBlinkInProgress) {
1282 _cancel_timer_ex(&(pLed->BlinkTimer));
1283 pLed->bLedScanBlinkInProgress = false;
1284 }
1285 _set_timer(&(pLed->BlinkTimer), 0);
1286 break;
1287 case LED_CTL_START_WPS: /* wait until xinpin finish */
1288 case LED_CTL_START_WPS_BOTTON:
1289 if (pLed->bLedWPSBlinkInProgress == false) {
1290 if (pLed->bLedBlinkInProgress == true) {
1291 _cancel_timer_ex(&(pLed->BlinkTimer));
1292 pLed->bLedBlinkInProgress = false;
1293 }
1294 if (pLed->bLedScanBlinkInProgress == true) {
1295 _cancel_timer_ex(&(pLed->BlinkTimer));
1296 pLed->bLedScanBlinkInProgress = false;
1297 }
1298 pLed->bLedWPSBlinkInProgress = true;
1299 pLed->CurrLedState = LED_BLINK_WPS;
1300 if (pLed->bLedOn)
1301 pLed->BlinkingLedState = LED_OFF;
1302 else
1303 pLed->BlinkingLedState = LED_ON;
1304 _set_timer(&(pLed->BlinkTimer),
1305 LED_BLINK_SCAN_INTERVAL_ALPHA);
1306 }
1307 break;
1308 case LED_CTL_STOP_WPS:
1309 if (pLed->bLedWPSBlinkInProgress) {
1310 _cancel_timer_ex(&(pLed->BlinkTimer));
1311 pLed->bLedWPSBlinkInProgress = false;
1312 } else
1313 pLed->bLedWPSBlinkInProgress = true;
1314 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1315 if (pLed->bLedOn) {
1316 pLed->BlinkingLedState = LED_OFF;
1317 _set_timer(&(pLed->BlinkTimer),
1318 LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1319 } else {
1320 pLed->BlinkingLedState = LED_ON;
1321 _set_timer(&(pLed->BlinkTimer), 0);
1322 }
1323 break;
1324 case LED_CTL_STOP_WPS_FAIL:
1325 if (pLed->bLedWPSBlinkInProgress) {
1326 _cancel_timer_ex(&(pLed->BlinkTimer));
1327 pLed->bLedWPSBlinkInProgress = false;
1328 }
1329 pLed->CurrLedState = LED_OFF;
1330 pLed->BlinkingLedState = LED_OFF;
1331 _set_timer(&(pLed->BlinkTimer), 0);
1332 break;
1333 case LED_CTL_START_TO_LINK:
1334 case LED_CTL_NO_LINK:
1335 if (!IS_LED_BLINKING(pLed)) {
1336 pLed->CurrLedState = LED_OFF;
1337 pLed->BlinkingLedState = LED_OFF;
1338 _set_timer(&(pLed->BlinkTimer), 0);
1339 }
1340 break;
1341 case LED_CTL_POWER_OFF:
1342 pLed->CurrLedState = LED_OFF;
1343 pLed->BlinkingLedState = LED_OFF;
1344 if (pLed->bLedBlinkInProgress) {
1345 _cancel_timer_ex(&(pLed->BlinkTimer));
1346 pLed->bLedBlinkInProgress = false;
1347 }
1348 if (pLed->bLedScanBlinkInProgress) {
1349 _cancel_timer_ex(&(pLed->BlinkTimer));
1350 pLed->bLedScanBlinkInProgress = false;
1351 }
1352 if (pLed->bLedWPSBlinkInProgress) {
1353 _cancel_timer_ex(&(pLed->BlinkTimer));
1354 pLed->bLedWPSBlinkInProgress = false;
1355 }
1356 _set_timer(&(pLed->BlinkTimer), 0);
1357 break;
1358 default:
1359 break;
1360 }
1361 }
1362
1363 static void SwLedControlMode4(struct _adapter *padapter,
1364 enum LED_CTL_MODE LedAction)
1365 {
1366 struct led_priv *ledpriv = &(padapter->ledpriv);
1367 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1368 struct LED_871x *pLed = &(ledpriv->SwLed0);
1369 struct LED_871x *pLed1 = &(ledpriv->SwLed1);
1370
1371 switch (LedAction) {
1372 case LED_CTL_START_TO_LINK:
1373 if (pLed1->bLedWPSBlinkInProgress) {
1374 pLed1->bLedWPSBlinkInProgress = false;
1375 _cancel_timer_ex(&(pLed1->BlinkTimer));
1376 pLed1->BlinkingLedState = LED_OFF;
1377 pLed1->CurrLedState = LED_OFF;
1378 if (pLed1->bLedOn)
1379 _set_timer(&(pLed->BlinkTimer), 0);
1380 }
1381 if (pLed->bLedStartToLinkBlinkInProgress == false) {
1382 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1383 IS_LED_WPS_BLINKING(pLed))
1384 return;
1385 if (pLed->bLedBlinkInProgress == true) {
1386 _cancel_timer_ex(&(pLed->BlinkTimer));
1387 pLed->bLedBlinkInProgress = false;
1388 }
1389 if (pLed->bLedNoLinkBlinkInProgress == true) {
1390 _cancel_timer_ex(&(pLed->BlinkTimer));
1391 pLed->bLedNoLinkBlinkInProgress = false;
1392 }
1393 pLed->bLedStartToLinkBlinkInProgress = true;
1394 pLed->CurrLedState = LED_BLINK_StartToBlink;
1395 if (pLed->bLedOn) {
1396 pLed->BlinkingLedState = LED_OFF;
1397 _set_timer(&(pLed->BlinkTimer),
1398 LED_BLINK_SLOWLY_INTERVAL);
1399 } else {
1400 pLed->BlinkingLedState = LED_ON;
1401 _set_timer(&(pLed->BlinkTimer),
1402 LED_BLINK_NORMAL_INTERVAL);
1403 }
1404 }
1405 break;
1406 case LED_CTL_LINK:
1407 case LED_CTL_NO_LINK:
1408 /*LED1 settings*/
1409 if (LedAction == LED_CTL_LINK) {
1410 if (pLed1->bLedWPSBlinkInProgress) {
1411 pLed1->bLedWPSBlinkInProgress = false;
1412 _cancel_timer_ex(&(pLed1->BlinkTimer));
1413 pLed1->BlinkingLedState = LED_OFF;
1414 pLed1->CurrLedState = LED_OFF;
1415 if (pLed1->bLedOn)
1416 _set_timer(&(pLed->BlinkTimer), 0);
1417 }
1418 }
1419 if (pLed->bLedNoLinkBlinkInProgress == false) {
1420 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1421 IS_LED_WPS_BLINKING(pLed))
1422 return;
1423 if (pLed->bLedBlinkInProgress == true) {
1424 _cancel_timer_ex(&(pLed->BlinkTimer));
1425 pLed->bLedBlinkInProgress = false;
1426 }
1427 pLed->bLedNoLinkBlinkInProgress = true;
1428 pLed->CurrLedState = LED_BLINK_SLOWLY;
1429 if (pLed->bLedOn)
1430 pLed->BlinkingLedState = LED_OFF;
1431 else
1432 pLed->BlinkingLedState = LED_ON;
1433 _set_timer(&(pLed->BlinkTimer),
1434 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1435 }
1436 break;
1437 case LED_CTL_SITE_SURVEY:
1438 if ((pmlmepriv->sitesurveyctrl.traffic_busy) &&
1439 (check_fwstate(pmlmepriv, _FW_LINKED) == true))
1440 ;
1441 else if (pLed->bLedScanBlinkInProgress == false) {
1442 if (IS_LED_WPS_BLINKING(pLed))
1443 return;
1444 if (pLed->bLedNoLinkBlinkInProgress == true) {
1445 _cancel_timer_ex(&(pLed->BlinkTimer));
1446 pLed->bLedNoLinkBlinkInProgress = false;
1447 }
1448 if (pLed->bLedBlinkInProgress == true) {
1449 _cancel_timer_ex(&(pLed->BlinkTimer));
1450 pLed->bLedBlinkInProgress = false;
1451 }
1452 pLed->bLedScanBlinkInProgress = true;
1453 pLed->CurrLedState = LED_SCAN_BLINK;
1454 pLed->BlinkTimes = 24;
1455 if (pLed->bLedOn)
1456 pLed->BlinkingLedState = LED_OFF;
1457 else
1458 pLed->BlinkingLedState = LED_ON;
1459 _set_timer(&(pLed->BlinkTimer),
1460 LED_BLINK_SCAN_INTERVAL_ALPHA);
1461 }
1462 break;
1463 case LED_CTL_TX:
1464 case LED_CTL_RX:
1465 if (pLed->bLedBlinkInProgress == false) {
1466 if (pLed->CurrLedState == LED_SCAN_BLINK ||
1467 IS_LED_WPS_BLINKING(pLed))
1468 return;
1469 if (pLed->bLedNoLinkBlinkInProgress == true) {
1470 _cancel_timer_ex(&(pLed->BlinkTimer));
1471 pLed->bLedNoLinkBlinkInProgress = false;
1472 }
1473 pLed->bLedBlinkInProgress = true;
1474 pLed->CurrLedState = LED_TXRX_BLINK;
1475 pLed->BlinkTimes = 2;
1476 if (pLed->bLedOn)
1477 pLed->BlinkingLedState = LED_OFF;
1478 else
1479 pLed->BlinkingLedState = LED_ON;
1480 _set_timer(&(pLed->BlinkTimer),
1481 LED_BLINK_FASTER_INTERVAL_ALPHA);
1482 }
1483 break;
1484 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1485 case LED_CTL_START_WPS_BOTTON:
1486 if (pLed1->bLedWPSBlinkInProgress) {
1487 pLed1->bLedWPSBlinkInProgress = false;
1488 _cancel_timer_ex(&(pLed1->BlinkTimer));
1489 pLed1->BlinkingLedState = LED_OFF;
1490 pLed1->CurrLedState = LED_OFF;
1491 if (pLed1->bLedOn)
1492 _set_timer(&(pLed->BlinkTimer), 0);
1493 }
1494 if (pLed->bLedWPSBlinkInProgress == false) {
1495 if (pLed->bLedNoLinkBlinkInProgress == true) {
1496 _cancel_timer_ex(&(pLed->BlinkTimer));
1497 pLed->bLedNoLinkBlinkInProgress = false;
1498 }
1499 if (pLed->bLedBlinkInProgress == true) {
1500 _cancel_timer_ex(&(pLed->BlinkTimer));
1501 pLed->bLedBlinkInProgress = false;
1502 }
1503 if (pLed->bLedScanBlinkInProgress == true) {
1504 _cancel_timer_ex(&(pLed->BlinkTimer));
1505 pLed->bLedScanBlinkInProgress = false;
1506 }
1507 pLed->bLedWPSBlinkInProgress = true;
1508 pLed->CurrLedState = LED_BLINK_WPS;
1509 if (pLed->bLedOn) {
1510 pLed->BlinkingLedState = LED_OFF;
1511 _set_timer(&(pLed->BlinkTimer),
1512 LED_BLINK_SLOWLY_INTERVAL);
1513 } else {
1514 pLed->BlinkingLedState = LED_ON;
1515 _set_timer(&(pLed->BlinkTimer),
1516 LED_BLINK_NORMAL_INTERVAL);
1517 }
1518 }
1519 break;
1520 case LED_CTL_STOP_WPS: /*WPS connect success*/
1521 if (pLed->bLedWPSBlinkInProgress) {
1522 _cancel_timer_ex(&(pLed->BlinkTimer));
1523 pLed->bLedWPSBlinkInProgress = false;
1524 }
1525 pLed->bLedNoLinkBlinkInProgress = true;
1526 pLed->CurrLedState = LED_BLINK_SLOWLY;
1527 if (pLed->bLedOn)
1528 pLed->BlinkingLedState = LED_OFF;
1529 else
1530 pLed->BlinkingLedState = LED_ON;
1531 _set_timer(&(pLed->BlinkTimer),
1532 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1533 break;
1534 case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/
1535 if (pLed->bLedWPSBlinkInProgress) {
1536 _cancel_timer_ex(&(pLed->BlinkTimer));
1537 pLed->bLedWPSBlinkInProgress = false;
1538 }
1539 pLed->bLedNoLinkBlinkInProgress = true;
1540 pLed->CurrLedState = LED_BLINK_SLOWLY;
1541 if (pLed->bLedOn)
1542 pLed->BlinkingLedState = LED_OFF;
1543 else
1544 pLed->BlinkingLedState = LED_ON;
1545 _set_timer(&(pLed->BlinkTimer),
1546 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1547 /*LED1 settings*/
1548 if (pLed1->bLedWPSBlinkInProgress)
1549 _cancel_timer_ex(&(pLed1->BlinkTimer));
1550 else
1551 pLed1->bLedWPSBlinkInProgress = true;
1552 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1553 if (pLed1->bLedOn)
1554 pLed1->BlinkingLedState = LED_OFF;
1555 else
1556 pLed1->BlinkingLedState = LED_ON;
1557 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1558 break;
1559 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/
1560 if (pLed->bLedWPSBlinkInProgress) {
1561 _cancel_timer_ex(&(pLed->BlinkTimer));
1562 pLed->bLedWPSBlinkInProgress = false;
1563 }
1564 pLed->bLedNoLinkBlinkInProgress = true;
1565 pLed->CurrLedState = LED_BLINK_SLOWLY;
1566 if (pLed->bLedOn)
1567 pLed->BlinkingLedState = LED_OFF;
1568 else
1569 pLed->BlinkingLedState = LED_ON;
1570 _set_timer(&(pLed->BlinkTimer),
1571 LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1572 /*LED1 settings*/
1573 if (pLed1->bLedWPSBlinkInProgress)
1574 _cancel_timer_ex(&(pLed1->BlinkTimer));
1575 else
1576 pLed1->bLedWPSBlinkInProgress = true;
1577 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1578 pLed1->BlinkTimes = 10;
1579 if (pLed1->bLedOn)
1580 pLed1->BlinkingLedState = LED_OFF;
1581 else
1582 pLed1->BlinkingLedState = LED_ON;
1583 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1584 break;
1585 case LED_CTL_POWER_OFF:
1586 pLed->CurrLedState = LED_OFF;
1587 pLed->BlinkingLedState = LED_OFF;
1588 if (pLed->bLedNoLinkBlinkInProgress) {
1589 _cancel_timer_ex(&(pLed->BlinkTimer));
1590 pLed->bLedNoLinkBlinkInProgress = false;
1591 }
1592 if (pLed->bLedLinkBlinkInProgress) {
1593 _cancel_timer_ex(&(pLed->BlinkTimer));
1594 pLed->bLedLinkBlinkInProgress = false;
1595 }
1596 if (pLed->bLedBlinkInProgress) {
1597 _cancel_timer_ex(&(pLed->BlinkTimer));
1598 pLed->bLedBlinkInProgress = false;
1599 }
1600 if (pLed->bLedWPSBlinkInProgress) {
1601 _cancel_timer_ex(&(pLed->BlinkTimer));
1602 pLed->bLedWPSBlinkInProgress = false;
1603 }
1604 if (pLed->bLedScanBlinkInProgress) {
1605 _cancel_timer_ex(&(pLed->BlinkTimer));
1606 pLed->bLedScanBlinkInProgress = false;
1607 }
1608 if (pLed->bLedStartToLinkBlinkInProgress) {
1609 _cancel_timer_ex(&(pLed->BlinkTimer));
1610 pLed->bLedStartToLinkBlinkInProgress = false;
1611 }
1612 if (pLed1->bLedWPSBlinkInProgress) {
1613 _cancel_timer_ex(&(pLed1->BlinkTimer));
1614 pLed1->bLedWPSBlinkInProgress = false;
1615 }
1616 pLed1->BlinkingLedState = LED_UNKNOWN;
1617 SwLedOff(padapter, pLed);
1618 SwLedOff(padapter, pLed1);
1619 break;
1620 default:
1621 break;
1622 }
1623 }
1624
1625 static void SwLedControlMode5(struct _adapter *padapter,
1626 enum LED_CTL_MODE LedAction)
1627 {
1628 struct led_priv *ledpriv = &(padapter->ledpriv);
1629 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1630 struct LED_871x *pLed = &(ledpriv->SwLed0);
1631
1632 if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1633 pLed = &(ledpriv->SwLed1);
1634
1635 switch (LedAction) {
1636 case LED_CTL_POWER_ON:
1637 case LED_CTL_NO_LINK:
1638 case LED_CTL_LINK: /* solid blue */
1639 if (pLed->CurrLedState == LED_SCAN_BLINK)
1640 return;
1641 pLed->CurrLedState = LED_ON;
1642 pLed->BlinkingLedState = LED_ON;
1643 pLed->bLedBlinkInProgress = false;
1644 _set_timer(&(pLed->BlinkTimer), 0);
1645 break;
1646 case LED_CTL_SITE_SURVEY:
1647 if ((pmlmepriv->sitesurveyctrl.traffic_busy) &&
1648 (check_fwstate(pmlmepriv, _FW_LINKED) == true))
1649 ; /* dummy branch */
1650 else if (pLed->bLedScanBlinkInProgress == false) {
1651 if (pLed->bLedBlinkInProgress == true) {
1652 _cancel_timer_ex(&(pLed->BlinkTimer));
1653 pLed->bLedBlinkInProgress = false;
1654 }
1655 pLed->bLedScanBlinkInProgress = true;
1656 pLed->CurrLedState = LED_SCAN_BLINK;
1657 pLed->BlinkTimes = 24;
1658 if (pLed->bLedOn)
1659 pLed->BlinkingLedState = LED_OFF;
1660 else
1661 pLed->BlinkingLedState = LED_ON;
1662 _set_timer(&(pLed->BlinkTimer),
1663 LED_BLINK_SCAN_INTERVAL_ALPHA);
1664 }
1665 break;
1666 case LED_CTL_TX:
1667 case LED_CTL_RX:
1668 if (pLed->bLedBlinkInProgress == false) {
1669 if (pLed->CurrLedState == LED_SCAN_BLINK)
1670 return;
1671 pLed->bLedBlinkInProgress = true;
1672 pLed->CurrLedState = LED_TXRX_BLINK;
1673 pLed->BlinkTimes = 2;
1674 if (pLed->bLedOn)
1675 pLed->BlinkingLedState = LED_OFF;
1676 else
1677 pLed->BlinkingLedState = LED_ON;
1678 _set_timer(&(pLed->BlinkTimer),
1679 LED_BLINK_FASTER_INTERVAL_ALPHA);
1680 }
1681 break;
1682 case LED_CTL_POWER_OFF:
1683 pLed->CurrLedState = LED_OFF;
1684 pLed->BlinkingLedState = LED_OFF;
1685 if (pLed->bLedBlinkInProgress) {
1686 _cancel_timer_ex(&(pLed->BlinkTimer));
1687 pLed->bLedBlinkInProgress = false;
1688 }
1689 SwLedOff(padapter, pLed);
1690 break;
1691 default:
1692 break;
1693 }
1694 }
1695
1696
1697 static void SwLedControlMode6(struct _adapter *padapter,
1698 enum LED_CTL_MODE LedAction)
1699 {
1700 struct led_priv *ledpriv = &(padapter->ledpriv);
1701 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1702 struct LED_871x *pLed = &(ledpriv->SwLed0);
1703
1704 switch (LedAction) {
1705 case LED_CTL_POWER_ON:
1706 case LED_CTL_NO_LINK:
1707 case LED_CTL_LINK: /*solid blue*/
1708 case LED_CTL_SITE_SURVEY:
1709 if (IS_LED_WPS_BLINKING(pLed))
1710 return;
1711 pLed->CurrLedState = LED_ON;
1712 pLed->BlinkingLedState = LED_ON;
1713 pLed->bLedBlinkInProgress = false;
1714 _set_timer(&(pLed->BlinkTimer), 0);
1715 break;
1716 case LED_CTL_TX:
1717 case LED_CTL_RX:
1718 if (pLed->bLedBlinkInProgress == false &&
1719 (check_fwstate(pmlmepriv, _FW_LINKED) == true)) {
1720 if (IS_LED_WPS_BLINKING(pLed))
1721 return;
1722 pLed->bLedBlinkInProgress = true;
1723 pLed->CurrLedState = LED_TXRX_BLINK;
1724 pLed->BlinkTimes = 2;
1725 if (pLed->bLedOn)
1726 pLed->BlinkingLedState = LED_OFF;
1727 else
1728 pLed->BlinkingLedState = LED_ON;
1729 _set_timer(&(pLed->BlinkTimer),
1730 LED_BLINK_FASTER_INTERVAL_ALPHA);
1731 }
1732 break;
1733 case LED_CTL_START_WPS: /*wait until xinpin finish*/
1734 case LED_CTL_START_WPS_BOTTON:
1735 if (pLed->bLedWPSBlinkInProgress == false) {
1736 if (pLed->bLedBlinkInProgress == true) {
1737 _cancel_timer_ex(&(pLed->BlinkTimer));
1738 pLed->bLedBlinkInProgress = false;
1739 }
1740 pLed->bLedWPSBlinkInProgress = true;
1741 pLed->CurrLedState = LED_BLINK_WPS;
1742 if (pLed->bLedOn)
1743 pLed->BlinkingLedState = LED_OFF;
1744 else
1745 pLed->BlinkingLedState = LED_ON;
1746 _set_timer(&(pLed->BlinkTimer),
1747 LED_BLINK_SCAN_INTERVAL_ALPHA);
1748 }
1749 break;
1750 case LED_CTL_STOP_WPS_FAIL:
1751 case LED_CTL_STOP_WPS:
1752 if (pLed->bLedWPSBlinkInProgress) {
1753 _cancel_timer_ex(&(pLed->BlinkTimer));
1754 pLed->bLedWPSBlinkInProgress = false;
1755 }
1756 pLed->CurrLedState = LED_ON;
1757 pLed->BlinkingLedState = LED_ON;
1758 _set_timer(&(pLed->BlinkTimer), 0);
1759 break;
1760 case LED_CTL_POWER_OFF:
1761 pLed->CurrLedState = LED_OFF;
1762 pLed->BlinkingLedState = LED_OFF;
1763 if (pLed->bLedBlinkInProgress) {
1764 _cancel_timer_ex(&(pLed->BlinkTimer));
1765 pLed->bLedBlinkInProgress = false;
1766 }
1767 if (pLed->bLedWPSBlinkInProgress) {
1768 _cancel_timer_ex(&(pLed->BlinkTimer));
1769 pLed->bLedWPSBlinkInProgress = false;
1770 }
1771 SwLedOff(padapter, pLed);
1772 break;
1773 default:
1774 break;
1775 }
1776 }
1777
1778 /* Description:
1779 * Dispatch LED action according to pHalData->LedStrategy.
1780 */
1781 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1782 {
1783 struct led_priv *ledpriv = &(padapter->ledpriv);
1784
1785 if (ledpriv->bRegUseLed == false)
1786 return;
1787 switch (ledpriv->LedStrategy) {
1788 case SW_LED_MODE0:
1789 break;
1790 case SW_LED_MODE1:
1791 SwLedControlMode1(padapter, LedAction);
1792 break;
1793 case SW_LED_MODE2:
1794 SwLedControlMode2(padapter, LedAction);
1795 break;
1796 case SW_LED_MODE3:
1797 SwLedControlMode3(padapter, LedAction);
1798 break;
1799 case SW_LED_MODE4:
1800 SwLedControlMode4(padapter, LedAction);
1801 break;
1802 case SW_LED_MODE5:
1803 SwLedControlMode5(padapter, LedAction);
1804 break;
1805 case SW_LED_MODE6:
1806 SwLedControlMode6(padapter, LedAction);
1807 break;
1808 default:
1809 break;
1810 }
1811 }
Linux kernel - Deliverables
This page took 0.068697 seconds and 5 git commands to generate.