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