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