1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2017 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15
16 #include <drv_types.h>
17 #include <hal_data.h>
18 #ifdef CONFIG_RTW_SW_LED
19
20 /*
21 * Description:
22 * Implementation of LED blinking behavior.
23 * It toggle off LED and schedule corresponding timer if necessary.
24 * */
25 void
SwLedBlink(PLED_USB pLed)26 SwLedBlink(
27 PLED_USB pLed
28 )
29 {
30 _adapter *padapter = pLed->padapter;
31 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
32 u8 bStopBlinking = _FALSE;
33
34 /* Change LED according to BlinkingLedState specified. */
35 if (pLed->BlinkingLedState == RTW_LED_ON) {
36 SwLedOn(padapter, pLed);
37 } else {
38 SwLedOff(padapter, pLed);
39 }
40
41 /* Determine if we shall change LED state again. */
42 pLed->BlinkTimes--;
43 switch (pLed->CurrLedState) {
44
45 case LED_BLINK_NORMAL:
46 if (pLed->BlinkTimes == 0)
47 bStopBlinking = _TRUE;
48 break;
49
50 case LED_BLINK_StartToBlink:
51 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
52 bStopBlinking = _TRUE;
53 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) &&
54 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
55 bStopBlinking = _TRUE;
56 else if (pLed->BlinkTimes == 0)
57 bStopBlinking = _TRUE;
58 break;
59
60 case LED_BLINK_WPS:
61 if (pLed->BlinkTimes == 0)
62 bStopBlinking = _TRUE;
63 break;
64
65
66 default:
67 bStopBlinking = _TRUE;
68 break;
69
70 }
71
72 if (bStopBlinking) {
73 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
74 SwLedOff(padapter, pLed);
75 else if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) && (pLed->bLedOn == _FALSE))
76 SwLedOn(padapter, pLed);
77 else if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) && pLed->bLedOn == _TRUE)
78 SwLedOff(padapter, pLed);
79
80 pLed->BlinkTimes = 0;
81 pLed->bLedBlinkInProgress = _FALSE;
82 } else {
83 /* Assign LED state to toggle. */
84 if (pLed->BlinkingLedState == RTW_LED_ON)
85 pLed->BlinkingLedState = RTW_LED_OFF;
86 else
87 pLed->BlinkingLedState = RTW_LED_ON;
88
89 /* Schedule a timer to toggle LED state. */
90 switch (pLed->CurrLedState) {
91 case LED_BLINK_NORMAL:
92 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
93 break;
94
95 case LED_BLINK_SLOWLY:
96 case LED_BLINK_StartToBlink:
97 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
98 break;
99
100 case LED_BLINK_WPS:
101 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
102 break;
103
104 default:
105 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
106 break;
107 }
108 }
109 }
110
111 void
SwLedBlink1(PLED_USB pLed)112 SwLedBlink1(
113 PLED_USB pLed
114 )
115 {
116 _adapter *padapter = pLed->padapter;
117 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
118 struct led_priv *ledpriv = adapter_to_led(padapter);
119 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
120 PLED_USB pLed1 = &(ledpriv->SwLed1);
121 u8 bStopBlinking = _FALSE;
122
123 u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; /* add by ylb 20121012 for customer led for alpha */
124 if (pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)
125 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;
126
127 if (pHalData->CustomerID == RT_CID_819x_CAMEO)
128 pLed = &(ledpriv->SwLed1);
129
130 /* Change LED according to BlinkingLedState specified. */
131 if (pLed->BlinkingLedState == RTW_LED_ON) {
132 SwLedOn(padapter, pLed);
133 } else {
134 SwLedOff(padapter, pLed);
135 }
136
137
138 if (pHalData->CustomerID == RT_CID_DEFAULT) {
139 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
140 if (!pLed1->bSWLedCtrl) {
141 SwLedOn(padapter, pLed1);
142 pLed1->bSWLedCtrl = _TRUE;
143 } else if (!pLed1->bLedOn)
144 SwLedOn(padapter, pLed1);
145 } else {
146 if (!pLed1->bSWLedCtrl) {
147 SwLedOff(padapter, pLed1);
148 pLed1->bSWLedCtrl = _TRUE;
149 } else if (pLed1->bLedOn)
150 SwLedOff(padapter, pLed1);
151 }
152 }
153
154 switch (pLed->CurrLedState) {
155 case LED_BLINK_SLOWLY:
156 if (pLed->bLedOn)
157 pLed->BlinkingLedState = RTW_LED_OFF;
158 else
159 pLed->BlinkingLedState = RTW_LED_ON;
160 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);/* change by ylb 20121012 for customer led for alpha */
161 break;
162
163 case LED_BLINK_NORMAL:
164 if (pLed->bLedOn)
165 pLed->BlinkingLedState = RTW_LED_OFF;
166 else
167 pLed->BlinkingLedState = RTW_LED_ON;
168 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
169 break;
170
171 case LED_BLINK_SCAN:
172 pLed->BlinkTimes--;
173 if (pLed->BlinkTimes == 0)
174 bStopBlinking = _TRUE;
175
176 if (bStopBlinking) {
177 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
178 SwLedOff(padapter, pLed);
179 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
180 pLed->bLedLinkBlinkInProgress = _TRUE;
181 pLed->CurrLedState = LED_BLINK_NORMAL;
182 if (pLed->bLedOn)
183 pLed->BlinkingLedState = RTW_LED_OFF;
184 else
185 pLed->BlinkingLedState = RTW_LED_ON;
186 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
187
188 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
189 pLed->bLedNoLinkBlinkInProgress = _TRUE;
190 pLed->CurrLedState = LED_BLINK_SLOWLY;
191 if (pLed->bLedOn)
192 pLed->BlinkingLedState = RTW_LED_OFF;
193 else
194 pLed->BlinkingLedState = RTW_LED_ON;
195 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);
196 }
197 pLed->bLedScanBlinkInProgress = _FALSE;
198 } else {
199 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
200 SwLedOff(padapter, pLed);
201 else {
202 if (pLed->bLedOn)
203 pLed->BlinkingLedState = RTW_LED_OFF;
204 else
205 pLed->BlinkingLedState = RTW_LED_ON;
206 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
207 }
208 }
209 break;
210
211 case LED_BLINK_TXRX:
212 pLed->BlinkTimes--;
213 if (pLed->BlinkTimes == 0)
214 bStopBlinking = _TRUE;
215 if (bStopBlinking) {
216 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
217 SwLedOff(padapter, pLed);
218 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
219 pLed->bLedLinkBlinkInProgress = _TRUE;
220 pLed->CurrLedState = LED_BLINK_NORMAL;
221 if (pLed->bLedOn)
222 pLed->BlinkingLedState = RTW_LED_OFF;
223 else
224 pLed->BlinkingLedState = RTW_LED_ON;
225 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
226 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
227 pLed->bLedNoLinkBlinkInProgress = _TRUE;
228 pLed->CurrLedState = LED_BLINK_SLOWLY;
229 if (pLed->bLedOn)
230 pLed->BlinkingLedState = RTW_LED_OFF;
231 else
232 pLed->BlinkingLedState = RTW_LED_ON;
233 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);
234 }
235 pLed->BlinkTimes = 0;
236 pLed->bLedBlinkInProgress = _FALSE;
237 } else {
238 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
239 SwLedOff(padapter, pLed);
240 else {
241 if (pLed->bLedOn)
242 pLed->BlinkingLedState = RTW_LED_OFF;
243 else
244 pLed->BlinkingLedState = RTW_LED_ON;
245 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
246 }
247 }
248 break;
249
250 case LED_BLINK_WPS:
251 if (pLed->bLedOn)
252 pLed->BlinkingLedState = RTW_LED_OFF;
253 else
254 pLed->BlinkingLedState = RTW_LED_ON;
255 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
256 break;
257
258 case LED_BLINK_WPS_STOP: /* WPS success */
259 if (pLed->BlinkingLedState == RTW_LED_ON) {
260 pLed->BlinkingLedState = RTW_LED_OFF;
261 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
262 bStopBlinking = _FALSE;
263 } else
264 bStopBlinking = _TRUE;
265
266 if (bStopBlinking) {
267 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
268 SwLedOff(padapter, pLed);
269 else {
270 pLed->bLedLinkBlinkInProgress = _TRUE;
271 pLed->CurrLedState = LED_BLINK_NORMAL;
272 if (pLed->bLedOn)
273 pLed->BlinkingLedState = RTW_LED_OFF;
274 else
275 pLed->BlinkingLedState = RTW_LED_ON;
276 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
277 }
278 pLed->bLedWPSBlinkInProgress = _FALSE;
279 }
280 break;
281
282 default:
283 break;
284 }
285
286 }
287
288 void
SwLedBlink2(PLED_USB pLed)289 SwLedBlink2(
290 PLED_USB pLed
291 )
292 {
293 _adapter *padapter = pLed->padapter;
294 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
295 u8 bStopBlinking = _FALSE;
296
297 /* Change LED according to BlinkingLedState specified. */
298 if (pLed->BlinkingLedState == RTW_LED_ON) {
299 SwLedOn(padapter, pLed);
300 } else {
301 SwLedOff(padapter, pLed);
302 }
303
304 switch (pLed->CurrLedState) {
305 case LED_BLINK_SCAN:
306 pLed->BlinkTimes--;
307 if (pLed->BlinkTimes == 0)
308 bStopBlinking = _TRUE;
309
310 if (bStopBlinking) {
311 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
312 SwLedOff(padapter, pLed);
313 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
314 pLed->CurrLedState = RTW_LED_ON;
315 pLed->BlinkingLedState = RTW_LED_ON;
316 SwLedOn(padapter, pLed);
317
318 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
319 pLed->CurrLedState = RTW_LED_OFF;
320 pLed->BlinkingLedState = RTW_LED_OFF;
321 SwLedOff(padapter, pLed);
322 }
323 pLed->bLedScanBlinkInProgress = _FALSE;
324 } else {
325 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
326 SwLedOff(padapter, pLed);
327 else {
328 if (pLed->bLedOn)
329 pLed->BlinkingLedState = RTW_LED_OFF;
330 else
331 pLed->BlinkingLedState = RTW_LED_ON;
332 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
333 }
334 }
335 break;
336
337 case LED_BLINK_TXRX:
338 pLed->BlinkTimes--;
339 if (pLed->BlinkTimes == 0)
340 bStopBlinking = _TRUE;
341 if (bStopBlinking) {
342 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
343 SwLedOff(padapter, pLed);
344 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
345 pLed->CurrLedState = RTW_LED_ON;
346 pLed->BlinkingLedState = RTW_LED_ON;
347 SwLedOn(padapter, pLed);
348
349 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
350 pLed->CurrLedState = RTW_LED_OFF;
351 pLed->BlinkingLedState = RTW_LED_OFF;
352 SwLedOff(padapter, pLed);
353 }
354 pLed->bLedBlinkInProgress = _FALSE;
355 } else {
356 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
357 SwLedOff(padapter, pLed);
358 else {
359 if (pLed->bLedOn)
360 pLed->BlinkingLedState = RTW_LED_OFF;
361 else
362 pLed->BlinkingLedState = RTW_LED_ON;
363 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
364 }
365 }
366 break;
367
368 default:
369 break;
370 }
371
372 }
373
374 void
SwLedBlink3(PLED_USB pLed)375 SwLedBlink3(
376 PLED_USB pLed
377 )
378 {
379 _adapter *padapter = pLed->padapter;
380 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
381 u8 bStopBlinking = _FALSE;
382
383 /* Change LED according to BlinkingLedState specified. */
384 if (pLed->BlinkingLedState == RTW_LED_ON) {
385 SwLedOn(padapter, pLed);
386 } else {
387 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
388 SwLedOff(padapter, pLed);
389 }
390
391 switch (pLed->CurrLedState) {
392 case LED_BLINK_SCAN:
393 pLed->BlinkTimes--;
394 if (pLed->BlinkTimes == 0)
395 bStopBlinking = _TRUE;
396
397 if (bStopBlinking) {
398 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
399 SwLedOff(padapter, pLed);
400 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
401 pLed->CurrLedState = RTW_LED_ON;
402 pLed->BlinkingLedState = RTW_LED_ON;
403 if (!pLed->bLedOn)
404 SwLedOn(padapter, pLed);
405
406 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
407 pLed->CurrLedState = RTW_LED_OFF;
408 pLed->BlinkingLedState = RTW_LED_OFF;
409 if (pLed->bLedOn)
410 SwLedOff(padapter, pLed);
411
412 }
413 pLed->bLedScanBlinkInProgress = _FALSE;
414 } else {
415 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
416 SwLedOff(padapter, pLed);
417 else {
418 if (pLed->bLedOn)
419 pLed->BlinkingLedState = RTW_LED_OFF;
420 else
421 pLed->BlinkingLedState = RTW_LED_ON;
422 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
423 }
424 }
425 break;
426
427 case LED_BLINK_TXRX:
428 pLed->BlinkTimes--;
429 if (pLed->BlinkTimes == 0)
430 bStopBlinking = _TRUE;
431 if (bStopBlinking) {
432 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
433 SwLedOff(padapter, pLed);
434 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
435 pLed->CurrLedState = RTW_LED_ON;
436 pLed->BlinkingLedState = RTW_LED_ON;
437
438 if (!pLed->bLedOn)
439 SwLedOn(padapter, pLed);
440
441 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
442 pLed->CurrLedState = RTW_LED_OFF;
443 pLed->BlinkingLedState = RTW_LED_OFF;
444
445 if (pLed->bLedOn)
446 SwLedOff(padapter, pLed);
447
448
449 }
450 pLed->bLedBlinkInProgress = _FALSE;
451 } else {
452 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
453 SwLedOff(padapter, pLed);
454 else {
455 if (pLed->bLedOn)
456 pLed->BlinkingLedState = RTW_LED_OFF;
457 else
458 pLed->BlinkingLedState = RTW_LED_ON;
459 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
460 }
461 }
462 break;
463
464 case LED_BLINK_WPS:
465 if (pLed->bLedOn)
466 pLed->BlinkingLedState = RTW_LED_OFF;
467 else
468 pLed->BlinkingLedState = RTW_LED_ON;
469 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
470 break;
471
472 case LED_BLINK_WPS_STOP: /* WPS success */
473 if (pLed->BlinkingLedState == RTW_LED_ON) {
474 pLed->BlinkingLedState = RTW_LED_OFF;
475 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
476 bStopBlinking = _FALSE;
477 } else
478 bStopBlinking = _TRUE;
479
480 if (bStopBlinking) {
481 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
482 SwLedOff(padapter, pLed);
483 else {
484 pLed->CurrLedState = RTW_LED_ON;
485 pLed->BlinkingLedState = RTW_LED_ON;
486 SwLedOn(padapter, pLed);
487 }
488 pLed->bLedWPSBlinkInProgress = _FALSE;
489 }
490 break;
491
492
493 default:
494 break;
495 }
496
497 }
498
499
500 void
SwLedBlink4(PLED_USB pLed)501 SwLedBlink4(
502 PLED_USB pLed
503 )
504 {
505 _adapter *padapter = pLed->padapter;
506 struct led_priv *ledpriv = adapter_to_led(padapter);
507 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
508 PLED_USB pLed1 = &(ledpriv->SwLed1);
509 u8 bStopBlinking = _FALSE;
510
511 /* Change LED according to BlinkingLedState specified. */
512 if (pLed->BlinkingLedState == RTW_LED_ON) {
513 SwLedOn(padapter, pLed);
514 } else {
515 SwLedOff(padapter, pLed);
516 }
517
518 if (!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN) {
519 pLed1->BlinkingLedState = RTW_LED_OFF;
520 pLed1->CurrLedState = RTW_LED_OFF;
521 SwLedOff(padapter, pLed1);
522 }
523
524 switch (pLed->CurrLedState) {
525 case LED_BLINK_SLOWLY:
526 if (pLed->bLedOn)
527 pLed->BlinkingLedState = RTW_LED_OFF;
528 else
529 pLed->BlinkingLedState = RTW_LED_ON;
530 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
531 break;
532
533 case LED_BLINK_StartToBlink:
534 if (pLed->bLedOn) {
535 pLed->BlinkingLedState = RTW_LED_OFF;
536 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
537 } else {
538 pLed->BlinkingLedState = RTW_LED_ON;
539 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
540 }
541 break;
542
543 case LED_BLINK_SCAN:
544 pLed->BlinkTimes--;
545 if (pLed->BlinkTimes == 0)
546 bStopBlinking = _FALSE;
547 #if 0
548
549 if (bStopBlinking) {
550 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
551 SwLedOff(padapter, pLed);
552 else {
553 pLed->bLedNoLinkBlinkInProgress = _FALSE;
554 pLed->CurrLedState = LED_BLINK_SLOWLY;
555 if (pLed->bLedOn)
556 pLed->BlinkingLedState = RTW_LED_OFF;
557 else
558 pLed->BlinkingLedState = RTW_LED_ON;
559 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
560 }
561 pLed->bLedScanBlinkInProgress = _FALSE;
562 } else
563 #endif
564 {
565 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
566 SwLedOff(padapter, pLed);
567 else {
568 if (pLed->bLedOn)
569 pLed->BlinkingLedState = RTW_LED_OFF;
570 else
571 pLed->BlinkingLedState = RTW_LED_ON;
572 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
573 }
574 }
575
576 break;
577
578 case LED_BLINK_TXRX:
579 pLed->BlinkTimes--;
580 if (pLed->BlinkTimes == 0)
581 bStopBlinking = _TRUE;
582 if (bStopBlinking) {
583 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
584 SwLedOff(padapter, pLed);
585 else {
586 pLed->bLedNoLinkBlinkInProgress = _TRUE;
587 pLed->CurrLedState = LED_BLINK_SLOWLY;
588 if (pLed->bLedOn)
589 pLed->BlinkingLedState = RTW_LED_OFF;
590 else
591 pLed->BlinkingLedState = RTW_LED_ON;
592 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
593 }
594 pLed->bLedBlinkInProgress = _FALSE;
595 } else {
596 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
597 SwLedOff(padapter, pLed);
598 else {
599
600 if (pLed->bLedOn)
601 pLed->BlinkingLedState = RTW_LED_OFF;
602 else
603 pLed->BlinkingLedState = RTW_LED_ON;
604
605 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
606 }
607 }
608 break;
609
610 case LED_BLINK_WPS:
611 if (pLed->bLedOn) {
612 pLed->BlinkingLedState = RTW_LED_OFF;
613 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
614 } else {
615 pLed->BlinkingLedState = RTW_LED_ON;
616 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
617 }
618 break;
619
620 case LED_BLINK_WPS_STOP: /* WPS authentication fail */
621 if (pLed->bLedOn)
622 pLed->BlinkingLedState = RTW_LED_OFF;
623 else
624 pLed->BlinkingLedState = RTW_LED_ON;
625
626 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
627 break;
628
629 case LED_BLINK_WPS_STOP_OVERLAP: /* WPS session overlap */
630 pLed->BlinkTimes--;
631 if (pLed->BlinkTimes == 0) {
632 if (pLed->bLedOn)
633 pLed->BlinkTimes = 1;
634 else
635 bStopBlinking = _TRUE;
636 }
637
638 if (bStopBlinking) {
639 pLed->BlinkTimes = 10;
640 pLed->BlinkingLedState = RTW_LED_ON;
641 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
642 } else {
643 if (pLed->bLedOn)
644 pLed->BlinkingLedState = RTW_LED_OFF;
645 else
646 pLed->BlinkingLedState = RTW_LED_ON;
647
648 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
649 }
650 break;
651
652 case LED_BLINK_ALWAYS_ON:
653 pLed->BlinkTimes--;
654 if (pLed->BlinkTimes == 0)
655 bStopBlinking = _TRUE;
656 if (bStopBlinking) {
657 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
658 SwLedOff(padapter, pLed);
659 else {
660 pLed->bLedNoLinkBlinkInProgress = _TRUE;
661 pLed->CurrLedState = LED_BLINK_SLOWLY;
662 if (pLed->bLedOn)
663 pLed->BlinkingLedState = RTW_LED_OFF;
664 else
665 pLed->BlinkingLedState = RTW_LED_ON;
666
667 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
668 }
669 pLed->bLedBlinkInProgress = _FALSE;
670 } else {
671 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
672 SwLedOff(padapter, pLed);
673 } else {
674 if (pLed->bLedOn)
675 pLed->BlinkingLedState = RTW_LED_OFF;
676 else
677 pLed->BlinkingLedState = RTW_LED_ON;
678
679 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
680 }
681 }
682 break;
683
684 default:
685 break;
686 }
687
688
689
690 }
691
692 void
SwLedBlink5(PLED_USB pLed)693 SwLedBlink5(
694 PLED_USB pLed
695 )
696 {
697 _adapter *padapter = pLed->padapter;
698 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
699 u8 bStopBlinking = _FALSE;
700
701 /* Change LED according to BlinkingLedState specified. */
702 if (pLed->BlinkingLedState == RTW_LED_ON) {
703 SwLedOn(padapter, pLed);
704 } else {
705 SwLedOff(padapter, pLed);
706 }
707
708 switch (pLed->CurrLedState) {
709 case LED_BLINK_SCAN:
710 pLed->BlinkTimes--;
711 if (pLed->BlinkTimes == 0)
712 bStopBlinking = _TRUE;
713
714 if (bStopBlinking) {
715 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
716 pLed->CurrLedState = RTW_LED_OFF;
717 pLed->BlinkingLedState = RTW_LED_OFF;
718 if (pLed->bLedOn)
719 SwLedOff(padapter, pLed);
720 } else {
721 pLed->CurrLedState = RTW_LED_ON;
722 pLed->BlinkingLedState = RTW_LED_ON;
723 if (!pLed->bLedOn)
724 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
725 }
726
727 pLed->bLedScanBlinkInProgress = _FALSE;
728 } else {
729 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
730 SwLedOff(padapter, pLed);
731 else {
732 if (pLed->bLedOn)
733 pLed->BlinkingLedState = RTW_LED_OFF;
734 else
735 pLed->BlinkingLedState = RTW_LED_ON;
736 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
737 }
738 }
739 break;
740
741
742 case LED_BLINK_TXRX:
743 pLed->BlinkTimes--;
744 if (pLed->BlinkTimes == 0)
745 bStopBlinking = _TRUE;
746
747 if (bStopBlinking) {
748 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
749 pLed->CurrLedState = RTW_LED_OFF;
750 pLed->BlinkingLedState = RTW_LED_OFF;
751 if (pLed->bLedOn)
752 SwLedOff(padapter, pLed);
753 } else {
754 pLed->CurrLedState = RTW_LED_ON;
755 pLed->BlinkingLedState = RTW_LED_ON;
756 if (!pLed->bLedOn)
757 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
758 }
759
760 pLed->bLedBlinkInProgress = _FALSE;
761 } else {
762 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
763 SwLedOff(padapter, pLed);
764 else {
765 if (pLed->bLedOn)
766 pLed->BlinkingLedState = RTW_LED_OFF;
767 else
768 pLed->BlinkingLedState = RTW_LED_ON;
769 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
770 }
771 }
772 break;
773
774 default:
775 break;
776 }
777
778
779
780 }
781
782 void
SwLedBlink6(PLED_USB pLed)783 SwLedBlink6(
784 PLED_USB pLed
785 )
786 {
787 _adapter *padapter = pLed->padapter;
788 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
789 u8 bStopBlinking = _FALSE;
790
791 /* Change LED according to BlinkingLedState specified. */
792 if (pLed->BlinkingLedState == RTW_LED_ON) {
793 SwLedOn(padapter, pLed);
794 } else {
795 SwLedOff(padapter, pLed);
796 }
797
798 }
799
800 void
SwLedBlink7(PLED_USB pLed)801 SwLedBlink7(
802 PLED_USB pLed
803 )
804 {
805 PADAPTER Adapter = pLed->padapter;
806 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
807 BOOLEAN bStopBlinking = _FALSE;
808
809 /* Change LED according to BlinkingLedState specified. */
810 if (pLed->BlinkingLedState == RTW_LED_ON) {
811 SwLedOn(Adapter, pLed);
812 } else {
813 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
814 SwLedOff(Adapter, pLed);
815 }
816
817 switch (pLed->CurrLedState) {
818 case LED_BLINK_SCAN:
819 pLed->BlinkTimes--;
820 if (pLed->BlinkTimes == 0)
821 bStopBlinking = _TRUE;
822
823 if (bStopBlinking) {
824 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
825 SwLedOff(Adapter, pLed);
826 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
827 pLed->CurrLedState = RTW_LED_ON;
828 pLed->BlinkingLedState = RTW_LED_ON;
829 if (!pLed->bLedOn)
830 SwLedOn(Adapter, pLed);
831
832 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
833 pLed->CurrLedState = RTW_LED_OFF;
834 pLed->BlinkingLedState = RTW_LED_OFF;
835 if (pLed->bLedOn)
836 SwLedOff(Adapter, pLed);
837
838 }
839 pLed->bLedScanBlinkInProgress = _FALSE;
840 } else {
841 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
842 SwLedOff(Adapter, pLed);
843 else {
844 if (pLed->bLedOn)
845 pLed->BlinkingLedState = RTW_LED_OFF;
846 else
847 pLed->BlinkingLedState = RTW_LED_ON;
848 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
849 }
850 }
851 break;
852
853 case LED_BLINK_WPS:
854 if (pLed->bLedOn)
855 pLed->BlinkingLedState = RTW_LED_OFF;
856 else
857 pLed->BlinkingLedState = RTW_LED_ON;
858 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
859 break;
860
861 case LED_BLINK_WPS_STOP: /* WPS success */
862 if (pLed->BlinkingLedState == RTW_LED_ON) {
863 pLed->BlinkingLedState = RTW_LED_OFF;
864 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
865 bStopBlinking = _FALSE;
866 } else
867 bStopBlinking = _TRUE;
868
869 if (bStopBlinking) {
870 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
871 SwLedOff(Adapter, pLed);
872 else {
873 pLed->CurrLedState = RTW_LED_ON;
874 pLed->BlinkingLedState = RTW_LED_ON;
875 SwLedOn(Adapter, pLed);
876 }
877 pLed->bLedWPSBlinkInProgress = _FALSE;
878 }
879 break;
880
881
882 default:
883 break;
884 }
885
886
887 }
888
889 void
SwLedBlink8(PLED_USB pLed)890 SwLedBlink8(
891 PLED_USB pLed
892 )
893 {
894 PADAPTER Adapter = pLed->padapter;
895
896 /* Change LED according to BlinkingLedState specified. */
897 if (pLed->BlinkingLedState == RTW_LED_ON) {
898 SwLedOn(Adapter, pLed);
899 } else {
900 SwLedOff(Adapter, pLed);
901 }
902
903
904 }
905
906 /* page added for Belkin AC950. 20120813 */
907 void
SwLedBlink9(PLED_USB pLed)908 SwLedBlink9(
909 PLED_USB pLed
910 )
911 {
912 PADAPTER Adapter = pLed->padapter;
913 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
914 BOOLEAN bStopBlinking = _FALSE;
915
916 /* Change LED according to BlinkingLedState specified. */
917 if (pLed->BlinkingLedState == RTW_LED_ON) {
918 SwLedOn(Adapter, pLed);
919 } else {
920 SwLedOff(Adapter, pLed);
921 }
922 /* RTW_INFO("%s, pLed->CurrLedState=%d, pLed->BlinkingLedState=%d\n", __FUNCTION__, pLed->CurrLedState, pLed->BlinkingLedState); */
923
924
925 switch (pLed->CurrLedState) {
926 case RTW_LED_ON:
927 SwLedOn(Adapter, pLed);
928 break;
929
930 case RTW_LED_OFF:
931 SwLedOff(Adapter, pLed);
932 break;
933
934 case LED_BLINK_SLOWLY:
935 if (pLed->bLedOn)
936 pLed->BlinkingLedState = RTW_LED_OFF;
937 else
938 pLed->BlinkingLedState = RTW_LED_ON;
939 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
940 break;
941
942 case LED_BLINK_StartToBlink:
943 if (pLed->bLedOn) {
944 pLed->BlinkingLedState = RTW_LED_OFF;
945 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
946 } else {
947 pLed->BlinkingLedState = RTW_LED_ON;
948 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
949 }
950 break;
951
952 case LED_BLINK_SCAN:
953 pLed->BlinkTimes--;
954 if (pLed->BlinkTimes == 0)
955 bStopBlinking = _TRUE;
956
957 if (bStopBlinking) {
958 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
959 SwLedOff(Adapter, pLed);
960 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
961 pLed->bLedLinkBlinkInProgress = _TRUE;
962 pLed->CurrLedState = LED_BLINK_SLOWLY;
963
964 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
965 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
966 pLed->bLedNoLinkBlinkInProgress = _TRUE;
967 pLed->CurrLedState = LED_BLINK_SLOWLY;
968 if (pLed->bLedOn)
969 pLed->BlinkingLedState = RTW_LED_OFF;
970 else
971 pLed->BlinkingLedState = RTW_LED_ON;
972 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
973 }
974 pLed->BlinkTimes = 0;
975 pLed->bLedBlinkInProgress = _FALSE;
976 } else {
977 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
978 SwLedOff(Adapter, pLed);
979 else {
980 if (pLed->bLedOn)
981 pLed->BlinkingLedState = RTW_LED_OFF;
982 else
983 pLed->BlinkingLedState = RTW_LED_ON;
984 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
985 }
986 }
987 break;
988
989 case LED_BLINK_TXRX:
990 pLed->BlinkTimes--;
991 if (pLed->BlinkTimes == 0)
992 bStopBlinking = _TRUE;
993 if (bStopBlinking) {
994 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
995 SwLedOff(Adapter, pLed);
996 else {
997 pLed->CurrLedState = LED_BLINK_SLOWLY;
998 if (pLed->bLedOn)
999 pLed->BlinkingLedState = RTW_LED_OFF;
1000 else
1001 pLed->BlinkingLedState = RTW_LED_ON;
1002 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1003 }
1004 pLed->bLedBlinkInProgress = _FALSE;
1005 } else {
1006 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1007 SwLedOff(Adapter, pLed);
1008 else {
1009 if (pLed->bLedOn)
1010 pLed->BlinkingLedState = RTW_LED_OFF;
1011 else
1012 pLed->BlinkingLedState = RTW_LED_ON;
1013
1014 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1015 }
1016 }
1017 break;
1018
1019 case LED_BLINK_WPS:
1020 if (pLed->bLedOn) {
1021 pLed->BlinkingLedState = RTW_LED_OFF;
1022 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1023 } else {
1024 pLed->BlinkingLedState = RTW_LED_ON;
1025 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1026 }
1027 break;
1028
1029 case LED_BLINK_WPS_STOP: /* WPS authentication fail */
1030 if (pLed->bLedOn)
1031 pLed->BlinkingLedState = RTW_LED_OFF;
1032 else
1033 pLed->BlinkingLedState = RTW_LED_ON;
1034
1035 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1036 break;
1037
1038 case LED_BLINK_WPS_STOP_OVERLAP: /* WPS session overlap */
1039 pLed->BlinkTimes--;
1040 pLed->BlinkCounter--;
1041 if (pLed->BlinkCounter == 0) {
1042 pLed->BlinkingLedState = RTW_LED_OFF;
1043 pLed->CurrLedState = RTW_LED_OFF;
1044 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1045 } else {
1046 if (pLed->BlinkTimes == 0) {
1047 if (pLed->bLedOn)
1048 pLed->BlinkTimes = 1;
1049 else
1050 bStopBlinking = _TRUE;
1051 }
1052
1053 if (bStopBlinking) {
1054 pLed->BlinkTimes = 10;
1055 pLed->BlinkingLedState = RTW_LED_ON;
1056 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1057 } else {
1058 if (pLed->bLedOn)
1059 pLed->BlinkingLedState = RTW_LED_OFF;
1060 else
1061 pLed->BlinkingLedState = RTW_LED_ON;
1062
1063 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1064 }
1065 }
1066 break;
1067
1068 case LED_BLINK_ALWAYS_ON:
1069 pLed->BlinkTimes--;
1070 if (pLed->BlinkTimes == 0)
1071 bStopBlinking = _TRUE;
1072 if (bStopBlinking) {
1073 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1074 SwLedOff(Adapter, pLed);
1075 else {
1076 if (IS_HARDWARE_TYPE_8812AU(Adapter)) {
1077 pLed->BlinkingLedState = RTW_LED_ON;
1078 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
1079 } else {
1080 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1081 pLed->CurrLedState = LED_BLINK_SLOWLY;
1082 if (pLed->bLedOn)
1083 pLed->BlinkingLedState = RTW_LED_OFF;
1084 else
1085 pLed->BlinkingLedState = RTW_LED_ON;
1086 }
1087 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1088 }
1089 pLed->bLedBlinkInProgress = _FALSE;
1090 } else {
1091 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
1092 SwLedOff(Adapter, pLed);
1093 } else {
1094 if (IS_HARDWARE_TYPE_8812AU(Adapter))
1095 pLed->BlinkingLedState = RTW_LED_ON;
1096 else {
1097 if (pLed->bLedOn)
1098 pLed->BlinkingLedState = RTW_LED_OFF;
1099 else
1100 pLed->BlinkingLedState = RTW_LED_ON;
1101 }
1102 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1103 }
1104 }
1105 break;
1106
1107 case LED_BLINK_LINK_IN_PROCESS:
1108 if (pLed->bLedOn) {
1109 pLed->BlinkingLedState = RTW_LED_OFF;
1110 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);
1111 } else {
1112 pLed->BlinkingLedState = RTW_LED_ON;
1113 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);
1114 }
1115 break;
1116
1117 case LED_BLINK_AUTH_ERROR:
1118 pLed->BlinkTimes--;
1119 if (pLed->BlinkTimes == 0)
1120 bStopBlinking = _TRUE;
1121 if (bStopBlinking == _FALSE) {
1122 if (pLed->bLedOn) {
1123 pLed->BlinkingLedState = RTW_LED_OFF;
1124 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1125 } else {
1126 pLed->BlinkingLedState = RTW_LED_ON;
1127 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1128 }
1129 } else {
1130 pLed->CurrLedState = RTW_LED_OFF;
1131 pLed->BlinkingLedState = RTW_LED_OFF;
1132 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1133 }
1134 break;
1135
1136 default:
1137 break;
1138 }
1139
1140 }
1141
1142 /* page added for Netgear A6200V2. 20120827 */
1143 void
SwLedBlink10(PLED_USB pLed)1144 SwLedBlink10(
1145 PLED_USB pLed
1146 )
1147 {
1148 PADAPTER Adapter = pLed->padapter;
1149 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1150 BOOLEAN bStopBlinking = _FALSE;
1151
1152 /* Change LED according to BlinkingLedState specified. */
1153 if (pLed->BlinkingLedState == RTW_LED_ON) {
1154 SwLedOn(Adapter, pLed);
1155 } else {
1156 SwLedOff(Adapter, pLed);
1157 }
1158
1159
1160 switch (pLed->CurrLedState) {
1161 case RTW_LED_ON:
1162 SwLedOn(Adapter, pLed);
1163 break;
1164
1165 case RTW_LED_OFF:
1166 SwLedOff(Adapter, pLed);
1167 break;
1168
1169 case LED_BLINK_SLOWLY:
1170 if (pLed->bLedOn)
1171 pLed->BlinkingLedState = RTW_LED_OFF;
1172 else
1173 pLed->BlinkingLedState = RTW_LED_ON;
1174 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1175 break;
1176
1177 case LED_BLINK_StartToBlink:
1178 if (pLed->bLedOn) {
1179 pLed->BlinkingLedState = RTW_LED_OFF;
1180 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1181 } else {
1182 pLed->BlinkingLedState = RTW_LED_ON;
1183 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1184 }
1185 break;
1186
1187 case LED_BLINK_SCAN:
1188 pLed->BlinkTimes--;
1189 if (pLed->BlinkTimes == 0)
1190 bStopBlinking = _TRUE;
1191
1192 if (bStopBlinking) {
1193 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
1194 SwLedOff(Adapter, pLed);
1195 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
1196 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1197 pLed->CurrLedState = RTW_LED_OFF;
1198 pLed->BlinkingLedState = RTW_LED_OFF;
1199
1200 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1201 }
1202 pLed->BlinkTimes = 0;
1203 pLed->bLedBlinkInProgress = _FALSE;
1204 } else {
1205 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1206 SwLedOff(Adapter, pLed);
1207 else {
1208 if (pLed->bLedOn) {
1209 pLed->BlinkingLedState = RTW_LED_OFF;
1210 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1211 } else {
1212 pLed->BlinkingLedState = RTW_LED_ON;
1213 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR + LED_BLINK_LINK_INTERVAL_NETGEAR);
1214 }
1215 }
1216 }
1217 break;
1218
1219 case LED_BLINK_WPS:
1220 if (pLed->bLedOn) {
1221 pLed->BlinkingLedState = RTW_LED_OFF;
1222 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1223 } else {
1224 pLed->BlinkingLedState = RTW_LED_ON;
1225 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL + LED_BLINK_LINK_INTERVAL_NETGEAR);
1226 }
1227 break;
1228
1229 case LED_BLINK_WPS_STOP: /* WPS authentication fail */
1230 if (pLed->bLedOn)
1231 pLed->BlinkingLedState = RTW_LED_OFF;
1232 else
1233 pLed->BlinkingLedState = RTW_LED_ON;
1234
1235 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1236 break;
1237
1238 case LED_BLINK_WPS_STOP_OVERLAP: /* WPS session overlap */
1239 pLed->BlinkTimes--;
1240 pLed->BlinkCounter--;
1241 if (pLed->BlinkCounter == 0) {
1242 pLed->BlinkingLedState = RTW_LED_OFF;
1243 pLed->CurrLedState = RTW_LED_OFF;
1244 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1245 } else {
1246 if (pLed->BlinkTimes == 0) {
1247 if (pLed->bLedOn)
1248 pLed->BlinkTimes = 1;
1249 else
1250 bStopBlinking = _TRUE;
1251 }
1252
1253 if (bStopBlinking) {
1254 pLed->BlinkTimes = 10;
1255 pLed->BlinkingLedState = RTW_LED_ON;
1256 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1257 } else {
1258 if (pLed->bLedOn)
1259 pLed->BlinkingLedState = RTW_LED_OFF;
1260 else
1261 pLed->BlinkingLedState = RTW_LED_ON;
1262
1263 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1264 }
1265 }
1266 break;
1267
1268 case LED_BLINK_ALWAYS_ON:
1269 pLed->BlinkTimes--;
1270 if (pLed->BlinkTimes == 0)
1271 bStopBlinking = _TRUE;
1272 if (bStopBlinking) {
1273 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1274 SwLedOff(Adapter, pLed);
1275 else {
1276 if (IS_HARDWARE_TYPE_8812AU(Adapter)) {
1277 pLed->BlinkingLedState = RTW_LED_ON;
1278 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
1279 } else {
1280 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1281 pLed->CurrLedState = LED_BLINK_SLOWLY;
1282 if (pLed->bLedOn)
1283 pLed->BlinkingLedState = RTW_LED_OFF;
1284 else
1285 pLed->BlinkingLedState = RTW_LED_ON;
1286 }
1287 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1288 }
1289 pLed->bLedBlinkInProgress = _FALSE;
1290 } else {
1291 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
1292 SwLedOff(Adapter, pLed);
1293 } else {
1294 if (IS_HARDWARE_TYPE_8812AU(Adapter))
1295 pLed->BlinkingLedState = RTW_LED_ON;
1296 else {
1297 if (pLed->bLedOn)
1298 pLed->BlinkingLedState = RTW_LED_OFF;
1299 else
1300 pLed->BlinkingLedState = RTW_LED_ON;
1301 }
1302 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1303 }
1304 }
1305 break;
1306
1307 case LED_BLINK_LINK_IN_PROCESS:
1308 if (pLed->bLedOn) {
1309 pLed->BlinkingLedState = RTW_LED_OFF;
1310 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);
1311 } else {
1312 pLed->BlinkingLedState = RTW_LED_ON;
1313 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);
1314 }
1315 break;
1316
1317 case LED_BLINK_AUTH_ERROR:
1318 pLed->BlinkTimes--;
1319 if (pLed->BlinkTimes == 0)
1320 bStopBlinking = _TRUE;
1321 if (bStopBlinking == _FALSE) {
1322 if (pLed->bLedOn) {
1323 pLed->BlinkingLedState = RTW_LED_OFF;
1324 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1325 } else {
1326 pLed->BlinkingLedState = RTW_LED_ON;
1327 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1328 }
1329 } else {
1330 pLed->CurrLedState = RTW_LED_OFF;
1331 pLed->BlinkingLedState = RTW_LED_OFF;
1332 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1333 }
1334 break;
1335
1336 default:
1337 break;
1338 }
1339
1340
1341 }
1342
1343 void
SwLedBlink11(PLED_USB pLed)1344 SwLedBlink11(
1345 PLED_USB pLed
1346 )
1347 {
1348 PADAPTER Adapter = pLed->padapter;
1349 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1350 BOOLEAN bStopBlinking = _FALSE;
1351
1352 /* Change LED according to BlinkingLedState specified. */
1353 if (pLed->BlinkingLedState == RTW_LED_ON) {
1354 SwLedOn(Adapter, pLed);
1355 } else {
1356 SwLedOff(Adapter, pLed);
1357 }
1358
1359 switch (pLed->CurrLedState) {
1360 case LED_BLINK_TXRX:
1361 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1362 SwLedOff(Adapter, pLed);
1363 else {
1364 if (pLed->bLedOn)
1365 pLed->BlinkingLedState = RTW_LED_OFF;
1366 else
1367 pLed->BlinkingLedState = RTW_LED_ON;
1368 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1369 }
1370
1371 break;
1372
1373 case LED_BLINK_WPS:
1374 if (pLed->BlinkTimes == 5) {
1375 SwLedOn(Adapter, pLed);
1376 _set_timer(&(pLed->BlinkTimer), LED_CM11_LINK_ON_INTERVEL);
1377 } else {
1378 if (pLed->bLedOn) {
1379 pLed->BlinkingLedState = RTW_LED_OFF;
1380 _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1381 } else {
1382 pLed->BlinkingLedState = RTW_LED_ON;
1383 _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1384 }
1385 }
1386 pLed->BlinkTimes--;
1387 if (pLed->BlinkTimes == 0)
1388 bStopBlinking = _TRUE;
1389 if (bStopBlinking == _TRUE)
1390 pLed->BlinkTimes = 5;
1391 break;
1392
1393 case LED_BLINK_WPS_STOP: /* WPS authentication fail */
1394 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
1395 if (pLed->bLedOn)
1396 pLed->BlinkingLedState = RTW_LED_OFF;
1397 else
1398 pLed->BlinkingLedState = RTW_LED_ON;
1399 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1400 } else {
1401 pLed->CurrLedState = RTW_LED_ON;
1402 pLed->BlinkingLedState = RTW_LED_ON;
1403 SwLedOn(Adapter, pLed);
1404 _set_timer(&(pLed->BlinkTimer), 0);
1405 }
1406 break;
1407
1408 default:
1409 break;
1410 }
1411
1412 }
1413
1414 void
SwLedBlink12(PLED_USB pLed)1415 SwLedBlink12(
1416 PLED_USB pLed
1417 )
1418 {
1419 PADAPTER Adapter = pLed->padapter;
1420 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1421 BOOLEAN bStopBlinking = _FALSE;
1422
1423 /* Change LED according to BlinkingLedState specified. */
1424 if (pLed->BlinkingLedState == RTW_LED_ON) {
1425 SwLedOn(Adapter, pLed);
1426 } else {
1427 SwLedOff(Adapter, pLed);
1428 }
1429
1430 switch (pLed->CurrLedState) {
1431 case LED_BLINK_SLOWLY:
1432 if (pLed->bLedOn)
1433 pLed->BlinkingLedState = RTW_LED_OFF;
1434 else
1435 pLed->BlinkingLedState = RTW_LED_ON;
1436 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1437 break;
1438
1439 case LED_BLINK_TXRX:
1440 pLed->BlinkTimes--;
1441 if (pLed->BlinkTimes == 0)
1442 bStopBlinking = _TRUE;
1443
1444 if (bStopBlinking) {
1445 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
1446 pLed->CurrLedState = RTW_LED_OFF;
1447 pLed->BlinkingLedState = RTW_LED_OFF;
1448 if (pLed->bLedOn)
1449 SwLedOff(Adapter, pLed);
1450 } else {
1451 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1452 pLed->CurrLedState = LED_BLINK_SLOWLY;
1453 if (pLed->bLedOn)
1454 pLed->BlinkingLedState = RTW_LED_OFF;
1455 else
1456 pLed->BlinkingLedState = RTW_LED_ON;
1457 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1458 }
1459
1460 pLed->bLedBlinkInProgress = _FALSE;
1461 } else {
1462 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1463 SwLedOff(Adapter, pLed);
1464 else {
1465 if (pLed->bLedOn)
1466 pLed->BlinkingLedState = RTW_LED_OFF;
1467 else
1468 pLed->BlinkingLedState = RTW_LED_ON;
1469 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1470 }
1471 }
1472 break;
1473
1474 default:
1475 break;
1476 }
1477
1478
1479
1480 }
1481
1482 void
SwLedBlink13(PLED_USB pLed)1483 SwLedBlink13(
1484 PLED_USB pLed
1485 )
1486 {
1487 PADAPTER Adapter = pLed->padapter;
1488 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1489 BOOLEAN bStopBlinking = _FALSE;
1490 static u8 LinkBlinkCnt = 0;
1491
1492 /* Change LED according to BlinkingLedState specified. */
1493 if (pLed->BlinkingLedState == RTW_LED_ON) {
1494 SwLedOn(Adapter, pLed);
1495 } else {
1496 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
1497 SwLedOff(Adapter, pLed);
1498 }
1499 switch (pLed->CurrLedState) {
1500 case LED_BLINK_LINK_IN_PROCESS:
1501 if (!pLed->bLedWPSBlinkInProgress)
1502 LinkBlinkCnt++;
1503
1504 if (LinkBlinkCnt > 15) {
1505 LinkBlinkCnt = 0;
1506 pLed->bLedBlinkInProgress = _FALSE;
1507 break;
1508 }
1509 if (pLed->bLedOn) {
1510 pLed->BlinkingLedState = RTW_LED_OFF;
1511 _set_timer(&(pLed->BlinkTimer), 500);
1512 } else {
1513 pLed->BlinkingLedState = RTW_LED_ON;
1514 _set_timer(&(pLed->BlinkTimer), 500);
1515 }
1516
1517 break;
1518
1519 case LED_BLINK_WPS:
1520 if (pLed->bLedOn) {
1521 pLed->BlinkingLedState = RTW_LED_OFF;
1522 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
1523 } else {
1524 pLed->BlinkingLedState = RTW_LED_ON;
1525 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
1526 }
1527
1528 break;
1529
1530 case LED_BLINK_WPS_STOP: /* WPS success */
1531 SwLedOff(Adapter, pLed);
1532 pLed->bLedWPSBlinkInProgress = _FALSE;
1533 break;
1534
1535 default:
1536 LinkBlinkCnt = 0;
1537 break;
1538 }
1539
1540
1541 }
1542
1543 void
SwLedBlink14(PLED_USB pLed)1544 SwLedBlink14(
1545 PLED_USB pLed
1546 )
1547 {
1548 PADAPTER Adapter = pLed->padapter;
1549 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1550 BOOLEAN bStopBlinking = _FALSE;
1551 static u8 LinkBlinkCnt = 0;
1552
1553 /* Change LED according to BlinkingLedState specified. */
1554 if (pLed->BlinkingLedState == RTW_LED_ON) {
1555 SwLedOn(Adapter, pLed);
1556 } else {
1557 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
1558 SwLedOff(Adapter, pLed);
1559 }
1560 switch (pLed->CurrLedState) {
1561 case LED_BLINK_TXRX:
1562 pLed->BlinkTimes--;
1563 if (pLed->BlinkTimes == 0)
1564 bStopBlinking = _TRUE;
1565 if (bStopBlinking) {
1566 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1567 SwLedOff(Adapter, pLed);
1568 else
1569 SwLedOn(Adapter, pLed);
1570 pLed->bLedBlinkInProgress = _FALSE;
1571 } else {
1572 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1573 SwLedOff(Adapter, pLed);
1574 else {
1575 if (pLed->bLedOn) {
1576 pLed->BlinkingLedState = RTW_LED_OFF;
1577 if (IS_HARDWARE_TYPE_8812AU(Adapter))
1578 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1579 else
1580 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1581 } else {
1582 pLed->BlinkingLedState = RTW_LED_ON;
1583 if (IS_HARDWARE_TYPE_8812AU(Adapter))
1584 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1585 else
1586 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1587 }
1588 }
1589 }
1590
1591 break;
1592
1593 default:
1594 LinkBlinkCnt = 0;
1595 break;
1596 }
1597
1598 }
1599
1600 void
SwLedBlink15(PLED_USB pLed)1601 SwLedBlink15(
1602 PLED_USB pLed
1603 )
1604 {
1605 PADAPTER Adapter = pLed->padapter;
1606 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1607 BOOLEAN bStopBlinking = _FALSE;
1608 static u8 LinkBlinkCnt = 0;
1609 /* Change LED according to BlinkingLedState specified. */
1610
1611 if (pLed->BlinkingLedState == RTW_LED_ON) {
1612 SwLedOn(Adapter, pLed);
1613 } else {
1614 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
1615 SwLedOff(Adapter, pLed);
1616 }
1617 switch (pLed->CurrLedState) {
1618 case LED_BLINK_WPS:
1619 if (pLed->bLedOn) {
1620 pLed->BlinkingLedState = RTW_LED_OFF;
1621 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_DLINK);
1622 } else {
1623 pLed->BlinkingLedState = RTW_LED_ON;
1624 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_DLINK);
1625 }
1626 break;
1627
1628 case LED_BLINK_WPS_STOP: /* WPS success */
1629
1630 if (pLed->BlinkingLedState == RTW_LED_OFF) {
1631 pLed->bLedWPSBlinkInProgress = _FALSE;
1632 return;
1633 }
1634
1635 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1636 pLed->BlinkingLedState = RTW_LED_OFF;
1637
1638 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_LINKED_ON_INTERVAL_DLINK);
1639 break;
1640
1641 case LED_BLINK_NO_LINK: {
1642 static BOOLEAN bLedOn = _TRUE;
1643 if (bLedOn) {
1644 bLedOn = _FALSE;
1645 pLed->BlinkingLedState = RTW_LED_OFF;
1646 } else {
1647 bLedOn = _TRUE;
1648 pLed->BlinkingLedState = RTW_LED_ON;
1649 }
1650 pLed->bLedBlinkInProgress = _TRUE;
1651 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL);
1652 }
1653 break;
1654
1655 case LED_BLINK_LINK_IDEL: {
1656 static BOOLEAN bLedOn = _TRUE;
1657 if (bLedOn) {
1658 bLedOn = _FALSE;
1659 pLed->BlinkingLedState = RTW_LED_OFF;
1660 } else {
1661 bLedOn = _TRUE;
1662 pLed->BlinkingLedState = RTW_LED_ON;
1663
1664 }
1665 pLed->bLedBlinkInProgress = _TRUE;
1666 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_IDEL_INTERVAL);
1667 }
1668 break;
1669
1670 case LED_BLINK_SCAN: {
1671 static u8 BlinkTime = 0;
1672 if (BlinkTime % 2 == 0)
1673 pLed->BlinkingLedState = RTW_LED_ON;
1674 else
1675 pLed->BlinkingLedState = RTW_LED_OFF;
1676 BlinkTime++;
1677
1678 if (BlinkTime < 24) {
1679 pLed->bLedBlinkInProgress = _TRUE;
1680
1681 if (pLed->BlinkingLedState == RTW_LED_ON)
1682 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_OFF_INTERVAL);
1683 else
1684 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_ON_INTERVAL);
1685 } else {
1686 /* if(pLed->OLDLedState ==LED_NO_LINK_BLINK) */
1687 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
1688 pLed->CurrLedState = LED_BLINK_NO_LINK;
1689 pLed->BlinkingLedState = RTW_LED_ON;
1690
1691 _set_timer(&(pLed->BlinkTimer), 100);
1692 }
1693 BlinkTime = 0;
1694 }
1695 }
1696 break;
1697
1698 case LED_BLINK_TXRX:
1699 pLed->BlinkTimes--;
1700 if (pLed->BlinkTimes == 0)
1701 bStopBlinking = _TRUE;
1702 if (bStopBlinking) {
1703 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1704 SwLedOff(Adapter, pLed);
1705 else
1706 SwLedOn(Adapter, pLed);
1707 pLed->bLedBlinkInProgress = _FALSE;
1708 } else {
1709 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1710 SwLedOff(Adapter, pLed);
1711 else {
1712 if (pLed->bLedOn)
1713 pLed->BlinkingLedState = RTW_LED_OFF;
1714 else
1715 pLed->BlinkingLedState = RTW_LED_ON;
1716 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1717 }
1718 }
1719 break;
1720
1721 default:
1722 LinkBlinkCnt = 0;
1723 break;
1724 }
1725
1726 }
1727
1728 /*
1729 * Description:
1730 * Handler function of LED Blinking.
1731 * We dispatch acture LED blink action according to LedStrategy.
1732 * */
BlinkHandler(PLED_USB pLed)1733 void BlinkHandler(PLED_USB pLed)
1734 {
1735 _adapter *padapter = pLed->padapter;
1736 struct led_priv *ledpriv = adapter_to_led(padapter);
1737
1738 /* RTW_INFO("%s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); */
1739
1740 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
1741 /*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
1742 , __func__
1743 , rtw_is_drv_stopped(padapter)?"True":"False"
1744 , rtw_is_surprise_removed(padapter)?"True":"False" );*/
1745 return;
1746 }
1747
1748 switch (ledpriv->LedStrategy) {
1749 #if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
1750 case SW_LED_MODE_UC_TRX_ONLY:
1751 rtw_sw_led_blink_uc_trx_only(pLed);
1752 break;
1753 #endif
1754
1755 case SW_LED_MODE0:
1756 SwLedBlink(pLed);
1757 break;
1758
1759 case SW_LED_MODE1:
1760 SwLedBlink1(pLed);
1761 break;
1762
1763 case SW_LED_MODE2:
1764 SwLedBlink2(pLed);
1765 break;
1766
1767 case SW_LED_MODE3:
1768 SwLedBlink3(pLed);
1769 break;
1770
1771 case SW_LED_MODE4:
1772 SwLedBlink4(pLed);
1773 break;
1774
1775 case SW_LED_MODE5:
1776 SwLedBlink5(pLed);
1777 break;
1778
1779 case SW_LED_MODE6:
1780 SwLedBlink6(pLed);
1781 break;
1782
1783 case SW_LED_MODE7:
1784 SwLedBlink7(pLed);
1785 break;
1786
1787 case SW_LED_MODE8:
1788 SwLedBlink8(pLed);
1789 break;
1790
1791 case SW_LED_MODE9:
1792 SwLedBlink9(pLed);
1793 break;
1794
1795 case SW_LED_MODE10:
1796 SwLedBlink10(pLed);
1797 break;
1798
1799 case SW_LED_MODE11:
1800 SwLedBlink11(pLed);
1801 break;
1802
1803 case SW_LED_MODE12:
1804 SwLedBlink12(pLed);
1805 break;
1806
1807 case SW_LED_MODE13:
1808 SwLedBlink13(pLed);
1809 break;
1810
1811 case SW_LED_MODE14:
1812 SwLedBlink14(pLed);
1813 break;
1814
1815 case SW_LED_MODE15:
1816 SwLedBlink15(pLed);
1817 break;
1818
1819 default:
1820 /* SwLedBlink(pLed); */
1821 break;
1822 }
1823 }
1824
1825 /*
1826 * Description:
1827 * Callback function of LED BlinkTimer,
1828 * it just schedules to corresponding BlinkWorkItem/led_blink_hdl
1829 * */
BlinkTimerCallback(void * data)1830 void BlinkTimerCallback(void *data)
1831 {
1832 PLED_USB pLed = (PLED_USB)data;
1833 _adapter *padapter = pLed->padapter;
1834
1835 /* RTW_INFO("%s\n", __FUNCTION__); */
1836
1837 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
1838 /*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
1839 , __func__
1840 , rtw_is_drv_stopped(padapter)?"True":"False"
1841 , rtw_is_surprise_removed(padapter)?"True":"False" );*/
1842 return;
1843 }
1844
1845 #ifdef CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD
1846 rtw_led_blink_cmd(padapter, (void *)pLed);
1847 #else
1848 _set_workitem(&(pLed->BlinkWorkItem));
1849 #endif
1850 }
1851
1852 /*
1853 * Description:
1854 * Callback function of LED BlinkWorkItem.
1855 * We dispatch acture LED blink action according to LedStrategy.
1856 * */
BlinkWorkItemCallback(_workitem * work)1857 void BlinkWorkItemCallback(_workitem *work)
1858 {
1859 PLED_USB pLed = container_of(work, LED_USB, BlinkWorkItem);
1860 BlinkHandler(pLed);
1861 }
1862
1863 static void
SwLedControlMode0(_adapter * padapter,LED_CTL_MODE LedAction)1864 SwLedControlMode0(
1865 _adapter *padapter,
1866 LED_CTL_MODE LedAction
1867 )
1868 {
1869 struct led_priv *ledpriv = adapter_to_led(padapter);
1870 PLED_USB pLed = &(ledpriv->SwLed1);
1871
1872 /* Decide led state */
1873 switch (LedAction) {
1874 case LED_CTL_TX:
1875 case LED_CTL_RX:
1876 if (pLed->bLedBlinkInProgress == _FALSE) {
1877 pLed->bLedBlinkInProgress = _TRUE;
1878
1879 pLed->CurrLedState = LED_BLINK_NORMAL;
1880 pLed->BlinkTimes = 2;
1881
1882 if (pLed->bLedOn)
1883 pLed->BlinkingLedState = RTW_LED_OFF;
1884 else
1885 pLed->BlinkingLedState = RTW_LED_ON;
1886 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1887 }
1888 break;
1889
1890 case LED_CTL_START_TO_LINK:
1891 if (pLed->bLedBlinkInProgress == _FALSE) {
1892 pLed->bLedBlinkInProgress = _TRUE;
1893
1894 pLed->CurrLedState = LED_BLINK_StartToBlink;
1895 pLed->BlinkTimes = 24;
1896
1897 if (pLed->bLedOn)
1898 pLed->BlinkingLedState = RTW_LED_OFF;
1899 else
1900 pLed->BlinkingLedState = RTW_LED_ON;
1901 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1902 } else
1903 pLed->CurrLedState = LED_BLINK_StartToBlink;
1904 break;
1905
1906 case LED_CTL_LINK:
1907 pLed->CurrLedState = RTW_LED_ON;
1908 if (pLed->bLedBlinkInProgress == _FALSE) {
1909 pLed->BlinkingLedState = RTW_LED_ON;
1910 _set_timer(&(pLed->BlinkTimer), 0);
1911 }
1912 break;
1913
1914 case LED_CTL_NO_LINK:
1915 pLed->CurrLedState = RTW_LED_OFF;
1916 if (pLed->bLedBlinkInProgress == _FALSE) {
1917 pLed->BlinkingLedState = RTW_LED_OFF;
1918 _set_timer(&(pLed->BlinkTimer), 0);
1919 }
1920 break;
1921
1922 case LED_CTL_POWER_OFF:
1923 pLed->CurrLedState = RTW_LED_OFF;
1924 if (pLed->bLedBlinkInProgress) {
1925 _cancel_timer_ex(&(pLed->BlinkTimer));
1926 pLed->bLedBlinkInProgress = _FALSE;
1927 }
1928 SwLedOff(padapter, pLed);
1929 break;
1930
1931 case LED_CTL_START_WPS:
1932 if (pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState == RTW_LED_ON) {
1933 pLed->bLedBlinkInProgress = _TRUE;
1934
1935 pLed->CurrLedState = LED_BLINK_WPS;
1936 pLed->BlinkTimes = 20;
1937
1938 if (pLed->bLedOn) {
1939 pLed->BlinkingLedState = RTW_LED_OFF;
1940 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
1941 } else {
1942 pLed->BlinkingLedState = RTW_LED_ON;
1943 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
1944 }
1945 }
1946 break;
1947
1948 case LED_CTL_STOP_WPS:
1949 if (pLed->bLedBlinkInProgress) {
1950 pLed->CurrLedState = RTW_LED_OFF;
1951 _cancel_timer_ex(&(pLed->BlinkTimer));
1952 pLed->bLedBlinkInProgress = _FALSE;
1953 }
1954 break;
1955
1956
1957 default:
1958 break;
1959 }
1960
1961
1962 }
1963
1964 /* ALPHA, added by chiyoko, 20090106 */
1965 static void
SwLedControlMode1(_adapter * padapter,LED_CTL_MODE LedAction)1966 SwLedControlMode1(
1967 _adapter *padapter,
1968 LED_CTL_MODE LedAction
1969 )
1970 {
1971 struct led_priv *ledpriv = adapter_to_led(padapter);
1972 PLED_USB pLed = &(ledpriv->SwLed0);
1973 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1974 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
1975
1976 u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; /* add by ylb 20121012 for customer led for alpha */
1977 if (pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)
1978 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;
1979
1980 if (pHalData->CustomerID == RT_CID_819x_CAMEO)
1981 pLed = &(ledpriv->SwLed1);
1982
1983 switch (LedAction) {
1984 case LED_CTL_POWER_ON:
1985 case LED_CTL_START_TO_LINK:
1986 case LED_CTL_NO_LINK:
1987 if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
1988 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1989 return;
1990 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
1991 _cancel_timer_ex(&(pLed->BlinkTimer));
1992 pLed->bLedLinkBlinkInProgress = _FALSE;
1993 }
1994 if (pLed->bLedBlinkInProgress == _TRUE) {
1995 _cancel_timer_ex(&(pLed->BlinkTimer));
1996 pLed->bLedBlinkInProgress = _FALSE;
1997 }
1998
1999 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2000 pLed->CurrLedState = LED_BLINK_SLOWLY;
2001 if (pLed->bLedOn)
2002 pLed->BlinkingLedState = RTW_LED_OFF;
2003 else
2004 pLed->BlinkingLedState = RTW_LED_ON;
2005 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);/* change by ylb 20121012 for customer led for alpha */
2006 }
2007 break;
2008
2009 case LED_CTL_LINK:
2010 if (pLed->bLedLinkBlinkInProgress == _FALSE) {
2011 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2012 return;
2013 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2014 _cancel_timer_ex(&(pLed->BlinkTimer));
2015 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2016 }
2017 if (pLed->bLedBlinkInProgress == _TRUE) {
2018 _cancel_timer_ex(&(pLed->BlinkTimer));
2019 pLed->bLedBlinkInProgress = _FALSE;
2020 }
2021 pLed->bLedLinkBlinkInProgress = _TRUE;
2022 pLed->CurrLedState = LED_BLINK_NORMAL;
2023 if (pLed->bLedOn)
2024 pLed->BlinkingLedState = RTW_LED_OFF;
2025 else
2026 pLed->BlinkingLedState = RTW_LED_ON;
2027 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
2028 }
2029 break;
2030
2031 case LED_CTL_SITE_SURVEY:
2032 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
2033 ;
2034 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2035 if (IS_LED_WPS_BLINKING(pLed))
2036 return;
2037
2038 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2039 _cancel_timer_ex(&(pLed->BlinkTimer));
2040 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2041 }
2042 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2043 _cancel_timer_ex(&(pLed->BlinkTimer));
2044 pLed->bLedLinkBlinkInProgress = _FALSE;
2045 }
2046 if (pLed->bLedBlinkInProgress == _TRUE) {
2047 _cancel_timer_ex(&(pLed->BlinkTimer));
2048 pLed->bLedBlinkInProgress = _FALSE;
2049 }
2050 pLed->bLedScanBlinkInProgress = _TRUE;
2051 pLed->CurrLedState = LED_BLINK_SCAN;
2052 pLed->BlinkTimes = 24;
2053 if (pLed->bLedOn)
2054 pLed->BlinkingLedState = RTW_LED_OFF;
2055 else
2056 pLed->BlinkingLedState = RTW_LED_ON;
2057
2058 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason == RF_CHANGE_BY_IPS)
2059 _set_timer(&(pLed->BlinkTimer), LED_INITIAL_INTERVAL);
2060 else
2061 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2062
2063 }
2064 break;
2065
2066 case LED_CTL_TX:
2067 case LED_CTL_RX:
2068 if (pLed->bLedBlinkInProgress == _FALSE) {
2069 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2070 return;
2071 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2072 _cancel_timer_ex(&(pLed->BlinkTimer));
2073 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2074 }
2075 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2076 _cancel_timer_ex(&(pLed->BlinkTimer));
2077 pLed->bLedLinkBlinkInProgress = _FALSE;
2078 }
2079 pLed->bLedBlinkInProgress = _TRUE;
2080 pLed->CurrLedState = LED_BLINK_TXRX;
2081 pLed->BlinkTimes = 2;
2082 if (pLed->bLedOn)
2083 pLed->BlinkingLedState = RTW_LED_OFF;
2084 else
2085 pLed->BlinkingLedState = RTW_LED_ON;
2086 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2087 }
2088 break;
2089
2090 case LED_CTL_START_WPS: /* wait until xinpin finish */
2091 case LED_CTL_START_WPS_BOTTON:
2092 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2093 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2094 _cancel_timer_ex(&(pLed->BlinkTimer));
2095 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2096 }
2097 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2098 _cancel_timer_ex(&(pLed->BlinkTimer));
2099 pLed->bLedLinkBlinkInProgress = _FALSE;
2100 }
2101 if (pLed->bLedBlinkInProgress == _TRUE) {
2102 _cancel_timer_ex(&(pLed->BlinkTimer));
2103 pLed->bLedBlinkInProgress = _FALSE;
2104 }
2105 if (pLed->bLedScanBlinkInProgress == _TRUE) {
2106 _cancel_timer_ex(&(pLed->BlinkTimer));
2107 pLed->bLedScanBlinkInProgress = _FALSE;
2108 }
2109 pLed->bLedWPSBlinkInProgress = _TRUE;
2110 pLed->CurrLedState = LED_BLINK_WPS;
2111 if (pLed->bLedOn)
2112 pLed->BlinkingLedState = RTW_LED_OFF;
2113 else
2114 pLed->BlinkingLedState = RTW_LED_ON;
2115 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2116 }
2117 break;
2118
2119
2120 case LED_CTL_STOP_WPS:
2121 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2122 _cancel_timer_ex(&(pLed->BlinkTimer));
2123 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2124 }
2125 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2126 _cancel_timer_ex(&(pLed->BlinkTimer));
2127 pLed->bLedLinkBlinkInProgress = _FALSE;
2128 }
2129 if (pLed->bLedBlinkInProgress == _TRUE) {
2130 _cancel_timer_ex(&(pLed->BlinkTimer));
2131 pLed->bLedBlinkInProgress = _FALSE;
2132 }
2133 if (pLed->bLedScanBlinkInProgress == _TRUE) {
2134 _cancel_timer_ex(&(pLed->BlinkTimer));
2135 pLed->bLedScanBlinkInProgress = _FALSE;
2136 }
2137 if (pLed->bLedWPSBlinkInProgress)
2138 _cancel_timer_ex(&(pLed->BlinkTimer));
2139 else
2140 pLed->bLedWPSBlinkInProgress = _TRUE;
2141
2142 pLed->CurrLedState = LED_BLINK_WPS_STOP;
2143 if (pLed->bLedOn) {
2144 pLed->BlinkingLedState = RTW_LED_OFF;
2145 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
2146 } else {
2147 pLed->BlinkingLedState = RTW_LED_ON;
2148 _set_timer(&(pLed->BlinkTimer), 0);
2149 }
2150 break;
2151
2152 case LED_CTL_STOP_WPS_FAIL:
2153 if (pLed->bLedWPSBlinkInProgress) {
2154 _cancel_timer_ex(&(pLed->BlinkTimer));
2155 pLed->bLedWPSBlinkInProgress = _FALSE;
2156 }
2157
2158 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2159 pLed->CurrLedState = LED_BLINK_SLOWLY;
2160 if (pLed->bLedOn)
2161 pLed->BlinkingLedState = RTW_LED_OFF;
2162 else
2163 pLed->BlinkingLedState = RTW_LED_ON;
2164 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);/* change by ylb 20121012 for customer led for alpha */
2165 break;
2166
2167 case LED_CTL_POWER_OFF:
2168 pLed->CurrLedState = RTW_LED_OFF;
2169 pLed->BlinkingLedState = RTW_LED_OFF;
2170 if (pLed->bLedNoLinkBlinkInProgress) {
2171 _cancel_timer_ex(&(pLed->BlinkTimer));
2172 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2173 }
2174 if (pLed->bLedLinkBlinkInProgress) {
2175 _cancel_timer_ex(&(pLed->BlinkTimer));
2176 pLed->bLedLinkBlinkInProgress = _FALSE;
2177 }
2178 if (pLed->bLedBlinkInProgress) {
2179 _cancel_timer_ex(&(pLed->BlinkTimer));
2180 pLed->bLedBlinkInProgress = _FALSE;
2181 }
2182 if (pLed->bLedWPSBlinkInProgress) {
2183 _cancel_timer_ex(&(pLed->BlinkTimer));
2184 pLed->bLedWPSBlinkInProgress = _FALSE;
2185 }
2186 if (pLed->bLedScanBlinkInProgress) {
2187 _cancel_timer_ex(&(pLed->BlinkTimer));
2188 pLed->bLedScanBlinkInProgress = _FALSE;
2189 }
2190
2191 SwLedOff(padapter, pLed);
2192 break;
2193
2194 default:
2195 break;
2196
2197 }
2198
2199 }
2200
2201 /* Arcadyan/Sitecom , added by chiyoko, 20090216 */
2202 static void
SwLedControlMode2(_adapter * padapter,LED_CTL_MODE LedAction)2203 SwLedControlMode2(
2204 _adapter *padapter,
2205 LED_CTL_MODE LedAction
2206 )
2207 {
2208 struct led_priv *ledpriv = adapter_to_led(padapter);
2209 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2210 PLED_USB pLed = &(ledpriv->SwLed0);
2211
2212 switch (LedAction) {
2213 case LED_CTL_SITE_SURVEY:
2214 if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
2215 ;
2216 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2217 if (IS_LED_WPS_BLINKING(pLed))
2218 return;
2219
2220 if (pLed->bLedBlinkInProgress == _TRUE) {
2221 _cancel_timer_ex(&(pLed->BlinkTimer));
2222 pLed->bLedBlinkInProgress = _FALSE;
2223 }
2224 pLed->bLedScanBlinkInProgress = _TRUE;
2225 pLed->CurrLedState = LED_BLINK_SCAN;
2226 pLed->BlinkTimes = 24;
2227 if (pLed->bLedOn)
2228 pLed->BlinkingLedState = RTW_LED_OFF;
2229 else
2230 pLed->BlinkingLedState = RTW_LED_ON;
2231 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2232 }
2233 break;
2234
2235 case LED_CTL_TX:
2236 case LED_CTL_RX:
2237 if ((pLed->bLedBlinkInProgress == _FALSE) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
2238 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2239 return;
2240
2241 pLed->bLedBlinkInProgress = _TRUE;
2242 pLed->CurrLedState = LED_BLINK_TXRX;
2243 pLed->BlinkTimes = 2;
2244 if (pLed->bLedOn)
2245 pLed->BlinkingLedState = RTW_LED_OFF;
2246 else
2247 pLed->BlinkingLedState = RTW_LED_ON;
2248 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2249 }
2250 break;
2251
2252 case LED_CTL_LINK:
2253 pLed->CurrLedState = RTW_LED_ON;
2254 pLed->BlinkingLedState = RTW_LED_ON;
2255 if (pLed->bLedBlinkInProgress) {
2256 _cancel_timer_ex(&(pLed->BlinkTimer));
2257 pLed->bLedBlinkInProgress = _FALSE;
2258 }
2259 if (pLed->bLedScanBlinkInProgress) {
2260 _cancel_timer_ex(&(pLed->BlinkTimer));
2261 pLed->bLedScanBlinkInProgress = _FALSE;
2262 }
2263
2264 _set_timer(&(pLed->BlinkTimer), 0);
2265 break;
2266
2267 case LED_CTL_START_WPS: /* wait until xinpin finish */
2268 case LED_CTL_START_WPS_BOTTON:
2269 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2270 if (pLed->bLedBlinkInProgress == _TRUE) {
2271 _cancel_timer_ex(&(pLed->BlinkTimer));
2272 pLed->bLedBlinkInProgress = _FALSE;
2273 }
2274 if (pLed->bLedScanBlinkInProgress == _TRUE) {
2275 _cancel_timer_ex(&(pLed->BlinkTimer));
2276 pLed->bLedScanBlinkInProgress = _FALSE;
2277 }
2278 pLed->bLedWPSBlinkInProgress = _TRUE;
2279 pLed->CurrLedState = RTW_LED_ON;
2280 pLed->BlinkingLedState = RTW_LED_ON;
2281 _set_timer(&(pLed->BlinkTimer), 0);
2282 }
2283 break;
2284
2285 case LED_CTL_STOP_WPS:
2286 pLed->bLedWPSBlinkInProgress = _FALSE;
2287 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on) {
2288 pLed->CurrLedState = RTW_LED_OFF;
2289 pLed->BlinkingLedState = RTW_LED_OFF;
2290 _set_timer(&(pLed->BlinkTimer), 0);
2291 } else {
2292 pLed->CurrLedState = RTW_LED_ON;
2293 pLed->BlinkingLedState = RTW_LED_ON;
2294 _set_timer(&(pLed->BlinkTimer), 0);
2295 }
2296 break;
2297
2298 case LED_CTL_STOP_WPS_FAIL:
2299 pLed->bLedWPSBlinkInProgress = _FALSE;
2300 pLed->CurrLedState = RTW_LED_OFF;
2301 pLed->BlinkingLedState = RTW_LED_OFF;
2302 _set_timer(&(pLed->BlinkTimer), 0);
2303 break;
2304
2305 case LED_CTL_START_TO_LINK:
2306 case LED_CTL_NO_LINK:
2307 if (!IS_LED_BLINKING(pLed)) {
2308 pLed->CurrLedState = RTW_LED_OFF;
2309 pLed->BlinkingLedState = RTW_LED_OFF;
2310 _set_timer(&(pLed->BlinkTimer), 0);
2311 }
2312 break;
2313
2314 case LED_CTL_POWER_OFF:
2315 pLed->CurrLedState = RTW_LED_OFF;
2316 pLed->BlinkingLedState = RTW_LED_OFF;
2317 if (pLed->bLedBlinkInProgress) {
2318 _cancel_timer_ex(&(pLed->BlinkTimer));
2319 pLed->bLedBlinkInProgress = _FALSE;
2320 }
2321 if (pLed->bLedScanBlinkInProgress) {
2322 _cancel_timer_ex(&(pLed->BlinkTimer));
2323 pLed->bLedScanBlinkInProgress = _FALSE;
2324 }
2325 if (pLed->bLedWPSBlinkInProgress) {
2326 _cancel_timer_ex(&(pLed->BlinkTimer));
2327 pLed->bLedWPSBlinkInProgress = _FALSE;
2328 }
2329
2330 SwLedOff(padapter, pLed);
2331 break;
2332
2333 default:
2334 break;
2335
2336 }
2337
2338 }
2339
2340 /* COREGA, added by chiyoko, 20090316 */
2341 static void
SwLedControlMode3(_adapter * padapter,LED_CTL_MODE LedAction)2342 SwLedControlMode3(
2343 _adapter *padapter,
2344 LED_CTL_MODE LedAction
2345 )
2346 {
2347 struct led_priv *ledpriv = adapter_to_led(padapter);
2348 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2349 PLED_USB pLed = &(ledpriv->SwLed0);
2350
2351 switch (LedAction) {
2352 case LED_CTL_SITE_SURVEY:
2353 if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
2354 ;
2355 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2356 if (IS_LED_WPS_BLINKING(pLed))
2357 return;
2358
2359 if (pLed->bLedBlinkInProgress == _TRUE) {
2360 _cancel_timer_ex(&(pLed->BlinkTimer));
2361 pLed->bLedBlinkInProgress = _FALSE;
2362 }
2363 pLed->bLedScanBlinkInProgress = _TRUE;
2364 pLed->CurrLedState = LED_BLINK_SCAN;
2365 pLed->BlinkTimes = 24;
2366 if (pLed->bLedOn)
2367 pLed->BlinkingLedState = RTW_LED_OFF;
2368 else
2369 pLed->BlinkingLedState = RTW_LED_ON;
2370 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2371 }
2372 break;
2373
2374 case LED_CTL_TX:
2375 case LED_CTL_RX:
2376 if ((pLed->bLedBlinkInProgress == _FALSE) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
2377 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2378 return;
2379
2380 pLed->bLedBlinkInProgress = _TRUE;
2381 pLed->CurrLedState = LED_BLINK_TXRX;
2382 pLed->BlinkTimes = 2;
2383 if (pLed->bLedOn)
2384 pLed->BlinkingLedState = RTW_LED_OFF;
2385 else
2386 pLed->BlinkingLedState = RTW_LED_ON;
2387 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2388 }
2389 break;
2390
2391 case LED_CTL_LINK:
2392 if (IS_LED_WPS_BLINKING(pLed))
2393 return;
2394
2395 pLed->CurrLedState = RTW_LED_ON;
2396 pLed->BlinkingLedState = RTW_LED_ON;
2397 if (pLed->bLedBlinkInProgress) {
2398 _cancel_timer_ex(&(pLed->BlinkTimer));
2399 pLed->bLedBlinkInProgress = _FALSE;
2400 }
2401 if (pLed->bLedScanBlinkInProgress) {
2402 _cancel_timer_ex(&(pLed->BlinkTimer));
2403 pLed->bLedScanBlinkInProgress = _FALSE;
2404 }
2405
2406 _set_timer(&(pLed->BlinkTimer), 0);
2407 break;
2408
2409 case LED_CTL_START_WPS: /* wait until xinpin finish */
2410 case LED_CTL_START_WPS_BOTTON:
2411 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2412 if (pLed->bLedBlinkInProgress == _TRUE) {
2413 _cancel_timer_ex(&(pLed->BlinkTimer));
2414 pLed->bLedBlinkInProgress = _FALSE;
2415 }
2416 if (pLed->bLedScanBlinkInProgress == _TRUE) {
2417 _cancel_timer_ex(&(pLed->BlinkTimer));
2418 pLed->bLedScanBlinkInProgress = _FALSE;
2419 }
2420 pLed->bLedWPSBlinkInProgress = _TRUE;
2421 pLed->CurrLedState = LED_BLINK_WPS;
2422 if (pLed->bLedOn)
2423 pLed->BlinkingLedState = RTW_LED_OFF;
2424 else
2425 pLed->BlinkingLedState = RTW_LED_ON;
2426 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2427 }
2428 break;
2429
2430 case LED_CTL_STOP_WPS:
2431 if (pLed->bLedWPSBlinkInProgress) {
2432 _cancel_timer_ex(&(pLed->BlinkTimer));
2433 pLed->bLedWPSBlinkInProgress = _FALSE;
2434 } else
2435 pLed->bLedWPSBlinkInProgress = _TRUE;
2436
2437 pLed->CurrLedState = LED_BLINK_WPS_STOP;
2438 if (pLed->bLedOn) {
2439 pLed->BlinkingLedState = RTW_LED_OFF;
2440 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
2441 } else {
2442 pLed->BlinkingLedState = RTW_LED_ON;
2443 _set_timer(&(pLed->BlinkTimer), 0);
2444 }
2445
2446 break;
2447
2448 case LED_CTL_STOP_WPS_FAIL:
2449 if (pLed->bLedWPSBlinkInProgress) {
2450 _cancel_timer_ex(&(pLed->BlinkTimer));
2451 pLed->bLedWPSBlinkInProgress = _FALSE;
2452 }
2453
2454 pLed->CurrLedState = RTW_LED_OFF;
2455 pLed->BlinkingLedState = RTW_LED_OFF;
2456 _set_timer(&(pLed->BlinkTimer), 0);
2457 break;
2458
2459 case LED_CTL_START_TO_LINK:
2460 case LED_CTL_NO_LINK:
2461 if (!IS_LED_BLINKING(pLed)) {
2462 pLed->CurrLedState = RTW_LED_OFF;
2463 pLed->BlinkingLedState = RTW_LED_OFF;
2464 _set_timer(&(pLed->BlinkTimer), 0);
2465 }
2466 break;
2467
2468 case LED_CTL_POWER_OFF:
2469 pLed->CurrLedState = RTW_LED_OFF;
2470 pLed->BlinkingLedState = RTW_LED_OFF;
2471 if (pLed->bLedBlinkInProgress) {
2472 _cancel_timer_ex(&(pLed->BlinkTimer));
2473 pLed->bLedBlinkInProgress = _FALSE;
2474 }
2475 if (pLed->bLedScanBlinkInProgress) {
2476 _cancel_timer_ex(&(pLed->BlinkTimer));
2477 pLed->bLedScanBlinkInProgress = _FALSE;
2478 }
2479 if (pLed->bLedWPSBlinkInProgress) {
2480 _cancel_timer_ex(&(pLed->BlinkTimer));
2481 pLed->bLedWPSBlinkInProgress = _FALSE;
2482 }
2483
2484 SwLedOff(padapter, pLed);
2485 break;
2486
2487 default:
2488 break;
2489
2490 }
2491
2492 }
2493
2494
2495 /* Edimax-Belkin, added by chiyoko, 20090413 */
2496 static void
SwLedControlMode4(_adapter * padapter,LED_CTL_MODE LedAction)2497 SwLedControlMode4(
2498 _adapter *padapter,
2499 LED_CTL_MODE LedAction
2500 )
2501 {
2502 struct led_priv *ledpriv = adapter_to_led(padapter);
2503 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2504 PLED_USB pLed = &(ledpriv->SwLed0);
2505 PLED_USB pLed1 = &(ledpriv->SwLed1);
2506
2507 switch (LedAction) {
2508 case LED_CTL_START_TO_LINK:
2509 if (pLed1->bLedWPSBlinkInProgress) {
2510 pLed1->bLedWPSBlinkInProgress = _FALSE;
2511 _cancel_timer_ex(&(pLed1->BlinkTimer));
2512
2513 pLed1->BlinkingLedState = RTW_LED_OFF;
2514 pLed1->CurrLedState = RTW_LED_OFF;
2515
2516 if (pLed1->bLedOn)
2517 _set_timer(&(pLed->BlinkTimer), 0);
2518 }
2519
2520 if (pLed->bLedStartToLinkBlinkInProgress == _FALSE) {
2521 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2522 return;
2523 if (pLed->bLedBlinkInProgress == _TRUE) {
2524 _cancel_timer_ex(&(pLed->BlinkTimer));
2525 pLed->bLedBlinkInProgress = _FALSE;
2526 }
2527 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2528 _cancel_timer_ex(&(pLed->BlinkTimer));
2529 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2530 }
2531
2532 pLed->bLedStartToLinkBlinkInProgress = _TRUE;
2533 pLed->CurrLedState = LED_BLINK_StartToBlink;
2534 if (pLed->bLedOn) {
2535 pLed->BlinkingLedState = RTW_LED_OFF;
2536 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2537 } else {
2538 pLed->BlinkingLedState = RTW_LED_ON;
2539 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2540 }
2541 }
2542 break;
2543
2544 case LED_CTL_LINK:
2545 case LED_CTL_NO_LINK:
2546 /* LED1 settings */
2547 if (LedAction == LED_CTL_LINK) {
2548 if (pLed1->bLedWPSBlinkInProgress) {
2549 pLed1->bLedWPSBlinkInProgress = _FALSE;
2550 _cancel_timer_ex(&(pLed1->BlinkTimer));
2551
2552 pLed1->BlinkingLedState = RTW_LED_OFF;
2553 pLed1->CurrLedState = RTW_LED_OFF;
2554
2555 if (pLed1->bLedOn)
2556 _set_timer(&(pLed->BlinkTimer), 0);
2557 }
2558 }
2559
2560 if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
2561 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2562 return;
2563 if (pLed->bLedBlinkInProgress == _TRUE) {
2564 _cancel_timer_ex(&(pLed->BlinkTimer));
2565 pLed->bLedBlinkInProgress = _FALSE;
2566 }
2567
2568 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2569 pLed->CurrLedState = LED_BLINK_SLOWLY;
2570 if (pLed->bLedOn)
2571 pLed->BlinkingLedState = RTW_LED_OFF;
2572 else
2573 pLed->BlinkingLedState = RTW_LED_ON;
2574
2575 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2576 }
2577 break;
2578
2579 case LED_CTL_SITE_SURVEY:
2580 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
2581 ;
2582 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2583 if (IS_LED_WPS_BLINKING(pLed))
2584 return;
2585
2586 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2587 _cancel_timer_ex(&(pLed->BlinkTimer));
2588 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2589 }
2590 if (pLed->bLedBlinkInProgress == _TRUE) {
2591 _cancel_timer_ex(&(pLed->BlinkTimer));
2592 pLed->bLedBlinkInProgress = _FALSE;
2593 }
2594 pLed->bLedScanBlinkInProgress = _TRUE;
2595 pLed->CurrLedState = LED_BLINK_SCAN;
2596 pLed->BlinkTimes = 24;
2597 if (pLed->bLedOn)
2598 pLed->BlinkingLedState = RTW_LED_OFF;
2599 else
2600 pLed->BlinkingLedState = RTW_LED_ON;
2601 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2602 }
2603 break;
2604
2605 case LED_CTL_TX:
2606 case LED_CTL_RX:
2607 if (pLed->bLedBlinkInProgress == _FALSE) {
2608 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2609 return;
2610 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2611 _cancel_timer_ex(&(pLed->BlinkTimer));
2612 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2613 }
2614 pLed->bLedBlinkInProgress = _TRUE;
2615 pLed->CurrLedState = LED_BLINK_TXRX;
2616 pLed->BlinkTimes = 2;
2617 if (pLed->bLedOn)
2618 pLed->BlinkingLedState = RTW_LED_OFF;
2619 else
2620 pLed->BlinkingLedState = RTW_LED_ON;
2621 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2622 }
2623 break;
2624
2625 case LED_CTL_START_WPS: /* wait until xinpin finish */
2626 case LED_CTL_START_WPS_BOTTON:
2627 if (pLed1->bLedWPSBlinkInProgress) {
2628 pLed1->bLedWPSBlinkInProgress = _FALSE;
2629 _cancel_timer_ex(&(pLed1->BlinkTimer));
2630
2631 pLed1->BlinkingLedState = RTW_LED_OFF;
2632 pLed1->CurrLedState = RTW_LED_OFF;
2633
2634 if (pLed1->bLedOn)
2635 _set_timer(&(pLed->BlinkTimer), 0);
2636 }
2637
2638 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2639 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2640 _cancel_timer_ex(&(pLed->BlinkTimer));
2641 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2642 }
2643 if (pLed->bLedBlinkInProgress == _TRUE) {
2644 _cancel_timer_ex(&(pLed->BlinkTimer));
2645 pLed->bLedBlinkInProgress = _FALSE;
2646 }
2647 if (pLed->bLedScanBlinkInProgress == _TRUE) {
2648 _cancel_timer_ex(&(pLed->BlinkTimer));
2649 pLed->bLedScanBlinkInProgress = _FALSE;
2650 }
2651 pLed->bLedWPSBlinkInProgress = _TRUE;
2652 pLed->CurrLedState = LED_BLINK_WPS;
2653 if (pLed->bLedOn) {
2654 pLed->BlinkingLedState = RTW_LED_OFF;
2655 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2656 } else {
2657 pLed->BlinkingLedState = RTW_LED_ON;
2658 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2659 }
2660 }
2661 break;
2662
2663 case LED_CTL_STOP_WPS: /* WPS connect success */
2664 if (pLed->bLedWPSBlinkInProgress) {
2665 _cancel_timer_ex(&(pLed->BlinkTimer));
2666 pLed->bLedWPSBlinkInProgress = _FALSE;
2667 }
2668
2669 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2670 pLed->CurrLedState = LED_BLINK_SLOWLY;
2671 if (pLed->bLedOn)
2672 pLed->BlinkingLedState = RTW_LED_OFF;
2673 else
2674 pLed->BlinkingLedState = RTW_LED_ON;
2675 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2676
2677 break;
2678
2679 case LED_CTL_STOP_WPS_FAIL: /* WPS authentication fail */
2680 if (pLed->bLedWPSBlinkInProgress) {
2681 _cancel_timer_ex(&(pLed->BlinkTimer));
2682 pLed->bLedWPSBlinkInProgress = _FALSE;
2683 }
2684
2685 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2686 pLed->CurrLedState = LED_BLINK_SLOWLY;
2687 if (pLed->bLedOn)
2688 pLed->BlinkingLedState = RTW_LED_OFF;
2689 else
2690 pLed->BlinkingLedState = RTW_LED_ON;
2691 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2692
2693 /* LED1 settings */
2694 if (pLed1->bLedWPSBlinkInProgress)
2695 _cancel_timer_ex(&(pLed1->BlinkTimer));
2696 else
2697 pLed1->bLedWPSBlinkInProgress = _TRUE;
2698
2699 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
2700 if (pLed1->bLedOn)
2701 pLed1->BlinkingLedState = RTW_LED_OFF;
2702 else
2703 pLed1->BlinkingLedState = RTW_LED_ON;
2704 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2705
2706 break;
2707
2708 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
2709 if (pLed->bLedWPSBlinkInProgress) {
2710 _cancel_timer_ex(&(pLed->BlinkTimer));
2711 pLed->bLedWPSBlinkInProgress = _FALSE;
2712 }
2713
2714 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2715 pLed->CurrLedState = LED_BLINK_SLOWLY;
2716 if (pLed->bLedOn)
2717 pLed->BlinkingLedState = RTW_LED_OFF;
2718 else
2719 pLed->BlinkingLedState = RTW_LED_ON;
2720 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2721
2722 /* LED1 settings */
2723 if (pLed1->bLedWPSBlinkInProgress)
2724 _cancel_timer_ex(&(pLed1->BlinkTimer));
2725 else
2726 pLed1->bLedWPSBlinkInProgress = _TRUE;
2727
2728 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
2729 pLed1->BlinkTimes = 10;
2730 if (pLed1->bLedOn)
2731 pLed1->BlinkingLedState = RTW_LED_OFF;
2732 else
2733 pLed1->BlinkingLedState = RTW_LED_ON;
2734 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2735
2736 break;
2737
2738 case LED_CTL_POWER_OFF:
2739 pLed->CurrLedState = RTW_LED_OFF;
2740 pLed->BlinkingLedState = RTW_LED_OFF;
2741
2742 if (pLed->bLedNoLinkBlinkInProgress) {
2743 _cancel_timer_ex(&(pLed->BlinkTimer));
2744 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2745 }
2746 if (pLed->bLedLinkBlinkInProgress) {
2747 _cancel_timer_ex(&(pLed->BlinkTimer));
2748 pLed->bLedLinkBlinkInProgress = _FALSE;
2749 }
2750 if (pLed->bLedBlinkInProgress) {
2751 _cancel_timer_ex(&(pLed->BlinkTimer));
2752 pLed->bLedBlinkInProgress = _FALSE;
2753 }
2754 if (pLed->bLedWPSBlinkInProgress) {
2755 _cancel_timer_ex(&(pLed->BlinkTimer));
2756 pLed->bLedWPSBlinkInProgress = _FALSE;
2757 }
2758 if (pLed->bLedScanBlinkInProgress) {
2759 _cancel_timer_ex(&(pLed->BlinkTimer));
2760 pLed->bLedScanBlinkInProgress = _FALSE;
2761 }
2762 if (pLed->bLedStartToLinkBlinkInProgress) {
2763 _cancel_timer_ex(&(pLed->BlinkTimer));
2764 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
2765 }
2766
2767 if (pLed1->bLedWPSBlinkInProgress) {
2768 _cancel_timer_ex(&(pLed1->BlinkTimer));
2769 pLed1->bLedWPSBlinkInProgress = _FALSE;
2770 }
2771
2772 pLed1->BlinkingLedState = LED_UNKNOWN;
2773 SwLedOff(padapter, pLed);
2774 SwLedOff(padapter, pLed1);
2775 break;
2776
2777 case LED_CTL_CONNECTION_NO_TRANSFER:
2778 if (pLed->bLedBlinkInProgress == _FALSE) {
2779 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2780 _cancel_timer_ex(&(pLed->BlinkTimer));
2781 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2782 }
2783 pLed->bLedBlinkInProgress = _TRUE;
2784
2785 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
2786 pLed->BlinkingLedState = RTW_LED_ON;
2787 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2788 }
2789 break;
2790
2791 default:
2792 break;
2793
2794 }
2795
2796 }
2797
2798
2799
2800 /* Sercomm-Belkin, added by chiyoko, 20090415 */
2801 static void
SwLedControlMode5(_adapter * padapter,LED_CTL_MODE LedAction)2802 SwLedControlMode5(
2803 _adapter *padapter,
2804 LED_CTL_MODE LedAction
2805 )
2806 {
2807 struct led_priv *ledpriv = adapter_to_led(padapter);
2808 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2809 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
2810 PLED_USB pLed = &(ledpriv->SwLed0);
2811
2812 if (pHalData->CustomerID == RT_CID_819x_CAMEO)
2813 pLed = &(ledpriv->SwLed1);
2814
2815 switch (LedAction) {
2816 case LED_CTL_POWER_ON:
2817 case LED_CTL_NO_LINK:
2818 case LED_CTL_LINK: /* solid blue */
2819 pLed->CurrLedState = RTW_LED_ON;
2820 pLed->BlinkingLedState = RTW_LED_ON;
2821
2822 _set_timer(&(pLed->BlinkTimer), 0);
2823 break;
2824
2825 case LED_CTL_SITE_SURVEY:
2826 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
2827 ;
2828 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2829 if (pLed->bLedBlinkInProgress == _TRUE) {
2830 _cancel_timer_ex(&(pLed->BlinkTimer));
2831 pLed->bLedBlinkInProgress = _FALSE;
2832 }
2833 pLed->bLedScanBlinkInProgress = _TRUE;
2834 pLed->CurrLedState = LED_BLINK_SCAN;
2835 pLed->BlinkTimes = 24;
2836 if (pLed->bLedOn)
2837 pLed->BlinkingLedState = RTW_LED_OFF;
2838 else
2839 pLed->BlinkingLedState = RTW_LED_ON;
2840 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2841 }
2842 break;
2843
2844 case LED_CTL_TX:
2845 case LED_CTL_RX:
2846 if (pLed->bLedBlinkInProgress == _FALSE) {
2847 if (pLed->CurrLedState == LED_BLINK_SCAN)
2848 return;
2849 pLed->bLedBlinkInProgress = _TRUE;
2850 pLed->CurrLedState = LED_BLINK_TXRX;
2851 pLed->BlinkTimes = 2;
2852 if (pLed->bLedOn)
2853 pLed->BlinkingLedState = RTW_LED_OFF;
2854 else
2855 pLed->BlinkingLedState = RTW_LED_ON;
2856 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2857 }
2858 break;
2859
2860 case LED_CTL_POWER_OFF:
2861 pLed->CurrLedState = RTW_LED_OFF;
2862 pLed->BlinkingLedState = RTW_LED_OFF;
2863
2864 if (pLed->bLedBlinkInProgress) {
2865 _cancel_timer_ex(&(pLed->BlinkTimer));
2866 pLed->bLedBlinkInProgress = _FALSE;
2867 }
2868
2869 SwLedOff(padapter, pLed);
2870 break;
2871
2872 default:
2873 break;
2874
2875 }
2876
2877 }
2878
2879 /* WNC-Corega, added by chiyoko, 20090902 */
2880 static void
SwLedControlMode6(_adapter * padapter,LED_CTL_MODE LedAction)2881 SwLedControlMode6(
2882 _adapter *padapter,
2883 LED_CTL_MODE LedAction
2884 )
2885 {
2886 struct led_priv *ledpriv = adapter_to_led(padapter);
2887 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2888 PLED_USB pLed0 = &(ledpriv->SwLed0);
2889
2890 switch (LedAction) {
2891 case LED_CTL_POWER_ON:
2892 case LED_CTL_LINK:
2893 case LED_CTL_NO_LINK:
2894 _cancel_timer_ex(&(pLed0->BlinkTimer));
2895 pLed0->CurrLedState = RTW_LED_ON;
2896 pLed0->BlinkingLedState = RTW_LED_ON;
2897 _set_timer(&(pLed0->BlinkTimer), 0);
2898 break;
2899
2900 case LED_CTL_POWER_OFF:
2901 SwLedOff(padapter, pLed0);
2902 break;
2903
2904 default:
2905 break;
2906 }
2907
2908 }
2909
2910 /* Netgear, added by sinda, 2011/11/11 */
2911 void
SwLedControlMode7(PADAPTER Adapter,LED_CTL_MODE LedAction)2912 SwLedControlMode7(
2913 PADAPTER Adapter,
2914 LED_CTL_MODE LedAction
2915 )
2916 {
2917 struct led_priv *ledpriv = adapter_to_led(Adapter);
2918 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
2919 PLED_USB pLed = &(ledpriv->SwLed0);
2920
2921 switch (LedAction) {
2922 case LED_CTL_SITE_SURVEY:
2923 if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
2924 ;
2925 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2926 if (IS_LED_WPS_BLINKING(pLed))
2927 return;
2928
2929 if (pLed->bLedBlinkInProgress == _TRUE) {
2930 _cancel_timer_ex(&(pLed->BlinkTimer));
2931 pLed->bLedBlinkInProgress = _FALSE;
2932 }
2933 pLed->bLedScanBlinkInProgress = _TRUE;
2934 pLed->CurrLedState = LED_BLINK_SCAN;
2935 pLed->BlinkTimes = 6;
2936 if (pLed->bLedOn)
2937 pLed->BlinkingLedState = RTW_LED_OFF;
2938 else
2939 pLed->BlinkingLedState = RTW_LED_ON;
2940 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
2941 }
2942 break;
2943
2944 case LED_CTL_LINK:
2945 if (IS_LED_WPS_BLINKING(pLed))
2946 return;
2947
2948 pLed->CurrLedState = RTW_LED_ON;
2949 pLed->BlinkingLedState = RTW_LED_ON;
2950 if (pLed->bLedBlinkInProgress) {
2951 _cancel_timer_ex(&(pLed->BlinkTimer));
2952 pLed->bLedBlinkInProgress = _FALSE;
2953 }
2954 if (pLed->bLedScanBlinkInProgress) {
2955 _cancel_timer_ex(&(pLed->BlinkTimer));
2956 pLed->bLedScanBlinkInProgress = _FALSE;
2957 }
2958
2959 _set_timer(&(pLed->BlinkTimer), 0);
2960 break;
2961
2962 case LED_CTL_START_WPS: /* wait until xinpin finish */
2963 case LED_CTL_START_WPS_BOTTON:
2964 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2965 if (pLed->bLedBlinkInProgress == _TRUE) {
2966 _cancel_timer_ex(&(pLed->BlinkTimer));
2967 pLed->bLedBlinkInProgress = _FALSE;
2968 }
2969 if (pLed->bLedScanBlinkInProgress == _TRUE) {
2970 _cancel_timer_ex(&(pLed->BlinkTimer));
2971 pLed->bLedScanBlinkInProgress = _FALSE;
2972 }
2973 pLed->bLedWPSBlinkInProgress = _TRUE;
2974 pLed->CurrLedState = LED_BLINK_WPS;
2975 if (pLed->bLedOn)
2976 pLed->BlinkingLedState = RTW_LED_OFF;
2977 else
2978 pLed->BlinkingLedState = RTW_LED_ON;
2979 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
2980 }
2981 break;
2982
2983 case LED_CTL_STOP_WPS:
2984 if (pLed->bLedWPSBlinkInProgress) {
2985 _cancel_timer_ex(&(pLed->BlinkTimer));
2986 pLed->bLedWPSBlinkInProgress = _FALSE;
2987 } else
2988 pLed->bLedWPSBlinkInProgress = _TRUE;
2989
2990 pLed->CurrLedState = LED_BLINK_WPS_STOP;
2991 if (pLed->bLedOn) {
2992 pLed->BlinkingLedState = RTW_LED_OFF;
2993 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
2994 } else {
2995 pLed->BlinkingLedState = RTW_LED_ON;
2996 _set_timer(&(pLed->BlinkTimer), 0);
2997 }
2998
2999 break;
3000
3001
3002 case LED_CTL_STOP_WPS_FAIL:
3003 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
3004 if (pLed->bLedWPSBlinkInProgress) {
3005 _cancel_timer_ex(&(pLed->BlinkTimer));
3006 pLed->bLedWPSBlinkInProgress = _FALSE;
3007 }
3008
3009 pLed->CurrLedState = RTW_LED_OFF;
3010 pLed->BlinkingLedState = RTW_LED_OFF;
3011 _set_timer(&(pLed->BlinkTimer), 0);
3012 break;
3013
3014 case LED_CTL_START_TO_LINK:
3015 case LED_CTL_NO_LINK:
3016 if (!IS_LED_BLINKING(pLed)) {
3017 pLed->CurrLedState = RTW_LED_OFF;
3018 pLed->BlinkingLedState = RTW_LED_OFF;
3019 _set_timer(&(pLed->BlinkTimer), 0);
3020 }
3021 break;
3022
3023 case LED_CTL_POWER_OFF:
3024 case LED_CTL_POWER_ON:
3025 pLed->CurrLedState = RTW_LED_OFF;
3026 pLed->BlinkingLedState = RTW_LED_OFF;
3027 if (pLed->bLedBlinkInProgress) {
3028 _cancel_timer_ex(&(pLed->BlinkTimer));
3029 pLed->bLedBlinkInProgress = _FALSE;
3030 }
3031 if (pLed->bLedScanBlinkInProgress) {
3032 _cancel_timer_ex(&(pLed->BlinkTimer));
3033 pLed->bLedScanBlinkInProgress = _FALSE;
3034 }
3035 if (pLed->bLedWPSBlinkInProgress) {
3036 _cancel_timer_ex(&(pLed->BlinkTimer));
3037 pLed->bLedWPSBlinkInProgress = _FALSE;
3038 }
3039
3040 _set_timer(&(pLed->BlinkTimer), 0);
3041 break;
3042
3043 default:
3044 break;
3045
3046 }
3047
3048 }
3049
3050 void
SwLedControlMode8(PADAPTER Adapter,LED_CTL_MODE LedAction)3051 SwLedControlMode8(
3052 PADAPTER Adapter,
3053 LED_CTL_MODE LedAction
3054 )
3055 {
3056 struct led_priv *ledpriv = adapter_to_led(Adapter);
3057 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3058 PLED_USB pLed0 = &(ledpriv->SwLed0);
3059
3060 switch (LedAction) {
3061 case LED_CTL_LINK:
3062 _cancel_timer_ex(&(pLed0->BlinkTimer));
3063 pLed0->CurrLedState = RTW_LED_ON;
3064 pLed0->BlinkingLedState = RTW_LED_ON;
3065 _set_timer(&(pLed0->BlinkTimer), 0);
3066 break;
3067
3068 case LED_CTL_NO_LINK:
3069 _cancel_timer_ex(&(pLed0->BlinkTimer));
3070 pLed0->CurrLedState = RTW_LED_OFF;
3071 pLed0->BlinkingLedState = RTW_LED_OFF;
3072 _set_timer(&(pLed0->BlinkTimer), 0);
3073 break;
3074
3075 case LED_CTL_POWER_OFF:
3076 SwLedOff(Adapter, pLed0);
3077 break;
3078
3079 default:
3080 break;
3081 }
3082
3083
3084 }
3085
3086 /* page added for Belkin AC950, 20120813 */
3087 void
SwLedControlMode9(PADAPTER Adapter,LED_CTL_MODE LedAction)3088 SwLedControlMode9(
3089 PADAPTER Adapter,
3090 LED_CTL_MODE LedAction
3091 )
3092 {
3093 struct led_priv *ledpriv = adapter_to_led(Adapter);
3094 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3095 PLED_USB pLed = &(ledpriv->SwLed0);
3096 PLED_USB pLed1 = &(ledpriv->SwLed1);
3097 PLED_USB pLed2 = &(ledpriv->SwLed2);
3098 BOOLEAN bWPSOverLap = _FALSE;
3099 /* RTW_INFO("LedAction=%d\n", LedAction); */
3100 switch (LedAction) {
3101 case LED_CTL_START_TO_LINK:
3102 if (pLed2->bLedBlinkInProgress == _FALSE) {
3103 pLed2->bLedBlinkInProgress = _TRUE;
3104 pLed2->BlinkingLedState = RTW_LED_ON;
3105 pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3106
3107 _set_timer(&(pLed2->BlinkTimer), 0);
3108 }
3109 break;
3110
3111 case LED_CTL_LINK:
3112 case LED_CTL_NO_LINK:
3113 /* LED1 settings */
3114 if (LedAction == LED_CTL_NO_LINK) {
3115 /* if(pMgntInfo->AuthStatus == AUTH_STATUS_FAILED) */
3116 if (0) {
3117 pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;
3118 if (pLed1->bLedOn)
3119 pLed1->BlinkingLedState = RTW_LED_OFF;
3120 else
3121 pLed1->BlinkingLedState = RTW_LED_ON;
3122 _set_timer(&(pLed1->BlinkTimer), 0);
3123 } else {
3124 pLed1->CurrLedState = RTW_LED_OFF;
3125 pLed1->BlinkingLedState = RTW_LED_OFF;
3126 if (pLed1->bLedOn)
3127 _set_timer(&(pLed1->BlinkTimer), 0);
3128 }
3129 } else {
3130 pLed1->CurrLedState = RTW_LED_OFF;
3131 pLed1->BlinkingLedState = RTW_LED_OFF;
3132 if (pLed1->bLedOn)
3133 _set_timer(&(pLed1->BlinkTimer), 0);
3134 }
3135
3136 /* LED2 settings */
3137 if (LedAction == LED_CTL_LINK) {
3138 if (Adapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_) {
3139 if (pLed2->bLedBlinkInProgress == _TRUE) {
3140 _cancel_timer_ex(&(pLed2->BlinkTimer));
3141 pLed2->bLedBlinkInProgress = _FALSE;
3142 }
3143 pLed2->CurrLedState = RTW_LED_ON;
3144 pLed2->bLedNoLinkBlinkInProgress = _TRUE;
3145 if (!pLed2->bLedOn)
3146 _set_timer(&(pLed2->BlinkTimer), 0);
3147 } else {
3148 if (pLed2->bLedWPSBlinkInProgress != _TRUE) {
3149 pLed2->CurrLedState = RTW_LED_OFF;
3150 pLed2->BlinkingLedState = RTW_LED_OFF;
3151 if (pLed2->bLedOn)
3152 _set_timer(&(pLed2->BlinkTimer), 0);
3153 }
3154 }
3155 } else { /* NO_LINK */
3156 if (pLed2->bLedWPSBlinkInProgress == _FALSE) {
3157 pLed2->CurrLedState = RTW_LED_OFF;
3158 pLed2->BlinkingLedState = RTW_LED_OFF;
3159 if (pLed2->bLedOn)
3160 _set_timer(&(pLed2->BlinkTimer), 0);
3161 }
3162 }
3163
3164 /* LED0 settings */
3165 if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
3166 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3167 return;
3168 if (pLed->bLedBlinkInProgress == _TRUE) {
3169 _cancel_timer_ex(&(pLed->BlinkTimer));
3170 pLed->bLedBlinkInProgress = _FALSE;
3171 }
3172
3173 pLed->bLedNoLinkBlinkInProgress = _TRUE;
3174 if (IS_HARDWARE_TYPE_8812AU(Adapter)) {
3175 if (LedAction == LED_CTL_LINK) {
3176 pLed->BlinkingLedState = RTW_LED_ON;
3177 pLed->CurrLedState = LED_BLINK_SLOWLY;
3178 } else {
3179 pLed->CurrLedState = LED_BLINK_SLOWLY;
3180 if (pLed->bLedOn)
3181 pLed->BlinkingLedState = RTW_LED_OFF;
3182 else
3183 pLed->BlinkingLedState = RTW_LED_ON;
3184 }
3185 } else {
3186 pLed->CurrLedState = LED_BLINK_SLOWLY;
3187 if (pLed->bLedOn)
3188 pLed->BlinkingLedState = RTW_LED_OFF;
3189 else
3190 pLed->BlinkingLedState = RTW_LED_ON;
3191 }
3192 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3193 }
3194
3195 break;
3196
3197 case LED_CTL_SITE_SURVEY:
3198 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
3199 ;
3200 else { /* if(pLed->bLedScanBlinkInProgress ==FALSE) */
3201 if (IS_LED_WPS_BLINKING(pLed))
3202 return;
3203
3204 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3205 _cancel_timer_ex(&(pLed->BlinkTimer));
3206 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3207 }
3208 if (pLed->bLedBlinkInProgress == _TRUE) {
3209 _cancel_timer_ex(&(pLed->BlinkTimer));
3210 pLed->bLedBlinkInProgress = _FALSE;
3211 }
3212 pLed->bLedScanBlinkInProgress = _TRUE;
3213 pLed->CurrLedState = LED_BLINK_SCAN;
3214 pLed->BlinkTimes = 24;
3215 if (pLed->bLedOn)
3216 pLed->BlinkingLedState = RTW_LED_OFF;
3217 else
3218 pLed->BlinkingLedState = RTW_LED_ON;
3219 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3220
3221 }
3222 break;
3223
3224 case LED_CTL_TX:
3225 case LED_CTL_RX:
3226 if (pLed->bLedBlinkInProgress == _FALSE) {
3227 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3228 return;
3229 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3230 _cancel_timer_ex(&(pLed->BlinkTimer));
3231 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3232 }
3233 pLed->bLedBlinkInProgress = _TRUE;
3234 pLed->CurrLedState = LED_BLINK_TXRX;
3235 pLed->BlinkTimes = 2;
3236 if (pLed->bLedOn)
3237 pLed->BlinkingLedState = RTW_LED_OFF;
3238 else
3239 pLed->BlinkingLedState = RTW_LED_ON;
3240 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3241 }
3242 break;
3243
3244 case LED_CTL_START_WPS: /* wait until xinpin finish */
3245 case LED_CTL_START_WPS_BOTTON:
3246 pLed2->bLedBlinkInProgress = _TRUE;
3247 pLed2->BlinkingLedState = RTW_LED_ON;
3248 pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3249 pLed2->bLedWPSBlinkInProgress = _TRUE;
3250
3251 _set_timer(&(pLed2->BlinkTimer), 500);
3252
3253 break;
3254
3255 case LED_CTL_STOP_WPS: /* WPS connect success */
3256 /* LED2 settings */
3257 if (pLed2->bLedWPSBlinkInProgress == _TRUE) {
3258 _cancel_timer_ex(&(pLed2->BlinkTimer));
3259 pLed2->bLedBlinkInProgress = _FALSE;
3260 pLed2->bLedWPSBlinkInProgress = _FALSE;
3261 }
3262 pLed2->CurrLedState = RTW_LED_ON;
3263 pLed2->bLedNoLinkBlinkInProgress = _TRUE;
3264 if (!pLed2->bLedOn)
3265 _set_timer(&(pLed2->BlinkTimer), 0);
3266
3267 /* LED1 settings */
3268 _cancel_timer_ex(&(pLed1->BlinkTimer));
3269 pLed1->CurrLedState = RTW_LED_OFF;
3270 pLed1->BlinkingLedState = RTW_LED_OFF;
3271 if (pLed1->bLedOn)
3272 _set_timer(&(pLed1->BlinkTimer), 0);
3273
3274
3275 break;
3276
3277 case LED_CTL_STOP_WPS_FAIL: /* WPS authentication fail */
3278 /* LED1 settings */
3279 /* if(bWPSOverLap == _FALSE) */
3280 {
3281 pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;
3282 pLed1->BlinkTimes = 50;
3283 if (pLed1->bLedOn)
3284 pLed1->BlinkingLedState = RTW_LED_OFF;
3285 else
3286 pLed1->BlinkingLedState = RTW_LED_ON;
3287 _set_timer(&(pLed1->BlinkTimer), 0);
3288 }
3289 /* else */
3290 /* { */
3291 /* bWPSOverLap = _FALSE; */
3292 /* pLed1->CurrLedState = RTW_LED_OFF; */
3293 /* pLed1->BlinkingLedState = RTW_LED_OFF; */
3294 /* _set_timer(&(pLed1->BlinkTimer), 0); */
3295 /* } */
3296
3297 /* LED2 settings */
3298 pLed2->CurrLedState = RTW_LED_OFF;
3299 pLed2->BlinkingLedState = RTW_LED_OFF;
3300 pLed2->bLedWPSBlinkInProgress = _FALSE;
3301 if (pLed2->bLedOn)
3302 _set_timer(&(pLed2->BlinkTimer), 0);
3303
3304 break;
3305
3306 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
3307 /* LED1 settings */
3308 bWPSOverLap = _TRUE;
3309 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
3310 pLed1->BlinkTimes = 10;
3311 pLed1->BlinkCounter = 50;
3312 if (pLed1->bLedOn)
3313 pLed1->BlinkingLedState = RTW_LED_OFF;
3314 else
3315 pLed1->BlinkingLedState = RTW_LED_ON;
3316 _set_timer(&(pLed1->BlinkTimer), 0);
3317
3318 /* LED2 settings */
3319 pLed2->CurrLedState = RTW_LED_OFF;
3320 pLed2->BlinkingLedState = RTW_LED_OFF;
3321 pLed2->bLedWPSBlinkInProgress = _FALSE;
3322 if (pLed2->bLedOn)
3323 _set_timer(&(pLed2->BlinkTimer), 0);
3324
3325 break;
3326
3327 case LED_CTL_POWER_OFF:
3328 pLed->CurrLedState = RTW_LED_OFF;
3329 pLed->BlinkingLedState = RTW_LED_OFF;
3330
3331 if (pLed->bLedNoLinkBlinkInProgress) {
3332 _cancel_timer_ex(&(pLed->BlinkTimer));
3333 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3334 }
3335 if (pLed->bLedLinkBlinkInProgress) {
3336 _cancel_timer_ex(&(pLed->BlinkTimer));
3337 pLed->bLedLinkBlinkInProgress = _FALSE;
3338 }
3339 if (pLed->bLedBlinkInProgress) {
3340 _cancel_timer_ex(&(pLed->BlinkTimer));
3341 pLed->bLedBlinkInProgress = _FALSE;
3342 }
3343 if (pLed->bLedWPSBlinkInProgress) {
3344 _cancel_timer_ex(&(pLed->BlinkTimer));
3345 pLed->bLedWPSBlinkInProgress = _FALSE;
3346 }
3347 if (pLed->bLedScanBlinkInProgress) {
3348 _cancel_timer_ex(&(pLed->BlinkTimer));
3349 pLed->bLedScanBlinkInProgress = _FALSE;
3350 }
3351 if (pLed->bLedStartToLinkBlinkInProgress) {
3352 _cancel_timer_ex(&(pLed->BlinkTimer));
3353 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
3354 }
3355
3356 if (pLed1->bLedWPSBlinkInProgress) {
3357 _cancel_timer_ex(&(pLed1->BlinkTimer));
3358 pLed1->bLedWPSBlinkInProgress = _FALSE;
3359 }
3360
3361
3362 pLed1->BlinkingLedState = LED_UNKNOWN;
3363 SwLedOff(Adapter, pLed);
3364 SwLedOff(Adapter, pLed1);
3365 break;
3366
3367 case LED_CTL_CONNECTION_NO_TRANSFER:
3368 if (pLed->bLedBlinkInProgress == _FALSE) {
3369 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3370 _cancel_timer_ex(&(pLed->BlinkTimer));
3371 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3372 }
3373 pLed->bLedBlinkInProgress = _TRUE;
3374
3375 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
3376 pLed->BlinkingLedState = RTW_LED_ON;
3377 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3378 }
3379 break;
3380
3381 default:
3382 break;
3383
3384 }
3385
3386 }
3387
3388 /* page added for Netgear A6200V2, 20120827 */
3389 void
SwLedControlMode10(PADAPTER Adapter,LED_CTL_MODE LedAction)3390 SwLedControlMode10(
3391 PADAPTER Adapter,
3392 LED_CTL_MODE LedAction
3393 )
3394 {
3395 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
3396 struct led_priv *ledpriv = adapter_to_led(Adapter);
3397 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3398 PLED_USB pLed = &(ledpriv->SwLed0);
3399 PLED_USB pLed1 = &(ledpriv->SwLed1);
3400
3401 switch (LedAction) {
3402 case LED_CTL_START_TO_LINK:
3403 if (pLed1->bLedBlinkInProgress == _FALSE) {
3404 pLed1->bLedBlinkInProgress = _TRUE;
3405 pLed1->BlinkingLedState = RTW_LED_ON;
3406 pLed1->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3407
3408 _set_timer(&(pLed1->BlinkTimer), 0);
3409 }
3410 break;
3411
3412 case LED_CTL_LINK:
3413 case LED_CTL_NO_LINK:
3414 if (LedAction == LED_CTL_LINK) {
3415 if (pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)
3416 ;
3417 else {
3418 if (pHalData->current_band_type == BAND_ON_2_4G)
3419 /* LED0 settings */
3420 {
3421 pLed->CurrLedState = RTW_LED_ON;
3422 pLed->BlinkingLedState = RTW_LED_ON;
3423 if (pLed->bLedBlinkInProgress == _TRUE) {
3424 _cancel_timer_ex(&(pLed->BlinkTimer));
3425 pLed->bLedBlinkInProgress = _FALSE;
3426 }
3427 _set_timer(&(pLed->BlinkTimer), 0);
3428
3429 pLed1->CurrLedState = RTW_LED_OFF;
3430 pLed1->BlinkingLedState = RTW_LED_OFF;
3431 _set_timer(&(pLed1->BlinkTimer), 0);
3432 } else if (pHalData->current_band_type == BAND_ON_5G)
3433 /* LED1 settings */
3434 {
3435 pLed1->CurrLedState = RTW_LED_ON;
3436 pLed1->BlinkingLedState = RTW_LED_ON;
3437 if (pLed1->bLedBlinkInProgress == _TRUE) {
3438 _cancel_timer_ex(&(pLed1->BlinkTimer));
3439 pLed1->bLedBlinkInProgress = _FALSE;
3440 }
3441 _set_timer(&(pLed1->BlinkTimer), 0);
3442
3443 pLed->CurrLedState = RTW_LED_OFF;
3444 pLed->BlinkingLedState = RTW_LED_OFF;
3445 _set_timer(&(pLed->BlinkTimer), 0);
3446 }
3447 }
3448 } else if (LedAction == LED_CTL_NO_LINK) { /* TODO by page */
3449 if (pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)
3450 ;
3451 else {
3452 pLed->CurrLedState = RTW_LED_OFF;
3453 pLed->BlinkingLedState = RTW_LED_OFF;
3454 if (pLed->bLedOn)
3455 _set_timer(&(pLed->BlinkTimer), 0);
3456
3457 pLed1->CurrLedState = RTW_LED_OFF;
3458 pLed1->BlinkingLedState = RTW_LED_OFF;
3459 if (pLed1->bLedOn)
3460 _set_timer(&(pLed1->BlinkTimer), 0);
3461 }
3462 }
3463
3464 break;
3465
3466 case LED_CTL_SITE_SURVEY:
3467 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
3468 ; /* don't blink when media connect */
3469 else { /* if(pLed->bLedScanBlinkInProgress ==FALSE) */
3470 if (IS_LED_WPS_BLINKING(pLed) || IS_LED_WPS_BLINKING(pLed1))
3471 return;
3472
3473 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3474 _cancel_timer_ex(&(pLed->BlinkTimer));
3475 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3476 }
3477 if (pLed->bLedBlinkInProgress == _TRUE) {
3478 _cancel_timer_ex(&(pLed->BlinkTimer));
3479 pLed->bLedBlinkInProgress = _FALSE;
3480 }
3481 pLed->bLedScanBlinkInProgress = _TRUE;
3482 pLed->CurrLedState = LED_BLINK_SCAN;
3483 pLed->BlinkTimes = 12;
3484 pLed->BlinkingLedState = LED_BLINK_SCAN;
3485 _set_timer(&(pLed->BlinkTimer), 0);
3486
3487 if (pLed1->bLedNoLinkBlinkInProgress == _TRUE) {
3488 _cancel_timer_ex(&(pLed1->BlinkTimer));
3489 pLed1->bLedNoLinkBlinkInProgress = _FALSE;
3490 }
3491 if (pLed1->bLedBlinkInProgress == _TRUE) {
3492 _cancel_timer_ex(&(pLed1->BlinkTimer));
3493 pLed1->bLedBlinkInProgress = _FALSE;
3494 }
3495 pLed1->bLedScanBlinkInProgress = _TRUE;
3496 pLed1->CurrLedState = LED_BLINK_SCAN;
3497 pLed1->BlinkTimes = 12;
3498 pLed1->BlinkingLedState = LED_BLINK_SCAN;
3499 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR);
3500
3501 }
3502 break;
3503
3504 case LED_CTL_START_WPS: /* wait until xinpin finish */
3505 case LED_CTL_START_WPS_BOTTON:
3506 /* LED0 settings */
3507 if (pLed->bLedBlinkInProgress == _FALSE) {
3508 pLed->bLedBlinkInProgress = _TRUE;
3509 pLed->bLedWPSBlinkInProgress = _TRUE;
3510 pLed->BlinkingLedState = LED_BLINK_WPS;
3511 pLed->CurrLedState = LED_BLINK_WPS;
3512 _set_timer(&(pLed->BlinkTimer), 0);
3513 }
3514
3515 /* LED1 settings */
3516 if (pLed1->bLedBlinkInProgress == _FALSE) {
3517 pLed1->bLedBlinkInProgress = _TRUE;
3518 pLed1->bLedWPSBlinkInProgress = _TRUE;
3519 pLed1->BlinkingLedState = LED_BLINK_WPS;
3520 pLed1->CurrLedState = LED_BLINK_WPS;
3521 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL + LED_BLINK_LINK_INTERVAL_NETGEAR);
3522 }
3523
3524
3525 break;
3526
3527 case LED_CTL_STOP_WPS: /* WPS connect success */
3528 if (pHalData->current_band_type == BAND_ON_2_4G)
3529 /* LED0 settings */
3530 {
3531 pLed->bLedWPSBlinkInProgress = _FALSE;
3532 pLed->CurrLedState = RTW_LED_ON;
3533 pLed->BlinkingLedState = RTW_LED_ON;
3534 if (pLed->bLedBlinkInProgress == _TRUE) {
3535 _cancel_timer_ex(&(pLed->BlinkTimer));
3536 pLed->bLedBlinkInProgress = _FALSE;
3537 }
3538 _set_timer(&(pLed->BlinkTimer), 0);
3539
3540 pLed1->CurrLedState = RTW_LED_OFF;
3541 pLed1->BlinkingLedState = RTW_LED_OFF;
3542 _set_timer(&(pLed1->BlinkTimer), 0);
3543 } else if (pHalData->current_band_type == BAND_ON_5G)
3544 /* LED1 settings */
3545 {
3546 pLed1->bLedWPSBlinkInProgress = _FALSE;
3547 pLed1->CurrLedState = RTW_LED_ON;
3548 pLed1->BlinkingLedState = RTW_LED_ON;
3549 if (pLed1->bLedBlinkInProgress == _TRUE) {
3550 _cancel_timer_ex(&(pLed1->BlinkTimer));
3551 pLed1->bLedBlinkInProgress = _FALSE;
3552 }
3553 _set_timer(&(pLed1->BlinkTimer), 0);
3554
3555 pLed->CurrLedState = RTW_LED_OFF;
3556 pLed->BlinkingLedState = RTW_LED_OFF;
3557 _set_timer(&(pLed->BlinkTimer), 0);
3558 }
3559
3560 break;
3561
3562 case LED_CTL_STOP_WPS_FAIL: /* WPS authentication fail */
3563 /* LED1 settings */
3564 pLed1->bLedWPSBlinkInProgress = _FALSE;
3565 pLed1->CurrLedState = RTW_LED_OFF;
3566 pLed1->BlinkingLedState = RTW_LED_OFF;
3567 _set_timer(&(pLed1->BlinkTimer), 0);
3568
3569 /* LED0 settings */
3570 pLed->bLedWPSBlinkInProgress = _FALSE;
3571 pLed->CurrLedState = RTW_LED_OFF;
3572 pLed->BlinkingLedState = RTW_LED_OFF;
3573 if (pLed->bLedOn)
3574 _set_timer(&(pLed->BlinkTimer), 0);
3575
3576 break;
3577
3578
3579 default:
3580 break;
3581
3582 }
3583
3584 }
3585
3586 /* Edimax-ASUS, added by Page, 20121221 */
3587 void
SwLedControlMode11(PADAPTER Adapter,LED_CTL_MODE LedAction)3588 SwLedControlMode11(
3589 PADAPTER Adapter,
3590 LED_CTL_MODE LedAction
3591 )
3592 {
3593 struct led_priv *ledpriv = adapter_to_led(Adapter);
3594 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3595 PLED_USB pLed = &(ledpriv->SwLed0);
3596
3597 switch (LedAction) {
3598 case LED_CTL_POWER_ON:
3599 case LED_CTL_START_TO_LINK:
3600 case LED_CTL_NO_LINK:
3601 pLed->CurrLedState = RTW_LED_ON;
3602 pLed->BlinkingLedState = RTW_LED_ON;
3603 _set_timer(&(pLed->BlinkTimer), 0);
3604 break;
3605
3606 case LED_CTL_LINK:
3607 if (pLed->bLedBlinkInProgress == _TRUE) {
3608 _cancel_timer_ex(&(pLed->BlinkTimer));
3609 pLed->bLedBlinkInProgress = _FALSE;
3610 }
3611 pLed->bLedBlinkInProgress = _TRUE;
3612 pLed->CurrLedState = LED_BLINK_TXRX;
3613 if (pLed->bLedOn)
3614 pLed->BlinkingLedState = RTW_LED_OFF;
3615 else
3616 pLed->BlinkingLedState = RTW_LED_ON;
3617 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3618 break;
3619
3620 case LED_CTL_START_WPS: /* wait until xinpin finish */
3621 case LED_CTL_START_WPS_BOTTON:
3622 if (pLed->bLedBlinkInProgress == _TRUE) {
3623 _cancel_timer_ex(&(pLed->BlinkTimer));
3624 pLed->bLedBlinkInProgress = _FALSE;
3625 }
3626 pLed->bLedWPSBlinkInProgress = _TRUE;
3627 pLed->bLedBlinkInProgress = _TRUE;
3628 pLed->CurrLedState = LED_BLINK_WPS;
3629 if (pLed->bLedOn)
3630 pLed->BlinkingLedState = RTW_LED_OFF;
3631 else
3632 pLed->BlinkingLedState = RTW_LED_ON;
3633 pLed->BlinkTimes = 5;
3634 _set_timer(&(pLed->BlinkTimer), 0);
3635
3636 break;
3637
3638
3639 case LED_CTL_STOP_WPS:
3640 case LED_CTL_STOP_WPS_FAIL:
3641 if (pLed->bLedBlinkInProgress == _TRUE) {
3642 _cancel_timer_ex(&(pLed->BlinkTimer));
3643 pLed->bLedBlinkInProgress = _FALSE;
3644 }
3645 pLed->CurrLedState = LED_BLINK_WPS_STOP;
3646 _set_timer(&(pLed->BlinkTimer), 0);
3647 break;
3648
3649 case LED_CTL_POWER_OFF:
3650 pLed->CurrLedState = RTW_LED_OFF;
3651 pLed->BlinkingLedState = RTW_LED_OFF;
3652
3653 if (pLed->bLedNoLinkBlinkInProgress) {
3654 _cancel_timer_ex(&(pLed->BlinkTimer));
3655 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3656 }
3657 if (pLed->bLedLinkBlinkInProgress) {
3658 _cancel_timer_ex(&(pLed->BlinkTimer));
3659 pLed->bLedLinkBlinkInProgress = _FALSE;
3660 }
3661 if (pLed->bLedBlinkInProgress) {
3662 _cancel_timer_ex(&(pLed->BlinkTimer));
3663 pLed->bLedBlinkInProgress = _FALSE;
3664 }
3665 if (pLed->bLedWPSBlinkInProgress) {
3666 _cancel_timer_ex(&(pLed->BlinkTimer));
3667 pLed->bLedWPSBlinkInProgress = _FALSE;
3668 }
3669 if (pLed->bLedScanBlinkInProgress) {
3670 _cancel_timer_ex(&(pLed->BlinkTimer));
3671 pLed->bLedScanBlinkInProgress = _FALSE;
3672 }
3673
3674 SwLedOff(Adapter, pLed);
3675 break;
3676
3677 default:
3678 break;
3679
3680 }
3681
3682 }
3683
3684 /* page added for NEC */
3685
3686 void
SwLedControlMode12(PADAPTER Adapter,LED_CTL_MODE LedAction)3687 SwLedControlMode12(
3688 PADAPTER Adapter,
3689 LED_CTL_MODE LedAction
3690 )
3691 {
3692 struct led_priv *ledpriv = adapter_to_led(Adapter);
3693 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3694 PLED_USB pLed = &(ledpriv->SwLed0);
3695
3696 switch (LedAction) {
3697 case LED_CTL_POWER_ON:
3698 case LED_CTL_NO_LINK:
3699 case LED_CTL_LINK:
3700 case LED_CTL_SITE_SURVEY:
3701
3702 if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
3703 if (pLed->bLedBlinkInProgress == _TRUE) {
3704 _cancel_timer_ex(&(pLed->BlinkTimer));
3705 pLed->bLedBlinkInProgress = _FALSE;
3706 }
3707
3708 pLed->bLedNoLinkBlinkInProgress = _TRUE;
3709 pLed->CurrLedState = LED_BLINK_SLOWLY;
3710 if (pLed->bLedOn)
3711 pLed->BlinkingLedState = RTW_LED_OFF;
3712 else
3713 pLed->BlinkingLedState = RTW_LED_ON;
3714 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3715 }
3716 break;
3717
3718 case LED_CTL_TX:
3719 case LED_CTL_RX:
3720 if (pLed->bLedBlinkInProgress == _FALSE) {
3721 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3722 _cancel_timer_ex(&(pLed->BlinkTimer));
3723 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3724 }
3725 pLed->bLedBlinkInProgress = _TRUE;
3726 pLed->CurrLedState = LED_BLINK_TXRX;
3727 pLed->BlinkTimes = 2;
3728 if (pLed->bLedOn)
3729 pLed->BlinkingLedState = RTW_LED_OFF;
3730 else
3731 pLed->BlinkingLedState = RTW_LED_ON;
3732 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3733 }
3734 break;
3735
3736 case LED_CTL_POWER_OFF:
3737 pLed->CurrLedState = RTW_LED_OFF;
3738 pLed->BlinkingLedState = RTW_LED_OFF;
3739
3740 if (pLed->bLedBlinkInProgress) {
3741 _cancel_timer_ex(&(pLed->BlinkTimer));
3742 pLed->bLedBlinkInProgress = _FALSE;
3743 }
3744
3745 if (pLed->bLedScanBlinkInProgress) {
3746 _cancel_timer_ex(&(pLed->BlinkTimer));
3747 pLed->bLedScanBlinkInProgress = _FALSE;
3748 }
3749
3750 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3751 _cancel_timer_ex(&(pLed->BlinkTimer));
3752 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3753 }
3754
3755 SwLedOff(Adapter, pLed);
3756 break;
3757
3758 default:
3759 break;
3760
3761 }
3762
3763 }
3764
3765 /* Maddest add for NETGEAR R6100 */
3766
3767 void
SwLedControlMode13(PADAPTER Adapter,LED_CTL_MODE LedAction)3768 SwLedControlMode13(
3769 PADAPTER Adapter,
3770 LED_CTL_MODE LedAction
3771 )
3772 {
3773 struct led_priv *ledpriv = adapter_to_led(Adapter);
3774 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3775 PLED_USB pLed = &(ledpriv->SwLed0);
3776
3777 switch (LedAction) {
3778 case LED_CTL_LINK:
3779 if (pLed->bLedWPSBlinkInProgress)
3780 return;
3781
3782
3783 pLed->CurrLedState = RTW_LED_ON;
3784 pLed->BlinkingLedState = RTW_LED_ON;
3785 if (pLed->bLedBlinkInProgress) {
3786 _cancel_timer_ex(&(pLed->BlinkTimer));
3787 pLed->bLedBlinkInProgress = _FALSE;
3788 }
3789 if (pLed->bLedScanBlinkInProgress) {
3790 _cancel_timer_ex(&(pLed->BlinkTimer));
3791 pLed->bLedScanBlinkInProgress = _FALSE;
3792 }
3793
3794 _set_timer(&(pLed->BlinkTimer), 0);
3795 break;
3796
3797 case LED_CTL_START_WPS: /* wait until xinpin finish */
3798 case LED_CTL_START_WPS_BOTTON:
3799 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
3800 if (pLed->bLedBlinkInProgress == _TRUE) {
3801 _cancel_timer_ex(&(pLed->BlinkTimer));
3802 pLed->bLedBlinkInProgress = _FALSE;
3803 }
3804 if (pLed->bLedScanBlinkInProgress == _TRUE) {
3805 _cancel_timer_ex(&(pLed->BlinkTimer));
3806 pLed->bLedScanBlinkInProgress = _FALSE;
3807 }
3808 pLed->bLedWPSBlinkInProgress = _TRUE;
3809 pLed->CurrLedState = LED_BLINK_WPS;
3810 if (pLed->bLedOn) {
3811 pLed->BlinkingLedState = RTW_LED_OFF;
3812 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
3813 } else {
3814 pLed->BlinkingLedState = RTW_LED_ON;
3815 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
3816 }
3817 }
3818 break;
3819
3820 case LED_CTL_STOP_WPS:
3821 if (pLed->bLedWPSBlinkInProgress) {
3822 _cancel_timer_ex(&(pLed->BlinkTimer));
3823 pLed->bLedWPSBlinkInProgress = _FALSE;
3824 } else
3825 pLed->bLedWPSBlinkInProgress = _TRUE;
3826
3827 pLed->bLedWPSBlinkInProgress = _FALSE;
3828 pLed->CurrLedState = LED_BLINK_WPS_STOP;
3829 if (pLed->bLedOn) {
3830 pLed->BlinkingLedState = RTW_LED_OFF;
3831
3832 _set_timer(&(pLed->BlinkTimer), 0);
3833 }
3834
3835 break;
3836
3837
3838 case LED_CTL_STOP_WPS_FAIL:
3839 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
3840 if (pLed->bLedWPSBlinkInProgress) {
3841 _cancel_timer_ex(&(pLed->BlinkTimer));
3842 pLed->bLedWPSBlinkInProgress = _FALSE;
3843 }
3844
3845 pLed->CurrLedState = RTW_LED_OFF;
3846 pLed->BlinkingLedState = RTW_LED_OFF;
3847 _set_timer(&(pLed->BlinkTimer), 0);
3848 break;
3849
3850 case LED_CTL_START_TO_LINK:
3851 if ((pLed->bLedBlinkInProgress == _FALSE) && (pLed->bLedWPSBlinkInProgress == _FALSE)) {
3852 pLed->bLedBlinkInProgress = _TRUE;
3853 pLed->BlinkingLedState = RTW_LED_ON;
3854 pLed->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3855
3856 _set_timer(&(pLed->BlinkTimer), 0);
3857 }
3858 break;
3859
3860 case LED_CTL_NO_LINK:
3861
3862 if (pLed->bLedWPSBlinkInProgress)
3863 return;
3864 if (pLed->bLedBlinkInProgress) {
3865 _cancel_timer_ex(&(pLed->BlinkTimer));
3866 pLed->bLedBlinkInProgress = _FALSE;
3867 }
3868 if (pLed->bLedScanBlinkInProgress) {
3869 _cancel_timer_ex(&(pLed->BlinkTimer));
3870 pLed->bLedScanBlinkInProgress = _FALSE;
3871 }
3872 /* if(!IS_LED_BLINKING(pLed)) */
3873 {
3874 pLed->CurrLedState = RTW_LED_OFF;
3875 pLed->BlinkingLedState = RTW_LED_OFF;
3876 _set_timer(&(pLed->BlinkTimer), 0);
3877 }
3878 break;
3879
3880 case LED_CTL_POWER_OFF:
3881 case LED_CTL_POWER_ON:
3882 pLed->CurrLedState = RTW_LED_OFF;
3883 pLed->BlinkingLedState = RTW_LED_OFF;
3884 if (pLed->bLedBlinkInProgress) {
3885 _cancel_timer_ex(&(pLed->BlinkTimer));
3886 pLed->bLedBlinkInProgress = _FALSE;
3887 }
3888 if (pLed->bLedScanBlinkInProgress) {
3889 _cancel_timer_ex(&(pLed->BlinkTimer));
3890 pLed->bLedScanBlinkInProgress = _FALSE;
3891 }
3892 if (pLed->bLedWPSBlinkInProgress) {
3893 _cancel_timer_ex(&(pLed->BlinkTimer));
3894 pLed->bLedWPSBlinkInProgress = _FALSE;
3895 }
3896
3897 if (LedAction == LED_CTL_POWER_ON)
3898 _set_timer(&(pLed->BlinkTimer), 0);
3899 else
3900 SwLedOff(Adapter, pLed);
3901 break;
3902
3903 default:
3904 break;
3905
3906 }
3907
3908
3909 }
3910
3911 /* Maddest add for DNI Buffalo */
3912
3913 void
SwLedControlMode14(PADAPTER Adapter,LED_CTL_MODE LedAction)3914 SwLedControlMode14(
3915 PADAPTER Adapter,
3916 LED_CTL_MODE LedAction
3917 )
3918 {
3919 struct led_priv *ledpriv = adapter_to_led(Adapter);
3920 PLED_USB pLed = &(ledpriv->SwLed0);
3921
3922 switch (LedAction) {
3923 case LED_CTL_POWER_OFF:
3924 pLed->CurrLedState = RTW_LED_OFF;
3925 pLed->BlinkingLedState = RTW_LED_OFF;
3926 if (pLed->bLedBlinkInProgress) {
3927 _cancel_timer_ex(&(pLed->BlinkTimer));
3928 pLed->bLedBlinkInProgress = _FALSE;
3929 }
3930 SwLedOff(Adapter, pLed);
3931 break;
3932
3933 case LED_CTL_POWER_ON:
3934 SwLedOn(Adapter, pLed);
3935 break;
3936
3937 case LED_CTL_LINK:
3938 case LED_CTL_NO_LINK:
3939 if (IS_HARDWARE_TYPE_8812AU(Adapter))
3940 SwLedOn(Adapter, pLed);
3941 break;
3942
3943 case LED_CTL_TX:
3944 case LED_CTL_RX:
3945 if (pLed->bLedBlinkInProgress == _FALSE) {
3946 pLed->bLedBlinkInProgress = _TRUE;
3947 pLed->CurrLedState = LED_BLINK_TXRX;
3948 pLed->BlinkTimes = 2;
3949 if (pLed->bLedOn) {
3950 pLed->BlinkingLedState = RTW_LED_OFF;
3951 if (IS_HARDWARE_TYPE_8812AU(Adapter))
3952 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
3953 else
3954 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3955 } else {
3956 pLed->BlinkingLedState = RTW_LED_ON;
3957 if (IS_HARDWARE_TYPE_8812AU(Adapter))
3958 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
3959 else
3960 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3961 }
3962 }
3963 break;
3964
3965 default:
3966 break;
3967 }
3968 }
3969
3970 /* Maddest add for Dlink */
3971
3972 void
SwLedControlMode15(PADAPTER Adapter,LED_CTL_MODE LedAction)3973 SwLedControlMode15(
3974 PADAPTER Adapter,
3975 LED_CTL_MODE LedAction
3976 )
3977 {
3978 struct led_priv *ledpriv = adapter_to_led(Adapter);
3979 struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
3980 PLED_USB pLed = &(ledpriv->SwLed0);
3981
3982 switch (LedAction) {
3983 case LED_CTL_START_WPS: /* wait until xinpin finish */
3984 case LED_CTL_START_WPS_BOTTON:
3985 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
3986 if (pLed->bLedBlinkInProgress == _TRUE) {
3987 _cancel_timer_ex(&(pLed->BlinkTimer));
3988 pLed->bLedBlinkInProgress = _FALSE;
3989 }
3990 if (pLed->bLedScanBlinkInProgress == _TRUE) {
3991 _cancel_timer_ex(&(pLed->BlinkTimer));
3992 pLed->bLedScanBlinkInProgress = _FALSE;
3993 }
3994 pLed->bLedWPSBlinkInProgress = _TRUE;
3995 pLed->CurrLedState = LED_BLINK_WPS;
3996 if (pLed->bLedOn) {
3997 pLed->BlinkingLedState = RTW_LED_OFF;
3998 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
3999 } else {
4000 pLed->BlinkingLedState = RTW_LED_ON;
4001 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
4002 }
4003 }
4004 break;
4005
4006 case LED_CTL_STOP_WPS:
4007 if (pLed->bLedWPSBlinkInProgress)
4008 _cancel_timer_ex(&(pLed->BlinkTimer));
4009
4010 pLed->CurrLedState = LED_BLINK_WPS_STOP;
4011 /* if(check_fwstate(pmlmepriv, WIFI_ASOC_STATE)== _TRUE) */
4012 {
4013 pLed->BlinkingLedState = RTW_LED_ON;
4014
4015 _set_timer(&(pLed->BlinkTimer), 0);
4016 }
4017
4018 break;
4019
4020 case LED_CTL_STOP_WPS_FAIL:
4021 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
4022 if (pLed->bLedWPSBlinkInProgress) {
4023 _cancel_timer_ex(&(pLed->BlinkTimer));
4024 pLed->bLedWPSBlinkInProgress = _FALSE;
4025 }
4026
4027 pLed->CurrLedState = RTW_LED_OFF;
4028 pLed->BlinkingLedState = RTW_LED_OFF;
4029 _set_timer(&(pLed->BlinkTimer), 0);
4030 break;
4031
4032 case LED_CTL_NO_LINK:
4033 if (pLed->bLedWPSBlinkInProgress)
4034 return;
4035
4036 /*if(Adapter->securitypriv.dot11PrivacyAlgrthm > _NO_PRIVACY_)
4037 {
4038 if(SecIsTxKeyInstalled(Adapter, pMgntInfo->Bssid))
4039 {
4040 }
4041 else
4042 {
4043 if(pMgntInfo->LEDAssocState ==LED_ASSOC_SECURITY_BEGIN)
4044 return;
4045 }
4046 }*/
4047
4048 if (pLed->bLedBlinkInProgress) {
4049 _cancel_timer_ex(&(pLed->BlinkTimer));
4050 pLed->bLedBlinkInProgress = _FALSE;
4051 }
4052 if (pLed->bLedScanBlinkInProgress) {
4053 _cancel_timer_ex(&(pLed->BlinkTimer));
4054 pLed->bLedScanBlinkInProgress = _FALSE;
4055 }
4056 /* if(!IS_LED_BLINKING(pLed)) */
4057 {
4058 pLed->CurrLedState = LED_BLINK_NO_LINK;
4059 pLed->BlinkingLedState = RTW_LED_ON;
4060 _set_timer(&(pLed->BlinkTimer), 30);
4061 }
4062 break;
4063
4064 case LED_CTL_LINK:
4065
4066 if (pLed->bLedWPSBlinkInProgress)
4067 return;
4068
4069 if (pLed->bLedBlinkInProgress) {
4070 _cancel_timer_ex(&(pLed->BlinkTimer));
4071 pLed->bLedBlinkInProgress = _FALSE;
4072 }
4073
4074 pLed->CurrLedState = LED_BLINK_LINK_IDEL;
4075 pLed->BlinkingLedState = RTW_LED_ON;
4076
4077 _set_timer(&(pLed->BlinkTimer), 30);
4078 break;
4079
4080 case LED_CTL_SITE_SURVEY:
4081 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
4082 return;
4083
4084 if (pLed->bLedWPSBlinkInProgress == _TRUE)
4085 return;
4086
4087 if (pLed->bLedBlinkInProgress) {
4088 _cancel_timer_ex(&(pLed->BlinkTimer));
4089 pLed->bLedBlinkInProgress = _FALSE;
4090 }
4091 pLed->CurrLedState = LED_BLINK_SCAN;
4092 pLed->BlinkingLedState = RTW_LED_ON;
4093 _set_timer(&(pLed->BlinkTimer), 0);
4094 break;
4095
4096 case LED_CTL_TX:
4097 case LED_CTL_RX:
4098 if (pLed->bLedWPSBlinkInProgress)
4099 return;
4100
4101 if (pLed->bLedBlinkInProgress) {
4102 _cancel_timer_ex(&(pLed->BlinkTimer));
4103 pLed->bLedBlinkInProgress = _FALSE;
4104 }
4105
4106 pLed->bLedBlinkInProgress = _TRUE;
4107 pLed->CurrLedState = LED_BLINK_TXRX;
4108 pLed->BlinkTimes = 2;
4109 if (pLed->bLedOn)
4110 pLed->BlinkingLedState = RTW_LED_OFF;
4111 else
4112 pLed->BlinkingLedState = RTW_LED_ON;
4113 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
4114 break;
4115
4116 default:
4117 break;
4118 }
4119 }
4120
4121 void
LedControlUSB(_adapter * padapter,LED_CTL_MODE LedAction)4122 LedControlUSB(
4123 _adapter *padapter,
4124 LED_CTL_MODE LedAction
4125 )
4126 {
4127 struct led_priv *ledpriv = adapter_to_led(padapter);
4128
4129 #if (MP_DRIVER == 1)
4130 if (padapter->registrypriv.mp_mode == 1)
4131 return;
4132 #endif
4133
4134 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
4135 /*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
4136 , __func__
4137 , rtw_is_drv_stopped(padapter)?"True":"False"
4138 , rtw_is_surprise_removed(padapter)?"True":"False" );*/
4139 return;
4140 }
4141
4142 if (ledpriv->bRegUseLed == _FALSE)
4143 return;
4144
4145 /* if(priv->bInHctTest) */
4146 /* return; */
4147
4148 if ((adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on &&
4149 adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&
4150 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
4151 LedAction == LED_CTL_SITE_SURVEY ||
4152 LedAction == LED_CTL_LINK ||
4153 LedAction == LED_CTL_NO_LINK ||
4154 LedAction == LED_CTL_POWER_ON))
4155 return;
4156
4157 switch (ledpriv->LedStrategy) {
4158 #if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
4159 case SW_LED_MODE_UC_TRX_ONLY:
4160 rtw_sw_led_ctl_mode_uc_trx_only(padapter, LedAction);
4161 break;
4162 #endif
4163
4164 case SW_LED_MODE0:
4165 SwLedControlMode0(padapter, LedAction);
4166 break;
4167
4168 case SW_LED_MODE1:
4169 SwLedControlMode1(padapter, LedAction);
4170 break;
4171
4172 case SW_LED_MODE2:
4173 SwLedControlMode2(padapter, LedAction);
4174 break;
4175
4176 case SW_LED_MODE3:
4177 SwLedControlMode3(padapter, LedAction);
4178 break;
4179
4180 case SW_LED_MODE4:
4181 SwLedControlMode4(padapter, LedAction);
4182 break;
4183
4184 case SW_LED_MODE5:
4185 SwLedControlMode5(padapter, LedAction);
4186 break;
4187
4188 case SW_LED_MODE6:
4189 SwLedControlMode6(padapter, LedAction);
4190 break;
4191
4192 case SW_LED_MODE7:
4193 SwLedControlMode7(padapter, LedAction);
4194 break;
4195
4196 case SW_LED_MODE8:
4197 SwLedControlMode8(padapter, LedAction);
4198 break;
4199
4200 case SW_LED_MODE9:
4201 SwLedControlMode9(padapter, LedAction);
4202 break;
4203
4204 case SW_LED_MODE10:
4205 SwLedControlMode10(padapter, LedAction);
4206 break;
4207
4208 case SW_LED_MODE11:
4209 SwLedControlMode11(padapter, LedAction);
4210 break;
4211
4212 case SW_LED_MODE12:
4213 SwLedControlMode12(padapter, LedAction);
4214 break;
4215
4216 case SW_LED_MODE13:
4217 SwLedControlMode13(padapter, LedAction);
4218 break;
4219
4220 case SW_LED_MODE14:
4221 SwLedControlMode14(padapter, LedAction);
4222 break;
4223
4224 case SW_LED_MODE15:
4225 SwLedControlMode15(padapter, LedAction);
4226 break;
4227
4228 default:
4229 break;
4230 }
4231
4232 }
4233
4234 /*
4235 * Description:
4236 * Reset status of LED_871x object.
4237 * */
ResetLedStatus(PLED_USB pLed)4238 void ResetLedStatus(PLED_USB pLed)
4239 {
4240
4241 pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
4242 pLed->bLedOn = _FALSE; /* true if LED is ON, false if LED is OFF. */
4243
4244 pLed->bLedBlinkInProgress = _FALSE; /* true if it is blinking, false o.w.. */
4245 pLed->bLedWPSBlinkInProgress = _FALSE;
4246
4247 pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
4248 pLed->BlinkCounter = 0;
4249 pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
4250
4251 pLed->bLedNoLinkBlinkInProgress = _FALSE;
4252 pLed->bLedLinkBlinkInProgress = _FALSE;
4253 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
4254 pLed->bLedScanBlinkInProgress = _FALSE;
4255 }
4256
4257 /*
4258 * Description:
4259 * Initialize an LED_871x object.
4260 * */
4261 void
InitLed(_adapter * padapter,PLED_USB pLed,LED_PIN LedPin)4262 InitLed(
4263 _adapter *padapter,
4264 PLED_USB pLed,
4265 LED_PIN LedPin
4266 )
4267 {
4268 pLed->padapter = padapter;
4269 pLed->LedPin = LedPin;
4270
4271 ResetLedStatus(pLed);
4272 rtw_init_timer(&(pLed->BlinkTimer), padapter, BlinkTimerCallback, pLed);
4273 _init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
4274 }
4275
4276
4277 /*
4278 * Description:
4279 * DeInitialize an LED_871x object.
4280 * */
4281 void
DeInitLed(PLED_USB pLed)4282 DeInitLed(
4283 PLED_USB pLed
4284 )
4285 {
4286 _cancel_workitem_sync(&(pLed->BlinkWorkItem));
4287 _cancel_timer_ex(&(pLed->BlinkTimer));
4288 ResetLedStatus(pLed);
4289 }
4290 #endif