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