]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/rtl8712/rtl8712_led.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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