1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
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 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20
21 #include <drv_types.h>
22 #include <hal_data.h>
23
24 /*
25 * Description:
26 * Turn on LED according to LedPin specified.
27 * */
28 VOID
HwLedBlink(IN PADAPTER Adapter,IN PLED_PCIE pLed)29 HwLedBlink(
30 IN PADAPTER Adapter,
31 IN PLED_PCIE pLed
32 )
33 {
34
35
36 switch (pLed->LedPin) {
37 case LED_PIN_GPIO0:
38 break;
39
40 case LED_PIN_LED0:
41 /* rtw_write8(Adapter, LED0Cfg, 0x2); */
42 break;
43
44 case LED_PIN_LED1:
45 /* rtw_write8(Adapter, LED1Cfg, 0x2); */
46 break;
47
48 default:
49 break;
50 }
51
52 pLed->bLedOn = _TRUE;
53 }
54
55 /*
56 * Description:
57 * Implement LED blinking behavior for SW_LED_MODE0.
58 * It toggle off LED and schedule corresponding timer if necessary.
59 * */
60 VOID
SwLedBlink(IN PLED_PCIE pLed)61 SwLedBlink(
62 IN PLED_PCIE pLed
63 )
64 {
65 PADAPTER Adapter = pLed->padapter;
66 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
67 BOOLEAN bStopBlinking = _FALSE;
68
69 /* Change LED according to BlinkingLedState specified. */
70 if (pLed->BlinkingLedState == RTW_LED_ON) {
71 SwLedOn(Adapter, pLed);
72 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
73 } else {
74 SwLedOff(Adapter, pLed);
75 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
76 }
77
78 /* Determine if we shall change LED state again. */
79 pLed->BlinkTimes--;
80 switch (pLed->CurrLedState) {
81 case LED_BLINK_NORMAL:
82 case LED_BLINK_TXRX:
83 case LED_BLINK_RUNTOP:
84 if (pLed->BlinkTimes == 0)
85 bStopBlinking = _TRUE;
86 break;
87
88 case LED_BLINK_SCAN:
89 if (((check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) ||
90 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) && /* Linked. */
91 (!check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) && /* Not in scan stage. */
92 (pLed->BlinkTimes % 2 == 0)) /* Even */
93 bStopBlinking = _TRUE;
94 break;
95
96 case LED_BLINK_NO_LINK:
97 case LED_BLINK_StartToBlink:
98 if (check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
99 bStopBlinking = _TRUE;
100 else if ((check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) &&
101 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
102 bStopBlinking = _TRUE;
103 else if (pLed->BlinkTimes == 0)
104 bStopBlinking = _TRUE;
105 break;
106
107 case LED_BLINK_CAMEO:
108 if (check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
109 bStopBlinking = _TRUE;
110 else if (check_fwstate(pmlmepriv, _FW_LINKED) &&
111 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
112 bStopBlinking = _TRUE;
113 break;
114
115 default:
116 bStopBlinking = _TRUE;
117 break;
118 }
119
120 if (bStopBlinking) {
121 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
122 SwLedOff(Adapter, pLed);
123 else if (pLed->CurrLedState == LED_BLINK_TXRX)
124 SwLedOff(Adapter, pLed);
125 else if (pLed->CurrLedState == LED_BLINK_RUNTOP)
126 SwLedOff(Adapter, pLed);
127 else if ((check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) && pLed->bLedOn == _FALSE)
128 SwLedOn(Adapter, pLed);
129 else if ((check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) && pLed->bLedOn == _TRUE)
130 SwLedOff(Adapter, pLed);
131
132 pLed->BlinkTimes = 0;
133 pLed->bLedBlinkInProgress = _FALSE;
134 } else {
135 /* Assign LED state to toggle. */
136 if (pLed->BlinkingLedState == RTW_LED_ON)
137 pLed->BlinkingLedState = RTW_LED_OFF;
138 else
139 pLed->BlinkingLedState = RTW_LED_ON;
140
141 /* Schedule a timer to toggle LED state. */
142 switch (pLed->CurrLedState) {
143 case LED_BLINK_NORMAL:
144 case LED_BLINK_TXRX:
145 case LED_BLINK_StartToBlink:
146 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
147 break;
148
149 case LED_BLINK_SLOWLY:
150 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
151 break;
152
153 case LED_BLINK_SCAN:
154 case LED_BLINK_NO_LINK:
155 if (pLed->bLedOn)
156 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
157 else
158 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
159 break;
160
161 case LED_BLINK_RUNTOP:
162 _set_timer(&(pLed->BlinkTimer), LED_RunTop_BLINK_INTERVAL);
163 break;
164
165 case LED_BLINK_CAMEO:
166 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
167 break;
168
169 default:
170 /* RTW_INFO("SwLedCm2Blink(): unexpected state!\n"); */
171 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
172 break;
173 }
174 }
175 }
176
177 VOID
SwLedBlink5(IN PLED_PCIE pLed)178 SwLedBlink5(
179 IN PLED_PCIE pLed
180 )
181 {
182 PADAPTER Adapter = pLed->padapter;
183 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
184 BOOLEAN bStopBlinking = _FALSE;
185
186 /* Change LED according to BlinkingLedState specified. */
187 if (pLed->BlinkingLedState == RTW_LED_ON) {
188 SwLedOn(Adapter, pLed);
189 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
190 } else {
191 SwLedOff(Adapter, pLed);
192 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
193 }
194
195 switch (pLed->CurrLedState) {
196 case RTW_LED_OFF:
197 SwLedOff(Adapter, pLed);
198 break;
199
200 case LED_BLINK_SLOWLY:
201 if (pLed->bLedOn)
202 pLed->BlinkingLedState = RTW_LED_OFF;
203 else
204 pLed->BlinkingLedState = RTW_LED_ON;
205 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
206 break;
207
208 case LED_BLINK_NORMAL:
209 pLed->BlinkTimes--;
210 if (pLed->BlinkTimes == 0)
211 bStopBlinking = _TRUE;
212 if (bStopBlinking) {
213 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
214 SwLedOff(Adapter, pLed);
215 else {
216 pLed->bLedSlowBlinkInProgress = _TRUE;
217 pLed->CurrLedState = LED_BLINK_SLOWLY;
218 if (pLed->bLedOn)
219 pLed->BlinkingLedState = RTW_LED_OFF;
220 else
221 pLed->BlinkingLedState = RTW_LED_ON;
222 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
223 }
224 pLed->BlinkTimes = 0;
225 pLed->bLedBlinkInProgress = _FALSE;
226 } else {
227 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
228 SwLedOff(Adapter, pLed);
229 else {
230 if (pLed->bLedOn)
231 pLed->BlinkingLedState = RTW_LED_OFF;
232 else
233 pLed->BlinkingLedState = RTW_LED_ON;
234
235 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_NETTRONIX);
236 }
237 }
238 break;
239
240 default:
241 break;
242 }
243
244 }
245
246
247 VOID
SwLedBlink6(IN PLED_PCIE pLed)248 SwLedBlink6(
249 IN PLED_PCIE pLed
250 )
251 {
252 PADAPTER Adapter = pLed->padapter;
253 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
254 BOOLEAN bStopBlinking = _FALSE;
255
256 /* Change LED according to BlinkingLedState specified. */
257 if (pLed->BlinkingLedState == RTW_LED_ON) {
258 SwLedOn(Adapter, pLed);
259 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
260 } else {
261 SwLedOff(Adapter, pLed);
262 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
263 }
264
265 switch (pLed->CurrLedState) {
266 case RTW_LED_OFF:
267 SwLedOff(Adapter, pLed);
268 break;
269
270 case LED_BLINK_SLOWLY:
271 if (pLed->bLedOn)
272 pLed->BlinkingLedState = RTW_LED_OFF;
273 else
274 pLed->BlinkingLedState = RTW_LED_ON;
275 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
276 break;
277
278 case LED_BLINK_NORMAL:
279 pLed->BlinkTimes--;
280 if (pLed->BlinkTimes == 0)
281 bStopBlinking = _TRUE;
282 if (bStopBlinking) {
283 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
284 SwLedOff(Adapter, pLed);
285 else {
286 pLed->bLedSlowBlinkInProgress = _TRUE;
287 pLed->CurrLedState = LED_BLINK_SLOWLY;
288 if (pLed->bLedOn)
289 pLed->BlinkingLedState = RTW_LED_OFF;
290 else
291 pLed->BlinkingLedState = RTW_LED_ON;
292 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
293 }
294 pLed->BlinkTimes = 0;
295 pLed->bLedBlinkInProgress = _FALSE;
296 } else {
297 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
298 SwLedOff(Adapter, pLed);
299 else {
300 if (pLed->bLedOn)
301 pLed->BlinkingLedState = RTW_LED_OFF;
302 else
303 pLed->BlinkingLedState = RTW_LED_ON;
304
305 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_PORNET);
306 }
307 }
308 break;
309
310 default:
311 break;
312 }
313
314 }
315
316 VOID
SwLedBlink7(IN PLED_PCIE pLed)317 SwLedBlink7(
318 IN PLED_PCIE pLed
319 )
320 {
321 PADAPTER Adapter = pLed->padapter;
322
323 SwLedOn(Adapter, pLed);
324 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
325 }
326
327
328
329 /*
330 * Description:
331 * Implement LED blinking behavior for SW_LED_MODE8.
332 * It toggle off LED and schedule corresponding timer if necessary.
333 * */
334 VOID
SwLedBlink8(IN PLED_PCIE pLed)335 SwLedBlink8(
336 IN PLED_PCIE pLed
337 )
338 {
339 PADAPTER Adapter = pLed->padapter;
340 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
341 BOOLEAN bStopBlinking = _FALSE;
342
343 /* Change LED according to BlinkingLedState specified. */
344 if (pLed->BlinkingLedState == RTW_LED_ON) {
345 SwLedOn(Adapter, pLed);
346 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
347 } else {
348 SwLedOff(Adapter, pLed);
349 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
350 }
351
352 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink8 CurrLedAction %d,\n", pLed->CurrLedState));
353
354 /* Determine if we shall change LED state again. */
355 if (pLed->CurrLedState != LED_BLINK_NO_LINK)
356 pLed->BlinkTimes--;
357
358 switch (pLed->CurrLedState) {
359 case LED_BLINK_NORMAL:
360 case LED_BLINK_SCAN:
361 if (pLed->BlinkTimes == 0)
362 bStopBlinking = _TRUE;
363 break;
364
365 default:
366 break;
367 }
368
369 if (bStopBlinking) {
370 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
371 pLed->CurrLedState = RTW_LED_OFF;
372 SwLedOff(Adapter, pLed);
373 } else {
374 pLed->CurrLedState = RTW_LED_ON;
375 SwLedOn(Adapter, pLed);
376 }
377
378 pLed->BlinkTimes = 0;
379 pLed->bLedBlinkInProgress = _FALSE;
380 } else {
381 /* Assign LED state to toggle. */
382 if (pLed->BlinkingLedState == RTW_LED_ON)
383 pLed->BlinkingLedState = RTW_LED_OFF;
384 else
385 pLed->BlinkingLedState = RTW_LED_ON;
386
387 /* Schedule a timer to toggle LED state. */
388 switch (pLed->CurrLedState) {
389 case LED_BLINK_NORMAL:
390 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
391 break;
392
393 default:
394 /* RTW_INFO("SwLedCm8Blink(): unexpected state!\n"); */
395 break;
396 }
397 }
398 }
399
400 VOID
SwLedBlink9(IN PLED_PCIE pLed)401 SwLedBlink9(
402 IN PLED_PCIE pLed
403 )
404 {
405 PADAPTER Adapter = pLed->padapter;
406 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
407 BOOLEAN bStopBlinking = _FALSE;
408
409 /* Change LED according to BlinkingLedState specified. */
410 if (pLed->BlinkingLedState == RTW_LED_ON) {
411 SwLedOn(Adapter, pLed);
412 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
413 } else {
414 SwLedOff(Adapter, pLed);
415 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
416 }
417
418 /* Determine if we shall change LED state again. */
419 if (pLed->CurrLedState != LED_BLINK_NO_LINK)
420 pLed->BlinkTimes--;
421
422 switch (pLed->CurrLedState) {
423 case LED_BLINK_NORMAL:
424 case LED_BLINK_SCAN:
425 if (pLed->BlinkTimes == 0)
426 bStopBlinking = _TRUE;
427 break;
428
429 case LED_BLINK_NO_LINK:
430 if (check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
431 bStopBlinking = _TRUE;
432 else if (check_fwstate(pmlmepriv, _FW_LINKED) &&
433 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
434 bStopBlinking = _TRUE;
435 break;
436
437 default:
438 break;
439 }
440
441 if (bStopBlinking) {
442 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
443 pLed->CurrLedState = RTW_LED_OFF;
444 SwLedOff(Adapter, pLed);
445 } else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
446 pLed->CurrLedState = RTW_LED_ON;
447 SwLedOn(Adapter, pLed);
448 } else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
449 pLed->CurrLedState = LED_BLINK_NO_LINK;
450 if (pLed->bLedOn)
451 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
452 else
453 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
454 }
455
456 pLed->BlinkTimes = 0;
457 if (pLed->CurrLedState != LED_BLINK_NO_LINK)
458 pLed->bLedBlinkInProgress = _FALSE;
459 } else {
460 /* Assign LED state to toggle. */
461 if (pLed->BlinkingLedState == RTW_LED_ON)
462 pLed->BlinkingLedState = RTW_LED_OFF;
463 else
464 pLed->BlinkingLedState = RTW_LED_ON;
465
466 /* Schedule a timer to toggle LED state. */
467 switch (pLed->CurrLedState) {
468 case LED_BLINK_NORMAL:
469 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FAST_INTERVAL_BITLAND);
470 break;
471
472 case LED_BLINK_SCAN:
473 case LED_BLINK_NO_LINK:
474 if (pLed->bLedOn)
475 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
476 else
477 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
478 break;
479
480 default:
481 /* RTW_INFO("SwLedCm2Blink(): unexpected state!\n"); */
482 break;
483 }
484 }
485
486 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink9 CurrLedAction %d,\n", pLed->CurrLedState));
487
488 }
489
490
491 VOID
SwLedBlink10(IN PLED_PCIE pLed)492 SwLedBlink10(
493 IN PLED_PCIE pLed
494 )
495 {
496 PADAPTER Adapter = pLed->padapter;
497 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
498 BOOLEAN bStopBlinking = _FALSE;
499
500 /* Change LED according to BlinkingLedState specified. */
501 if (pLed->BlinkingLedState == RTW_LED_ON) {
502 SwLedOn(Adapter, pLed);
503 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
504 } else {
505 SwLedOff(Adapter, pLed);
506 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
507 }
508
509 /* Determine if we shall change LED state again. */
510 if (pLed->CurrLedState != LED_BLINK_NO_LINK)
511 pLed->BlinkTimes--;
512
513 switch (pLed->CurrLedState) {
514 case LED_BLINK_NORMAL:
515 case LED_BLINK_SCAN:
516 if (pLed->BlinkTimes == 0)
517 bStopBlinking = _TRUE;
518 break;
519 default:
520 break;
521 }
522
523 if (bStopBlinking) {
524 pLed->CurrLedState = RTW_LED_OFF;
525 SwLedOff(Adapter, pLed);
526
527 pLed->BlinkTimes = 0;
528 pLed->bLedBlinkInProgress = _FALSE;
529 } else {
530 /* Assign LED state to toggle. */
531 if (pLed->BlinkingLedState == RTW_LED_ON)
532 pLed->BlinkingLedState = RTW_LED_OFF;
533 else
534 pLed->BlinkingLedState = RTW_LED_ON;
535
536 /* Schedule a timer to toggle LED state. */
537 switch (pLed->CurrLedState) {
538 case LED_BLINK_NORMAL:
539 case LED_BLINK_SCAN:
540 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FAST_INTERVAL_BITLAND);
541 break;
542
543 default:
544 /* RT_ASSERT(_FALSE, ("SwLedCm2Blink(): unexpected state!\n")); */
545 break;
546 }
547 }
548
549 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink10 CurrLedAction %d,\n", pLed->CurrLedState));
550
551 }
552
553
554 VOID
SwLedBlink11(IN PLED_PCIE pLed)555 SwLedBlink11(
556 IN PLED_PCIE pLed
557 )
558 {
559 PADAPTER Adapter = pLed->padapter;
560 BOOLEAN bStopBlinking = _FALSE;
561
562 /* Change LED according to BlinkingLedState specified. */
563 if (pLed->bLedBlinkInProgress == _TRUE) {
564 if (pLed->BlinkingLedState == RTW_LED_ON) {
565 SwLedOn(Adapter, pLed);
566 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%ld): turn on\n", pLed->BlinkTimes));
567 } else {
568 SwLedOff(Adapter, pLed);
569 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%ld): turn off\n", pLed->BlinkTimes));
570 }
571 }
572
573 /* Determine if we shall change LED state again. */
574 if (pLed->CurrLedState != LED_BLINK_NO_LINK)
575 pLed->BlinkTimes--;
576
577 switch (pLed->CurrLedState) {
578 case RTW_LED_ON:
579 bStopBlinking = _TRUE; /* LED on for 3 seconds */
580 default:
581 break;
582 }
583
584 if (bStopBlinking) {
585 pLed->CurrLedState = RTW_LED_OFF;
586 SwLedOff(Adapter, pLed);
587
588 pLed->BlinkTimes = 0;
589 pLed->bLedBlinkInProgress = _FALSE;
590 } else {
591 /* Assign LED state to toggle. */
592 if (pLed->BlinkingLedState == RTW_LED_ON)
593 pLed->BlinkingLedState = RTW_LED_OFF;
594 else
595 pLed->BlinkingLedState = RTW_LED_ON;
596
597 /* Schedule a timer to toggle LED state. */
598 switch (pLed->CurrLedState) {
599 case LED_BLINK_XAVI:
600 _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
601 break;
602
603 default:
604 /* RT_ASSERT(_FALSE, ("SwLedCm11Blink(): unexpected state!\n")); */
605 break;
606 }
607 }
608
609 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink11 CurrLedAction %d,\n", pLed->CurrLedState));
610
611 }
612
613
614 VOID
SwLedBlink12(IN PLED_PCIE pLed)615 SwLedBlink12(
616 IN PLED_PCIE pLed
617 )
618 {
619 PADAPTER Adapter = pLed->padapter;
620 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
621 BOOLEAN bStopBlinking = _FALSE;
622
623 /* Change LED according to BlinkingLedState specified. */
624 if (pLed->BlinkingLedState == RTW_LED_ON) {
625 SwLedOn(Adapter, pLed);
626 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink12 Blinktimes (%d): turn on\n", pLed->BlinkTimes));
627 } else {
628 SwLedOff(Adapter, pLed);
629 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink12 Blinktimes (%d): turn off\n", pLed->BlinkTimes));
630 }
631
632 /* Determine if we shall change LED state again. */
633 if (pLed->CurrLedState != LED_BLINK_NO_LINK && pLed->CurrLedState != LED_BLINK_Azurewave_5Mbps
634 && pLed->CurrLedState != LED_BLINK_Azurewave_10Mbps && pLed->CurrLedState != LED_BLINK_Azurewave_20Mbps
635 && pLed->CurrLedState != LED_BLINK_Azurewave_40Mbps && pLed->CurrLedState != LED_BLINK_Azurewave_80Mbps
636 && pLed->CurrLedState != LED_BLINK_Azurewave_MAXMbps)
637 pLed->BlinkTimes--;
638
639 switch (pLed->CurrLedState) {
640 case LED_BLINK_NORMAL:
641 case LED_BLINK_SCAN:
642 if (pLed->BlinkTimes == 0)
643 bStopBlinking = _TRUE;
644 break;
645
646 case LED_BLINK_NO_LINK:
647 if (check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
648 bStopBlinking = _TRUE;
649 else if (check_fwstate(pmlmepriv, _FW_LINKED) &&
650 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
651 bStopBlinking = _TRUE;
652 break;
653
654 case LED_BLINK_Azurewave_5Mbps:
655 case LED_BLINK_Azurewave_10Mbps:
656 case LED_BLINK_Azurewave_20Mbps:
657 case LED_BLINK_Azurewave_40Mbps:
658 case LED_BLINK_Azurewave_80Mbps:
659 case LED_BLINK_Azurewave_MAXMbps:
660 /* RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink12 pTurboCa->TxThroughput (%d) pTurboCa->RxThroughput (%d)\n", pTurboCa->TxThroughput, pTurboCa->RxThroughput)); */
661 /* if(pTurboCa->TxThroughput + pTurboCa->RxThroughput == 0) */
662 /* bStopBlinking = _TRUE; */
663
664 default:
665 break;
666 }
667
668 if (bStopBlinking) {
669 if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
670 pLed->CurrLedState = RTW_LED_OFF;
671 pLed->BlinkingLedState = RTW_LED_OFF;
672 SwLedOff(Adapter, pLed);
673 } else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
674 pLed->CurrLedState = RTW_LED_ON;
675 pLed->BlinkingLedState = RTW_LED_ON;
676 SwLedOn(Adapter, pLed);
677 } else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
678 pLed->CurrLedState = LED_BLINK_NO_LINK;
679 if (pLed->bLedOn) {
680 pLed->BlinkingLedState = RTW_LED_OFF;
681 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
682 } else {
683 pLed->BlinkingLedState = RTW_LED_ON;
684 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
685 }
686 }
687
688 pLed->BlinkTimes = 0;
689 if (pLed->CurrLedState != LED_BLINK_NO_LINK)
690 pLed->bLedBlinkInProgress = _FALSE;
691 } else {
692 /* Assign LED state to toggle. */
693 if (pLed->BlinkingLedState == RTW_LED_ON)
694 pLed->BlinkingLedState = RTW_LED_OFF;
695 else
696 pLed->BlinkingLedState = RTW_LED_ON;
697
698 /* Schedule a timer to toggle LED state. */
699 switch (pLed->CurrLedState) {
700 case LED_BLINK_Azurewave_5Mbps:
701 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_5Mbps);
702 break;
703
704 case LED_BLINK_Azurewave_10Mbps:
705 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_10Mbps);
706 break;
707
708 case LED_BLINK_Azurewave_20Mbps:
709 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_20Mbps);
710 break;
711
712 case LED_BLINK_Azurewave_40Mbps:
713 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_40Mbps);
714 break;
715
716 case LED_BLINK_Azurewave_80Mbps:
717 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_80Mbps);
718 break;
719
720 case LED_BLINK_Azurewave_MAXMbps:
721 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_MAXMbps);
722 break;
723
724 case LED_BLINK_SCAN:
725 case LED_BLINK_NO_LINK:
726 if (pLed->bLedOn)
727 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
728 else
729 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
730 break;
731
732 default:
733 /* RT_ASSERT(_FALSE, ("SwLedCm12Blink(): unexpected state!\n")); */
734 break;
735 }
736 }
737
738 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("SwLedBlink12 stopblink %d CurrLedAction %d BlinkingLedState %d,\n", bStopBlinking, pLed->CurrLedState, pLed->BlinkingLedState));
739
740 }
741
742 /*
743 * Description:
744 * Handler function of LED Blinking.
745 * We dispatch acture LED blink action according to LedStrategy.
746 * */
BlinkHandler(PLED_PCIE pLed)747 void BlinkHandler(PLED_PCIE pLed)
748 {
749 _adapter *padapter = pLed->padapter;
750 struct led_priv *ledpriv = &(padapter->ledpriv);
751
752 if (RTW_CANNOT_RUN(padapter))
753 return;
754
755 if (IS_HARDWARE_TYPE_8188E(padapter) ||
756 IS_HARDWARE_TYPE_JAGUAR(padapter) ||
757 IS_HARDWARE_TYPE_8723B(padapter) ||
758 IS_HARDWARE_TYPE_8192E(padapter))
759 return;
760
761 switch (ledpriv->LedStrategy) {
762 case SW_LED_MODE1:
763 /* SwLedBlink(pLed); */
764 break;
765 case SW_LED_MODE2:
766 /* SwLedBlink(pLed); */
767 break;
768 case SW_LED_MODE3:
769 /* SwLedBlink(pLed); */
770 break;
771 case SW_LED_MODE5:
772 /* SwLedBlink5(pLed); */
773 break;
774 case SW_LED_MODE6:
775 /* SwLedBlink6(pLed); */
776 break;
777 case SW_LED_MODE7:
778 SwLedBlink7(pLed);
779 break;
780 case SW_LED_MODE8:
781 SwLedBlink8(pLed);
782 break;
783
784 case SW_LED_MODE9:
785 SwLedBlink9(pLed);
786 break;
787
788 case SW_LED_MODE10:
789 SwLedBlink10(pLed);
790 break;
791
792 case SW_LED_MODE11:
793 SwLedBlink11(pLed);
794 break;
795
796 case SW_LED_MODE12:
797 SwLedBlink12(pLed);
798 break;
799
800 default:
801 /* SwLedBlink(pLed); */
802 break;
803 }
804 }
805
806 /*
807 * Description:
808 * Callback function of LED BlinkTimer,
809 * it just schedules to corresponding BlinkWorkItem/led_blink_hdl
810 * */
BlinkTimerCallback(void * data)811 void BlinkTimerCallback(void *data)
812 {
813 PLED_PCIE pLed = (PLED_PCIE)data;
814 _adapter *padapter = pLed->padapter;
815
816 /* RTW_INFO("%s\n", __FUNCTION__); */
817
818 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
819 /*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
820 , __func__
821 , rtw_is_drv_stopped(padapter)?"True":"False"
822 , rtw_is_surprise_removed(padapter)?"True":"False" );
823 */
824 return;
825 }
826
827 #ifdef CONFIG_LED_HANDLED_BY_CMD_THREAD
828 rtw_led_blink_cmd(padapter, pLed);
829 #else
830 BlinkHandler(pLed);
831 #endif
832 }
833
834 /*
835 * Description:
836 * Implement each led action for SW_LED_MODE0. */
837 VOID
SwLedControlMode0(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)838 SwLedControlMode0(
839 IN PADAPTER Adapter,
840 IN LED_CTL_MODE LedAction
841 )
842 {
843 struct led_priv *ledpriv = &(Adapter->ledpriv);
844 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
845 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
846
847 switch (LedAction) {
848 case LED_CTL_TX:
849 case LED_CTL_RX:
850 break;
851
852 case LED_CTL_LINK:
853 pLed0->CurrLedState = RTW_LED_ON;
854 SwLedOn(Adapter, pLed0);
855
856 pLed1->CurrLedState = LED_BLINK_NORMAL;
857 HwLedBlink(Adapter, pLed1);
858 break;
859
860 case LED_CTL_POWER_ON:
861 pLed0->CurrLedState = RTW_LED_OFF;
862 SwLedOff(Adapter, pLed0);
863
864 pLed1->CurrLedState = LED_BLINK_NORMAL;
865 HwLedBlink(Adapter, pLed1);
866
867 break;
868
869 case LED_CTL_POWER_OFF:
870 pLed0->CurrLedState = RTW_LED_OFF;
871 SwLedOff(Adapter, pLed0);
872
873 pLed1->CurrLedState = RTW_LED_OFF;
874 SwLedOff(Adapter, pLed1);
875 break;
876
877 case LED_CTL_SITE_SURVEY:
878 break;
879
880 case LED_CTL_NO_LINK:
881 pLed0->CurrLedState = RTW_LED_OFF;
882 SwLedOff(Adapter, pLed0);
883
884 pLed1->CurrLedState = LED_BLINK_NORMAL;
885 HwLedBlink(Adapter, pLed1);
886 break;
887
888 default:
889 break;
890 }
891
892 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led0 %d Led1 %d\n", pLed0->CurrLedState, pLed1->CurrLedState));
893 }
894
895
896 VOID
SwLedControlMode1(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)897 SwLedControlMode1(
898 IN PADAPTER Adapter,
899 IN LED_CTL_MODE LedAction
900 )
901 {
902 struct led_priv *ledpriv = &(Adapter->ledpriv);
903 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
904 PLED_PCIE pLed = &(ledpriv->SwLed1);
905
906 /* Decide led state */
907 switch (LedAction) {
908 case LED_CTL_TX:
909 case LED_CTL_RX:
910 if (pLed->bLedBlinkInProgress == _FALSE) {
911 pLed->bLedBlinkInProgress = _TRUE;
912
913 pLed->CurrLedState = LED_BLINK_NORMAL;
914 pLed->BlinkTimes = 2;
915
916 if (pLed->bLedOn)
917 pLed->BlinkingLedState = RTW_LED_OFF;
918 else
919 pLed->BlinkingLedState = RTW_LED_ON;
920 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
921 }
922 break;
923
924 case LED_CTL_SITE_SURVEY:
925 if (pLed->bLedBlinkInProgress == _FALSE) {
926 pLed->bLedBlinkInProgress = _TRUE;
927
928 if ((check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE)) ||
929 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) {
930 pLed->CurrLedState = LED_BLINK_SCAN;
931 pLed->BlinkTimes = 4;
932 } else {
933 pLed->CurrLedState = LED_BLINK_NO_LINK;
934 pLed->BlinkTimes = 24;
935 }
936
937 if (pLed->bLedOn) {
938 pLed->BlinkingLedState = RTW_LED_OFF;
939 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
940 } else {
941 pLed->BlinkingLedState = RTW_LED_ON;
942 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
943 }
944 } else {
945 if (pLed->CurrLedState != LED_BLINK_NO_LINK) {
946 if ((check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE)) ||
947 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
948 pLed->CurrLedState = LED_BLINK_SCAN;
949 else
950 pLed->CurrLedState = LED_BLINK_NO_LINK;
951 }
952 }
953 break;
954
955 case LED_CTL_NO_LINK:
956 if (pLed->bLedBlinkInProgress == _FALSE) {
957 pLed->bLedBlinkInProgress = _TRUE;
958
959 pLed->CurrLedState = LED_BLINK_NO_LINK;
960 pLed->BlinkTimes = 24;
961
962 if (pLed->bLedOn) {
963 pLed->BlinkingLedState = RTW_LED_OFF;
964 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
965 } else {
966 pLed->BlinkingLedState = RTW_LED_ON;
967 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
968 }
969 } else
970 pLed->CurrLedState = LED_BLINK_NO_LINK;
971 break;
972
973 case LED_CTL_LINK:
974 pLed->CurrLedState = RTW_LED_ON;
975 if (pLed->bLedBlinkInProgress == _FALSE)
976 SwLedOn(Adapter, pLed);
977 break;
978
979 case LED_CTL_POWER_OFF:
980 pLed->CurrLedState = RTW_LED_OFF;
981 if (pLed->bLedBlinkInProgress) {
982 _cancel_timer_ex(&(pLed->BlinkTimer));
983 pLed->bLedBlinkInProgress = _FALSE;
984 }
985 SwLedOff(Adapter, pLed);
986 break;
987
988 default:
989 break;
990 }
991
992 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led %d\n", pLed->CurrLedState));
993 }
994
995 VOID
SwLedControlMode2(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)996 SwLedControlMode2(
997 IN PADAPTER Adapter,
998 IN LED_CTL_MODE LedAction
999 )
1000 {
1001 struct led_priv *ledpriv = &(Adapter->ledpriv);
1002 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1003 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1004 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
1005
1006 /* Decide led state */
1007 switch (LedAction) {
1008 case LED_CTL_POWER_ON:
1009 pLed0->CurrLedState = RTW_LED_OFF;
1010 SwLedOff(Adapter, pLed0);
1011
1012 pLed1->CurrLedState = LED_BLINK_CAMEO;
1013 if (pLed1->bLedBlinkInProgress == _FALSE) {
1014 pLed1->bLedBlinkInProgress = _TRUE;
1015
1016 pLed1->BlinkTimes = 6;
1017
1018 if (pLed1->bLedOn)
1019 pLed1->BlinkingLedState = RTW_LED_OFF;
1020 else
1021 pLed1->BlinkingLedState = RTW_LED_ON;
1022 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
1023 }
1024 break;
1025
1026 case LED_CTL_TX:
1027 case LED_CTL_RX:
1028 if (pLed0->bLedBlinkInProgress == _FALSE) {
1029 pLed0->bLedBlinkInProgress = _TRUE;
1030
1031 pLed0->CurrLedState = LED_BLINK_TXRX;
1032 pLed0->BlinkTimes = 2;
1033
1034 if (pLed0->bLedOn)
1035 pLed0->BlinkingLedState = RTW_LED_OFF;
1036 else
1037 pLed0->BlinkingLedState = RTW_LED_ON;
1038
1039 _set_timer(&(pLed0->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1040 }
1041 break;
1042
1043 case LED_CTL_NO_LINK:
1044 pLed1->CurrLedState = LED_BLINK_CAMEO;
1045 if (pLed1->bLedBlinkInProgress == _FALSE) {
1046 pLed1->bLedBlinkInProgress = _TRUE;
1047
1048 pLed1->BlinkTimes = 6;
1049
1050 if (pLed1->bLedOn)
1051 pLed1->BlinkingLedState = RTW_LED_OFF;
1052 else
1053 pLed1->BlinkingLedState = RTW_LED_ON;
1054 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
1055 }
1056 break;
1057
1058 case LED_CTL_LINK:
1059 pLed1->CurrLedState = RTW_LED_ON;
1060 if (pLed1->bLedBlinkInProgress == _FALSE)
1061 SwLedOn(Adapter, pLed1);
1062 break;
1063
1064 case LED_CTL_POWER_OFF:
1065 pLed0->CurrLedState = RTW_LED_OFF;
1066 pLed1->CurrLedState = RTW_LED_OFF;
1067 if (pLed0->bLedBlinkInProgress) {
1068 _cancel_timer_ex(&(pLed0->BlinkTimer));
1069 pLed0->bLedBlinkInProgress = _FALSE;
1070 }
1071 if (pLed1->bLedBlinkInProgress) {
1072 _cancel_timer_ex(&(pLed1->BlinkTimer));
1073 pLed1->bLedBlinkInProgress = _FALSE;
1074 }
1075 SwLedOff(Adapter, pLed0);
1076 SwLedOff(Adapter, pLed1);
1077 break;
1078
1079 default:
1080 break;
1081 }
1082
1083 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led0 %d, Led1 %d\n", pLed0->CurrLedState, pLed1->CurrLedState));
1084 }
1085
1086
1087
1088 VOID
SwLedControlMode3(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1089 SwLedControlMode3(
1090 IN PADAPTER Adapter,
1091 IN LED_CTL_MODE LedAction
1092 )
1093 {
1094 struct led_priv *ledpriv = &(Adapter->ledpriv);
1095 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1096 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
1097
1098 /* Decide led state */
1099 switch (LedAction) {
1100 case LED_CTL_POWER_ON:
1101 pLed0->CurrLedState = RTW_LED_ON;
1102 SwLedOn(Adapter, pLed0);
1103 pLed1->CurrLedState = RTW_LED_OFF;
1104 SwLedOff(Adapter, pLed1);
1105 break;
1106
1107 case LED_CTL_TX:
1108 case LED_CTL_RX:
1109 if (pLed1->bLedBlinkInProgress == _FALSE) {
1110 pLed1->bLedBlinkInProgress = _TRUE;
1111
1112 pLed1->CurrLedState = LED_BLINK_RUNTOP;
1113 pLed1->BlinkTimes = 2;
1114
1115 if (pLed1->bLedOn)
1116 pLed1->BlinkingLedState = RTW_LED_OFF;
1117 else
1118 pLed1->BlinkingLedState = RTW_LED_ON;
1119
1120 _set_timer(&(pLed1->BlinkTimer), LED_RunTop_BLINK_INTERVAL);
1121 }
1122 break;
1123
1124 case LED_CTL_POWER_OFF:
1125 pLed0->CurrLedState = RTW_LED_OFF;
1126 pLed1->CurrLedState = RTW_LED_OFF;
1127 if (pLed0->bLedBlinkInProgress) {
1128 _cancel_timer_ex(&(pLed0->BlinkTimer));
1129 pLed0->bLedBlinkInProgress = _FALSE;
1130 }
1131 if (pLed1->bLedBlinkInProgress) {
1132 _cancel_timer_ex(&(pLed1->BlinkTimer));
1133 pLed1->bLedBlinkInProgress = _FALSE;
1134 }
1135 SwLedOff(Adapter, pLed0);
1136 SwLedOff(Adapter, pLed1);
1137 break;
1138
1139 default:
1140 break;
1141 }
1142
1143 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led0 %d, Led1 %d\n", pLed0->CurrLedState, pLed1->CurrLedState));
1144 }
1145
1146
1147 VOID
SwLedControlMode4(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1148 SwLedControlMode4(
1149 IN PADAPTER Adapter,
1150 IN LED_CTL_MODE LedAction
1151 )
1152 {
1153 struct led_priv *ledpriv = &(Adapter->ledpriv);
1154 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1155 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
1156
1157 /* Decide led state */
1158 switch (LedAction) {
1159 case LED_CTL_POWER_ON:
1160 pLed1->CurrLedState = RTW_LED_ON;
1161 SwLedOn(Adapter, pLed1);
1162 pLed0->CurrLedState = RTW_LED_OFF;
1163 SwLedOff(Adapter, pLed0);
1164 break;
1165
1166 case LED_CTL_TX:
1167 case LED_CTL_RX:
1168 if (pLed0->bLedBlinkInProgress == _FALSE) {
1169 pLed0->bLedBlinkInProgress = _TRUE;
1170
1171 pLed0->CurrLedState = LED_BLINK_RUNTOP;
1172 pLed0->BlinkTimes = 2;
1173
1174 if (pLed0->bLedOn)
1175 pLed0->BlinkingLedState = RTW_LED_OFF;
1176 else
1177 pLed0->BlinkingLedState = RTW_LED_ON;
1178
1179 _set_timer(&(pLed0->BlinkTimer), LED_RunTop_BLINK_INTERVAL);
1180 }
1181 break;
1182
1183 case LED_CTL_POWER_OFF:
1184 pLed0->CurrLedState = RTW_LED_OFF;
1185 pLed1->CurrLedState = RTW_LED_OFF;
1186 if (pLed0->bLedBlinkInProgress) {
1187 _cancel_timer_ex(&(pLed0->BlinkTimer));
1188 pLed0->bLedBlinkInProgress = _FALSE;
1189 }
1190 if (pLed1->bLedBlinkInProgress) {
1191 _cancel_timer_ex(&(pLed1->BlinkTimer));
1192 pLed1->bLedBlinkInProgress = _FALSE;
1193 }
1194 SwLedOff(Adapter, pLed0);
1195 SwLedOff(Adapter, pLed1);
1196 break;
1197
1198 default:
1199 break;
1200 }
1201
1202 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led0 %d, Led1 %d\n", pLed0->CurrLedState, pLed1->CurrLedState));
1203 }
1204
1205 /* added by vivi, for led new mode */
1206 VOID
SwLedControlMode5(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1207 SwLedControlMode5(
1208 IN PADAPTER Adapter,
1209 IN LED_CTL_MODE LedAction
1210 )
1211 {
1212 struct led_priv *ledpriv = &(Adapter->ledpriv);
1213 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1214 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
1215 /* Decide led state */
1216 switch (LedAction) {
1217 case LED_CTL_POWER_ON:
1218 case LED_CTL_START_TO_LINK:
1219 case LED_CTL_NO_LINK:
1220 pLed1->CurrLedState = RTW_LED_OFF;
1221 SwLedOff(Adapter, pLed1);
1222
1223
1224 if (pLed0->bLedSlowBlinkInProgress == _FALSE) {
1225 pLed0->bLedSlowBlinkInProgress = _TRUE;
1226 pLed0->CurrLedState = LED_BLINK_SLOWLY;
1227 if (pLed0->bLedOn)
1228 pLed0->BlinkingLedState = RTW_LED_OFF;
1229 else
1230 pLed0->BlinkingLedState = RTW_LED_ON;
1231 _set_timer(&(pLed0->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
1232 }
1233
1234 break;
1235
1236 case LED_CTL_TX:
1237 case LED_CTL_RX:
1238 pLed1->CurrLedState = RTW_LED_ON;
1239 SwLedOn(Adapter, pLed1);
1240
1241 if (pLed0->bLedBlinkInProgress == _FALSE) {
1242 _cancel_timer_ex(&(pLed0->BlinkTimer));
1243 pLed0->bLedSlowBlinkInProgress = _FALSE;
1244 pLed0->bLedBlinkInProgress = _TRUE;
1245 pLed0->CurrLedState = LED_BLINK_NORMAL;
1246 pLed0->BlinkTimes = 2;
1247
1248 if (pLed0->bLedOn)
1249 pLed0->BlinkingLedState = RTW_LED_OFF;
1250 else
1251 pLed0->BlinkingLedState = RTW_LED_ON;
1252 _set_timer(&(pLed0->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_NETTRONIX);
1253 }
1254 break;
1255
1256 case LED_CTL_LINK:
1257 pLed1->CurrLedState = RTW_LED_ON;
1258 SwLedOn(Adapter, pLed1);
1259
1260 if (pLed0->bLedSlowBlinkInProgress == _FALSE) {
1261 pLed0->bLedSlowBlinkInProgress = _TRUE;
1262 pLed0->CurrLedState = LED_BLINK_SLOWLY;
1263 if (pLed0->bLedOn)
1264 pLed0->BlinkingLedState = RTW_LED_OFF;
1265 else
1266 pLed0->BlinkingLedState = RTW_LED_ON;
1267 _set_timer(&(pLed0->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
1268 }
1269 break;
1270
1271
1272 case LED_CTL_POWER_OFF:
1273 pLed0->CurrLedState = RTW_LED_OFF;
1274 pLed1->CurrLedState = RTW_LED_OFF;
1275 if (pLed0->bLedSlowBlinkInProgress == _TRUE) {
1276 _cancel_timer_ex(&(pLed0->BlinkTimer));
1277 pLed0->bLedSlowBlinkInProgress = _FALSE;
1278 }
1279 if (pLed0->bLedBlinkInProgress == _TRUE) {
1280 _cancel_timer_ex(&(pLed0->BlinkTimer));
1281 pLed0->bLedBlinkInProgress = _FALSE;
1282 }
1283 SwLedOff(Adapter, pLed0);
1284 SwLedOff(Adapter, pLed1);
1285 break;
1286
1287 default:
1288 break;
1289 }
1290
1291
1292 }
1293
1294 /* added by vivi, for led new mode */
1295 VOID
SwLedControlMode6(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1296 SwLedControlMode6(
1297 IN PADAPTER Adapter,
1298 IN LED_CTL_MODE LedAction
1299 )
1300 {
1301 struct led_priv *ledpriv = &(Adapter->ledpriv);
1302 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1303 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
1304
1305
1306 switch (LedAction) {
1307 case LED_CTL_POWER_ON:
1308 case LED_CTL_START_TO_LINK:
1309 case LED_CTL_NO_LINK:
1310 case LED_CTL_LINK:
1311 case LED_CTL_SITE_SURVEY:
1312 pLed1->CurrLedState = RTW_LED_OFF;
1313 SwLedOff(Adapter, pLed1);
1314
1315 if (pLed0->bLedSlowBlinkInProgress == _FALSE) {
1316 pLed0->bLedSlowBlinkInProgress = _TRUE;
1317 pLed0->CurrLedState = LED_BLINK_SLOWLY;
1318 if (pLed0->bLedOn)
1319 pLed0->BlinkingLedState = RTW_LED_OFF;
1320 else
1321 pLed0->BlinkingLedState = RTW_LED_ON;
1322 _set_timer(&(pLed0->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
1323 }
1324 break;
1325
1326 case LED_CTL_TX:
1327 case LED_CTL_RX:
1328 pLed1->CurrLedState = RTW_LED_OFF;
1329 SwLedOff(Adapter, pLed1);
1330 if (pLed0->bLedBlinkInProgress == _FALSE) {
1331 _cancel_timer_ex(&(pLed0->BlinkTimer));
1332 pLed0->bLedSlowBlinkInProgress = _FALSE;
1333 pLed0->bLedBlinkInProgress = _TRUE;
1334 pLed0->CurrLedState = LED_BLINK_NORMAL;
1335 pLed0->BlinkTimes = 2;
1336 if (pLed0->bLedOn)
1337 pLed0->BlinkingLedState = RTW_LED_OFF;
1338 else
1339 pLed0->BlinkingLedState = RTW_LED_ON;
1340 _set_timer(&(pLed0->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_PORNET);
1341 }
1342 break;
1343
1344 case LED_CTL_POWER_OFF:
1345 pLed1->CurrLedState = RTW_LED_OFF;
1346 SwLedOff(Adapter, pLed1);
1347
1348 pLed0->CurrLedState = RTW_LED_OFF;
1349 if (pLed0->bLedSlowBlinkInProgress == _TRUE) {
1350 _cancel_timer_ex(&(pLed0->BlinkTimer));
1351 pLed0->bLedSlowBlinkInProgress = _FALSE;
1352 }
1353 if (pLed0->bLedBlinkInProgress == _TRUE) {
1354 _cancel_timer_ex(&(pLed0->BlinkTimer));
1355 pLed0->bLedBlinkInProgress = _FALSE;
1356 }
1357 SwLedOff(Adapter, pLed0);
1358 break;
1359
1360 default:
1361 break;
1362
1363 }
1364 }
1365
1366
1367 /* added by chiyokolin, for Lenovo */
1368 VOID
SwLedControlMode7(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1369 SwLedControlMode7(
1370 IN PADAPTER Adapter,
1371 IN LED_CTL_MODE LedAction
1372 )
1373 {
1374 struct led_priv *ledpriv = &(Adapter->ledpriv);
1375 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1376
1377 switch (LedAction) {
1378 case LED_CTL_POWER_ON:
1379 case LED_CTL_LINK:
1380 case LED_CTL_NO_LINK:
1381 SwLedOn(Adapter, pLed0);
1382 break;
1383
1384 case LED_CTL_POWER_OFF:
1385 SwLedOff(Adapter, pLed0);
1386 break;
1387
1388 default:
1389 break;
1390 }
1391 }
1392
1393 /* added by chiyokolin, for QMI */
1394 VOID
SwLedControlMode8(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1395 SwLedControlMode8(
1396 IN PADAPTER Adapter,
1397 IN LED_CTL_MODE LedAction
1398 )
1399 {
1400 struct led_priv *ledpriv = &(Adapter->ledpriv);
1401 PLED_PCIE pLed = &(ledpriv->SwLed0);
1402 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1403
1404 /* Decide led state */
1405 switch (LedAction) {
1406 case LED_CTL_TX:
1407 case LED_CTL_RX:
1408 if (pLed->bLedBlinkInProgress == _FALSE && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
1409 pLed->bLedBlinkInProgress = _TRUE;
1410
1411 pLed->CurrLedState = LED_BLINK_NORMAL;
1412 pLed->BlinkTimes = 2;
1413
1414 if (pLed->bLedOn)
1415 pLed->BlinkingLedState = RTW_LED_OFF;
1416 else
1417 pLed->BlinkingLedState = RTW_LED_ON;
1418 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1419 }
1420 break;
1421
1422 case LED_CTL_SITE_SURVEY:
1423 case LED_CTL_POWER_ON:
1424 case LED_CTL_NO_LINK:
1425 case LED_CTL_LINK:
1426 pLed->CurrLedState = RTW_LED_ON;
1427 if (pLed->bLedBlinkInProgress) {
1428 _cancel_timer_ex(&(pLed->BlinkTimer));
1429 pLed->bLedBlinkInProgress = _FALSE;
1430 }
1431 SwLedOn(Adapter, pLed);
1432 break;
1433
1434 case LED_CTL_POWER_OFF:
1435 pLed->CurrLedState = RTW_LED_OFF;
1436 if (pLed->bLedBlinkInProgress) {
1437 _cancel_timer_ex(&(pLed->BlinkTimer));
1438 pLed->bLedBlinkInProgress = _FALSE;
1439 }
1440 SwLedOff(Adapter, pLed);
1441 break;
1442
1443 default:
1444 break;
1445 }
1446 }
1447
1448 /* added by chiyokolin, for MSI */
1449 VOID
SwLedControlMode9(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1450 SwLedControlMode9(
1451 IN PADAPTER Adapter,
1452 IN LED_CTL_MODE LedAction
1453 )
1454 {
1455 struct led_priv *ledpriv = &(Adapter->ledpriv);
1456 PLED_PCIE pLed = &(ledpriv->SwLed0);
1457 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1458
1459 /* Decide led state */
1460 switch (LedAction) {
1461 case LED_CTL_TX:
1462 case LED_CTL_RX:
1463 if (pLed->bLedBlinkInProgress == _FALSE && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
1464 pLed->bLedBlinkInProgress = _TRUE;
1465
1466 pLed->CurrLedState = LED_BLINK_NORMAL;
1467 pLed->BlinkTimes = 2;
1468
1469 if (pLed->bLedOn)
1470 pLed->BlinkingLedState = RTW_LED_OFF;
1471 else
1472 pLed->BlinkingLedState = RTW_LED_ON;
1473 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FAST_INTERVAL_BITLAND);
1474 }
1475 break;
1476
1477 case LED_CTL_SITE_SURVEY:
1478 if (pLed->bLedBlinkInProgress == _FALSE) {
1479 pLed->bLedBlinkInProgress = _TRUE;
1480 pLed->CurrLedState = LED_BLINK_SCAN;
1481 pLed->BlinkTimes = 2;
1482
1483 if (pLed->bLedOn) {
1484 pLed->BlinkingLedState = RTW_LED_OFF;
1485 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
1486 } else {
1487 pLed->BlinkingLedState = RTW_LED_ON;
1488 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
1489 }
1490 } else if (pLed->CurrLedState != LED_BLINK_SCAN) {
1491 _cancel_timer_ex(&(pLed->BlinkTimer));
1492 pLed->CurrLedState = LED_BLINK_SCAN;
1493 pLed->BlinkTimes = 2;
1494
1495 if (pLed->bLedOn) {
1496 pLed->BlinkingLedState = RTW_LED_OFF;
1497 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
1498 } else {
1499 pLed->BlinkingLedState = RTW_LED_ON;
1500 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
1501 }
1502 }
1503 break;
1504
1505 case LED_CTL_POWER_ON:
1506 case LED_CTL_NO_LINK:
1507 if (pLed->bLedBlinkInProgress == _FALSE) {
1508 pLed->bLedBlinkInProgress = _TRUE;
1509
1510 pLed->CurrLedState = LED_BLINK_NO_LINK;
1511 pLed->BlinkTimes = 24;
1512
1513 if (pLed->bLedOn) {
1514 pLed->BlinkingLedState = RTW_LED_OFF;
1515 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
1516 } else {
1517 pLed->BlinkingLedState = RTW_LED_ON;
1518 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
1519 }
1520 } else if (pLed->CurrLedState != LED_BLINK_SCAN && pLed->CurrLedState != LED_BLINK_NO_LINK) {
1521 pLed->CurrLedState = LED_BLINK_NO_LINK;
1522 pLed->BlinkTimes = 24;
1523
1524 if (pLed->bLedOn) {
1525 pLed->BlinkingLedState = RTW_LED_OFF;
1526 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
1527 } else {
1528 pLed->BlinkingLedState = RTW_LED_ON;
1529 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
1530 }
1531 }
1532 break;
1533
1534 case LED_CTL_LINK:
1535 pLed->CurrLedState = RTW_LED_ON;
1536 if (pLed->bLedBlinkInProgress) {
1537 _cancel_timer_ex(&(pLed->BlinkTimer));
1538 pLed->bLedBlinkInProgress = _FALSE;
1539 }
1540 SwLedOn(Adapter, pLed);
1541 break;
1542
1543 case LED_CTL_POWER_OFF:
1544 pLed->CurrLedState = RTW_LED_OFF;
1545 if (pLed->bLedBlinkInProgress) {
1546 _cancel_timer_ex(&(pLed->BlinkTimer));
1547 pLed->bLedBlinkInProgress = _FALSE;
1548 }
1549 SwLedOff(Adapter, pLed);
1550 break;
1551
1552 default:
1553 break;
1554 }
1555
1556 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Ledcontrol 9 current led state %d,\n", pLed->CurrLedState));
1557
1558 }
1559
1560
1561 /* added by chiyokolin, for Edimax-ASUS */
1562 VOID
SwLedControlMode10(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1563 SwLedControlMode10(
1564 IN PADAPTER Adapter,
1565 IN LED_CTL_MODE LedAction
1566 )
1567 {
1568 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
1569 struct led_priv *ledpriv = &(Adapter->ledpriv);
1570 PLED_PCIE pLed0 = &(ledpriv->SwLed0);
1571 PLED_PCIE pLed1 = &(ledpriv->SwLed1);
1572 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1573
1574 /* Decide led state */
1575 switch (LedAction) {
1576 case LED_CTL_TX:
1577 case LED_CTL_RX:
1578 if (pLed1->bLedBlinkInProgress == _FALSE && pLed1->bLedWPSBlinkInProgress == _FALSE &&
1579 (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
1580 pLed1->bLedBlinkInProgress = _TRUE;
1581
1582 pLed1->CurrLedState = LED_BLINK_NORMAL;
1583 pLed1->BlinkTimes = 2;
1584
1585 if (pLed1->bLedOn)
1586 pLed1->BlinkingLedState = RTW_LED_OFF;
1587 else
1588 pLed1->BlinkingLedState = RTW_LED_ON;
1589 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1590 }
1591 break;
1592
1593 case LED_CTL_SITE_SURVEY:
1594 if (pLed1->bLedBlinkInProgress == _FALSE && pLed1->bLedWPSBlinkInProgress == _FALSE) {
1595 pLed1->bLedBlinkInProgress = _TRUE;
1596 pLed1->CurrLedState = LED_BLINK_SCAN;
1597 pLed1->BlinkTimes = 12;
1598
1599 if (pLed1->bLedOn) {
1600 pLed1->BlinkingLedState = RTW_LED_OFF;
1601 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1602 } else {
1603 pLed1->BlinkingLedState = RTW_LED_ON;
1604 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1605 }
1606 } else if (pLed1->CurrLedState != LED_BLINK_SCAN && pLed1->bLedWPSBlinkInProgress == _FALSE) {
1607 _cancel_timer_ex(&(pLed1->BlinkTimer));
1608 pLed1->CurrLedState = LED_BLINK_SCAN;
1609 pLed1->BlinkTimes = 24;
1610
1611 if (pLed1->bLedOn) {
1612 pLed1->BlinkingLedState = RTW_LED_OFF;
1613 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1614 } else {
1615 pLed1->BlinkingLedState = RTW_LED_ON;
1616 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1617 }
1618 }
1619 break;
1620
1621 case LED_CTL_START_WPS:
1622 case LED_CTL_START_WPS_BOTTON:
1623 pLed1->CurrLedState = RTW_LED_ON;
1624 if (pLed1->bLedBlinkInProgress == _TRUE) {
1625 _cancel_timer_ex(&(pLed1->BlinkTimer));
1626 pLed1->bLedBlinkInProgress = _FALSE;
1627 }
1628
1629 if (pLed1->bLedWPSBlinkInProgress == _FALSE) {
1630 pLed1->bLedWPSBlinkInProgress = _TRUE;
1631 SwLedOn(Adapter, pLed1);
1632 }
1633 break;
1634
1635 case LED_CTL_STOP_WPS:
1636 case LED_CTL_STOP_WPS_FAIL:
1637 case LED_CTL_STOP_WPS_FAIL_OVERLAP:
1638 if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
1639 pLed0->CurrLedState = RTW_LED_ON;
1640 if (pLed0->bLedBlinkInProgress) {
1641 _cancel_timer_ex(&(pLed0->BlinkTimer));
1642 pLed0->bLedBlinkInProgress = _FALSE;
1643 }
1644 SwLedOn(Adapter, pLed0);
1645 } else {
1646 pLed0->CurrLedState = RTW_LED_OFF;
1647 if (pLed0->bLedBlinkInProgress) {
1648 _cancel_timer_ex(&(pLed0->BlinkTimer));
1649 pLed0->bLedBlinkInProgress = _FALSE;
1650 }
1651 SwLedOff(Adapter, pLed0);
1652 }
1653
1654 pLed1->CurrLedState = RTW_LED_OFF;
1655 if (pLed1->bLedBlinkInProgress) {
1656 _cancel_timer_ex(&(pLed1->BlinkTimer));
1657 pLed1->bLedBlinkInProgress = _FALSE;
1658 }
1659 SwLedOff(Adapter, pLed1);
1660
1661 pLed1->bLedWPSBlinkInProgress = _FALSE;
1662
1663 break;
1664
1665 case LED_CTL_LINK:
1666 pLed0->CurrLedState = RTW_LED_ON;
1667 if (pLed0->bLedBlinkInProgress) {
1668 _cancel_timer_ex(&(pLed0->BlinkTimer));
1669 pLed0->bLedBlinkInProgress = _FALSE;
1670 }
1671 SwLedOn(Adapter, pLed0);
1672 break;
1673
1674 case LED_CTL_NO_LINK:
1675 if (pLed1->bLedWPSBlinkInProgress == _TRUE) {
1676 SwLedOn(Adapter, pLed1);
1677 break;
1678 }
1679
1680 if (pLed1->CurrLedState == LED_BLINK_SCAN)
1681 break;
1682
1683 pLed0->CurrLedState = RTW_LED_OFF;
1684 if (pLed0->bLedBlinkInProgress) {
1685 _cancel_timer_ex(&(pLed0->BlinkTimer));
1686 pLed0->bLedBlinkInProgress = _FALSE;
1687 }
1688 SwLedOff(Adapter, pLed0);
1689
1690 pLed1->CurrLedState = RTW_LED_OFF;
1691 if (pLed1->bLedBlinkInProgress) {
1692 _cancel_timer_ex(&(pLed1->BlinkTimer));
1693 pLed1->bLedBlinkInProgress = _FALSE;
1694 }
1695 SwLedOff(Adapter, pLed1);
1696
1697 break;
1698
1699
1700 case LED_CTL_POWER_ON:
1701 case LED_CTL_POWER_OFF:
1702 if (pLed1->bLedWPSBlinkInProgress == _TRUE) {
1703 SwLedOn(Adapter, pLed1);
1704 break;
1705 }
1706 pLed0->CurrLedState = RTW_LED_OFF;
1707 if (pLed0->bLedBlinkInProgress) {
1708 _cancel_timer_ex(&(pLed0->BlinkTimer));
1709 pLed0->bLedBlinkInProgress = _FALSE;
1710 }
1711 SwLedOff(Adapter, pLed0);
1712
1713 pLed1->CurrLedState = RTW_LED_OFF;
1714 if (pLed1->bLedBlinkInProgress) {
1715 _cancel_timer_ex(&(pLed1->BlinkTimer));
1716 pLed1->bLedBlinkInProgress = _FALSE;
1717 }
1718 SwLedOff(Adapter, pLed1);
1719
1720 break;
1721
1722 default:
1723 break;
1724
1725 }
1726
1727 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Ledcontrol 10 current led0 state %d led1 state %d,\n", pLed0->CurrLedState, pLed1->CurrLedState));
1728
1729 }
1730
1731
1732 /* added by hpfan, for Xavi */
1733 VOID
SwLedControlMode11(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1734 SwLedControlMode11(
1735 IN PADAPTER Adapter,
1736 IN LED_CTL_MODE LedAction
1737 )
1738 {
1739 struct led_priv *ledpriv = &(Adapter->ledpriv);
1740 PLED_PCIE pLed = &(ledpriv->SwLed0);
1741
1742 /* Decide led state */
1743 switch (LedAction) {
1744 case LED_CTL_START_WPS:
1745 case LED_CTL_START_WPS_BOTTON:
1746 pLed->bLedWPSBlinkInProgress = _TRUE;
1747 if (pLed->bLedBlinkInProgress == _FALSE) {
1748 pLed->bLedBlinkInProgress = _TRUE;
1749 pLed->CurrLedState = LED_BLINK_XAVI;
1750
1751 if (pLed->bLedOn) {
1752 pLed->BlinkingLedState = RTW_LED_OFF;
1753 _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1754 } else {
1755 pLed->BlinkingLedState = RTW_LED_ON;
1756 _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1757 }
1758 }
1759 break;
1760
1761 case LED_CTL_STOP_WPS:
1762 case LED_CTL_STOP_WPS_FAIL:
1763 case LED_CTL_STOP_WPS_FAIL_OVERLAP:
1764 pLed->bLedWPSBlinkInProgress = _FALSE;
1765 if (pLed->bLedBlinkInProgress) {
1766 _cancel_timer_ex(&(pLed->BlinkTimer));
1767 pLed->bLedBlinkInProgress = _FALSE;
1768 pLed->CurrLedState = RTW_LED_OFF;
1769 }
1770 SwLedOff(Adapter, pLed);
1771 break;
1772
1773 case LED_CTL_LINK:
1774 if (pLed->bLedWPSBlinkInProgress)
1775 break;
1776
1777 if (pLed->bLedBlinkInProgress) {
1778 _cancel_timer_ex(&(pLed->BlinkTimer));
1779 pLed->bLedBlinkInProgress = _FALSE;
1780 pLed->CurrLedState = RTW_LED_ON;
1781
1782 if (!pLed->bLedOn)
1783 SwLedOn(Adapter, pLed);
1784 } else {
1785 pLed->CurrLedState = RTW_LED_ON;
1786 SwLedOn(Adapter, pLed);
1787 }
1788
1789 _set_timer(&(pLed->BlinkTimer), LED_CM11_LINK_ON_INTERVEL);
1790 pLed->BlinkingLedState = RTW_LED_OFF;
1791 break;
1792
1793 case LED_CTL_NO_LINK:
1794 if (pLed->bLedWPSBlinkInProgress)
1795 break;
1796
1797 if (pLed->bLedBlinkInProgress == _TRUE) {
1798 _cancel_timer_ex(&(pLed->BlinkTimer));
1799 pLed->bLedBlinkInProgress = _FALSE;
1800 }
1801 pLed->CurrLedState = RTW_LED_OFF;
1802 SwLedOff(Adapter, pLed);
1803 break;
1804
1805 case LED_CTL_POWER_ON:
1806 case LED_CTL_POWER_OFF:
1807 if (pLed->bLedBlinkInProgress == _TRUE) {
1808 _cancel_timer_ex(&(pLed->BlinkTimer));
1809 pLed->bLedBlinkInProgress = _FALSE;
1810 }
1811
1812 pLed->CurrLedState = RTW_LED_OFF;
1813 SwLedOff(Adapter, pLed);
1814 break;
1815
1816 default:
1817 break;
1818
1819 }
1820
1821 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Ledcontrol 11 current led state %d\n", pLed->CurrLedState));
1822
1823 }
1824
1825 /* added by chiyokolin, for Azurewave */
1826 VOID
SwLedControlMode12(IN PADAPTER Adapter,IN LED_CTL_MODE LedAction)1827 SwLedControlMode12(
1828 IN PADAPTER Adapter,
1829 IN LED_CTL_MODE LedAction
1830 )
1831 {
1832 struct led_priv *ledpriv = &(Adapter->ledpriv);
1833 PLED_PCIE pLed = &(ledpriv->SwLed0);
1834 struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
1835 LED_STATE LedState = LED_UNKNOWN;
1836
1837 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("====>Ledcontrol 12 current led0 state %d\n", pLed->CurrLedState));
1838
1839 /* Decide led state */
1840 switch (LedAction) {
1841 case LED_CTL_TX:
1842 case LED_CTL_RX:
1843 if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
1844 if (pLed->CurrLedState == LED_BLINK_SCAN)
1845 break;
1846
1847 pLed->BlinkTimes = 0;
1848
1849 if (pLed->bLedOn)
1850 pLed->BlinkingLedState = RTW_LED_OFF;
1851 else
1852 pLed->BlinkingLedState = RTW_LED_ON;
1853
1854 /*if(pTurboCa->TotalThroughput <= 5)
1855 LedState = LED_BLINK_Azurewave_5Mbps;
1856 else if(pTurboCa->TotalThroughput <= 10)
1857 LedState = LED_BLINK_Azurewave_10Mbps;
1858 else if(pTurboCa->TotalThroughput <=20)
1859 LedState = LED_BLINK_Azurewave_20Mbps;
1860 else if(pTurboCa->TotalThroughput <=40)
1861 LedState = LED_BLINK_Azurewave_40Mbps;
1862 else if(pTurboCa->TotalThroughput <=80)
1863 LedState = LED_BLINK_Azurewave_80Mbps;
1864 else*/
1865 LedState = LED_BLINK_Azurewave_MAXMbps;
1866
1867 if (pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState != LedState) {
1868 _cancel_timer_ex(&(pLed->BlinkTimer));
1869 pLed->CurrLedState = LedState;
1870 pLed->bLedBlinkInProgress = _TRUE;
1871
1872 switch (LedState) {
1873 case LED_BLINK_Azurewave_5Mbps:
1874 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_5Mbps);
1875 break;
1876
1877 case LED_BLINK_Azurewave_10Mbps:
1878 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_10Mbps);
1879 break;
1880
1881 case LED_BLINK_Azurewave_20Mbps:
1882 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_20Mbps);
1883 break;
1884
1885 case LED_BLINK_Azurewave_40Mbps:
1886 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_40Mbps);
1887 break;
1888
1889 case LED_BLINK_Azurewave_80Mbps:
1890 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_80Mbps);
1891 break;
1892
1893 case LED_BLINK_Azurewave_MAXMbps:
1894 _set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_MAXMbps);
1895 break;
1896
1897 default:
1898 break;
1899 }
1900 }
1901 }
1902
1903 break;
1904
1905 case LED_CTL_SITE_SURVEY:
1906 case LED_CTL_START_WPS:
1907 case LED_CTL_START_WPS_BOTTON:
1908 if (pLed->bLedBlinkInProgress == _FALSE)
1909 pLed->bLedBlinkInProgress = _TRUE;
1910 else if (pLed->CurrLedState != LED_BLINK_SCAN)
1911 _cancel_timer_ex(&(pLed->BlinkTimer));
1912
1913 pLed->CurrLedState = LED_BLINK_SCAN;
1914 pLed->BlinkTimes = 2;
1915
1916 if (pLed->bLedOn) {
1917 pLed->BlinkingLedState = RTW_LED_OFF;
1918 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
1919 } else {
1920 pLed->BlinkingLedState = RTW_LED_ON;
1921 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
1922 }
1923 break;
1924
1925 case LED_CTL_LINK:
1926 pLed->CurrLedState = RTW_LED_ON;
1927 if (pLed->bLedBlinkInProgress) {
1928 _cancel_timer_ex(&(pLed->BlinkTimer));
1929 pLed->bLedBlinkInProgress = _FALSE;
1930 }
1931 SwLedOn(Adapter, pLed);
1932 break;
1933
1934 case LED_CTL_NO_LINK:
1935 case LED_CTL_POWER_ON:
1936 if (pLed->CurrLedState == LED_BLINK_SCAN)
1937 break;
1938
1939 pLed->CurrLedState = LED_BLINK_NO_LINK;
1940 pLed->bLedBlinkInProgress = _TRUE;
1941
1942 if (pLed->bLedOn) {
1943 pLed->BlinkingLedState = RTW_LED_OFF;
1944 _set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
1945 } else {
1946 pLed->BlinkingLedState = RTW_LED_ON;
1947 _set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
1948 }
1949 break;
1950
1951 case LED_CTL_POWER_OFF:
1952 pLed->CurrLedState = RTW_LED_OFF;
1953 if (pLed->bLedBlinkInProgress) {
1954 _cancel_timer_ex(&(pLed->BlinkTimer));
1955 pLed->bLedBlinkInProgress = _FALSE;
1956 }
1957 SwLedOff(Adapter, pLed);
1958 break;
1959
1960 default:
1961 break;
1962
1963 }
1964
1965 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("<====Ledcontrol 12 current led0 state %d\n", pLed->CurrLedState));
1966
1967 }
1968
1969 void
LedControlPCIE(_adapter * padapter,LED_CTL_MODE LedAction)1970 LedControlPCIE(
1971 _adapter *padapter,
1972 LED_CTL_MODE LedAction
1973 )
1974 {
1975 struct led_priv *ledpriv = &(padapter->ledpriv);
1976
1977 #if (MP_DRIVER == 1)
1978 if (padapter->registrypriv.mp_mode == 1)
1979 return;
1980 #endif
1981
1982 if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter)))
1983 return;
1984
1985 /* if(priv->bInHctTest) */
1986 /* return; */
1987
1988 #ifdef CONFIG_CONCURRENT_MODE
1989 /* Only do led action for PRIMARY_ADAPTER */
1990 if (padapter->adapter_type != PRIMARY_ADAPTER)
1991 return;
1992 #endif
1993
1994 if ((adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&
1995 (LedAction == LED_CTL_TX ||
1996 LedAction == LED_CTL_RX ||
1997 LedAction == LED_CTL_SITE_SURVEY ||
1998 LedAction == LED_CTL_LINK ||
1999 LedAction == LED_CTL_NO_LINK ||
2000 LedAction == LED_CTL_START_TO_LINK ||
2001 LedAction == LED_CTL_POWER_ON)) {
2002 RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("LedControlPCIE(): RfOffReason=0x%x\n", adapter_to_pwrctl(padapter)->rfoff_reason));
2003 return;
2004 }
2005
2006 switch (ledpriv->LedStrategy) {
2007 case SW_LED_MODE0:
2008 /* SwLedControlMode0(padapter, LedAction); */
2009 break;
2010
2011 case SW_LED_MODE1:
2012 /* SwLedControlMode1(padapter, LedAction); */
2013 break;
2014
2015 case SW_LED_MODE2:
2016 /* SwLedControlMode2(padapter, LedAction); */
2017 break;
2018
2019 case SW_LED_MODE3:
2020 /* SwLedControlMode3(padapter, LedAction); */
2021 break;
2022
2023 case SW_LED_MODE4:
2024 /* SwLedControlMode4(padapter, LedAction); */
2025 break;
2026
2027 case SW_LED_MODE5:
2028 /* SwLedControlMode5(padapter, LedAction); */
2029 break;
2030
2031 case SW_LED_MODE6:
2032 /* SwLedControlMode6(padapter, LedAction); */
2033 break;
2034
2035 case SW_LED_MODE7:
2036 SwLedControlMode7(padapter, LedAction);
2037 break;
2038
2039 case SW_LED_MODE8:
2040 SwLedControlMode8(padapter, LedAction);
2041 break;
2042
2043 case SW_LED_MODE9:
2044 SwLedControlMode9(padapter, LedAction);
2045 break;
2046
2047 case SW_LED_MODE10:
2048 SwLedControlMode10(padapter, LedAction);
2049 break;
2050
2051 case SW_LED_MODE11:
2052 SwLedControlMode11(padapter, LedAction);
2053 break;
2054
2055 case SW_LED_MODE12:
2056 SwLedControlMode12(padapter, LedAction);
2057 break;
2058
2059 default:
2060 break;
2061 }
2062 }
2063
2064 /*-----------------------------------------------------------------------------
2065 * Function: gen_RefreshLedState()
2066 *
2067 * Overview: When we call the function, media status is no link. It must be in SW/HW
2068 * radio off. Or IPS state. If IPS no link we will turn on LED, otherwise, we must turn off.
2069 * After MAC IO reset, we must write LED control 0x2f2 again.
2070 *
2071 * Input: IN PADAPTER Adapter)
2072 *
2073 * Output: NONE
2074 *
2075 * Return: NONE
2076 *
2077 * Revised History:
2078 * When Who Remark
2079 * 03/27/2009 MHC Create for LED judge only~!!
2080 *
2081 *---------------------------------------------------------------------------*/
2082 VOID
gen_RefreshLedState(IN PADAPTER Adapter)2083 gen_RefreshLedState(
2084 IN PADAPTER Adapter)
2085 {
2086 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
2087 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(Adapter);
2088 struct led_priv *pledpriv = &(Adapter->ledpriv);
2089 PLED_PCIE pLed0 = &(Adapter->ledpriv.SwLed0);
2090
2091 RTW_INFO("gen_RefreshLedState:() pwrctrlpriv->rfoff_reason=%x\n", pwrctrlpriv->rfoff_reason);
2092
2093 if (Adapter->bDriverIsGoingToUnload) {
2094 switch (pledpriv->LedStrategy) {
2095 case SW_LED_MODE9:
2096 case SW_LED_MODE10:
2097 rtw_led_control(Adapter, LED_CTL_POWER_OFF);
2098 break;
2099
2100 default:
2101 /* Turn off LED if RF is not ON. */
2102 SwLedOff(Adapter, pLed0);
2103 break;
2104 }
2105 } else if (pwrctrlpriv->rfoff_reason == RF_CHANGE_BY_IPS) {
2106 switch (pledpriv->LedStrategy) {
2107 case SW_LED_MODE7:
2108 SwLedOn(Adapter, pLed0);
2109 break;
2110
2111 case SW_LED_MODE8:
2112 case SW_LED_MODE9:
2113 rtw_led_control(Adapter, LED_CTL_NO_LINK);
2114 break;
2115
2116 default:
2117 SwLedOn(Adapter, pLed0);
2118 break;
2119 }
2120 } else if (pwrctrlpriv->rfoff_reason == RF_CHANGE_BY_INIT) {
2121 switch (pledpriv->LedStrategy) {
2122 case SW_LED_MODE7:
2123 SwLedOn(Adapter, pLed0);
2124 break;
2125
2126 case SW_LED_MODE9:
2127 rtw_led_control(Adapter, LED_CTL_NO_LINK);
2128 break;
2129
2130 default:
2131 SwLedOn(Adapter, pLed0);
2132 break;
2133
2134 }
2135 } else { /* SW/HW radio off */
2136
2137 switch (pledpriv->LedStrategy) {
2138 case SW_LED_MODE9:
2139 rtw_led_control(Adapter, LED_CTL_POWER_OFF);
2140 break;
2141
2142 default:
2143 /* Turn off LED if RF is not ON. */
2144 SwLedOff(Adapter, pLed0);
2145 break;
2146 }
2147 }
2148
2149 }
2150
2151 /*
2152 * Description:
2153 * Reset status of LED_871x object.
2154 * */
ResetLedStatus(PLED_PCIE pLed)2155 void ResetLedStatus(PLED_PCIE pLed)
2156 {
2157
2158 pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
2159 pLed->bLedOn = _FALSE; /* true if LED is ON, false if LED is OFF. */
2160
2161 pLed->bLedBlinkInProgress = _FALSE; /* true if it is blinking, false o.w.. */
2162 pLed->bLedWPSBlinkInProgress = _FALSE;
2163 pLed->bLedSlowBlinkInProgress = _FALSE;
2164
2165 pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
2166 pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
2167 }
2168
2169 /*
2170 * Description:
2171 * Initialize an LED_871x object.
2172 * */
2173 void
InitLed(_adapter * padapter,PLED_PCIE pLed,LED_PIN LedPin)2174 InitLed(
2175 _adapter *padapter,
2176 PLED_PCIE pLed,
2177 LED_PIN LedPin
2178 )
2179 {
2180 pLed->padapter = padapter;
2181 pLed->LedPin = LedPin;
2182
2183 ResetLedStatus(pLed);
2184
2185 _init_timer(&(pLed->BlinkTimer), padapter->pnetdev, BlinkTimerCallback, pLed);
2186 }
2187
2188
2189 /*
2190 * Description:
2191 * DeInitialize an LED_871x object.
2192 * */
2193 void
DeInitLed(PLED_PCIE pLed)2194 DeInitLed(
2195 PLED_PCIE pLed
2196 )
2197 {
2198 _cancel_timer_ex(&(pLed->BlinkTimer));
2199 ResetLedStatus(pLed);
2200 }
2201