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