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_SDIO pLed)26 SwLedBlink(
27 PLED_SDIO 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_SDIO pLed)112 SwLedBlink1(
113 PLED_SDIO 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_SDIO pLed1 = &(ledpriv->SwLed1);
121 u8 bStopBlinking = _FALSE;
122
123 if (pHalData->CustomerID == RT_CID_819x_CAMEO)
124 pLed = &(ledpriv->SwLed1);
125
126 /* Change LED according to BlinkingLedState specified. */
127 if (pLed->BlinkingLedState == RTW_LED_ON) {
128 SwLedOn(padapter, pLed);
129 } else {
130 SwLedOff(padapter, pLed);
131 }
132
133
134 if (pHalData->CustomerID == RT_CID_DEFAULT) {
135 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
136 if (!pLed1->bSWLedCtrl) {
137 SwLedOn(padapter, pLed1);
138 pLed1->bSWLedCtrl = _TRUE;
139 } else if (!pLed1->bLedOn)
140 SwLedOn(padapter, pLed1);
141 } else {
142 if (!pLed1->bSWLedCtrl) {
143 SwLedOff(padapter, pLed1);
144 pLed1->bSWLedCtrl = _TRUE;
145 } else if (pLed1->bLedOn)
146 SwLedOff(padapter, pLed1);
147 }
148 }
149
150 switch (pLed->CurrLedState) {
151 case LED_BLINK_SLOWLY:
152 if (pLed->bLedOn)
153 pLed->BlinkingLedState = RTW_LED_OFF;
154 else
155 pLed->BlinkingLedState = RTW_LED_ON;
156 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
157 break;
158
159 case LED_BLINK_NORMAL:
160 if (pLed->bLedOn)
161 pLed->BlinkingLedState = RTW_LED_OFF;
162 else
163 pLed->BlinkingLedState = RTW_LED_ON;
164 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
165 break;
166
167 case LED_BLINK_SCAN:
168 pLed->BlinkTimes--;
169 if (pLed->BlinkTimes == 0)
170 bStopBlinking = _TRUE;
171
172 if (bStopBlinking) {
173 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
174 SwLedOff(padapter, pLed);
175 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
176 pLed->bLedLinkBlinkInProgress = _TRUE;
177 pLed->CurrLedState = LED_BLINK_NORMAL;
178 if (pLed->bLedOn)
179 pLed->BlinkingLedState = RTW_LED_OFF;
180 else
181 pLed->BlinkingLedState = RTW_LED_ON;
182 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
183
184 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
185 pLed->bLedNoLinkBlinkInProgress = _TRUE;
186 pLed->CurrLedState = LED_BLINK_SLOWLY;
187 if (pLed->bLedOn)
188 pLed->BlinkingLedState = RTW_LED_OFF;
189 else
190 pLed->BlinkingLedState = RTW_LED_ON;
191 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
192 }
193 pLed->bLedScanBlinkInProgress = _FALSE;
194 } else {
195 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
196 SwLedOff(padapter, pLed);
197 else {
198 if (pLed->bLedOn)
199 pLed->BlinkingLedState = RTW_LED_OFF;
200 else
201 pLed->BlinkingLedState = RTW_LED_ON;
202 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
203 }
204 }
205 break;
206
207 case LED_BLINK_TXRX:
208 pLed->BlinkTimes--;
209 if (pLed->BlinkTimes == 0)
210 bStopBlinking = _TRUE;
211 if (bStopBlinking) {
212 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
213 SwLedOff(padapter, pLed);
214 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
215 pLed->bLedLinkBlinkInProgress = _TRUE;
216 pLed->CurrLedState = LED_BLINK_NORMAL;
217 if (pLed->bLedOn)
218 pLed->BlinkingLedState = RTW_LED_OFF;
219 else
220 pLed->BlinkingLedState = RTW_LED_ON;
221 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
222 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
223 pLed->bLedNoLinkBlinkInProgress = _TRUE;
224 pLed->CurrLedState = LED_BLINK_SLOWLY;
225 if (pLed->bLedOn)
226 pLed->BlinkingLedState = RTW_LED_OFF;
227 else
228 pLed->BlinkingLedState = RTW_LED_ON;
229 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
230 }
231 pLed->BlinkTimes = 0;
232 pLed->bLedBlinkInProgress = _FALSE;
233 } else {
234 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
235 SwLedOff(padapter, pLed);
236 else {
237 if (pLed->bLedOn)
238 pLed->BlinkingLedState = RTW_LED_OFF;
239 else
240 pLed->BlinkingLedState = RTW_LED_ON;
241 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
242 }
243 }
244 break;
245
246 case LED_BLINK_WPS:
247 if (pLed->bLedOn)
248 pLed->BlinkingLedState = RTW_LED_OFF;
249 else
250 pLed->BlinkingLedState = RTW_LED_ON;
251 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
252 break;
253
254 case LED_BLINK_WPS_STOP: /* WPS success */
255 if (pLed->BlinkingLedState == RTW_LED_ON) {
256 pLed->BlinkingLedState = RTW_LED_OFF;
257 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
258 bStopBlinking = _FALSE;
259 } else
260 bStopBlinking = _TRUE;
261
262 if (bStopBlinking) {
263 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
264 SwLedOff(padapter, pLed);
265 else {
266 pLed->bLedLinkBlinkInProgress = _TRUE;
267 pLed->CurrLedState = LED_BLINK_NORMAL;
268 if (pLed->bLedOn)
269 pLed->BlinkingLedState = RTW_LED_OFF;
270 else
271 pLed->BlinkingLedState = RTW_LED_ON;
272 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
273 }
274 pLed->bLedWPSBlinkInProgress = _FALSE;
275 }
276 break;
277
278 default:
279 break;
280 }
281
282 }
283
284 void
SwLedBlink2(PLED_SDIO pLed)285 SwLedBlink2(
286 PLED_SDIO pLed
287 )
288 {
289 _adapter *padapter = pLed->padapter;
290 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
291 u8 bStopBlinking = _FALSE;
292
293 /* Change LED according to BlinkingLedState specified. */
294 if (pLed->BlinkingLedState == RTW_LED_ON) {
295 SwLedOn(padapter, pLed);
296 } else {
297 SwLedOff(padapter, pLed);
298 }
299
300 switch (pLed->CurrLedState) {
301 case LED_BLINK_SCAN:
302 pLed->BlinkTimes--;
303 if (pLed->BlinkTimes == 0)
304 bStopBlinking = _TRUE;
305
306 if (bStopBlinking) {
307 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
308 SwLedOff(padapter, pLed);
309 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
310 pLed->CurrLedState = RTW_LED_ON;
311 pLed->BlinkingLedState = RTW_LED_ON;
312 SwLedOn(padapter, pLed);
313
314 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
315 pLed->CurrLedState = RTW_LED_OFF;
316 pLed->BlinkingLedState = RTW_LED_OFF;
317 SwLedOff(padapter, pLed);
318 }
319 pLed->bLedScanBlinkInProgress = _FALSE;
320 } else {
321 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
322 SwLedOff(padapter, pLed);
323 else {
324 if (pLed->bLedOn)
325 pLed->BlinkingLedState = RTW_LED_OFF;
326 else
327 pLed->BlinkingLedState = RTW_LED_ON;
328 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
329 }
330 }
331 break;
332
333 case LED_BLINK_TXRX:
334 pLed->BlinkTimes--;
335 if (pLed->BlinkTimes == 0)
336 bStopBlinking = _TRUE;
337 if (bStopBlinking) {
338 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
339 SwLedOff(padapter, pLed);
340 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
341 pLed->CurrLedState = RTW_LED_ON;
342 pLed->BlinkingLedState = RTW_LED_ON;
343 SwLedOn(padapter, pLed);
344
345 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
346 pLed->CurrLedState = RTW_LED_OFF;
347 pLed->BlinkingLedState = RTW_LED_OFF;
348 SwLedOff(padapter, pLed);
349 }
350 pLed->bLedBlinkInProgress = _FALSE;
351 } else {
352 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
353 SwLedOff(padapter, pLed);
354 else {
355 if (pLed->bLedOn)
356 pLed->BlinkingLedState = RTW_LED_OFF;
357 else
358 pLed->BlinkingLedState = RTW_LED_ON;
359 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
360 }
361 }
362 break;
363
364 default:
365 break;
366 }
367
368 }
369
370 void
SwLedBlink3(PLED_SDIO pLed)371 SwLedBlink3(
372 PLED_SDIO pLed
373 )
374 {
375 _adapter *padapter = pLed->padapter;
376 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
377 u8 bStopBlinking = _FALSE;
378
379 /* Change LED according to BlinkingLedState specified. */
380 if (pLed->BlinkingLedState == RTW_LED_ON) {
381 SwLedOn(padapter, pLed);
382 } else {
383 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
384 SwLedOff(padapter, pLed);
385 }
386
387 switch (pLed->CurrLedState) {
388 case LED_BLINK_SCAN:
389 pLed->BlinkTimes--;
390 if (pLed->BlinkTimes == 0)
391 bStopBlinking = _TRUE;
392
393 if (bStopBlinking) {
394 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
395 SwLedOff(padapter, pLed);
396 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
397 pLed->CurrLedState = RTW_LED_ON;
398 pLed->BlinkingLedState = RTW_LED_ON;
399 if (!pLed->bLedOn)
400 SwLedOn(padapter, pLed);
401
402 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
403 pLed->CurrLedState = RTW_LED_OFF;
404 pLed->BlinkingLedState = RTW_LED_OFF;
405 if (pLed->bLedOn)
406 SwLedOff(padapter, pLed);
407
408 }
409 pLed->bLedScanBlinkInProgress = _FALSE;
410 } else {
411 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
412 SwLedOff(padapter, pLed);
413 else {
414 if (pLed->bLedOn)
415 pLed->BlinkingLedState = RTW_LED_OFF;
416 else
417 pLed->BlinkingLedState = RTW_LED_ON;
418 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
419 }
420 }
421 break;
422
423 case LED_BLINK_TXRX:
424 pLed->BlinkTimes--;
425 if (pLed->BlinkTimes == 0)
426 bStopBlinking = _TRUE;
427 if (bStopBlinking) {
428 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
429 SwLedOff(padapter, pLed);
430 else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
431 pLed->CurrLedState = RTW_LED_ON;
432 pLed->BlinkingLedState = RTW_LED_ON;
433
434 if (!pLed->bLedOn)
435 SwLedOn(padapter, pLed);
436
437 } else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
438 pLed->CurrLedState = RTW_LED_OFF;
439 pLed->BlinkingLedState = RTW_LED_OFF;
440
441 if (pLed->bLedOn)
442 SwLedOff(padapter, pLed);
443
444
445 }
446 pLed->bLedBlinkInProgress = _FALSE;
447 } else {
448 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
449 SwLedOff(padapter, pLed);
450 else {
451 if (pLed->bLedOn)
452 pLed->BlinkingLedState = RTW_LED_OFF;
453 else
454 pLed->BlinkingLedState = RTW_LED_ON;
455 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
456 }
457 }
458 break;
459
460 case LED_BLINK_WPS:
461 if (pLed->bLedOn)
462 pLed->BlinkingLedState = RTW_LED_OFF;
463 else
464 pLed->BlinkingLedState = RTW_LED_ON;
465 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
466 break;
467
468 case LED_BLINK_WPS_STOP: /* WPS success */
469 if (pLed->BlinkingLedState == RTW_LED_ON) {
470 pLed->BlinkingLedState = RTW_LED_OFF;
471 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
472 bStopBlinking = _FALSE;
473 } else
474 bStopBlinking = _TRUE;
475
476 if (bStopBlinking) {
477 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
478 SwLedOff(padapter, pLed);
479 else {
480 pLed->CurrLedState = RTW_LED_ON;
481 pLed->BlinkingLedState = RTW_LED_ON;
482 SwLedOn(padapter, pLed);
483 }
484 pLed->bLedWPSBlinkInProgress = _FALSE;
485 }
486 break;
487
488
489 default:
490 break;
491 }
492
493 }
494
495
496 void
SwLedBlink4(PLED_SDIO pLed)497 SwLedBlink4(
498 PLED_SDIO pLed
499 )
500 {
501 _adapter *padapter = pLed->padapter;
502 struct led_priv *ledpriv = adapter_to_led(padapter);
503 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
504 PLED_SDIO pLed1 = &(ledpriv->SwLed1);
505 u8 bStopBlinking = _FALSE;
506
507 /* Change LED according to BlinkingLedState specified. */
508 if (pLed->BlinkingLedState == RTW_LED_ON) {
509 SwLedOn(padapter, pLed);
510 } else {
511 SwLedOff(padapter, pLed);
512 }
513
514 if (!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN) {
515 pLed1->BlinkingLedState = RTW_LED_OFF;
516 pLed1->CurrLedState = RTW_LED_OFF;
517 SwLedOff(padapter, pLed1);
518 }
519
520 switch (pLed->CurrLedState) {
521 case LED_BLINK_SLOWLY:
522 if (pLed->bLedOn)
523 pLed->BlinkingLedState = RTW_LED_OFF;
524 else
525 pLed->BlinkingLedState = RTW_LED_ON;
526 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
527 break;
528
529 case LED_BLINK_StartToBlink:
530 if (pLed->bLedOn) {
531 pLed->BlinkingLedState = RTW_LED_OFF;
532 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
533 } else {
534 pLed->BlinkingLedState = RTW_LED_ON;
535 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
536 }
537 break;
538
539 case LED_BLINK_SCAN:
540 pLed->BlinkTimes--;
541 if (pLed->BlinkTimes == 0)
542 bStopBlinking = _FALSE;
543
544 if (bStopBlinking) {
545 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
546 SwLedOff(padapter, pLed);
547 else {
548 pLed->bLedNoLinkBlinkInProgress = _FALSE;
549 pLed->CurrLedState = LED_BLINK_SLOWLY;
550 if (pLed->bLedOn)
551 pLed->BlinkingLedState = RTW_LED_OFF;
552 else
553 pLed->BlinkingLedState = RTW_LED_ON;
554 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
555 }
556 pLed->bLedScanBlinkInProgress = _FALSE;
557 } else {
558 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
559 SwLedOff(padapter, pLed);
560 else {
561 if (pLed->bLedOn)
562 pLed->BlinkingLedState = RTW_LED_OFF;
563 else
564 pLed->BlinkingLedState = RTW_LED_ON;
565 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
566 }
567 }
568 break;
569
570 case LED_BLINK_TXRX:
571 pLed->BlinkTimes--;
572 if (pLed->BlinkTimes == 0)
573 bStopBlinking = _TRUE;
574 if (bStopBlinking) {
575 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
576 SwLedOff(padapter, pLed);
577 else {
578 pLed->bLedNoLinkBlinkInProgress = _TRUE;
579 pLed->CurrLedState = LED_BLINK_SLOWLY;
580 if (pLed->bLedOn)
581 pLed->BlinkingLedState = RTW_LED_OFF;
582 else
583 pLed->BlinkingLedState = RTW_LED_ON;
584 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
585 }
586 pLed->bLedBlinkInProgress = _FALSE;
587 } else {
588 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
589 SwLedOff(padapter, pLed);
590 else {
591 if (pLed->bLedOn)
592 pLed->BlinkingLedState = RTW_LED_OFF;
593 else
594 pLed->BlinkingLedState = RTW_LED_ON;
595 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
596 }
597 }
598 break;
599
600 case LED_BLINK_WPS:
601 if (pLed->bLedOn) {
602 pLed->BlinkingLedState = RTW_LED_OFF;
603 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
604 } else {
605 pLed->BlinkingLedState = RTW_LED_ON;
606 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
607 }
608 break;
609
610 case LED_BLINK_WPS_STOP: /* WPS authentication fail */
611 if (pLed->bLedOn)
612 pLed->BlinkingLedState = RTW_LED_OFF;
613 else
614 pLed->BlinkingLedState = RTW_LED_ON;
615
616 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
617 break;
618
619 case LED_BLINK_WPS_STOP_OVERLAP: /* WPS session overlap */
620 pLed->BlinkTimes--;
621 if (pLed->BlinkTimes == 0) {
622 if (pLed->bLedOn)
623 pLed->BlinkTimes = 1;
624 else
625 bStopBlinking = _TRUE;
626 }
627
628 if (bStopBlinking) {
629 pLed->BlinkTimes = 10;
630 pLed->BlinkingLedState = RTW_LED_ON;
631 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
632 } else {
633 if (pLed->bLedOn)
634 pLed->BlinkingLedState = RTW_LED_OFF;
635 else
636 pLed->BlinkingLedState = RTW_LED_ON;
637
638 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
639 }
640 break;
641
642 default:
643 break;
644 }
645
646
647
648 }
649
650 void
SwLedBlink5(PLED_SDIO pLed)651 SwLedBlink5(
652 PLED_SDIO pLed
653 )
654 {
655 _adapter *padapter = pLed->padapter;
656 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
657 u8 bStopBlinking = _FALSE;
658
659 /* Change LED according to BlinkingLedState specified. */
660 if (pLed->BlinkingLedState == RTW_LED_ON) {
661 SwLedOn(padapter, pLed);
662 } else {
663 SwLedOff(padapter, pLed);
664 }
665
666 switch (pLed->CurrLedState) {
667 case LED_BLINK_SCAN:
668 pLed->BlinkTimes--;
669 if (pLed->BlinkTimes == 0)
670 bStopBlinking = _TRUE;
671
672 if (bStopBlinking) {
673 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
674 pLed->CurrLedState = RTW_LED_OFF;
675 pLed->BlinkingLedState = RTW_LED_OFF;
676 if (pLed->bLedOn)
677 SwLedOff(padapter, pLed);
678 } else {
679 pLed->CurrLedState = RTW_LED_ON;
680 pLed->BlinkingLedState = RTW_LED_ON;
681 if (!pLed->bLedOn)
682 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
683 }
684
685 pLed->bLedScanBlinkInProgress = _FALSE;
686 } else {
687 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
688 SwLedOff(padapter, pLed);
689 else {
690 if (pLed->bLedOn)
691 pLed->BlinkingLedState = RTW_LED_OFF;
692 else
693 pLed->BlinkingLedState = RTW_LED_ON;
694 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
695 }
696 }
697 break;
698
699
700 case LED_BLINK_TXRX:
701 pLed->BlinkTimes--;
702 if (pLed->BlinkTimes == 0)
703 bStopBlinking = _TRUE;
704
705 if (bStopBlinking) {
706 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
707 pLed->CurrLedState = RTW_LED_OFF;
708 pLed->BlinkingLedState = RTW_LED_OFF;
709 if (pLed->bLedOn)
710 SwLedOff(padapter, pLed);
711 } else {
712 pLed->CurrLedState = RTW_LED_ON;
713 pLed->BlinkingLedState = RTW_LED_ON;
714 if (!pLed->bLedOn)
715 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
716 }
717
718 pLed->bLedBlinkInProgress = _FALSE;
719 } else {
720 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
721 SwLedOff(padapter, pLed);
722 else {
723 if (pLed->bLedOn)
724 pLed->BlinkingLedState = RTW_LED_OFF;
725 else
726 pLed->BlinkingLedState = RTW_LED_ON;
727 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
728 }
729 }
730 break;
731
732 default:
733 break;
734 }
735
736
737
738 }
739
740 void
SwLedBlink6(PLED_SDIO pLed)741 SwLedBlink6(
742 PLED_SDIO pLed
743 )
744 {
745 _adapter *padapter = pLed->padapter;
746 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
747 u8 bStopBlinking = _FALSE;
748
749 /* Change LED according to BlinkingLedState specified. */
750 if (pLed->BlinkingLedState == RTW_LED_ON) {
751 SwLedOn(padapter, pLed);
752 } else {
753 SwLedOff(padapter, pLed);
754 }
755
756 }
757
758 /*
759 * Description:
760 * Handler function of LED Blinking.
761 * We dispatch acture LED blink action according to LedStrategy.
762 * */
BlinkHandler(PLED_SDIO pLed)763 void BlinkHandler(PLED_SDIO pLed)
764 {
765 _adapter *padapter = pLed->padapter;
766 struct led_priv *ledpriv = adapter_to_led(padapter);
767
768 /* RTW_INFO("%s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); */
769 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
770 RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
771 , __func__
772 , rtw_is_drv_stopped(padapter) ? "True" : "False"
773 , rtw_is_surprise_removed(padapter) ? "True" : "False");
774
775 return;
776 }
777
778 switch (ledpriv->LedStrategy) {
779 #if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
780 case SW_LED_MODE_UC_TRX_ONLY:
781 rtw_sw_led_blink_uc_trx_only(pLed);
782 break;
783 #endif
784
785 case SW_LED_MODE0:
786 SwLedBlink(pLed);
787 break;
788
789 case SW_LED_MODE1:
790 SwLedBlink1(pLed);
791 break;
792
793 case SW_LED_MODE2:
794 SwLedBlink2(pLed);
795 break;
796
797 case SW_LED_MODE3:
798 SwLedBlink3(pLed);
799 break;
800
801 case SW_LED_MODE4:
802 SwLedBlink4(pLed);
803 break;
804
805 case SW_LED_MODE5:
806 SwLedBlink5(pLed);
807 break;
808
809 case SW_LED_MODE6:
810 SwLedBlink6(pLed);
811 break;
812
813 default:
814 /* SwLedBlink(pLed); */
815 break;
816 }
817 }
818
819 /*
820 * Description:
821 * Callback function of LED BlinkTimer,
822 * it just schedules to corresponding BlinkWorkItem/led_blink_hdl
823 * */
BlinkTimerCallback(void * data)824 void BlinkTimerCallback(void *data)
825 {
826 PLED_SDIO pLed = (PLED_SDIO)data;
827 _adapter *padapter = pLed->padapter;
828
829 /* RTW_INFO("%s\n", __FUNCTION__); */
830
831 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
832 /*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
833 , __func__
834 , rtw_is_drv_stopped(padapter)?"True":"False"
835 , rtw_is_surprise_removed(padapter)?"True":"False" );*/
836 return;
837 }
838
839 #ifdef CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD
840 rtw_led_blink_cmd(padapter, pLed);
841 #else
842 _set_workitem(&(pLed->BlinkWorkItem));
843 #endif
844 }
845
846 /*
847 * Description:
848 * Callback function of LED BlinkWorkItem.
849 * We dispatch acture LED blink action according to LedStrategy.
850 * */
BlinkWorkItemCallback(_workitem * work)851 void BlinkWorkItemCallback(_workitem *work)
852 {
853 PLED_SDIO pLed = container_of(work, LED_SDIO, BlinkWorkItem);
854 BlinkHandler(pLed);
855 }
856
857 static void
SwLedControlMode0(_adapter * padapter,LED_CTL_MODE LedAction)858 SwLedControlMode0(
859 _adapter *padapter,
860 LED_CTL_MODE LedAction
861 )
862 {
863 struct led_priv *ledpriv = adapter_to_led(padapter);
864 PLED_SDIO pLed = &(ledpriv->SwLed1);
865
866 /* Decide led state */
867 switch (LedAction) {
868 case LED_CTL_TX:
869 case LED_CTL_RX:
870 if (pLed->bLedBlinkInProgress == _FALSE) {
871 pLed->bLedBlinkInProgress = _TRUE;
872
873 pLed->CurrLedState = LED_BLINK_NORMAL;
874 pLed->BlinkTimes = 2;
875
876 if (pLed->bLedOn)
877 pLed->BlinkingLedState = RTW_LED_OFF;
878 else
879 pLed->BlinkingLedState = RTW_LED_ON;
880 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
881 }
882 break;
883
884 case LED_CTL_START_TO_LINK:
885 if (pLed->bLedBlinkInProgress == _FALSE) {
886 pLed->bLedBlinkInProgress = _TRUE;
887
888 pLed->CurrLedState = LED_BLINK_StartToBlink;
889 pLed->BlinkTimes = 24;
890
891 if (pLed->bLedOn)
892 pLed->BlinkingLedState = RTW_LED_OFF;
893 else
894 pLed->BlinkingLedState = RTW_LED_ON;
895 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
896 } else
897 pLed->CurrLedState = LED_BLINK_StartToBlink;
898 break;
899
900 case LED_CTL_LINK:
901 pLed->CurrLedState = RTW_LED_ON;
902 if (pLed->bLedBlinkInProgress == _FALSE) {
903 pLed->BlinkingLedState = RTW_LED_ON;
904 _set_timer(&(pLed->BlinkTimer), 0);
905 }
906 break;
907
908 case LED_CTL_NO_LINK:
909 pLed->CurrLedState = RTW_LED_OFF;
910 if (pLed->bLedBlinkInProgress == _FALSE) {
911 pLed->BlinkingLedState = RTW_LED_OFF;
912 _set_timer(&(pLed->BlinkTimer), 0);
913 }
914 break;
915
916 case LED_CTL_POWER_OFF:
917 pLed->CurrLedState = RTW_LED_OFF;
918 if (pLed->bLedBlinkInProgress) {
919 _cancel_timer_ex(&(pLed->BlinkTimer));
920 pLed->bLedBlinkInProgress = _FALSE;
921 }
922 SwLedOff(padapter, pLed);
923 break;
924
925 case LED_CTL_START_WPS:
926 if (pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState == RTW_LED_ON) {
927 pLed->bLedBlinkInProgress = _TRUE;
928
929 pLed->CurrLedState = LED_BLINK_WPS;
930 pLed->BlinkTimes = 20;
931
932 if (pLed->bLedOn) {
933 pLed->BlinkingLedState = RTW_LED_OFF;
934 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
935 } else {
936 pLed->BlinkingLedState = RTW_LED_ON;
937 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
938 }
939 }
940 break;
941
942 case LED_CTL_STOP_WPS:
943 if (pLed->bLedBlinkInProgress) {
944 pLed->CurrLedState = RTW_LED_OFF;
945 _cancel_timer_ex(&(pLed->BlinkTimer));
946 pLed->bLedBlinkInProgress = _FALSE;
947 }
948 break;
949
950
951 default:
952 break;
953 }
954
955
956 }
957
958 /* ALPHA, added by chiyoko, 20090106 */
959 static void
SwLedControlMode1(_adapter * padapter,LED_CTL_MODE LedAction)960 SwLedControlMode1(
961 _adapter *padapter,
962 LED_CTL_MODE LedAction
963 )
964 {
965 struct led_priv *ledpriv = adapter_to_led(padapter);
966 PLED_SDIO pLed = &(ledpriv->SwLed0);
967 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
968 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
969
970 if (pHalData->CustomerID == RT_CID_819x_CAMEO)
971 pLed = &(ledpriv->SwLed1);
972
973 switch (LedAction) {
974 case LED_CTL_POWER_ON:
975 case LED_CTL_START_TO_LINK:
976 case LED_CTL_NO_LINK:
977 if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
978 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
979 return;
980 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
981 _cancel_timer_ex(&(pLed->BlinkTimer));
982 pLed->bLedLinkBlinkInProgress = _FALSE;
983 }
984 if (pLed->bLedBlinkInProgress == _TRUE) {
985 _cancel_timer_ex(&(pLed->BlinkTimer));
986 pLed->bLedBlinkInProgress = _FALSE;
987 }
988
989 pLed->bLedNoLinkBlinkInProgress = _TRUE;
990 pLed->CurrLedState = LED_BLINK_SLOWLY;
991 if (pLed->bLedOn)
992 pLed->BlinkingLedState = RTW_LED_OFF;
993 else
994 pLed->BlinkingLedState = RTW_LED_ON;
995 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
996 }
997 break;
998
999 case LED_CTL_LINK:
1000 if (pLed->bLedLinkBlinkInProgress == _FALSE) {
1001 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1002 return;
1003 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1004 _cancel_timer_ex(&(pLed->BlinkTimer));
1005 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1006 }
1007 if (pLed->bLedBlinkInProgress == _TRUE) {
1008 _cancel_timer_ex(&(pLed->BlinkTimer));
1009 pLed->bLedBlinkInProgress = _FALSE;
1010 }
1011 pLed->bLedLinkBlinkInProgress = _TRUE;
1012 pLed->CurrLedState = LED_BLINK_NORMAL;
1013 if (pLed->bLedOn)
1014 pLed->BlinkingLedState = RTW_LED_OFF;
1015 else
1016 pLed->BlinkingLedState = RTW_LED_ON;
1017 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1018 }
1019 break;
1020
1021 case LED_CTL_SITE_SURVEY:
1022 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
1023 ;
1024 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
1025 if (IS_LED_WPS_BLINKING(pLed))
1026 return;
1027
1028 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1029 _cancel_timer_ex(&(pLed->BlinkTimer));
1030 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1031 }
1032 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
1033 _cancel_timer_ex(&(pLed->BlinkTimer));
1034 pLed->bLedLinkBlinkInProgress = _FALSE;
1035 }
1036 if (pLed->bLedBlinkInProgress == _TRUE) {
1037 _cancel_timer_ex(&(pLed->BlinkTimer));
1038 pLed->bLedBlinkInProgress = _FALSE;
1039 }
1040 pLed->bLedScanBlinkInProgress = _TRUE;
1041 pLed->CurrLedState = LED_BLINK_SCAN;
1042 pLed->BlinkTimes = 24;
1043 if (pLed->bLedOn)
1044 pLed->BlinkingLedState = RTW_LED_OFF;
1045 else
1046 pLed->BlinkingLedState = RTW_LED_ON;
1047 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1048
1049 }
1050 break;
1051
1052 case LED_CTL_TX:
1053 case LED_CTL_RX:
1054 if (pLed->bLedBlinkInProgress == _FALSE) {
1055 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1056 return;
1057 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1058 _cancel_timer_ex(&(pLed->BlinkTimer));
1059 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1060 }
1061 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
1062 _cancel_timer_ex(&(pLed->BlinkTimer));
1063 pLed->bLedLinkBlinkInProgress = _FALSE;
1064 }
1065 pLed->bLedBlinkInProgress = _TRUE;
1066 pLed->CurrLedState = LED_BLINK_TXRX;
1067 pLed->BlinkTimes = 2;
1068 if (pLed->bLedOn)
1069 pLed->BlinkingLedState = RTW_LED_OFF;
1070 else
1071 pLed->BlinkingLedState = RTW_LED_ON;
1072 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1073 }
1074 break;
1075
1076 case LED_CTL_START_WPS: /* wait until xinpin finish */
1077 case LED_CTL_START_WPS_BOTTON:
1078 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
1079 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1080 _cancel_timer_ex(&(pLed->BlinkTimer));
1081 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1082 }
1083 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
1084 _cancel_timer_ex(&(pLed->BlinkTimer));
1085 pLed->bLedLinkBlinkInProgress = _FALSE;
1086 }
1087 if (pLed->bLedBlinkInProgress == _TRUE) {
1088 _cancel_timer_ex(&(pLed->BlinkTimer));
1089 pLed->bLedBlinkInProgress = _FALSE;
1090 }
1091 if (pLed->bLedScanBlinkInProgress == _TRUE) {
1092 _cancel_timer_ex(&(pLed->BlinkTimer));
1093 pLed->bLedScanBlinkInProgress = _FALSE;
1094 }
1095 pLed->bLedWPSBlinkInProgress = _TRUE;
1096 pLed->CurrLedState = LED_BLINK_WPS;
1097 if (pLed->bLedOn)
1098 pLed->BlinkingLedState = RTW_LED_OFF;
1099 else
1100 pLed->BlinkingLedState = RTW_LED_ON;
1101 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1102 }
1103 break;
1104
1105
1106 case LED_CTL_STOP_WPS:
1107 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1108 _cancel_timer_ex(&(pLed->BlinkTimer));
1109 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1110 }
1111 if (pLed->bLedLinkBlinkInProgress == _TRUE) {
1112 _cancel_timer_ex(&(pLed->BlinkTimer));
1113 pLed->bLedLinkBlinkInProgress = _FALSE;
1114 }
1115 if (pLed->bLedBlinkInProgress == _TRUE) {
1116 _cancel_timer_ex(&(pLed->BlinkTimer));
1117 pLed->bLedBlinkInProgress = _FALSE;
1118 }
1119 if (pLed->bLedScanBlinkInProgress == _TRUE) {
1120 _cancel_timer_ex(&(pLed->BlinkTimer));
1121 pLed->bLedScanBlinkInProgress = _FALSE;
1122 }
1123 if (pLed->bLedWPSBlinkInProgress)
1124 _cancel_timer_ex(&(pLed->BlinkTimer));
1125 else
1126 pLed->bLedWPSBlinkInProgress = _TRUE;
1127
1128 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1129 if (pLed->bLedOn) {
1130 pLed->BlinkingLedState = RTW_LED_OFF;
1131 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1132 } else {
1133 pLed->BlinkingLedState = RTW_LED_ON;
1134 _set_timer(&(pLed->BlinkTimer), 0);
1135 }
1136 break;
1137
1138 case LED_CTL_STOP_WPS_FAIL:
1139 if (pLed->bLedWPSBlinkInProgress) {
1140 _cancel_timer_ex(&(pLed->BlinkTimer));
1141 pLed->bLedWPSBlinkInProgress = _FALSE;
1142 }
1143
1144 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1145 pLed->CurrLedState = LED_BLINK_SLOWLY;
1146 if (pLed->bLedOn)
1147 pLed->BlinkingLedState = RTW_LED_OFF;
1148 else
1149 pLed->BlinkingLedState = RTW_LED_ON;
1150 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1151 break;
1152
1153 case LED_CTL_POWER_OFF:
1154 pLed->CurrLedState = RTW_LED_OFF;
1155 pLed->BlinkingLedState = RTW_LED_OFF;
1156 if (pLed->bLedNoLinkBlinkInProgress) {
1157 _cancel_timer_ex(&(pLed->BlinkTimer));
1158 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1159 }
1160 if (pLed->bLedLinkBlinkInProgress) {
1161 _cancel_timer_ex(&(pLed->BlinkTimer));
1162 pLed->bLedLinkBlinkInProgress = _FALSE;
1163 }
1164 if (pLed->bLedBlinkInProgress) {
1165 _cancel_timer_ex(&(pLed->BlinkTimer));
1166 pLed->bLedBlinkInProgress = _FALSE;
1167 }
1168 if (pLed->bLedWPSBlinkInProgress) {
1169 _cancel_timer_ex(&(pLed->BlinkTimer));
1170 pLed->bLedWPSBlinkInProgress = _FALSE;
1171 }
1172 if (pLed->bLedScanBlinkInProgress) {
1173 _cancel_timer_ex(&(pLed->BlinkTimer));
1174 pLed->bLedScanBlinkInProgress = _FALSE;
1175 }
1176
1177 SwLedOff(padapter, pLed);
1178 break;
1179
1180 default:
1181 break;
1182
1183 }
1184
1185 }
1186
1187 /* Arcadyan/Sitecom , added by chiyoko, 20090216 */
1188 static void
SwLedControlMode2(_adapter * padapter,LED_CTL_MODE LedAction)1189 SwLedControlMode2(
1190 _adapter *padapter,
1191 LED_CTL_MODE LedAction
1192 )
1193 {
1194 struct led_priv *ledpriv = adapter_to_led(padapter);
1195 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1196 PLED_SDIO pLed = &(ledpriv->SwLed0);
1197
1198 switch (LedAction) {
1199 case LED_CTL_SITE_SURVEY:
1200 if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
1201 ;
1202 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
1203 if (IS_LED_WPS_BLINKING(pLed))
1204 return;
1205
1206 if (pLed->bLedBlinkInProgress == _TRUE) {
1207 _cancel_timer_ex(&(pLed->BlinkTimer));
1208 pLed->bLedBlinkInProgress = _FALSE;
1209 }
1210 pLed->bLedScanBlinkInProgress = _TRUE;
1211 pLed->CurrLedState = LED_BLINK_SCAN;
1212 pLed->BlinkTimes = 24;
1213 if (pLed->bLedOn)
1214 pLed->BlinkingLedState = RTW_LED_OFF;
1215 else
1216 pLed->BlinkingLedState = RTW_LED_ON;
1217 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1218 }
1219 break;
1220
1221 case LED_CTL_TX:
1222 case LED_CTL_RX:
1223 if ((pLed->bLedBlinkInProgress == _FALSE) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
1224 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1225 return;
1226
1227 pLed->bLedBlinkInProgress = _TRUE;
1228 pLed->CurrLedState = LED_BLINK_TXRX;
1229 pLed->BlinkTimes = 2;
1230 if (pLed->bLedOn)
1231 pLed->BlinkingLedState = RTW_LED_OFF;
1232 else
1233 pLed->BlinkingLedState = RTW_LED_ON;
1234 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1235 }
1236 break;
1237
1238 case LED_CTL_LINK:
1239 pLed->CurrLedState = RTW_LED_ON;
1240 pLed->BlinkingLedState = RTW_LED_ON;
1241 if (pLed->bLedBlinkInProgress) {
1242 _cancel_timer_ex(&(pLed->BlinkTimer));
1243 pLed->bLedBlinkInProgress = _FALSE;
1244 }
1245 if (pLed->bLedScanBlinkInProgress) {
1246 _cancel_timer_ex(&(pLed->BlinkTimer));
1247 pLed->bLedScanBlinkInProgress = _FALSE;
1248 }
1249
1250 _set_timer(&(pLed->BlinkTimer), 0);
1251 break;
1252
1253 case LED_CTL_START_WPS: /* wait until xinpin finish */
1254 case LED_CTL_START_WPS_BOTTON:
1255 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
1256 if (pLed->bLedBlinkInProgress == _TRUE) {
1257 _cancel_timer_ex(&(pLed->BlinkTimer));
1258 pLed->bLedBlinkInProgress = _FALSE;
1259 }
1260 if (pLed->bLedScanBlinkInProgress == _TRUE) {
1261 _cancel_timer_ex(&(pLed->BlinkTimer));
1262 pLed->bLedScanBlinkInProgress = _FALSE;
1263 }
1264 pLed->bLedWPSBlinkInProgress = _TRUE;
1265 pLed->CurrLedState = RTW_LED_ON;
1266 pLed->BlinkingLedState = RTW_LED_ON;
1267 _set_timer(&(pLed->BlinkTimer), 0);
1268 }
1269 break;
1270
1271 case LED_CTL_STOP_WPS:
1272 pLed->bLedWPSBlinkInProgress = _FALSE;
1273 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on) {
1274 pLed->CurrLedState = RTW_LED_OFF;
1275 pLed->BlinkingLedState = RTW_LED_OFF;
1276 _set_timer(&(pLed->BlinkTimer), 0);
1277 } else {
1278 pLed->CurrLedState = RTW_LED_ON;
1279 pLed->BlinkingLedState = RTW_LED_ON;
1280 _set_timer(&(pLed->BlinkTimer), 0);
1281 }
1282 break;
1283
1284 case LED_CTL_STOP_WPS_FAIL:
1285 pLed->bLedWPSBlinkInProgress = _FALSE;
1286 pLed->CurrLedState = RTW_LED_OFF;
1287 pLed->BlinkingLedState = RTW_LED_OFF;
1288 _set_timer(&(pLed->BlinkTimer), 0);
1289 break;
1290
1291 case LED_CTL_START_TO_LINK:
1292 case LED_CTL_NO_LINK:
1293 if (!IS_LED_BLINKING(pLed)) {
1294 pLed->CurrLedState = RTW_LED_OFF;
1295 pLed->BlinkingLedState = RTW_LED_OFF;
1296 _set_timer(&(pLed->BlinkTimer), 0);
1297 }
1298 break;
1299
1300 case LED_CTL_POWER_OFF:
1301 pLed->CurrLedState = RTW_LED_OFF;
1302 pLed->BlinkingLedState = RTW_LED_OFF;
1303 if (pLed->bLedBlinkInProgress) {
1304 _cancel_timer_ex(&(pLed->BlinkTimer));
1305 pLed->bLedBlinkInProgress = _FALSE;
1306 }
1307 if (pLed->bLedScanBlinkInProgress) {
1308 _cancel_timer_ex(&(pLed->BlinkTimer));
1309 pLed->bLedScanBlinkInProgress = _FALSE;
1310 }
1311 if (pLed->bLedWPSBlinkInProgress) {
1312 _cancel_timer_ex(&(pLed->BlinkTimer));
1313 pLed->bLedWPSBlinkInProgress = _FALSE;
1314 }
1315
1316 SwLedOff(padapter, pLed);
1317 break;
1318
1319 default:
1320 break;
1321
1322 }
1323
1324 }
1325
1326 /* COREGA, added by chiyoko, 20090316 */
1327 static void
SwLedControlMode3(_adapter * padapter,LED_CTL_MODE LedAction)1328 SwLedControlMode3(
1329 _adapter *padapter,
1330 LED_CTL_MODE LedAction
1331 )
1332 {
1333 struct led_priv *ledpriv = adapter_to_led(padapter);
1334 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1335 PLED_SDIO pLed = &(ledpriv->SwLed0);
1336
1337 switch (LedAction) {
1338 case LED_CTL_SITE_SURVEY:
1339 if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
1340 ;
1341 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
1342 if (IS_LED_WPS_BLINKING(pLed))
1343 return;
1344
1345 if (pLed->bLedBlinkInProgress == _TRUE) {
1346 _cancel_timer_ex(&(pLed->BlinkTimer));
1347 pLed->bLedBlinkInProgress = _FALSE;
1348 }
1349 pLed->bLedScanBlinkInProgress = _TRUE;
1350 pLed->CurrLedState = LED_BLINK_SCAN;
1351 pLed->BlinkTimes = 24;
1352 if (pLed->bLedOn)
1353 pLed->BlinkingLedState = RTW_LED_OFF;
1354 else
1355 pLed->BlinkingLedState = RTW_LED_ON;
1356 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1357 }
1358 break;
1359
1360 case LED_CTL_TX:
1361 case LED_CTL_RX:
1362 if ((pLed->bLedBlinkInProgress == _FALSE) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
1363 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1364 return;
1365
1366 pLed->bLedBlinkInProgress = _TRUE;
1367 pLed->CurrLedState = LED_BLINK_TXRX;
1368 pLed->BlinkTimes = 2;
1369 if (pLed->bLedOn)
1370 pLed->BlinkingLedState = RTW_LED_OFF;
1371 else
1372 pLed->BlinkingLedState = RTW_LED_ON;
1373 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1374 }
1375 break;
1376
1377 case LED_CTL_LINK:
1378 if (IS_LED_WPS_BLINKING(pLed))
1379 return;
1380
1381 pLed->CurrLedState = RTW_LED_ON;
1382 pLed->BlinkingLedState = RTW_LED_ON;
1383 if (pLed->bLedBlinkInProgress) {
1384 _cancel_timer_ex(&(pLed->BlinkTimer));
1385 pLed->bLedBlinkInProgress = _FALSE;
1386 }
1387 if (pLed->bLedScanBlinkInProgress) {
1388 _cancel_timer_ex(&(pLed->BlinkTimer));
1389 pLed->bLedScanBlinkInProgress = _FALSE;
1390 }
1391
1392 _set_timer(&(pLed->BlinkTimer), 0);
1393 break;
1394
1395 case LED_CTL_START_WPS: /* wait until xinpin finish */
1396 case LED_CTL_START_WPS_BOTTON:
1397 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
1398 if (pLed->bLedBlinkInProgress == _TRUE) {
1399 _cancel_timer_ex(&(pLed->BlinkTimer));
1400 pLed->bLedBlinkInProgress = _FALSE;
1401 }
1402 if (pLed->bLedScanBlinkInProgress == _TRUE) {
1403 _cancel_timer_ex(&(pLed->BlinkTimer));
1404 pLed->bLedScanBlinkInProgress = _FALSE;
1405 }
1406 pLed->bLedWPSBlinkInProgress = _TRUE;
1407 pLed->CurrLedState = LED_BLINK_WPS;
1408 if (pLed->bLedOn)
1409 pLed->BlinkingLedState = RTW_LED_OFF;
1410 else
1411 pLed->BlinkingLedState = RTW_LED_ON;
1412 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1413 }
1414 break;
1415
1416 case LED_CTL_STOP_WPS:
1417 if (pLed->bLedWPSBlinkInProgress) {
1418 _cancel_timer_ex(&(pLed->BlinkTimer));
1419 pLed->bLedWPSBlinkInProgress = _FALSE;
1420 } else
1421 pLed->bLedWPSBlinkInProgress = _TRUE;
1422
1423 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1424 if (pLed->bLedOn) {
1425 pLed->BlinkingLedState = RTW_LED_OFF;
1426 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1427 } else {
1428 pLed->BlinkingLedState = RTW_LED_ON;
1429 _set_timer(&(pLed->BlinkTimer), 0);
1430 }
1431
1432 break;
1433
1434 case LED_CTL_STOP_WPS_FAIL:
1435 if (pLed->bLedWPSBlinkInProgress) {
1436 _cancel_timer_ex(&(pLed->BlinkTimer));
1437 pLed->bLedWPSBlinkInProgress = _FALSE;
1438 }
1439
1440 pLed->CurrLedState = RTW_LED_OFF;
1441 pLed->BlinkingLedState = RTW_LED_OFF;
1442 _set_timer(&(pLed->BlinkTimer), 0);
1443 break;
1444
1445 case LED_CTL_START_TO_LINK:
1446 case LED_CTL_NO_LINK:
1447 if (!IS_LED_BLINKING(pLed)) {
1448 pLed->CurrLedState = RTW_LED_OFF;
1449 pLed->BlinkingLedState = RTW_LED_OFF;
1450 _set_timer(&(pLed->BlinkTimer), 0);
1451 }
1452 break;
1453
1454 case LED_CTL_POWER_OFF:
1455 pLed->CurrLedState = RTW_LED_OFF;
1456 pLed->BlinkingLedState = RTW_LED_OFF;
1457 if (pLed->bLedBlinkInProgress) {
1458 _cancel_timer_ex(&(pLed->BlinkTimer));
1459 pLed->bLedBlinkInProgress = _FALSE;
1460 }
1461 if (pLed->bLedScanBlinkInProgress) {
1462 _cancel_timer_ex(&(pLed->BlinkTimer));
1463 pLed->bLedScanBlinkInProgress = _FALSE;
1464 }
1465 if (pLed->bLedWPSBlinkInProgress) {
1466 _cancel_timer_ex(&(pLed->BlinkTimer));
1467 pLed->bLedWPSBlinkInProgress = _FALSE;
1468 }
1469
1470 SwLedOff(padapter, pLed);
1471 break;
1472
1473 default:
1474 break;
1475
1476 }
1477
1478 }
1479
1480
1481 /* Edimax-Belkin, added by chiyoko, 20090413 */
1482 static void
SwLedControlMode4(_adapter * padapter,LED_CTL_MODE LedAction)1483 SwLedControlMode4(
1484 _adapter *padapter,
1485 LED_CTL_MODE LedAction
1486 )
1487 {
1488 struct led_priv *ledpriv = adapter_to_led(padapter);
1489 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1490 PLED_SDIO pLed = &(ledpriv->SwLed0);
1491 PLED_SDIO pLed1 = &(ledpriv->SwLed1);
1492
1493 switch (LedAction) {
1494 case LED_CTL_START_TO_LINK:
1495 if (pLed1->bLedWPSBlinkInProgress) {
1496 pLed1->bLedWPSBlinkInProgress = _FALSE;
1497 _cancel_timer_ex(&(pLed1->BlinkTimer));
1498
1499 pLed1->BlinkingLedState = RTW_LED_OFF;
1500 pLed1->CurrLedState = RTW_LED_OFF;
1501
1502 if (pLed1->bLedOn)
1503 _set_timer(&(pLed->BlinkTimer), 0);
1504 }
1505
1506 if (pLed->bLedStartToLinkBlinkInProgress == _FALSE) {
1507 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1508 return;
1509 if (pLed->bLedBlinkInProgress == _TRUE) {
1510 _cancel_timer_ex(&(pLed->BlinkTimer));
1511 pLed->bLedBlinkInProgress = _FALSE;
1512 }
1513 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1514 _cancel_timer_ex(&(pLed->BlinkTimer));
1515 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1516 }
1517
1518 pLed->bLedStartToLinkBlinkInProgress = _TRUE;
1519 pLed->CurrLedState = LED_BLINK_StartToBlink;
1520 if (pLed->bLedOn) {
1521 pLed->BlinkingLedState = RTW_LED_OFF;
1522 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1523 } else {
1524 pLed->BlinkingLedState = RTW_LED_ON;
1525 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1526 }
1527 }
1528 break;
1529
1530 case LED_CTL_LINK:
1531 case LED_CTL_NO_LINK:
1532 /* LED1 settings */
1533 if (LedAction == LED_CTL_LINK) {
1534 if (pLed1->bLedWPSBlinkInProgress) {
1535 pLed1->bLedWPSBlinkInProgress = _FALSE;
1536 _cancel_timer_ex(&(pLed1->BlinkTimer));
1537
1538 pLed1->BlinkingLedState = RTW_LED_OFF;
1539 pLed1->CurrLedState = RTW_LED_OFF;
1540
1541 if (pLed1->bLedOn)
1542 _set_timer(&(pLed->BlinkTimer), 0);
1543 }
1544 }
1545
1546 if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
1547 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1548 return;
1549 if (pLed->bLedBlinkInProgress == _TRUE) {
1550 _cancel_timer_ex(&(pLed->BlinkTimer));
1551 pLed->bLedBlinkInProgress = _FALSE;
1552 }
1553
1554 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1555 pLed->CurrLedState = LED_BLINK_SLOWLY;
1556 if (pLed->bLedOn)
1557 pLed->BlinkingLedState = RTW_LED_OFF;
1558 else
1559 pLed->BlinkingLedState = RTW_LED_ON;
1560 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1561 }
1562 break;
1563
1564 case LED_CTL_SITE_SURVEY:
1565 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
1566 ;
1567 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
1568 if (IS_LED_WPS_BLINKING(pLed))
1569 return;
1570
1571 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1572 _cancel_timer_ex(&(pLed->BlinkTimer));
1573 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1574 }
1575 if (pLed->bLedBlinkInProgress == _TRUE) {
1576 _cancel_timer_ex(&(pLed->BlinkTimer));
1577 pLed->bLedBlinkInProgress = _FALSE;
1578 }
1579 pLed->bLedScanBlinkInProgress = _TRUE;
1580 pLed->CurrLedState = LED_BLINK_SCAN;
1581 pLed->BlinkTimes = 24;
1582 if (pLed->bLedOn)
1583 pLed->BlinkingLedState = RTW_LED_OFF;
1584 else
1585 pLed->BlinkingLedState = RTW_LED_ON;
1586 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1587 }
1588 break;
1589
1590 case LED_CTL_TX:
1591 case LED_CTL_RX:
1592 if (pLed->bLedBlinkInProgress == _FALSE) {
1593 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1594 return;
1595 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1596 _cancel_timer_ex(&(pLed->BlinkTimer));
1597 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1598 }
1599 pLed->bLedBlinkInProgress = _TRUE;
1600 pLed->CurrLedState = LED_BLINK_TXRX;
1601 pLed->BlinkTimes = 2;
1602 if (pLed->bLedOn)
1603 pLed->BlinkingLedState = RTW_LED_OFF;
1604 else
1605 pLed->BlinkingLedState = RTW_LED_ON;
1606 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1607 }
1608 break;
1609
1610 case LED_CTL_START_WPS: /* wait until xinpin finish */
1611 case LED_CTL_START_WPS_BOTTON:
1612 if (pLed1->bLedWPSBlinkInProgress) {
1613 pLed1->bLedWPSBlinkInProgress = _FALSE;
1614 _cancel_timer_ex(&(pLed1->BlinkTimer));
1615
1616 pLed1->BlinkingLedState = RTW_LED_OFF;
1617 pLed1->CurrLedState = RTW_LED_OFF;
1618
1619 if (pLed1->bLedOn)
1620 _set_timer(&(pLed->BlinkTimer), 0);
1621 }
1622
1623 if (pLed->bLedWPSBlinkInProgress == _FALSE) {
1624 if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
1625 _cancel_timer_ex(&(pLed->BlinkTimer));
1626 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1627 }
1628 if (pLed->bLedBlinkInProgress == _TRUE) {
1629 _cancel_timer_ex(&(pLed->BlinkTimer));
1630 pLed->bLedBlinkInProgress = _FALSE;
1631 }
1632 if (pLed->bLedScanBlinkInProgress == _TRUE) {
1633 _cancel_timer_ex(&(pLed->BlinkTimer));
1634 pLed->bLedScanBlinkInProgress = _FALSE;
1635 }
1636 pLed->bLedWPSBlinkInProgress = _TRUE;
1637 pLed->CurrLedState = LED_BLINK_WPS;
1638 if (pLed->bLedOn) {
1639 pLed->BlinkingLedState = RTW_LED_OFF;
1640 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1641 } else {
1642 pLed->BlinkingLedState = RTW_LED_ON;
1643 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1644 }
1645 }
1646 break;
1647
1648 case LED_CTL_STOP_WPS: /* WPS connect success */
1649 if (pLed->bLedWPSBlinkInProgress) {
1650 _cancel_timer_ex(&(pLed->BlinkTimer));
1651 pLed->bLedWPSBlinkInProgress = _FALSE;
1652 }
1653
1654 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1655 pLed->CurrLedState = LED_BLINK_SLOWLY;
1656 if (pLed->bLedOn)
1657 pLed->BlinkingLedState = RTW_LED_OFF;
1658 else
1659 pLed->BlinkingLedState = RTW_LED_ON;
1660 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1661
1662 break;
1663
1664 case LED_CTL_STOP_WPS_FAIL: /* WPS authentication fail */
1665 if (pLed->bLedWPSBlinkInProgress) {
1666 _cancel_timer_ex(&(pLed->BlinkTimer));
1667 pLed->bLedWPSBlinkInProgress = _FALSE;
1668 }
1669
1670 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1671 pLed->CurrLedState = LED_BLINK_SLOWLY;
1672 if (pLed->bLedOn)
1673 pLed->BlinkingLedState = RTW_LED_OFF;
1674 else
1675 pLed->BlinkingLedState = RTW_LED_ON;
1676 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1677
1678 /* LED1 settings */
1679 if (pLed1->bLedWPSBlinkInProgress)
1680 _cancel_timer_ex(&(pLed1->BlinkTimer));
1681 else
1682 pLed1->bLedWPSBlinkInProgress = _TRUE;
1683
1684 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1685 if (pLed1->bLedOn)
1686 pLed1->BlinkingLedState = RTW_LED_OFF;
1687 else
1688 pLed1->BlinkingLedState = RTW_LED_ON;
1689 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1690
1691 break;
1692
1693 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
1694 if (pLed->bLedWPSBlinkInProgress) {
1695 _cancel_timer_ex(&(pLed->BlinkTimer));
1696 pLed->bLedWPSBlinkInProgress = _FALSE;
1697 }
1698
1699 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1700 pLed->CurrLedState = LED_BLINK_SLOWLY;
1701 if (pLed->bLedOn)
1702 pLed->BlinkingLedState = RTW_LED_OFF;
1703 else
1704 pLed->BlinkingLedState = RTW_LED_ON;
1705 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1706
1707 /* LED1 settings */
1708 if (pLed1->bLedWPSBlinkInProgress)
1709 _cancel_timer_ex(&(pLed1->BlinkTimer));
1710 else
1711 pLed1->bLedWPSBlinkInProgress = _TRUE;
1712
1713 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1714 pLed1->BlinkTimes = 10;
1715 if (pLed1->bLedOn)
1716 pLed1->BlinkingLedState = RTW_LED_OFF;
1717 else
1718 pLed1->BlinkingLedState = RTW_LED_ON;
1719 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1720
1721 break;
1722
1723 case LED_CTL_POWER_OFF:
1724 pLed->CurrLedState = RTW_LED_OFF;
1725 pLed->BlinkingLedState = RTW_LED_OFF;
1726
1727 if (pLed->bLedNoLinkBlinkInProgress) {
1728 _cancel_timer_ex(&(pLed->BlinkTimer));
1729 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1730 }
1731 if (pLed->bLedLinkBlinkInProgress) {
1732 _cancel_timer_ex(&(pLed->BlinkTimer));
1733 pLed->bLedLinkBlinkInProgress = _FALSE;
1734 }
1735 if (pLed->bLedBlinkInProgress) {
1736 _cancel_timer_ex(&(pLed->BlinkTimer));
1737 pLed->bLedBlinkInProgress = _FALSE;
1738 }
1739 if (pLed->bLedWPSBlinkInProgress) {
1740 _cancel_timer_ex(&(pLed->BlinkTimer));
1741 pLed->bLedWPSBlinkInProgress = _FALSE;
1742 }
1743 if (pLed->bLedScanBlinkInProgress) {
1744 _cancel_timer_ex(&(pLed->BlinkTimer));
1745 pLed->bLedScanBlinkInProgress = _FALSE;
1746 }
1747 if (pLed->bLedStartToLinkBlinkInProgress) {
1748 _cancel_timer_ex(&(pLed->BlinkTimer));
1749 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
1750 }
1751
1752 if (pLed1->bLedWPSBlinkInProgress) {
1753 _cancel_timer_ex(&(pLed1->BlinkTimer));
1754 pLed1->bLedWPSBlinkInProgress = _FALSE;
1755 }
1756
1757 pLed1->BlinkingLedState = LED_UNKNOWN;
1758 SwLedOff(padapter, pLed);
1759 SwLedOff(padapter, pLed1);
1760 break;
1761
1762 default:
1763 break;
1764
1765 }
1766
1767 }
1768
1769
1770
1771 /* Sercomm-Belkin, added by chiyoko, 20090415 */
1772 static void
SwLedControlMode5(_adapter * padapter,LED_CTL_MODE LedAction)1773 SwLedControlMode5(
1774 _adapter *padapter,
1775 LED_CTL_MODE LedAction
1776 )
1777 {
1778 struct led_priv *ledpriv = adapter_to_led(padapter);
1779 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1780 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
1781 PLED_SDIO pLed = &(ledpriv->SwLed0);
1782
1783 if (pHalData->CustomerID == RT_CID_819x_CAMEO)
1784 pLed = &(ledpriv->SwLed1);
1785
1786 switch (LedAction) {
1787 case LED_CTL_POWER_ON:
1788 case LED_CTL_NO_LINK:
1789 case LED_CTL_LINK: /* solid blue */
1790 pLed->CurrLedState = RTW_LED_ON;
1791 pLed->BlinkingLedState = RTW_LED_ON;
1792
1793 _set_timer(&(pLed->BlinkTimer), 0);
1794 break;
1795
1796 case LED_CTL_SITE_SURVEY:
1797 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE))
1798 ;
1799 else if (pLed->bLedScanBlinkInProgress == _FALSE) {
1800 if (pLed->bLedBlinkInProgress == _TRUE) {
1801 _cancel_timer_ex(&(pLed->BlinkTimer));
1802 pLed->bLedBlinkInProgress = _FALSE;
1803 }
1804 pLed->bLedScanBlinkInProgress = _TRUE;
1805 pLed->CurrLedState = LED_BLINK_SCAN;
1806 pLed->BlinkTimes = 24;
1807 if (pLed->bLedOn)
1808 pLed->BlinkingLedState = RTW_LED_OFF;
1809 else
1810 pLed->BlinkingLedState = RTW_LED_ON;
1811 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1812 }
1813 break;
1814
1815 case LED_CTL_TX:
1816 case LED_CTL_RX:
1817 if (pLed->bLedBlinkInProgress == _FALSE) {
1818 if (pLed->CurrLedState == LED_BLINK_SCAN)
1819 return;
1820 pLed->bLedBlinkInProgress = _TRUE;
1821 pLed->CurrLedState = LED_BLINK_TXRX;
1822 pLed->BlinkTimes = 2;
1823 if (pLed->bLedOn)
1824 pLed->BlinkingLedState = RTW_LED_OFF;
1825 else
1826 pLed->BlinkingLedState = RTW_LED_ON;
1827 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1828 }
1829 break;
1830
1831 case LED_CTL_POWER_OFF:
1832 pLed->CurrLedState = RTW_LED_OFF;
1833 pLed->BlinkingLedState = RTW_LED_OFF;
1834
1835 if (pLed->bLedBlinkInProgress) {
1836 _cancel_timer_ex(&(pLed->BlinkTimer));
1837 pLed->bLedBlinkInProgress = _FALSE;
1838 }
1839
1840 SwLedOff(padapter, pLed);
1841 break;
1842
1843 default:
1844 break;
1845
1846 }
1847
1848 }
1849
1850 /* WNC-Corega, added by chiyoko, 20090902 */
1851 static void
SwLedControlMode6(_adapter * padapter,LED_CTL_MODE LedAction)1852 SwLedControlMode6(
1853 _adapter *padapter,
1854 LED_CTL_MODE LedAction
1855 )
1856 {
1857 struct led_priv *ledpriv = adapter_to_led(padapter);
1858 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1859 PLED_SDIO pLed0 = &(ledpriv->SwLed0);
1860
1861 switch (LedAction) {
1862 case LED_CTL_POWER_ON:
1863 case LED_CTL_LINK:
1864 case LED_CTL_NO_LINK:
1865 _cancel_timer_ex(&(pLed0->BlinkTimer));
1866 pLed0->CurrLedState = RTW_LED_ON;
1867 pLed0->BlinkingLedState = RTW_LED_ON;
1868 _set_timer(&(pLed0->BlinkTimer), 0);
1869 break;
1870
1871 case LED_CTL_POWER_OFF:
1872 SwLedOff(padapter, pLed0);
1873 break;
1874
1875 default:
1876 break;
1877 }
1878
1879 }
1880
1881 void
LedControlSDIO(_adapter * padapter,LED_CTL_MODE LedAction)1882 LedControlSDIO(
1883 _adapter *padapter,
1884 LED_CTL_MODE LedAction
1885 )
1886 {
1887 struct led_priv *ledpriv = adapter_to_led(padapter);
1888
1889 #if (MP_DRIVER == 1)
1890 if (padapter->registrypriv.mp_mode == 1)
1891 return;
1892 #endif
1893
1894 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
1895 /*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
1896 , __func__
1897 , rtw_is_drv_stopped(padapter)?"True":"False"
1898 , rtw_is_surprise_removed(padapter)?"True":"False");*/
1899 return;
1900 }
1901
1902 if (ledpriv->bRegUseLed == _FALSE)
1903 return;
1904
1905 /* if(priv->bInHctTest) */
1906 /* return; */
1907
1908 if ((adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on &&
1909 adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&
1910 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
1911 LedAction == LED_CTL_SITE_SURVEY ||
1912 LedAction == LED_CTL_LINK ||
1913 LedAction == LED_CTL_NO_LINK ||
1914 LedAction == LED_CTL_POWER_ON))
1915 return;
1916
1917 switch (ledpriv->LedStrategy) {
1918 #if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
1919 case SW_LED_MODE_UC_TRX_ONLY:
1920 rtw_sw_led_ctl_mode_uc_trx_only(padapter, LedAction);
1921 break;
1922 #endif
1923
1924 case SW_LED_MODE0:
1925 SwLedControlMode0(padapter, LedAction);
1926 break;
1927
1928 case SW_LED_MODE1:
1929 SwLedControlMode1(padapter, LedAction);
1930 break;
1931 case SW_LED_MODE2:
1932 SwLedControlMode2(padapter, LedAction);
1933 break;
1934
1935 case SW_LED_MODE3:
1936 SwLedControlMode3(padapter, LedAction);
1937 break;
1938
1939 case SW_LED_MODE4:
1940 SwLedControlMode4(padapter, LedAction);
1941 break;
1942
1943 case SW_LED_MODE5:
1944 SwLedControlMode5(padapter, LedAction);
1945 break;
1946
1947 case SW_LED_MODE6:
1948 SwLedControlMode6(padapter, LedAction);
1949 break;
1950
1951 default:
1952 break;
1953 }
1954
1955 }
1956
1957 /*
1958 * Description:
1959 * Reset status of LED_871x object.
1960 * */
ResetLedStatus(PLED_SDIO pLed)1961 void ResetLedStatus(PLED_SDIO pLed)
1962 {
1963
1964 pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
1965 pLed->bLedOn = _FALSE; /* true if LED is ON, false if LED is OFF. */
1966
1967 pLed->bLedBlinkInProgress = _FALSE; /* true if it is blinking, false o.w.. */
1968 pLed->bLedWPSBlinkInProgress = _FALSE;
1969
1970 pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
1971 pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
1972
1973 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1974 pLed->bLedLinkBlinkInProgress = _FALSE;
1975 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
1976 pLed->bLedScanBlinkInProgress = _FALSE;
1977 }
1978
1979 /*
1980 * Description:
1981 * Initialize an LED_871x object.
1982 * */
1983 void
InitLed(_adapter * padapter,PLED_SDIO pLed,LED_PIN LedPin)1984 InitLed(
1985 _adapter *padapter,
1986 PLED_SDIO pLed,
1987 LED_PIN LedPin
1988 )
1989 {
1990 pLed->padapter = padapter;
1991 pLed->LedPin = LedPin;
1992
1993 ResetLedStatus(pLed);
1994
1995 rtw_init_timer(&(pLed->BlinkTimer), padapter, BlinkTimerCallback, pLed);
1996
1997 _init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
1998 }
1999
2000
2001 /*
2002 * Description:
2003 * DeInitialize an LED_871x object.
2004 * */
2005 void
DeInitLed(PLED_SDIO pLed)2006 DeInitLed(
2007 PLED_SDIO pLed
2008 )
2009 {
2010 _cancel_workitem_sync(&(pLed->BlinkWorkItem));
2011 _cancel_timer_ex(&(pLed->BlinkTimer));
2012 ResetLedStatus(pLed);
2013 }
2014 #endif
2015