1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2007 - 2012 Realtek Corporation. */
3
4 #include "../include/drv_types.h"
5 #include "../include/rtw_led.h"
6
7 /* */
8 /* Description: */
9 /* Callback function of LED BlinkTimer, */
10 /* it just schedules to corresponding BlinkWorkItem/led_blink_hdl */
11 /* */
BlinkTimerCallback(struct timer_list * t)12 void BlinkTimerCallback(struct timer_list *t)
13 {
14 struct LED_871x *pLed = from_timer(pLed, t, BlinkTimer);
15 struct adapter *padapter = pLed->padapter;
16
17 if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped))
18 return;
19
20 _set_workitem(&pLed->BlinkWorkItem);
21 }
22
23 /* */
24 /* Description: */
25 /* Callback function of LED BlinkWorkItem. */
26 /* We dispatch acture LED blink action according to LedStrategy. */
27 /* */
BlinkWorkItemCallback(struct work_struct * work)28 void BlinkWorkItemCallback(struct work_struct *work)
29 {
30 struct LED_871x *pLed = container_of(work, struct LED_871x, BlinkWorkItem);
31 BlinkHandler(pLed);
32 }
33
34 /* */
35 /* Description: */
36 /* Reset status of LED_871x object. */
37 /* */
ResetLedStatus(struct LED_871x * pLed)38 void ResetLedStatus(struct LED_871x *pLed)
39 {
40 pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
41 pLed->bLedOn = false; /* true if LED is ON, false if LED is OFF. */
42
43 pLed->bLedBlinkInProgress = false; /* true if it is blinking, false o.w.. */
44 pLed->bLedWPSBlinkInProgress = false;
45
46 pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
47 pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
48
49 pLed->bLedNoLinkBlinkInProgress = false;
50 pLed->bLedLinkBlinkInProgress = false;
51 pLed->bLedStartToLinkBlinkInProgress = false;
52 pLed->bLedScanBlinkInProgress = false;
53 }
54
55 /*Description: */
56 /* Initialize an LED_871x object. */
InitLed871x(struct adapter * padapter,struct LED_871x * pLed,enum LED_PIN_871x LedPin)57 void InitLed871x(struct adapter *padapter, struct LED_871x *pLed, enum LED_PIN_871x LedPin)
58 {
59 pLed->padapter = padapter;
60 pLed->LedPin = LedPin;
61
62 ResetLedStatus(pLed);
63
64 timer_setup(&pLed->BlinkTimer, BlinkTimerCallback, 0);
65 _init_workitem(&pLed->BlinkWorkItem, BlinkWorkItemCallback, pLed);
66 }
67
68 /* */
69 /* Description: */
70 /* DeInitialize an LED_871x object. */
71 /* */
DeInitLed871x(struct LED_871x * pLed)72 void DeInitLed871x(struct LED_871x *pLed)
73 {
74 _cancel_workitem_sync(&pLed->BlinkWorkItem);
75 _cancel_timer_ex(&pLed->BlinkTimer);
76 ResetLedStatus(pLed);
77 }
78
79 /* */
80 /* Description: */
81 /* Implementation of LED blinking behavior. */
82 /* It toggle off LED and schedule corresponding timer if necessary. */
83 /* */
84
SwLedBlink(struct LED_871x * pLed)85 static void SwLedBlink(struct LED_871x *pLed)
86 {
87 struct adapter *padapter = pLed->padapter;
88 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
89 u8 bStopBlinking = false;
90
91 /* Change LED according to BlinkingLedState specified. */
92 if (pLed->BlinkingLedState == RTW_LED_ON)
93 SwLedOn(padapter, pLed);
94 else
95 SwLedOff(padapter, pLed);
96
97 /* Determine if we shall change LED state again. */
98 pLed->BlinkTimes--;
99 switch (pLed->CurrLedState) {
100 case LED_BLINK_NORMAL:
101 if (pLed->BlinkTimes == 0)
102 bStopBlinking = true;
103 break;
104 case LED_BLINK_StartToBlink:
105 if (check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
106 bStopBlinking = true;
107 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
108 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
109 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
110 bStopBlinking = true;
111 else if (pLed->BlinkTimes == 0)
112 bStopBlinking = true;
113 break;
114 case LED_BLINK_WPS:
115 if (pLed->BlinkTimes == 0)
116 bStopBlinking = true;
117 break;
118 default:
119 bStopBlinking = true;
120 break;
121 }
122
123 if (bStopBlinking) {
124 if (check_fwstate(pmlmepriv, _FW_LINKED) && !pLed->bLedOn) {
125 SwLedOn(padapter, pLed);
126 } else if (check_fwstate(pmlmepriv, _FW_LINKED) && pLed->bLedOn) {
127 SwLedOff(padapter, pLed);
128 }
129 pLed->BlinkTimes = 0;
130 pLed->bLedBlinkInProgress = false;
131 } else {
132 /* Assign LED state to toggle. */
133 if (pLed->BlinkingLedState == RTW_LED_ON)
134 pLed->BlinkingLedState = RTW_LED_OFF;
135 else
136 pLed->BlinkingLedState = RTW_LED_ON;
137
138 /* Schedule a timer to toggle LED state. */
139 switch (pLed->CurrLedState) {
140 case LED_BLINK_NORMAL:
141 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
142 break;
143 case LED_BLINK_SLOWLY:
144 case LED_BLINK_StartToBlink:
145 _set_timer(&pLed->BlinkTimer, LED_BLINK_SLOWLY_INTERVAL);
146 break;
147 case LED_BLINK_WPS:
148 _set_timer(&pLed->BlinkTimer, LED_BLINK_LONG_INTERVAL);
149 break;
150 default:
151 _set_timer(&pLed->BlinkTimer, LED_BLINK_SLOWLY_INTERVAL);
152 break;
153 }
154 }
155 }
156
SwLedBlink1(struct LED_871x * pLed)157 static void SwLedBlink1(struct LED_871x *pLed)
158 {
159 struct adapter *padapter = pLed->padapter;
160 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
161 u8 bStopBlinking = false;
162
163 /* Change LED according to BlinkingLedState specified. */
164 if (pLed->BlinkingLedState == RTW_LED_ON)
165 SwLedOn(padapter, pLed);
166 else
167 SwLedOff(padapter, pLed);
168
169 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
170 SwLedOff(padapter, pLed);
171 ResetLedStatus(pLed);
172 return;
173 }
174
175 switch (pLed->CurrLedState) {
176 case LED_BLINK_SLOWLY:
177 if (pLed->bLedOn)
178 pLed->BlinkingLedState = RTW_LED_OFF;
179 else
180 pLed->BlinkingLedState = RTW_LED_ON;
181 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
182 break;
183 case LED_BLINK_NORMAL:
184 if (pLed->bLedOn)
185 pLed->BlinkingLedState = RTW_LED_OFF;
186 else
187 pLed->BlinkingLedState = RTW_LED_ON;
188 _set_timer(&pLed->BlinkTimer, LED_BLINK_LINK_INTERVAL_ALPHA);
189 break;
190 case LED_BLINK_SCAN:
191 pLed->BlinkTimes--;
192 if (pLed->BlinkTimes == 0)
193 bStopBlinking = true;
194 if (bStopBlinking) {
195 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
196 pLed->bLedLinkBlinkInProgress = true;
197 pLed->CurrLedState = LED_BLINK_NORMAL;
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_LINK_INTERVAL_ALPHA);
203 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
204 pLed->bLedNoLinkBlinkInProgress = true;
205 pLed->CurrLedState = LED_BLINK_SLOWLY;
206 if (pLed->bLedOn)
207 pLed->BlinkingLedState = RTW_LED_OFF;
208 else
209 pLed->BlinkingLedState = RTW_LED_ON;
210 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
211 }
212 pLed->bLedScanBlinkInProgress = false;
213 } else {
214 if (pLed->bLedOn)
215 pLed->BlinkingLedState = RTW_LED_OFF;
216 else
217 pLed->BlinkingLedState = RTW_LED_ON;
218 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
219 }
220 break;
221 case LED_BLINK_TXRX:
222 pLed->BlinkTimes--;
223 if (pLed->BlinkTimes == 0)
224 bStopBlinking = true;
225 if (bStopBlinking) {
226 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
227 pLed->bLedLinkBlinkInProgress = true;
228 pLed->CurrLedState = LED_BLINK_NORMAL;
229 if (pLed->bLedOn)
230 pLed->BlinkingLedState = RTW_LED_OFF;
231 else
232 pLed->BlinkingLedState = RTW_LED_ON;
233 _set_timer(&pLed->BlinkTimer, LED_BLINK_LINK_INTERVAL_ALPHA);
234 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
235 pLed->bLedNoLinkBlinkInProgress = true;
236 pLed->CurrLedState = LED_BLINK_SLOWLY;
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_NO_LINK_INTERVAL_ALPHA);
242 }
243 pLed->BlinkTimes = 0;
244 pLed->bLedBlinkInProgress = false;
245 } else {
246 if (pLed->bLedOn)
247 pLed->BlinkingLedState = RTW_LED_OFF;
248 else
249 pLed->BlinkingLedState = RTW_LED_ON;
250 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
251 }
252 break;
253 case LED_BLINK_WPS:
254 if (pLed->bLedOn)
255 pLed->BlinkingLedState = RTW_LED_OFF;
256 else
257 pLed->BlinkingLedState = RTW_LED_ON;
258 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
259 break;
260 case LED_BLINK_WPS_STOP: /* WPS success */
261 if (pLed->BlinkingLedState == RTW_LED_ON)
262 bStopBlinking = false;
263 else
264 bStopBlinking = true;
265
266 if (bStopBlinking) {
267 pLed->bLedLinkBlinkInProgress = true;
268 pLed->CurrLedState = LED_BLINK_NORMAL;
269 if (pLed->bLedOn)
270 pLed->BlinkingLedState = RTW_LED_OFF;
271 else
272 pLed->BlinkingLedState = RTW_LED_ON;
273 _set_timer(&pLed->BlinkTimer, LED_BLINK_LINK_INTERVAL_ALPHA);
274
275 pLed->bLedWPSBlinkInProgress = false;
276 } else {
277 pLed->BlinkingLedState = RTW_LED_OFF;
278 _set_timer(&pLed->BlinkTimer, LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
279 }
280 break;
281 default:
282 break;
283 }
284 }
285
SwLedBlink2(struct LED_871x * pLed)286 static void SwLedBlink2(struct LED_871x *pLed)
287 {
288 struct adapter *padapter = pLed->padapter;
289 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
290 u8 bStopBlinking = false;
291
292 /* Change LED according to BlinkingLedState specified. */
293 if (pLed->BlinkingLedState == RTW_LED_ON)
294 SwLedOn(padapter, pLed);
295 else
296 SwLedOff(padapter, pLed);
297
298 switch (pLed->CurrLedState) {
299 case LED_BLINK_SCAN:
300 pLed->BlinkTimes--;
301 if (pLed->BlinkTimes == 0)
302 bStopBlinking = true;
303 if (bStopBlinking) {
304 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
305 SwLedOff(padapter, pLed);
306 } else if (check_fwstate(pmlmepriv, _FW_LINKED)) {
307 pLed->CurrLedState = RTW_LED_ON;
308 pLed->BlinkingLedState = RTW_LED_ON;
309 SwLedOn(padapter, pLed);
310 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
311 pLed->CurrLedState = RTW_LED_OFF;
312 pLed->BlinkingLedState = RTW_LED_OFF;
313 SwLedOff(padapter, pLed);
314 }
315 pLed->bLedScanBlinkInProgress = false;
316 } else {
317 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
318 SwLedOff(padapter, pLed);
319 } else {
320 if (pLed->bLedOn)
321 pLed->BlinkingLedState = RTW_LED_OFF;
322 else
323 pLed->BlinkingLedState = RTW_LED_ON;
324 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
325 }
326 }
327 break;
328 case LED_BLINK_TXRX:
329 pLed->BlinkTimes--;
330 if (pLed->BlinkTimes == 0)
331 bStopBlinking = true;
332 if (bStopBlinking) {
333 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
334 SwLedOff(padapter, pLed);
335 } else if (check_fwstate(pmlmepriv, _FW_LINKED)) {
336 pLed->CurrLedState = RTW_LED_ON;
337 pLed->BlinkingLedState = RTW_LED_ON;
338 SwLedOn(padapter, pLed);
339 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
340 pLed->CurrLedState = RTW_LED_OFF;
341 pLed->BlinkingLedState = RTW_LED_OFF;
342 SwLedOff(padapter, pLed);
343 }
344 pLed->bLedBlinkInProgress = false;
345 } else {
346 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
347 SwLedOff(padapter, pLed);
348 } else {
349 if (pLed->bLedOn)
350 pLed->BlinkingLedState = RTW_LED_OFF;
351 else
352 pLed->BlinkingLedState = RTW_LED_ON;
353 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
354 }
355 }
356 break;
357 default:
358 break;
359 }
360 }
361
SwLedBlink3(struct LED_871x * pLed)362 static void SwLedBlink3(struct LED_871x *pLed)
363 {
364 struct adapter *padapter = pLed->padapter;
365 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
366 u8 bStopBlinking = false;
367
368 /* Change LED according to BlinkingLedState specified. */
369 if (pLed->BlinkingLedState == RTW_LED_ON) {
370 SwLedOn(padapter, pLed);
371 } else {
372 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
373 SwLedOff(padapter, pLed);
374 }
375
376 switch (pLed->CurrLedState) {
377 case LED_BLINK_SCAN:
378 pLed->BlinkTimes--;
379 if (pLed->BlinkTimes == 0)
380 bStopBlinking = true;
381 if (bStopBlinking) {
382 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
383 SwLedOff(padapter, pLed);
384 } else if (check_fwstate(pmlmepriv, _FW_LINKED)) {
385 pLed->CurrLedState = RTW_LED_ON;
386 pLed->BlinkingLedState = RTW_LED_ON;
387 if (!pLed->bLedOn)
388 SwLedOn(padapter, pLed);
389 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
390 pLed->CurrLedState = RTW_LED_OFF;
391 pLed->BlinkingLedState = RTW_LED_OFF;
392 if (pLed->bLedOn)
393 SwLedOff(padapter, pLed);
394 }
395 pLed->bLedScanBlinkInProgress = false;
396 } else {
397 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
398 SwLedOff(padapter, pLed);
399 } else {
400 if (pLed->bLedOn)
401 pLed->BlinkingLedState = RTW_LED_OFF;
402 else
403 pLed->BlinkingLedState = RTW_LED_ON;
404 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
405 }
406 }
407 break;
408 case LED_BLINK_TXRX:
409 pLed->BlinkTimes--;
410 if (pLed->BlinkTimes == 0)
411 bStopBlinking = true;
412 if (bStopBlinking) {
413 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
414 SwLedOff(padapter, pLed);
415 } else if (check_fwstate(pmlmepriv, _FW_LINKED)) {
416 pLed->CurrLedState = RTW_LED_ON;
417 pLed->BlinkingLedState = RTW_LED_ON;
418 if (!pLed->bLedOn)
419 SwLedOn(padapter, pLed);
420 } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
421 pLed->CurrLedState = RTW_LED_OFF;
422 pLed->BlinkingLedState = RTW_LED_OFF;
423
424 if (pLed->bLedOn)
425 SwLedOff(padapter, pLed);
426 }
427 pLed->bLedBlinkInProgress = false;
428 } else {
429 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
430 SwLedOff(padapter, pLed);
431 } else {
432 if (pLed->bLedOn)
433 pLed->BlinkingLedState = RTW_LED_OFF;
434 else
435 pLed->BlinkingLedState = RTW_LED_ON;
436 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
437 }
438 }
439 break;
440 case LED_BLINK_WPS:
441 if (pLed->bLedOn)
442 pLed->BlinkingLedState = RTW_LED_OFF;
443 else
444 pLed->BlinkingLedState = RTW_LED_ON;
445 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
446 break;
447 case LED_BLINK_WPS_STOP: /* WPS success */
448 if (pLed->BlinkingLedState == RTW_LED_ON) {
449 pLed->BlinkingLedState = RTW_LED_OFF;
450 _set_timer(&pLed->BlinkTimer, LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
451 bStopBlinking = false;
452 } else {
453 bStopBlinking = true;
454 }
455 if (bStopBlinking) {
456 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
457 SwLedOff(padapter, pLed);
458 } else {
459 pLed->CurrLedState = RTW_LED_ON;
460 pLed->BlinkingLedState = RTW_LED_ON;
461 SwLedOn(padapter, pLed);
462 }
463 pLed->bLedWPSBlinkInProgress = false;
464 }
465 break;
466 default:
467 break;
468 }
469 }
470
SwLedBlink4(struct LED_871x * pLed)471 static void SwLedBlink4(struct LED_871x *pLed)
472 {
473 struct adapter *padapter = pLed->padapter;
474 struct led_priv *ledpriv = &padapter->ledpriv;
475 struct LED_871x *pLed1 = &ledpriv->SwLed1;
476 u8 bStopBlinking = false;
477
478 /* Change LED according to BlinkingLedState specified. */
479 if (pLed->BlinkingLedState == RTW_LED_ON)
480 SwLedOn(padapter, pLed);
481 else
482 SwLedOff(padapter, pLed);
483
484 if (!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN) {
485 pLed1->BlinkingLedState = RTW_LED_OFF;
486 pLed1->CurrLedState = RTW_LED_OFF;
487 SwLedOff(padapter, pLed1);
488 }
489
490 switch (pLed->CurrLedState) {
491 case LED_BLINK_SLOWLY:
492 if (pLed->bLedOn)
493 pLed->BlinkingLedState = RTW_LED_OFF;
494 else
495 pLed->BlinkingLedState = RTW_LED_ON;
496 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
497 break;
498 case LED_BLINK_StartToBlink:
499 if (pLed->bLedOn) {
500 pLed->BlinkingLedState = RTW_LED_OFF;
501 _set_timer(&pLed->BlinkTimer, LED_BLINK_SLOWLY_INTERVAL);
502 } else {
503 pLed->BlinkingLedState = RTW_LED_ON;
504 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
505 }
506 break;
507 case LED_BLINK_SCAN:
508 pLed->BlinkTimes--;
509 if (pLed->BlinkTimes == 0)
510 bStopBlinking = false;
511 if (bStopBlinking) {
512 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
513 SwLedOff(padapter, pLed);
514 } else {
515 pLed->bLedNoLinkBlinkInProgress = false;
516 pLed->CurrLedState = LED_BLINK_SLOWLY;
517 if (pLed->bLedOn)
518 pLed->BlinkingLedState = RTW_LED_OFF;
519 else
520 pLed->BlinkingLedState = RTW_LED_ON;
521 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
522 }
523 pLed->bLedScanBlinkInProgress = false;
524 } else {
525 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
526 SwLedOff(padapter, pLed);
527 } else {
528 if (pLed->bLedOn)
529 pLed->BlinkingLedState = RTW_LED_OFF;
530 else
531 pLed->BlinkingLedState = RTW_LED_ON;
532 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
533 }
534 }
535 break;
536 case LED_BLINK_TXRX:
537 pLed->BlinkTimes--;
538 if (pLed->BlinkTimes == 0)
539 bStopBlinking = true;
540 if (bStopBlinking) {
541 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
542 SwLedOff(padapter, pLed);
543 } else {
544 pLed->bLedNoLinkBlinkInProgress = true;
545 pLed->CurrLedState = LED_BLINK_SLOWLY;
546 if (pLed->bLedOn)
547 pLed->BlinkingLedState = RTW_LED_OFF;
548 else
549 pLed->BlinkingLedState = RTW_LED_ON;
550 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
551 }
552 pLed->bLedBlinkInProgress = false;
553 } else {
554 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
555 SwLedOff(padapter, pLed);
556 } else {
557 if (pLed->bLedOn)
558 pLed->BlinkingLedState = RTW_LED_OFF;
559 else
560 pLed->BlinkingLedState = RTW_LED_ON;
561 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
562 }
563 }
564 break;
565 case LED_BLINK_WPS:
566 if (pLed->bLedOn) {
567 pLed->BlinkingLedState = RTW_LED_OFF;
568 _set_timer(&pLed->BlinkTimer, LED_BLINK_SLOWLY_INTERVAL);
569 } else {
570 pLed->BlinkingLedState = RTW_LED_ON;
571 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
572 }
573 break;
574 case LED_BLINK_WPS_STOP: /* WPS authentication fail */
575 if (pLed->bLedOn)
576 pLed->BlinkingLedState = RTW_LED_OFF;
577 else
578 pLed->BlinkingLedState = RTW_LED_ON;
579
580 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
581 break;
582 case LED_BLINK_WPS_STOP_OVERLAP: /* WPS session overlap */
583 pLed->BlinkTimes--;
584 if (pLed->BlinkTimes == 0) {
585 if (pLed->bLedOn)
586 pLed->BlinkTimes = 1;
587 else
588 bStopBlinking = true;
589 }
590
591 if (bStopBlinking) {
592 pLed->BlinkTimes = 10;
593 pLed->BlinkingLedState = RTW_LED_ON;
594 _set_timer(&pLed->BlinkTimer, LED_BLINK_LINK_INTERVAL_ALPHA);
595 } else {
596 if (pLed->bLedOn)
597 pLed->BlinkingLedState = RTW_LED_OFF;
598 else
599 pLed->BlinkingLedState = RTW_LED_ON;
600
601 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
602 }
603 break;
604 default:
605 break;
606 }
607 }
608
SwLedBlink5(struct LED_871x * pLed)609 static void SwLedBlink5(struct LED_871x *pLed)
610 {
611 struct adapter *padapter = pLed->padapter;
612 u8 bStopBlinking = false;
613
614 /* Change LED according to BlinkingLedState specified. */
615 if (pLed->BlinkingLedState == RTW_LED_ON)
616 SwLedOn(padapter, pLed);
617 else
618 SwLedOff(padapter, pLed);
619
620 switch (pLed->CurrLedState) {
621 case LED_BLINK_SCAN:
622 pLed->BlinkTimes--;
623 if (pLed->BlinkTimes == 0)
624 bStopBlinking = true;
625
626 if (bStopBlinking) {
627 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
628 pLed->CurrLedState = RTW_LED_OFF;
629 pLed->BlinkingLedState = RTW_LED_OFF;
630 if (pLed->bLedOn)
631 SwLedOff(padapter, pLed);
632 } else {
633 pLed->CurrLedState = RTW_LED_ON;
634 pLed->BlinkingLedState = RTW_LED_ON;
635 if (!pLed->bLedOn)
636 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
637 }
638
639 pLed->bLedScanBlinkInProgress = false;
640 } else {
641 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
642 SwLedOff(padapter, pLed);
643 } else {
644 if (pLed->bLedOn)
645 pLed->BlinkingLedState = RTW_LED_OFF;
646 else
647 pLed->BlinkingLedState = RTW_LED_ON;
648 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
649 }
650 }
651 break;
652 case LED_BLINK_TXRX:
653 pLed->BlinkTimes--;
654 if (pLed->BlinkTimes == 0)
655 bStopBlinking = true;
656
657 if (bStopBlinking) {
658 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
659 pLed->CurrLedState = RTW_LED_OFF;
660 pLed->BlinkingLedState = RTW_LED_OFF;
661 if (pLed->bLedOn)
662 SwLedOff(padapter, pLed);
663 } else {
664 pLed->CurrLedState = RTW_LED_ON;
665 pLed->BlinkingLedState = RTW_LED_ON;
666 if (!pLed->bLedOn)
667 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
668 }
669
670 pLed->bLedBlinkInProgress = false;
671 } else {
672 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) {
673 SwLedOff(padapter, pLed);
674 } else {
675 if (pLed->bLedOn)
676 pLed->BlinkingLedState = RTW_LED_OFF;
677 else
678 pLed->BlinkingLedState = RTW_LED_ON;
679 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
680 }
681 }
682 break;
683
684 default:
685 break;
686 }
687 }
688
SwLedBlink6(struct LED_871x * pLed)689 static void SwLedBlink6(struct LED_871x *pLed)
690 {
691 struct adapter *padapter = pLed->padapter;
692
693 /* Change LED according to BlinkingLedState specified. */
694 if (pLed->BlinkingLedState == RTW_LED_ON)
695 SwLedOn(padapter, pLed);
696 else
697 SwLedOff(padapter, pLed);
698 }
699
700 /* ALPHA, added by chiyoko, 20090106 */
SwLedControlMode1(struct adapter * padapter,enum LED_CTL_MODE LedAction)701 static void SwLedControlMode1(struct adapter *padapter, enum LED_CTL_MODE LedAction)
702 {
703 struct led_priv *ledpriv = &padapter->ledpriv;
704 struct LED_871x *pLed = &ledpriv->SwLed0;
705 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
706
707 switch (LedAction) {
708 case LED_CTL_POWER_ON:
709 case LED_CTL_START_TO_LINK:
710 case LED_CTL_NO_LINK:
711 if (!pLed->bLedNoLinkBlinkInProgress) {
712 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
713 return;
714 if (pLed->bLedLinkBlinkInProgress) {
715 _cancel_timer_ex(&pLed->BlinkTimer);
716 pLed->bLedLinkBlinkInProgress = false;
717 }
718 if (pLed->bLedBlinkInProgress) {
719 _cancel_timer_ex(&pLed->BlinkTimer);
720 pLed->bLedBlinkInProgress = false;
721 }
722
723 pLed->bLedNoLinkBlinkInProgress = true;
724 pLed->CurrLedState = LED_BLINK_SLOWLY;
725 if (pLed->bLedOn)
726 pLed->BlinkingLedState = RTW_LED_OFF;
727 else
728 pLed->BlinkingLedState = RTW_LED_ON;
729 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
730 }
731 break;
732 case LED_CTL_LINK:
733 if (!pLed->bLedLinkBlinkInProgress) {
734 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
735 return;
736 if (pLed->bLedNoLinkBlinkInProgress) {
737 _cancel_timer_ex(&pLed->BlinkTimer);
738 pLed->bLedNoLinkBlinkInProgress = false;
739 }
740 if (pLed->bLedBlinkInProgress) {
741 _cancel_timer_ex(&pLed->BlinkTimer);
742 pLed->bLedBlinkInProgress = false;
743 }
744 pLed->bLedLinkBlinkInProgress = true;
745 pLed->CurrLedState = LED_BLINK_NORMAL;
746 if (pLed->bLedOn)
747 pLed->BlinkingLedState = RTW_LED_OFF;
748 else
749 pLed->BlinkingLedState = RTW_LED_ON;
750 _set_timer(&pLed->BlinkTimer, LED_BLINK_LINK_INTERVAL_ALPHA);
751 }
752 break;
753 case LED_CTL_SITE_SURVEY:
754 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
755 ;
756 } else if (!pLed->bLedScanBlinkInProgress) {
757 if (IS_LED_WPS_BLINKING(pLed))
758 return;
759 if (pLed->bLedNoLinkBlinkInProgress) {
760 _cancel_timer_ex(&pLed->BlinkTimer);
761 pLed->bLedNoLinkBlinkInProgress = false;
762 }
763 if (pLed->bLedLinkBlinkInProgress) {
764 _cancel_timer_ex(&pLed->BlinkTimer);
765 pLed->bLedLinkBlinkInProgress = false;
766 }
767 if (pLed->bLedBlinkInProgress) {
768 _cancel_timer_ex(&pLed->BlinkTimer);
769 pLed->bLedBlinkInProgress = false;
770 }
771 pLed->bLedScanBlinkInProgress = true;
772 pLed->CurrLedState = LED_BLINK_SCAN;
773 pLed->BlinkTimes = 24;
774 if (pLed->bLedOn)
775 pLed->BlinkingLedState = RTW_LED_OFF;
776 else
777 pLed->BlinkingLedState = RTW_LED_ON;
778 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
779 }
780 break;
781 case LED_CTL_TX:
782 case LED_CTL_RX:
783 if (!pLed->bLedBlinkInProgress) {
784 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
785 return;
786 if (pLed->bLedNoLinkBlinkInProgress) {
787 _cancel_timer_ex(&pLed->BlinkTimer);
788 pLed->bLedNoLinkBlinkInProgress = false;
789 }
790 if (pLed->bLedLinkBlinkInProgress) {
791 _cancel_timer_ex(&pLed->BlinkTimer);
792 pLed->bLedLinkBlinkInProgress = false;
793 }
794 pLed->bLedBlinkInProgress = true;
795 pLed->CurrLedState = LED_BLINK_TXRX;
796 pLed->BlinkTimes = 2;
797 if (pLed->bLedOn)
798 pLed->BlinkingLedState = RTW_LED_OFF;
799 else
800 pLed->BlinkingLedState = RTW_LED_ON;
801 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
802 }
803 break;
804 case LED_CTL_START_WPS: /* wait until xinpin finish */
805 case LED_CTL_START_WPS_BOTTON:
806 if (!pLed->bLedWPSBlinkInProgress) {
807 if (pLed->bLedNoLinkBlinkInProgress) {
808 _cancel_timer_ex(&pLed->BlinkTimer);
809 pLed->bLedNoLinkBlinkInProgress = false;
810 }
811 if (pLed->bLedLinkBlinkInProgress) {
812 _cancel_timer_ex(&pLed->BlinkTimer);
813 pLed->bLedLinkBlinkInProgress = false;
814 }
815 if (pLed->bLedBlinkInProgress) {
816 _cancel_timer_ex(&pLed->BlinkTimer);
817 pLed->bLedBlinkInProgress = false;
818 }
819 if (pLed->bLedScanBlinkInProgress) {
820 _cancel_timer_ex(&pLed->BlinkTimer);
821 pLed->bLedScanBlinkInProgress = false;
822 }
823 pLed->bLedWPSBlinkInProgress = true;
824 pLed->CurrLedState = LED_BLINK_WPS;
825 if (pLed->bLedOn)
826 pLed->BlinkingLedState = RTW_LED_OFF;
827 else
828 pLed->BlinkingLedState = RTW_LED_ON;
829 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
830 }
831 break;
832 case LED_CTL_STOP_WPS:
833 if (pLed->bLedNoLinkBlinkInProgress) {
834 _cancel_timer_ex(&pLed->BlinkTimer);
835 pLed->bLedNoLinkBlinkInProgress = false;
836 }
837 if (pLed->bLedLinkBlinkInProgress) {
838 _cancel_timer_ex(&pLed->BlinkTimer);
839 pLed->bLedLinkBlinkInProgress = false;
840 }
841 if (pLed->bLedBlinkInProgress) {
842 _cancel_timer_ex(&pLed->BlinkTimer);
843 pLed->bLedBlinkInProgress = false;
844 }
845 if (pLed->bLedScanBlinkInProgress) {
846 _cancel_timer_ex(&pLed->BlinkTimer);
847 pLed->bLedScanBlinkInProgress = false;
848 }
849 if (pLed->bLedWPSBlinkInProgress)
850 _cancel_timer_ex(&pLed->BlinkTimer);
851 else
852 pLed->bLedWPSBlinkInProgress = true;
853 pLed->CurrLedState = LED_BLINK_WPS_STOP;
854 if (pLed->bLedOn) {
855 pLed->BlinkingLedState = RTW_LED_OFF;
856 _set_timer(&pLed->BlinkTimer, LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
857 } else {
858 pLed->BlinkingLedState = RTW_LED_ON;
859 _set_timer(&pLed->BlinkTimer, 0);
860 }
861 break;
862 case LED_CTL_STOP_WPS_FAIL:
863 if (pLed->bLedWPSBlinkInProgress) {
864 _cancel_timer_ex(&pLed->BlinkTimer);
865 pLed->bLedWPSBlinkInProgress = false;
866 }
867 pLed->bLedNoLinkBlinkInProgress = true;
868 pLed->CurrLedState = LED_BLINK_SLOWLY;
869 if (pLed->bLedOn)
870 pLed->BlinkingLedState = RTW_LED_OFF;
871 else
872 pLed->BlinkingLedState = RTW_LED_ON;
873 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
874 break;
875 case LED_CTL_POWER_OFF:
876 pLed->CurrLedState = RTW_LED_OFF;
877 pLed->BlinkingLedState = RTW_LED_OFF;
878 if (pLed->bLedNoLinkBlinkInProgress) {
879 _cancel_timer_ex(&pLed->BlinkTimer);
880 pLed->bLedNoLinkBlinkInProgress = false;
881 }
882 if (pLed->bLedLinkBlinkInProgress) {
883 _cancel_timer_ex(&pLed->BlinkTimer);
884 pLed->bLedLinkBlinkInProgress = false;
885 }
886 if (pLed->bLedBlinkInProgress) {
887 _cancel_timer_ex(&pLed->BlinkTimer);
888 pLed->bLedBlinkInProgress = false;
889 }
890 if (pLed->bLedWPSBlinkInProgress) {
891 _cancel_timer_ex(&pLed->BlinkTimer);
892 pLed->bLedWPSBlinkInProgress = false;
893 }
894 if (pLed->bLedScanBlinkInProgress) {
895 _cancel_timer_ex(&pLed->BlinkTimer);
896 pLed->bLedScanBlinkInProgress = false;
897 }
898 SwLedOff(padapter, pLed);
899 break;
900 default:
901 break;
902 }
903 }
904
905 /* Arcadyan/Sitecom , added by chiyoko, 20090216 */
SwLedControlMode2(struct adapter * padapter,enum LED_CTL_MODE LedAction)906 static void SwLedControlMode2(struct adapter *padapter, enum LED_CTL_MODE LedAction)
907 {
908 struct led_priv *ledpriv = &padapter->ledpriv;
909 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
910 struct LED_871x *pLed = &ledpriv->SwLed0;
911
912 switch (LedAction) {
913 case LED_CTL_SITE_SURVEY:
914 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) {
915 } else if (!pLed->bLedScanBlinkInProgress) {
916 if (IS_LED_WPS_BLINKING(pLed))
917 return;
918
919 if (pLed->bLedBlinkInProgress) {
920 _cancel_timer_ex(&pLed->BlinkTimer);
921 pLed->bLedBlinkInProgress = false;
922 }
923 pLed->bLedScanBlinkInProgress = true;
924 pLed->CurrLedState = LED_BLINK_SCAN;
925 pLed->BlinkTimes = 24;
926 if (pLed->bLedOn)
927 pLed->BlinkingLedState = RTW_LED_OFF;
928 else
929 pLed->BlinkingLedState = RTW_LED_ON;
930 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
931 }
932 break;
933 case LED_CTL_TX:
934 case LED_CTL_RX:
935 if ((!pLed->bLedBlinkInProgress) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
936 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
937 return;
938 pLed->bLedBlinkInProgress = true;
939 pLed->CurrLedState = LED_BLINK_TXRX;
940 pLed->BlinkTimes = 2;
941 if (pLed->bLedOn)
942 pLed->BlinkingLedState = RTW_LED_OFF;
943 else
944 pLed->BlinkingLedState = RTW_LED_ON;
945 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
946 }
947 break;
948 case LED_CTL_LINK:
949 pLed->CurrLedState = RTW_LED_ON;
950 pLed->BlinkingLedState = RTW_LED_ON;
951 if (pLed->bLedBlinkInProgress) {
952 _cancel_timer_ex(&pLed->BlinkTimer);
953 pLed->bLedBlinkInProgress = false;
954 }
955 if (pLed->bLedScanBlinkInProgress) {
956 _cancel_timer_ex(&pLed->BlinkTimer);
957 pLed->bLedScanBlinkInProgress = false;
958 }
959 _set_timer(&pLed->BlinkTimer, 0);
960 break;
961 case LED_CTL_START_WPS: /* wait until xinpin finish */
962 case LED_CTL_START_WPS_BOTTON:
963 if (!pLed->bLedWPSBlinkInProgress) {
964 if (pLed->bLedBlinkInProgress) {
965 _cancel_timer_ex(&pLed->BlinkTimer);
966 pLed->bLedBlinkInProgress = false;
967 }
968 if (pLed->bLedScanBlinkInProgress) {
969 _cancel_timer_ex(&pLed->BlinkTimer);
970 pLed->bLedScanBlinkInProgress = false;
971 }
972 pLed->bLedWPSBlinkInProgress = true;
973 pLed->CurrLedState = RTW_LED_ON;
974 pLed->BlinkingLedState = RTW_LED_ON;
975 _set_timer(&pLed->BlinkTimer, 0);
976 }
977 break;
978 case LED_CTL_STOP_WPS:
979 pLed->bLedWPSBlinkInProgress = false;
980 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
981 SwLedOff(padapter, pLed);
982 } else {
983 pLed->CurrLedState = RTW_LED_ON;
984 pLed->BlinkingLedState = RTW_LED_ON;
985 _set_timer(&pLed->BlinkTimer, 0);
986 }
987 break;
988 case LED_CTL_STOP_WPS_FAIL:
989 pLed->bLedWPSBlinkInProgress = false;
990 if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
991 SwLedOff(padapter, pLed);
992 } else {
993 pLed->CurrLedState = RTW_LED_OFF;
994 pLed->BlinkingLedState = RTW_LED_OFF;
995 _set_timer(&pLed->BlinkTimer, 0);
996 }
997 break;
998 case LED_CTL_START_TO_LINK:
999 case LED_CTL_NO_LINK:
1000 if (!IS_LED_BLINKING(pLed)) {
1001 pLed->CurrLedState = RTW_LED_OFF;
1002 pLed->BlinkingLedState = RTW_LED_OFF;
1003 _set_timer(&pLed->BlinkTimer, 0);
1004 }
1005 break;
1006 case LED_CTL_POWER_OFF:
1007 pLed->CurrLedState = RTW_LED_OFF;
1008 pLed->BlinkingLedState = RTW_LED_OFF;
1009 if (pLed->bLedBlinkInProgress) {
1010 _cancel_timer_ex(&pLed->BlinkTimer);
1011 pLed->bLedBlinkInProgress = false;
1012 }
1013 if (pLed->bLedScanBlinkInProgress) {
1014 _cancel_timer_ex(&pLed->BlinkTimer);
1015 pLed->bLedScanBlinkInProgress = false;
1016 }
1017 if (pLed->bLedWPSBlinkInProgress) {
1018 _cancel_timer_ex(&pLed->BlinkTimer);
1019 pLed->bLedWPSBlinkInProgress = false;
1020 }
1021
1022 _set_timer(&pLed->BlinkTimer, 0);
1023 break;
1024 default:
1025 break;
1026 }
1027 }
1028
1029 /* COREGA, added by chiyoko, 20090316 */
SwLedControlMode3(struct adapter * padapter,enum LED_CTL_MODE LedAction)1030 static void SwLedControlMode3(struct adapter *padapter, enum LED_CTL_MODE LedAction)
1031 {
1032 struct led_priv *ledpriv = &padapter->ledpriv;
1033 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1034 struct LED_871x *pLed = &ledpriv->SwLed0;
1035
1036 switch (LedAction) {
1037 case LED_CTL_SITE_SURVEY:
1038 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) {
1039 } else if (!pLed->bLedScanBlinkInProgress) {
1040 if (IS_LED_WPS_BLINKING(pLed))
1041 return;
1042
1043 if (pLed->bLedBlinkInProgress) {
1044 _cancel_timer_ex(&pLed->BlinkTimer);
1045 pLed->bLedBlinkInProgress = false;
1046 }
1047 pLed->bLedScanBlinkInProgress = true;
1048 pLed->CurrLedState = LED_BLINK_SCAN;
1049 pLed->BlinkTimes = 24;
1050 if (pLed->bLedOn)
1051 pLed->BlinkingLedState = RTW_LED_OFF;
1052 else
1053 pLed->BlinkingLedState = RTW_LED_ON;
1054 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
1055 }
1056 break;
1057 case LED_CTL_TX:
1058 case LED_CTL_RX:
1059 if ((!pLed->bLedBlinkInProgress) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
1060 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1061 return;
1062 pLed->bLedBlinkInProgress = true;
1063 pLed->CurrLedState = LED_BLINK_TXRX;
1064 pLed->BlinkTimes = 2;
1065 if (pLed->bLedOn)
1066 pLed->BlinkingLedState = RTW_LED_OFF;
1067 else
1068 pLed->BlinkingLedState = RTW_LED_ON;
1069 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
1070 }
1071 break;
1072 case LED_CTL_LINK:
1073 if (IS_LED_WPS_BLINKING(pLed))
1074 return;
1075 pLed->CurrLedState = RTW_LED_ON;
1076 pLed->BlinkingLedState = RTW_LED_ON;
1077 if (pLed->bLedBlinkInProgress) {
1078 _cancel_timer_ex(&pLed->BlinkTimer);
1079 pLed->bLedBlinkInProgress = false;
1080 }
1081 if (pLed->bLedScanBlinkInProgress) {
1082 _cancel_timer_ex(&pLed->BlinkTimer);
1083 pLed->bLedScanBlinkInProgress = false;
1084 }
1085
1086 _set_timer(&pLed->BlinkTimer, 0);
1087 break;
1088 case LED_CTL_START_WPS: /* wait until xinpin finish */
1089 case LED_CTL_START_WPS_BOTTON:
1090 if (!pLed->bLedWPSBlinkInProgress) {
1091 if (pLed->bLedBlinkInProgress) {
1092 _cancel_timer_ex(&pLed->BlinkTimer);
1093 pLed->bLedBlinkInProgress = false;
1094 }
1095 if (pLed->bLedScanBlinkInProgress) {
1096 _cancel_timer_ex(&pLed->BlinkTimer);
1097 pLed->bLedScanBlinkInProgress = false;
1098 }
1099 pLed->bLedWPSBlinkInProgress = true;
1100 pLed->CurrLedState = LED_BLINK_WPS;
1101 if (pLed->bLedOn)
1102 pLed->BlinkingLedState = RTW_LED_OFF;
1103 else
1104 pLed->BlinkingLedState = RTW_LED_ON;
1105 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
1106 }
1107 break;
1108 case LED_CTL_STOP_WPS:
1109 if (pLed->bLedWPSBlinkInProgress) {
1110 _cancel_timer_ex(&pLed->BlinkTimer);
1111 pLed->bLedWPSBlinkInProgress = false;
1112 } else {
1113 pLed->bLedWPSBlinkInProgress = true;
1114 }
1115
1116 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1117 if (pLed->bLedOn) {
1118 pLed->BlinkingLedState = RTW_LED_OFF;
1119 _set_timer(&pLed->BlinkTimer, LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1120 } else {
1121 pLed->BlinkingLedState = RTW_LED_ON;
1122 _set_timer(&pLed->BlinkTimer, 0);
1123 }
1124 break;
1125 case LED_CTL_STOP_WPS_FAIL:
1126 if (pLed->bLedWPSBlinkInProgress) {
1127 _cancel_timer_ex(&pLed->BlinkTimer);
1128 pLed->bLedWPSBlinkInProgress = false;
1129 }
1130 pLed->CurrLedState = RTW_LED_OFF;
1131 pLed->BlinkingLedState = RTW_LED_OFF;
1132 _set_timer(&pLed->BlinkTimer, 0);
1133 break;
1134 case LED_CTL_START_TO_LINK:
1135 case LED_CTL_NO_LINK:
1136 if (!IS_LED_BLINKING(pLed)) {
1137 pLed->CurrLedState = RTW_LED_OFF;
1138 pLed->BlinkingLedState = RTW_LED_OFF;
1139 _set_timer(&pLed->BlinkTimer, 0);
1140 }
1141 break;
1142 case LED_CTL_POWER_OFF:
1143 pLed->CurrLedState = RTW_LED_OFF;
1144 pLed->BlinkingLedState = RTW_LED_OFF;
1145 if (pLed->bLedBlinkInProgress) {
1146 _cancel_timer_ex(&pLed->BlinkTimer);
1147 pLed->bLedBlinkInProgress = false;
1148 }
1149 if (pLed->bLedScanBlinkInProgress) {
1150 _cancel_timer_ex(&pLed->BlinkTimer);
1151 pLed->bLedScanBlinkInProgress = false;
1152 }
1153 if (pLed->bLedWPSBlinkInProgress) {
1154 _cancel_timer_ex(&pLed->BlinkTimer);
1155 pLed->bLedWPSBlinkInProgress = false;
1156 }
1157
1158 _set_timer(&pLed->BlinkTimer, 0);
1159 break;
1160 default:
1161 break;
1162 }
1163 }
1164
1165 /* Edimax-Belkin, added by chiyoko, 20090413 */
SwLedControlMode4(struct adapter * padapter,enum LED_CTL_MODE LedAction)1166 static void SwLedControlMode4(struct adapter *padapter, enum LED_CTL_MODE LedAction)
1167 {
1168 struct led_priv *ledpriv = &padapter->ledpriv;
1169 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1170 struct LED_871x *pLed = &ledpriv->SwLed0;
1171 struct LED_871x *pLed1 = &ledpriv->SwLed1;
1172
1173 switch (LedAction) {
1174 case LED_CTL_START_TO_LINK:
1175 if (pLed1->bLedWPSBlinkInProgress) {
1176 pLed1->bLedWPSBlinkInProgress = false;
1177 _cancel_timer_ex(&pLed1->BlinkTimer);
1178
1179 pLed1->BlinkingLedState = RTW_LED_OFF;
1180 pLed1->CurrLedState = RTW_LED_OFF;
1181
1182 if (pLed1->bLedOn)
1183 _set_timer(&pLed->BlinkTimer, 0);
1184 }
1185
1186 if (!pLed->bLedStartToLinkBlinkInProgress) {
1187 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1188 return;
1189 if (pLed->bLedBlinkInProgress) {
1190 _cancel_timer_ex(&pLed->BlinkTimer);
1191 pLed->bLedBlinkInProgress = false;
1192 }
1193 if (pLed->bLedNoLinkBlinkInProgress) {
1194 _cancel_timer_ex(&pLed->BlinkTimer);
1195 pLed->bLedNoLinkBlinkInProgress = false;
1196 }
1197
1198 pLed->bLedStartToLinkBlinkInProgress = true;
1199 pLed->CurrLedState = LED_BLINK_StartToBlink;
1200 if (pLed->bLedOn) {
1201 pLed->BlinkingLedState = RTW_LED_OFF;
1202 _set_timer(&pLed->BlinkTimer, LED_BLINK_SLOWLY_INTERVAL);
1203 } else {
1204 pLed->BlinkingLedState = RTW_LED_ON;
1205 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
1206 }
1207 }
1208 break;
1209 case LED_CTL_LINK:
1210 case LED_CTL_NO_LINK:
1211 /* LED1 settings */
1212 if (LedAction == LED_CTL_LINK) {
1213 if (pLed1->bLedWPSBlinkInProgress) {
1214 pLed1->bLedWPSBlinkInProgress = false;
1215 _cancel_timer_ex(&pLed1->BlinkTimer);
1216
1217 pLed1->BlinkingLedState = RTW_LED_OFF;
1218 pLed1->CurrLedState = RTW_LED_OFF;
1219
1220 if (pLed1->bLedOn)
1221 _set_timer(&pLed->BlinkTimer, 0);
1222 }
1223 }
1224
1225 if (!pLed->bLedNoLinkBlinkInProgress) {
1226 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1227 return;
1228 if (pLed->bLedBlinkInProgress) {
1229 _cancel_timer_ex(&pLed->BlinkTimer);
1230 pLed->bLedBlinkInProgress = false;
1231 }
1232
1233 pLed->bLedNoLinkBlinkInProgress = true;
1234 pLed->CurrLedState = LED_BLINK_SLOWLY;
1235 if (pLed->bLedOn)
1236 pLed->BlinkingLedState = RTW_LED_OFF;
1237 else
1238 pLed->BlinkingLedState = RTW_LED_ON;
1239 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1240 }
1241 break;
1242 case LED_CTL_SITE_SURVEY:
1243 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
1244 } else if (!pLed->bLedScanBlinkInProgress) {
1245 if (IS_LED_WPS_BLINKING(pLed))
1246 return;
1247
1248 if (pLed->bLedNoLinkBlinkInProgress) {
1249 _cancel_timer_ex(&pLed->BlinkTimer);
1250 pLed->bLedNoLinkBlinkInProgress = false;
1251 }
1252 if (pLed->bLedBlinkInProgress) {
1253 _cancel_timer_ex(&pLed->BlinkTimer);
1254 pLed->bLedBlinkInProgress = false;
1255 }
1256 pLed->bLedScanBlinkInProgress = true;
1257 pLed->CurrLedState = LED_BLINK_SCAN;
1258 pLed->BlinkTimes = 24;
1259 if (pLed->bLedOn)
1260 pLed->BlinkingLedState = RTW_LED_OFF;
1261 else
1262 pLed->BlinkingLedState = RTW_LED_ON;
1263 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
1264 }
1265 break;
1266 case LED_CTL_TX:
1267 case LED_CTL_RX:
1268 if (!pLed->bLedBlinkInProgress) {
1269 if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
1270 return;
1271 if (pLed->bLedNoLinkBlinkInProgress) {
1272 _cancel_timer_ex(&pLed->BlinkTimer);
1273 pLed->bLedNoLinkBlinkInProgress = false;
1274 }
1275 pLed->bLedBlinkInProgress = true;
1276 pLed->CurrLedState = LED_BLINK_TXRX;
1277 pLed->BlinkTimes = 2;
1278 if (pLed->bLedOn)
1279 pLed->BlinkingLedState = RTW_LED_OFF;
1280 else
1281 pLed->BlinkingLedState = RTW_LED_ON;
1282 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
1283 }
1284 break;
1285 case LED_CTL_START_WPS: /* wait until xinpin finish */
1286 case LED_CTL_START_WPS_BOTTON:
1287 if (pLed1->bLedWPSBlinkInProgress) {
1288 pLed1->bLedWPSBlinkInProgress = false;
1289 _cancel_timer_ex(&pLed1->BlinkTimer);
1290
1291 pLed1->BlinkingLedState = RTW_LED_OFF;
1292 pLed1->CurrLedState = RTW_LED_OFF;
1293
1294 if (pLed1->bLedOn)
1295 _set_timer(&pLed->BlinkTimer, 0);
1296 }
1297
1298 if (!pLed->bLedWPSBlinkInProgress) {
1299 if (pLed->bLedNoLinkBlinkInProgress) {
1300 _cancel_timer_ex(&pLed->BlinkTimer);
1301 pLed->bLedNoLinkBlinkInProgress = false;
1302 }
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 pLed->bLedWPSBlinkInProgress = true;
1312 pLed->CurrLedState = LED_BLINK_WPS;
1313 if (pLed->bLedOn) {
1314 pLed->BlinkingLedState = RTW_LED_OFF;
1315 _set_timer(&pLed->BlinkTimer, LED_BLINK_SLOWLY_INTERVAL);
1316 } else {
1317 pLed->BlinkingLedState = RTW_LED_ON;
1318 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
1319 }
1320 }
1321 break;
1322 case LED_CTL_STOP_WPS: /* WPS connect success */
1323 if (pLed->bLedWPSBlinkInProgress) {
1324 _cancel_timer_ex(&pLed->BlinkTimer);
1325 pLed->bLedWPSBlinkInProgress = false;
1326 }
1327
1328 pLed->bLedNoLinkBlinkInProgress = true;
1329 pLed->CurrLedState = LED_BLINK_SLOWLY;
1330 if (pLed->bLedOn)
1331 pLed->BlinkingLedState = RTW_LED_OFF;
1332 else
1333 pLed->BlinkingLedState = RTW_LED_ON;
1334 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1335
1336 break;
1337 case LED_CTL_STOP_WPS_FAIL: /* WPS authentication fail */
1338 if (pLed->bLedWPSBlinkInProgress) {
1339 _cancel_timer_ex(&pLed->BlinkTimer);
1340 pLed->bLedWPSBlinkInProgress = false;
1341 }
1342 pLed->bLedNoLinkBlinkInProgress = true;
1343 pLed->CurrLedState = LED_BLINK_SLOWLY;
1344 if (pLed->bLedOn)
1345 pLed->BlinkingLedState = RTW_LED_OFF;
1346 else
1347 pLed->BlinkingLedState = RTW_LED_ON;
1348 _set_timer(&pLed->BlinkTimer, LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1349
1350 /* LED1 settings */
1351 if (pLed1->bLedWPSBlinkInProgress)
1352 _cancel_timer_ex(&pLed1->BlinkTimer);
1353 else
1354 pLed1->bLedWPSBlinkInProgress = true;
1355 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1356 if (pLed1->bLedOn)
1357 pLed1->BlinkingLedState = RTW_LED_OFF;
1358 else
1359 pLed1->BlinkingLedState = RTW_LED_ON;
1360 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
1361 break;
1362 case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
1363 if (pLed->bLedWPSBlinkInProgress) {
1364 _cancel_timer_ex(&pLed->BlinkTimer);
1365 pLed->bLedWPSBlinkInProgress = false;
1366 }
1367 pLed->bLedNoLinkBlinkInProgress = true;
1368 pLed->CurrLedState = LED_BLINK_SLOWLY;
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_NO_LINK_INTERVAL_ALPHA);
1374
1375 /* LED1 settings */
1376 if (pLed1->bLedWPSBlinkInProgress)
1377 _cancel_timer_ex(&pLed1->BlinkTimer);
1378 else
1379 pLed1->bLedWPSBlinkInProgress = true;
1380 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1381 pLed1->BlinkTimes = 10;
1382 if (pLed1->bLedOn)
1383 pLed1->BlinkingLedState = RTW_LED_OFF;
1384 else
1385 pLed1->BlinkingLedState = RTW_LED_ON;
1386 _set_timer(&pLed->BlinkTimer, LED_BLINK_NORMAL_INTERVAL);
1387 break;
1388 case LED_CTL_POWER_OFF:
1389 pLed->CurrLedState = RTW_LED_OFF;
1390 pLed->BlinkingLedState = RTW_LED_OFF;
1391
1392 if (pLed->bLedNoLinkBlinkInProgress) {
1393 _cancel_timer_ex(&pLed->BlinkTimer);
1394 pLed->bLedNoLinkBlinkInProgress = false;
1395 }
1396 if (pLed->bLedLinkBlinkInProgress) {
1397 _cancel_timer_ex(&pLed->BlinkTimer);
1398 pLed->bLedLinkBlinkInProgress = false;
1399 }
1400 if (pLed->bLedBlinkInProgress) {
1401 _cancel_timer_ex(&pLed->BlinkTimer);
1402 pLed->bLedBlinkInProgress = false;
1403 }
1404 if (pLed->bLedWPSBlinkInProgress) {
1405 _cancel_timer_ex(&pLed->BlinkTimer);
1406 pLed->bLedWPSBlinkInProgress = false;
1407 }
1408 if (pLed->bLedScanBlinkInProgress) {
1409 _cancel_timer_ex(&pLed->BlinkTimer);
1410 pLed->bLedScanBlinkInProgress = false;
1411 }
1412 if (pLed->bLedStartToLinkBlinkInProgress) {
1413 _cancel_timer_ex(&pLed->BlinkTimer);
1414 pLed->bLedStartToLinkBlinkInProgress = false;
1415 }
1416 if (pLed1->bLedWPSBlinkInProgress) {
1417 _cancel_timer_ex(&pLed1->BlinkTimer);
1418 pLed1->bLedWPSBlinkInProgress = false;
1419 }
1420 pLed1->BlinkingLedState = LED_UNKNOWN;
1421 SwLedOff(padapter, pLed);
1422 SwLedOff(padapter, pLed1);
1423 break;
1424 default:
1425 break;
1426 }
1427 }
1428
1429 /* Sercomm-Belkin, added by chiyoko, 20090415 */
1430 static void
SwLedControlMode5(struct adapter * padapter,enum LED_CTL_MODE LedAction)1431 SwLedControlMode5(
1432 struct adapter *padapter,
1433 enum LED_CTL_MODE LedAction
1434 )
1435 {
1436 struct led_priv *ledpriv = &padapter->ledpriv;
1437 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1438 struct LED_871x *pLed = &ledpriv->SwLed0;
1439
1440 switch (LedAction) {
1441 case LED_CTL_POWER_ON:
1442 case LED_CTL_NO_LINK:
1443 case LED_CTL_LINK: /* solid blue */
1444 pLed->CurrLedState = RTW_LED_ON;
1445 pLed->BlinkingLedState = RTW_LED_ON;
1446
1447 _set_timer(&pLed->BlinkTimer, 0);
1448 break;
1449 case LED_CTL_SITE_SURVEY:
1450 if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
1451 } else if (!pLed->bLedScanBlinkInProgress) {
1452 if (pLed->bLedBlinkInProgress) {
1453 _cancel_timer_ex(&pLed->BlinkTimer);
1454 pLed->bLedBlinkInProgress = false;
1455 }
1456 pLed->bLedScanBlinkInProgress = true;
1457 pLed->CurrLedState = LED_BLINK_SCAN;
1458 pLed->BlinkTimes = 24;
1459 if (pLed->bLedOn)
1460 pLed->BlinkingLedState = RTW_LED_OFF;
1461 else
1462 pLed->BlinkingLedState = RTW_LED_ON;
1463 _set_timer(&pLed->BlinkTimer, LED_BLINK_SCAN_INTERVAL_ALPHA);
1464 }
1465 break;
1466 case LED_CTL_TX:
1467 case LED_CTL_RX:
1468 if (!pLed->bLedBlinkInProgress) {
1469 if (pLed->CurrLedState == LED_BLINK_SCAN)
1470 return;
1471 pLed->bLedBlinkInProgress = true;
1472 pLed->CurrLedState = LED_BLINK_TXRX;
1473 pLed->BlinkTimes = 2;
1474 if (pLed->bLedOn)
1475 pLed->BlinkingLedState = RTW_LED_OFF;
1476 else
1477 pLed->BlinkingLedState = RTW_LED_ON;
1478 _set_timer(&pLed->BlinkTimer, LED_BLINK_FASTER_INTERVAL_ALPHA);
1479 }
1480 break;
1481 case LED_CTL_POWER_OFF:
1482 pLed->CurrLedState = RTW_LED_OFF;
1483 pLed->BlinkingLedState = RTW_LED_OFF;
1484
1485 if (pLed->bLedBlinkInProgress) {
1486 _cancel_timer_ex(&pLed->BlinkTimer);
1487 pLed->bLedBlinkInProgress = false;
1488 }
1489 SwLedOff(padapter, pLed);
1490 break;
1491 default:
1492 break;
1493 }
1494 }
1495
1496 /* WNC-Corega, added by chiyoko, 20090902 */
1497 static void
SwLedControlMode6(struct adapter * padapter,enum LED_CTL_MODE LedAction)1498 SwLedControlMode6(
1499 struct adapter *padapter,
1500 enum LED_CTL_MODE LedAction
1501 )
1502 {
1503 struct led_priv *ledpriv = &padapter->ledpriv;
1504 struct LED_871x *pLed0 = &ledpriv->SwLed0;
1505
1506 switch (LedAction) {
1507 case LED_CTL_POWER_ON:
1508 case LED_CTL_LINK:
1509 case LED_CTL_NO_LINK:
1510 _cancel_timer_ex(&pLed0->BlinkTimer);
1511 pLed0->CurrLedState = RTW_LED_ON;
1512 pLed0->BlinkingLedState = RTW_LED_ON;
1513 _set_timer(&pLed0->BlinkTimer, 0);
1514 break;
1515 case LED_CTL_POWER_OFF:
1516 SwLedOff(padapter, pLed0);
1517 break;
1518 default:
1519 break;
1520 }
1521 }
1522
1523 /* */
1524 /* Description: */
1525 /* Handler function of LED Blinking. */
1526 /* We dispatch acture LED blink action according to LedStrategy. */
1527 /* */
BlinkHandler(struct LED_871x * pLed)1528 void BlinkHandler(struct LED_871x *pLed)
1529 {
1530 struct adapter *padapter = pLed->padapter;
1531 struct led_priv *ledpriv = &padapter->ledpriv;
1532
1533 if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped))
1534 return;
1535
1536 switch (ledpriv->LedStrategy) {
1537 case SW_LED_MODE0:
1538 SwLedBlink(pLed);
1539 break;
1540 case SW_LED_MODE1:
1541 SwLedBlink1(pLed);
1542 break;
1543 case SW_LED_MODE2:
1544 SwLedBlink2(pLed);
1545 break;
1546 case SW_LED_MODE3:
1547 SwLedBlink3(pLed);
1548 break;
1549 case SW_LED_MODE4:
1550 SwLedBlink4(pLed);
1551 break;
1552 case SW_LED_MODE5:
1553 SwLedBlink5(pLed);
1554 break;
1555 case SW_LED_MODE6:
1556 SwLedBlink6(pLed);
1557 break;
1558 default:
1559 break;
1560 }
1561 }
1562
LedControl8188eu(struct adapter * padapter,enum LED_CTL_MODE LedAction)1563 void LedControl8188eu(struct adapter *padapter, enum LED_CTL_MODE LedAction)
1564 {
1565 struct led_priv *ledpriv = &padapter->ledpriv;
1566 struct registry_priv *registry_par;
1567
1568 if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped) ||
1569 (!padapter->hw_init_completed))
1570 return;
1571
1572 if (!ledpriv->bRegUseLed)
1573 return;
1574
1575 registry_par = &padapter->registrypriv;
1576 if (!registry_par->led_enable)
1577 return;
1578
1579 if ((padapter->pwrctrlpriv.rf_pwrstate != rf_on &&
1580 padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) &&
1581 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
1582 LedAction == LED_CTL_SITE_SURVEY ||
1583 LedAction == LED_CTL_LINK ||
1584 LedAction == LED_CTL_NO_LINK ||
1585 LedAction == LED_CTL_POWER_ON))
1586 return;
1587
1588 switch (ledpriv->LedStrategy) {
1589 case SW_LED_MODE0:
1590 break;
1591 case SW_LED_MODE1:
1592 SwLedControlMode1(padapter, LedAction);
1593 break;
1594 case SW_LED_MODE2:
1595 SwLedControlMode2(padapter, LedAction);
1596 break;
1597 case SW_LED_MODE3:
1598 SwLedControlMode3(padapter, LedAction);
1599 break;
1600 case SW_LED_MODE4:
1601 SwLedControlMode4(padapter, LedAction);
1602 break;
1603 case SW_LED_MODE5:
1604 SwLedControlMode5(padapter, LedAction);
1605 break;
1606 case SW_LED_MODE6:
1607 SwLedControlMode6(padapter, LedAction);
1608 break;
1609 default:
1610 break;
1611 }
1612 }
1613
