aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorFlorian Schilhabel <florian.c.schilhabel@googlemail.com>2010-05-13 07:55:25 -0400
committerGreg Kroah-Hartman <gregkh@suse.de>2010-05-14 16:54:55 -0400
commit5c2af91bbcc19c96d2fb35c4bb3f3d66b039e978 (patch)
treedd461f9cc7560b6bdd293382b3ecbef57ae7ad56
parent7d8e737dd7e3519110a7bc529ef6ac80ac41c3f5 (diff)
Staging: rtl819su: added r8192SU_led.c/.h
added the necessary infrastructure for the leds on the device this is a port from Realteks driver. leds are now working partially. Signed-off-by: Florian Schilhabel <florian.c.schilhabel@googlemail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat
-rw-r--r--drivers/staging/rtl8192su/Makefile1
-rw-r--r--drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h24
-rw-r--r--drivers/staging/rtl8192su/r8192SU_led.c2347
-rw-r--r--drivers/staging/rtl8192su/r8192SU_led.h93
-rw-r--r--drivers/staging/rtl8192su/r8192U.h27
5 files changed, 2466 insertions, 26 deletions
diff --git a/drivers/staging/rtl8192su/Makefile b/drivers/staging/rtl8192su/Makefile
index 9374a0179e5b..7133894afe76 100644
--- a/drivers/staging/rtl8192su/Makefile
+++ b/drivers/staging/rtl8192su/Makefile
@@ -20,6 +20,7 @@ r8192s_usb-objs := \
20 r8192S_Efuse.o \ 20 r8192S_Efuse.o \
21 r8192U_core.o \ 21 r8192U_core.o \
22 r8192U_pm.o \ 22 r8192U_pm.o \
23 r8192SU_led.o \
23 ieee80211/ieee80211_crypt.o \ 24 ieee80211/ieee80211_crypt.o \
24 ieee80211/ieee80211_crypt_tkip.o \ 25 ieee80211/ieee80211_crypt_tkip.o \
25 ieee80211/ieee80211_crypt_ccmp.o \ 26 ieee80211/ieee80211_crypt_ccmp.o \
diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h b/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h
index 7d6c3bc143ae..1824cda790d8 100644
--- a/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h
+++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h
@@ -172,18 +172,20 @@ enum {
172 IG_Max 172 IG_Max
173}; 173};
174 174
175typedef enum _LED_CTL_MODE { 175typedef enum _LED_CTL_MODE{
176 LED_CTL_POWER_ON = 1, 176 LED_CTL_POWER_ON = 1,
177 LED_CTL_LINK = 2, 177 LED_CTL_LINK = 2,
178 LED_CTL_NO_LINK = 3, 178 LED_CTL_NO_LINK = 3,
179 LED_CTL_TX = 4, 179 LED_CTL_TX = 4,
180 LED_CTL_RX = 5, 180 LED_CTL_RX = 5,
181 LED_CTL_SITE_SURVEY = 6, 181 LED_CTL_SITE_SURVEY = 6,
182 LED_CTL_POWER_OFF = 7, 182 LED_CTL_POWER_OFF = 7,
183 LED_CTL_START_TO_LINK = 8, 183 LED_CTL_START_TO_LINK = 8,
184 LED_CTL_START_WPS = 9, 184 LED_CTL_START_WPS = 9,
185 LED_CTL_STOP_WPS = 10, 185 LED_CTL_STOP_WPS = 10,
186 LED_CTL_START_WPS_BOTTON = 11, 186 LED_CTL_START_WPS_BOTTON = 11,
187 LED_CTL_STOP_WPS_FAIL = 12,
188 LED_CTL_STOP_WPS_FAIL_OVERLAP = 13,
187} LED_CTL_MODE; 189} LED_CTL_MODE;
188 190
189typedef union _frameqos { 191typedef union _frameqos {
diff --git a/drivers/staging/rtl8192su/r8192SU_led.c b/drivers/staging/rtl8192su/r8192SU_led.c
new file mode 100644
index 000000000000..609dba67eb4e
--- /dev/null
+++ b/drivers/staging/rtl8192su/r8192SU_led.c
@@ -0,0 +1,2347 @@
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
36static void BlinkTimerCallback (unsigned long data);
37
38static void BlinkWorkItemCallback (struct work_struct *work);
39
40void 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
63void DeInitLed819xUsb (PLED_819xUsb pLed)
64{
65 del_timer_sync(&(pLed->BlinkTimer));
66 pLed->bLedBlinkInProgress = FALSE;
67}
68
69void 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
89void 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
112void
113InitSwLeds(
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
125void
126DeInitSwLeds(
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
137void
138SwLedBlink(
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
250void
251SwLedBlink1(
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
475void
476SwLedBlink2(
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
597void
598SwLedBlink3(
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
767void
768SwLedBlink4(
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
964void
965SwLedBlink5(
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
1082void
1083BlinkTimerCallback(
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#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
1091 schedule_work(&(priv->BlinkWorkItem));
1092#endif
1093}
1094
1095
1096#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1097void BlinkWorkItemCallback(struct work_struct *work)
1098{
1099 struct r8192_priv *priv = container_of(work, struct r8192_priv, BlinkWorkItem);
1100#else
1101void BlinkWorkItemCallback(void * Context)
1102{
1103 struct net_device *dev = (struct net_device *)Context;
1104 struct r8192_priv *priv = ieee80211_priv(dev);
1105#endif
1106
1107 PLED_819xUsb pLed = priv->pLed;
1108
1109 switch(priv->LedStrategy)
1110 {
1111 case SW_LED_MODE0:
1112 SwLedBlink(pLed);
1113 break;
1114
1115 case SW_LED_MODE1:
1116 SwLedBlink1(pLed);
1117 break;
1118
1119 case SW_LED_MODE2:
1120 SwLedBlink2(pLed);
1121 break;
1122
1123 case SW_LED_MODE3:
1124 SwLedBlink3(pLed);
1125 break;
1126
1127 case SW_LED_MODE4:
1128 SwLedBlink4(pLed);
1129 break;
1130
1131 case SW_LED_MODE5:
1132 SwLedBlink5(pLed);
1133 break;
1134
1135 default:
1136 SwLedBlink(pLed);
1137 break;
1138 }
1139}
1140
1141
1142
1143
1144void
1145SwLedControlMode0(
1146 struct net_device *dev,
1147 LED_CTL_MODE LedAction
1148)
1149{
1150 struct r8192_priv *priv = ieee80211_priv(dev);
1151 PLED_819xUsb pLed = &(priv->SwLed1);
1152
1153 switch(LedAction)
1154 {
1155 case LED_CTL_TX:
1156 case LED_CTL_RX:
1157 if( pLed->bLedBlinkInProgress == FALSE )
1158 {
1159 pLed->bLedBlinkInProgress = TRUE;
1160
1161 pLed->CurrLedState = LED_BLINK_NORMAL;
1162 pLed->BlinkTimes = 2;
1163
1164 if( pLed->bLedOn )
1165 pLed->BlinkingLedState = LED_OFF;
1166 else
1167 pLed->BlinkingLedState = LED_ON;
1168 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL));
1169 }
1170 break;
1171
1172 case LED_CTL_START_TO_LINK:
1173 if( pLed->bLedBlinkInProgress == FALSE )
1174 {
1175 pLed->bLedBlinkInProgress = TRUE;
1176
1177 pLed->CurrLedState = LED_BLINK_StartToBlink;
1178 pLed->BlinkTimes = 24;
1179
1180 if( pLed->bLedOn )
1181 pLed->BlinkingLedState = LED_OFF;
1182 else
1183 pLed->BlinkingLedState = LED_ON;
1184 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL));
1185 }
1186 else
1187 {
1188 pLed->CurrLedState = LED_BLINK_StartToBlink;
1189 }
1190 break;
1191
1192 case LED_CTL_LINK:
1193 pLed->CurrLedState = LED_ON;
1194 if( pLed->bLedBlinkInProgress == FALSE )
1195 {
1196 SwLedOn(dev, pLed);
1197 }
1198 break;
1199
1200 case LED_CTL_NO_LINK:
1201 pLed->CurrLedState = LED_OFF;
1202 if( pLed->bLedBlinkInProgress == FALSE )
1203 {
1204 SwLedOff(dev, pLed);
1205 }
1206 break;
1207
1208 case LED_CTL_POWER_OFF:
1209 pLed->CurrLedState = LED_OFF;
1210 if(pLed->bLedBlinkInProgress)
1211 {
1212 del_timer_sync(&(pLed->BlinkTimer));
1213 pLed->bLedBlinkInProgress = FALSE;
1214 }
1215 SwLedOff(dev, pLed);
1216 break;
1217
1218 case LED_CTL_START_WPS:
1219 if( pLed->bLedBlinkInProgress == FALSE || pLed->CurrLedState == LED_ON)
1220 {
1221 pLed->bLedBlinkInProgress = TRUE;
1222
1223 pLed->CurrLedState = LED_BLINK_WPS;
1224 pLed->BlinkTimes = 20;
1225
1226 if( pLed->bLedOn )
1227 {
1228 pLed->BlinkingLedState = LED_OFF;
1229 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LONG_INTERVAL));
1230 }
1231 else
1232 {
1233 pLed->BlinkingLedState = LED_ON;
1234 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LONG_INTERVAL));
1235 }
1236 }
1237 break;
1238
1239 case LED_CTL_STOP_WPS:
1240 if(pLed->bLedBlinkInProgress)
1241 {
1242 pLed->CurrLedState = LED_OFF;
1243 del_timer_sync(&(pLed->BlinkTimer));
1244 pLed->bLedBlinkInProgress = FALSE;
1245 }
1246 break;
1247
1248
1249 default:
1250 break;
1251 }
1252
1253 RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState);
1254
1255}
1256
1257void
1258SwLedControlMode1(
1259 struct net_device *dev,
1260 LED_CTL_MODE LedAction
1261)
1262{
1263 struct r8192_priv *priv = ieee80211_priv(dev);
1264 PLED_819xUsb pLed = &(priv->SwLed0);
1265
1266 if(priv->CustomerID == RT_CID_819x_CAMEO)
1267 pLed = &(priv->SwLed1);
1268
1269 switch(LedAction)
1270 {
1271 case LED_CTL_START_TO_LINK:
1272 case LED_CTL_NO_LINK:
1273 if( pLed->bLedNoLinkBlinkInProgress == FALSE )
1274 {
1275 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1276 {
1277 return;
1278 }
1279 if( pLed->bLedLinkBlinkInProgress == TRUE )
1280 {
1281 del_timer_sync(&(pLed->BlinkTimer));
1282 pLed->bLedLinkBlinkInProgress = FALSE;
1283 }
1284 if(pLed->bLedBlinkInProgress ==TRUE)
1285 {
1286 del_timer_sync(&(pLed->BlinkTimer));
1287 pLed->bLedBlinkInProgress = FALSE;
1288 }
1289
1290 pLed->bLedNoLinkBlinkInProgress = TRUE;
1291 pLed->CurrLedState = LED_BLINK_SLOWLY;
1292 if( pLed->bLedOn )
1293 pLed->BlinkingLedState = LED_OFF;
1294 else
1295 pLed->BlinkingLedState = LED_ON;
1296 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1297 }
1298 break;
1299
1300 case LED_CTL_LINK:
1301 if( pLed->bLedLinkBlinkInProgress == FALSE )
1302 {
1303 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1304 {
1305 return;
1306 }
1307 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
1308 {
1309 del_timer_sync(&(pLed->BlinkTimer));
1310 pLed->bLedNoLinkBlinkInProgress = FALSE;
1311 }
1312 if(pLed->bLedBlinkInProgress ==TRUE)
1313 {
1314 del_timer_sync(&(pLed->BlinkTimer));
1315 pLed->bLedBlinkInProgress = FALSE;
1316 }
1317 pLed->bLedLinkBlinkInProgress = TRUE;
1318 pLed->CurrLedState = LED_BLINK_NORMAL;
1319 if( pLed->bLedOn )
1320 pLed->BlinkingLedState = LED_OFF;
1321 else
1322 pLed->BlinkingLedState = LED_ON;
1323 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA));
1324 }
1325 break;
1326
1327 case LED_CTL_SITE_SURVEY:
1328 if((priv->ieee80211->LinkDetectInfo.bBusyTraffic) && (priv->ieee80211->state == IEEE80211_LINKED))
1329 ;
1330 else if(pLed->bLedScanBlinkInProgress ==FALSE)
1331 {
1332 if(IS_LED_WPS_BLINKING(pLed))
1333 return;
1334
1335 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
1336 {
1337 del_timer_sync(&(pLed->BlinkTimer));
1338 pLed->bLedNoLinkBlinkInProgress = FALSE;
1339 }
1340 if( pLed->bLedLinkBlinkInProgress == TRUE )
1341 {
1342 del_timer_sync(&(pLed->BlinkTimer));
1343 pLed->bLedLinkBlinkInProgress = FALSE;
1344 }
1345 if(pLed->bLedBlinkInProgress ==TRUE)
1346 {
1347 del_timer_sync(&(pLed->BlinkTimer));
1348 pLed->bLedBlinkInProgress = FALSE;
1349 }
1350 pLed->bLedScanBlinkInProgress = TRUE;
1351 pLed->CurrLedState = LED_SCAN_BLINK;
1352 pLed->BlinkTimes = 24;
1353 if( pLed->bLedOn )
1354 pLed->BlinkingLedState = LED_OFF;
1355 else
1356 pLed->BlinkingLedState = LED_ON;
1357 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
1358
1359 }
1360 break;
1361
1362 case LED_CTL_TX:
1363 case LED_CTL_RX:
1364 if(pLed->bLedBlinkInProgress ==FALSE)
1365 {
1366 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1367 {
1368 }
1369 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
1370 {
1371 del_timer_sync(&(pLed->BlinkTimer));
1372 pLed->bLedNoLinkBlinkInProgress = FALSE;
1373 }
1374 if( pLed->bLedLinkBlinkInProgress == TRUE )
1375 {
1376 del_timer_sync(&(pLed->BlinkTimer));
1377 pLed->bLedLinkBlinkInProgress = FALSE;
1378 }
1379 pLed->bLedBlinkInProgress = TRUE;
1380 pLed->CurrLedState = LED_TXRX_BLINK;
1381 pLed->BlinkTimes = 2;
1382 if( pLed->bLedOn )
1383 pLed->BlinkingLedState = LED_OFF;
1384 else
1385 pLed->BlinkingLedState = LED_ON;
1386 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA));
1387 }
1388 break;
1389
1390 case LED_CTL_START_WPS:
1391 case LED_CTL_START_WPS_BOTTON:
1392 if(pLed->bLedWPSBlinkInProgress ==FALSE)
1393 {
1394 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
1395 {
1396 del_timer_sync(&(pLed->BlinkTimer));
1397 pLed->bLedNoLinkBlinkInProgress = FALSE;
1398 }
1399 if( pLed->bLedLinkBlinkInProgress == TRUE )
1400 {
1401 del_timer_sync(&(pLed->BlinkTimer));
1402 pLed->bLedLinkBlinkInProgress = FALSE;
1403 }
1404 if(pLed->bLedBlinkInProgress ==TRUE)
1405 {
1406 del_timer_sync(&(pLed->BlinkTimer));
1407 pLed->bLedBlinkInProgress = FALSE;
1408 }
1409 if(pLed->bLedScanBlinkInProgress ==TRUE)
1410 {
1411 del_timer_sync(&(pLed->BlinkTimer));
1412 pLed->bLedScanBlinkInProgress = FALSE;
1413 }
1414 pLed->bLedWPSBlinkInProgress = TRUE;
1415 pLed->CurrLedState = LED_BLINK_WPS;
1416 if( pLed->bLedOn )
1417 pLed->BlinkingLedState = LED_OFF;
1418 else
1419 pLed->BlinkingLedState = LED_ON;
1420 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
1421
1422 }
1423 break;
1424
1425
1426 case LED_CTL_STOP_WPS:
1427 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
1428 {
1429 del_timer_sync(&(pLed->BlinkTimer));
1430 pLed->bLedNoLinkBlinkInProgress = FALSE;
1431 }
1432 if( pLed->bLedLinkBlinkInProgress == TRUE )
1433 {
1434 del_timer_sync(&(pLed->BlinkTimer));
1435 pLed->bLedLinkBlinkInProgress = FALSE;
1436 }
1437 if(pLed->bLedBlinkInProgress ==TRUE)
1438 {
1439 del_timer_sync(&(pLed->BlinkTimer));
1440 pLed->bLedBlinkInProgress = FALSE;
1441 }
1442 if(pLed->bLedScanBlinkInProgress ==TRUE)
1443 {
1444 del_timer_sync(&(pLed->BlinkTimer));
1445 pLed->bLedScanBlinkInProgress = FALSE;
1446 }
1447 if(pLed->bLedWPSBlinkInProgress)
1448 {
1449 del_timer_sync(&(pLed->BlinkTimer));
1450 }
1451 else
1452 {
1453 pLed->bLedWPSBlinkInProgress = TRUE;
1454 }
1455
1456 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1457 if(pLed->bLedOn)
1458 {
1459 pLed->BlinkingLedState = LED_OFF;
1460 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA));
1461 }
1462 else
1463 {
1464 pLed->BlinkingLedState = LED_ON;
1465 mod_timer(&(pLed->BlinkTimer), 0);
1466 }
1467 break;
1468
1469 case LED_CTL_STOP_WPS_FAIL:
1470 if(pLed->bLedWPSBlinkInProgress)
1471 {
1472 del_timer_sync(&(pLed->BlinkTimer));
1473 pLed->bLedWPSBlinkInProgress = FALSE;
1474 }
1475
1476 pLed->bLedNoLinkBlinkInProgress = TRUE;
1477 pLed->CurrLedState = LED_BLINK_SLOWLY;
1478 if( pLed->bLedOn )
1479 pLed->BlinkingLedState = LED_OFF;
1480 else
1481 pLed->BlinkingLedState = LED_ON;
1482 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1483 break;
1484
1485 case LED_CTL_POWER_OFF:
1486 pLed->CurrLedState = LED_OFF;
1487 if( pLed->bLedNoLinkBlinkInProgress)
1488 {
1489 del_timer_sync(&(pLed->BlinkTimer));
1490 pLed->bLedNoLinkBlinkInProgress = FALSE;
1491 }
1492 if( pLed->bLedLinkBlinkInProgress)
1493 {
1494 del_timer_sync(&(pLed->BlinkTimer));
1495 pLed->bLedLinkBlinkInProgress = FALSE;
1496 }
1497 if( pLed->bLedBlinkInProgress)
1498 {
1499 del_timer_sync(&(pLed->BlinkTimer));
1500 pLed->bLedBlinkInProgress = FALSE;
1501 }
1502 if( pLed->bLedWPSBlinkInProgress )
1503 {
1504 del_timer_sync(&(pLed->BlinkTimer));
1505 pLed->bLedWPSBlinkInProgress = FALSE;
1506 }
1507 if( pLed->bLedScanBlinkInProgress)
1508 {
1509 del_timer_sync(&(pLed->BlinkTimer));
1510 pLed->bLedScanBlinkInProgress = FALSE;
1511 }
1512
1513 SwLedOff(dev, pLed);
1514 break;
1515
1516 default:
1517 break;
1518
1519 }
1520
1521 RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState);
1522}
1523
1524void
1525SwLedControlMode2(
1526 struct net_device *dev,
1527 LED_CTL_MODE LedAction
1528)
1529{
1530 struct r8192_priv *priv = ieee80211_priv(dev);
1531 PLED_819xUsb pLed = &(priv->SwLed0);
1532
1533 switch(LedAction)
1534 {
1535 case LED_CTL_SITE_SURVEY:
1536 if(priv->ieee80211->LinkDetectInfo.bBusyTraffic)
1537 ;
1538 else if(pLed->bLedScanBlinkInProgress ==FALSE)
1539 {
1540 if(IS_LED_WPS_BLINKING(pLed))
1541 return;
1542
1543 if(pLed->bLedBlinkInProgress ==TRUE)
1544 {
1545 del_timer_sync(&(pLed->BlinkTimer));
1546 pLed->bLedBlinkInProgress = FALSE;
1547 }
1548 pLed->bLedScanBlinkInProgress = TRUE;
1549 pLed->CurrLedState = LED_SCAN_BLINK;
1550 pLed->BlinkTimes = 24;
1551 if( pLed->bLedOn )
1552 pLed->BlinkingLedState = LED_OFF;
1553 else
1554 pLed->BlinkingLedState = LED_ON;
1555 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
1556
1557 }
1558 break;
1559
1560 case LED_CTL_TX:
1561 case LED_CTL_RX:
1562 if((pLed->bLedBlinkInProgress ==FALSE) && (priv->ieee80211->state == IEEE80211_LINKED))
1563 {
1564 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1565 {
1566 return;
1567 }
1568
1569 pLed->bLedBlinkInProgress = TRUE;
1570 pLed->CurrLedState = LED_TXRX_BLINK;
1571 pLed->BlinkTimes = 2;
1572 if( pLed->bLedOn )
1573 pLed->BlinkingLedState = LED_OFF;
1574 else
1575 pLed->BlinkingLedState = LED_ON;
1576 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA));
1577 }
1578 break;
1579
1580 case LED_CTL_LINK:
1581 pLed->CurrLedState = LED_ON;
1582 pLed->BlinkingLedState = LED_ON;
1583 if( pLed->bLedBlinkInProgress)
1584 {
1585 del_timer_sync(&(pLed->BlinkTimer));
1586 pLed->bLedBlinkInProgress = FALSE;
1587 }
1588 if( pLed->bLedScanBlinkInProgress)
1589 {
1590 del_timer_sync(&(pLed->BlinkTimer));
1591 pLed->bLedScanBlinkInProgress = FALSE;
1592 }
1593
1594 mod_timer(&(pLed->BlinkTimer), 0);
1595 break;
1596
1597 case LED_CTL_START_WPS:
1598 case LED_CTL_START_WPS_BOTTON:
1599 if(pLed->bLedWPSBlinkInProgress ==FALSE)
1600 {
1601 if(pLed->bLedBlinkInProgress ==TRUE)
1602 {
1603 del_timer_sync(&(pLed->BlinkTimer));
1604 pLed->bLedBlinkInProgress = FALSE;
1605 }
1606 if(pLed->bLedScanBlinkInProgress ==TRUE)
1607 {
1608 del_timer_sync(&(pLed->BlinkTimer));
1609 pLed->bLedScanBlinkInProgress = FALSE;
1610 }
1611 pLed->bLedWPSBlinkInProgress = TRUE;
1612 pLed->CurrLedState = LED_ON;
1613 pLed->BlinkingLedState = LED_ON;
1614 mod_timer(&(pLed->BlinkTimer), 0);
1615 }
1616 break;
1617
1618 case LED_CTL_STOP_WPS:
1619 pLed->bLedWPSBlinkInProgress = FALSE;
1620 if( priv->ieee80211->eRFPowerState != eRfOn )
1621 {
1622 SwLedOff(dev, pLed);
1623 }
1624 else
1625 {
1626 pLed->CurrLedState = LED_ON;
1627 pLed->BlinkingLedState = LED_ON;
1628 mod_timer(&(pLed->BlinkTimer), 0);
1629 RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState);
1630 }
1631 break;
1632
1633 case LED_CTL_STOP_WPS_FAIL:
1634 pLed->bLedWPSBlinkInProgress = FALSE;
1635 if( priv->ieee80211->eRFPowerState != eRfOn )
1636 {
1637 SwLedOff(dev, pLed);
1638 }
1639 else
1640 {
1641 pLed->CurrLedState = LED_OFF;
1642 pLed->BlinkingLedState = LED_OFF;
1643 mod_timer(&(pLed->BlinkTimer), 0);
1644 RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState);
1645 }
1646 break;
1647
1648 case LED_CTL_START_TO_LINK:
1649 case LED_CTL_NO_LINK:
1650 if(!IS_LED_BLINKING(pLed))
1651 {
1652 pLed->CurrLedState = LED_OFF;
1653 pLed->BlinkingLedState = LED_OFF;
1654 mod_timer(&(pLed->BlinkTimer), 0);
1655 }
1656 break;
1657
1658 case LED_CTL_POWER_OFF:
1659 pLed->CurrLedState = LED_OFF;
1660 pLed->BlinkingLedState = LED_OFF;
1661 if( pLed->bLedBlinkInProgress)
1662 {
1663 del_timer_sync(&(pLed->BlinkTimer));
1664 pLed->bLedBlinkInProgress = FALSE;
1665 }
1666 if( pLed->bLedScanBlinkInProgress)
1667 {
1668 del_timer_sync(&(pLed->BlinkTimer));
1669 pLed->bLedScanBlinkInProgress = FALSE;
1670 }
1671 if( pLed->bLedWPSBlinkInProgress )
1672 {
1673 del_timer_sync(&(pLed->BlinkTimer));
1674 pLed->bLedWPSBlinkInProgress = FALSE;
1675 }
1676
1677 mod_timer(&(pLed->BlinkTimer), 0);
1678 break;
1679
1680 default:
1681 break;
1682
1683 }
1684
1685 RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState);
1686}
1687
1688 void
1689 SwLedControlMode3(
1690 struct net_device *dev,
1691 LED_CTL_MODE LedAction
1692)
1693{
1694 struct r8192_priv *priv = ieee80211_priv(dev);
1695 PLED_819xUsb pLed = &(priv->SwLed0);
1696
1697 switch(LedAction)
1698 {
1699 case LED_CTL_SITE_SURVEY:
1700 if(priv->ieee80211->LinkDetectInfo.bBusyTraffic)
1701 ;
1702 else if(pLed->bLedScanBlinkInProgress ==FALSE)
1703 {
1704 if(IS_LED_WPS_BLINKING(pLed))
1705 return;
1706
1707 if(pLed->bLedBlinkInProgress ==TRUE)
1708 {
1709 del_timer_sync(&(pLed->BlinkTimer));
1710 pLed->bLedBlinkInProgress = FALSE;
1711 }
1712 pLed->bLedScanBlinkInProgress = TRUE;
1713 pLed->CurrLedState = LED_SCAN_BLINK;
1714 pLed->BlinkTimes = 24;
1715 if( pLed->bLedOn )
1716 pLed->BlinkingLedState = LED_OFF;
1717 else
1718 pLed->BlinkingLedState = LED_ON;
1719 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
1720
1721 }
1722 break;
1723
1724 case LED_CTL_TX:
1725 case LED_CTL_RX:
1726 if((pLed->bLedBlinkInProgress ==FALSE) && (priv->ieee80211->state == IEEE80211_LINKED))
1727 {
1728 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1729 {
1730 return;
1731 }
1732
1733 pLed->bLedBlinkInProgress = TRUE;
1734 pLed->CurrLedState = LED_TXRX_BLINK;
1735 pLed->BlinkTimes = 2;
1736 if( pLed->bLedOn )
1737 pLed->BlinkingLedState = LED_OFF;
1738 else
1739 pLed->BlinkingLedState = LED_ON;
1740 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA));
1741 }
1742 break;
1743
1744 case LED_CTL_LINK:
1745 if(IS_LED_WPS_BLINKING(pLed))
1746 return;
1747
1748 pLed->CurrLedState = LED_ON;
1749 pLed->BlinkingLedState = LED_ON;
1750 if( pLed->bLedBlinkInProgress)
1751 {
1752 del_timer_sync(&(pLed->BlinkTimer));
1753 pLed->bLedBlinkInProgress = FALSE;
1754 }
1755 if( pLed->bLedScanBlinkInProgress)
1756 {
1757 del_timer_sync(&(pLed->BlinkTimer));
1758 pLed->bLedScanBlinkInProgress = FALSE;
1759 }
1760
1761 mod_timer(&(pLed->BlinkTimer), 0);
1762 break;
1763
1764 case LED_CTL_START_WPS:
1765 case LED_CTL_START_WPS_BOTTON:
1766 if(pLed->bLedWPSBlinkInProgress ==FALSE)
1767 {
1768 if(pLed->bLedBlinkInProgress ==TRUE)
1769 {
1770 del_timer_sync(&(pLed->BlinkTimer));
1771 pLed->bLedBlinkInProgress = FALSE;
1772 }
1773 if(pLed->bLedScanBlinkInProgress ==TRUE)
1774 {
1775 del_timer_sync(&(pLed->BlinkTimer));
1776 pLed->bLedScanBlinkInProgress = FALSE;
1777 }
1778 pLed->bLedWPSBlinkInProgress = TRUE;
1779 pLed->CurrLedState = LED_BLINK_WPS;
1780 if( pLed->bLedOn )
1781 pLed->BlinkingLedState = LED_OFF;
1782 else
1783 pLed->BlinkingLedState = LED_ON;
1784 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
1785
1786 }
1787 break;
1788
1789 case LED_CTL_STOP_WPS:
1790 if(pLed->bLedWPSBlinkInProgress)
1791 {
1792 del_timer_sync(&(pLed->BlinkTimer));
1793 pLed->bLedWPSBlinkInProgress = FALSE;
1794 }
1795 else
1796 {
1797 pLed->bLedWPSBlinkInProgress = TRUE;
1798 }
1799
1800 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1801 if(pLed->bLedOn)
1802 {
1803 pLed->BlinkingLedState = LED_OFF;
1804 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA));
1805 }
1806 else
1807 {
1808 pLed->BlinkingLedState = LED_ON;
1809 mod_timer(&(pLed->BlinkTimer), 0);
1810 }
1811
1812 break;
1813
1814
1815 case LED_CTL_STOP_WPS_FAIL:
1816 if(pLed->bLedWPSBlinkInProgress)
1817 {
1818 del_timer_sync(&(pLed->BlinkTimer));
1819 pLed->bLedWPSBlinkInProgress = FALSE;
1820 }
1821
1822 pLed->CurrLedState = LED_OFF;
1823 pLed->BlinkingLedState = LED_OFF;
1824 mod_timer(&(pLed->BlinkTimer), 0);
1825 break;
1826
1827 case LED_CTL_START_TO_LINK:
1828 case LED_CTL_NO_LINK:
1829 if(!IS_LED_BLINKING(pLed))
1830 {
1831 pLed->CurrLedState = LED_OFF;
1832 pLed->BlinkingLedState = LED_OFF;
1833 mod_timer(&(pLed->BlinkTimer), 0);
1834 }
1835 break;
1836
1837 case LED_CTL_POWER_OFF:
1838 pLed->CurrLedState = LED_OFF;
1839 pLed->BlinkingLedState = LED_OFF;
1840 if( pLed->bLedBlinkInProgress)
1841 {
1842 del_timer_sync(&(pLed->BlinkTimer));
1843 pLed->bLedBlinkInProgress = FALSE;
1844 }
1845 if( pLed->bLedScanBlinkInProgress)
1846 {
1847 del_timer_sync(&(pLed->BlinkTimer));
1848 pLed->bLedScanBlinkInProgress = FALSE;
1849 }
1850 if( pLed->bLedWPSBlinkInProgress )
1851 {
1852 del_timer_sync(&(pLed->BlinkTimer));
1853 pLed->bLedWPSBlinkInProgress = FALSE;
1854 }
1855
1856 mod_timer(&(pLed->BlinkTimer), 0);
1857 break;
1858
1859 default:
1860 break;
1861
1862 }
1863
1864 RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState);
1865}
1866
1867
1868void
1869SwLedControlMode4(
1870 struct net_device *dev,
1871 LED_CTL_MODE LedAction
1872)
1873{
1874 struct r8192_priv *priv = ieee80211_priv(dev);
1875 PLED_819xUsb pLed = &(priv->SwLed0);
1876 PLED_819xUsb pLed1 = &(priv->SwLed1);
1877
1878 switch(LedAction)
1879 {
1880 case LED_CTL_START_TO_LINK:
1881 if(pLed1->bLedWPSBlinkInProgress)
1882 {
1883 pLed1->bLedWPSBlinkInProgress = FALSE;
1884 del_timer_sync(&(pLed1->BlinkTimer));
1885
1886 pLed1->BlinkingLedState = LED_OFF;
1887 pLed1->CurrLedState = LED_OFF;
1888
1889 if(pLed1->bLedOn)
1890 mod_timer(&(pLed1->BlinkTimer), 0);
1891 }
1892
1893 if( pLed->bLedStartToLinkBlinkInProgress == FALSE )
1894 {
1895 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1896 {
1897 return;
1898 }
1899 if(pLed->bLedBlinkInProgress ==TRUE)
1900 {
1901 del_timer_sync(&(pLed->BlinkTimer));
1902 pLed->bLedBlinkInProgress = FALSE;
1903 }
1904 if(pLed->bLedNoLinkBlinkInProgress ==TRUE)
1905 {
1906 del_timer_sync(&(pLed->BlinkTimer));
1907 pLed->bLedNoLinkBlinkInProgress = FALSE;
1908 }
1909
1910 pLed->bLedStartToLinkBlinkInProgress = TRUE;
1911 pLed->CurrLedState = LED_BLINK_StartToBlink;
1912 if( pLed->bLedOn )
1913 {
1914 pLed->BlinkingLedState = LED_OFF;
1915 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL));
1916 }
1917 else
1918 {
1919 pLed->BlinkingLedState = LED_ON;
1920 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL));
1921 }
1922 }
1923 break;
1924
1925 case LED_CTL_LINK:
1926 case LED_CTL_NO_LINK:
1927 if(LedAction == LED_CTL_LINK)
1928 {
1929 if(pLed1->bLedWPSBlinkInProgress)
1930 {
1931 pLed1->bLedWPSBlinkInProgress = FALSE;
1932 del_timer_sync(&(pLed1->BlinkTimer));
1933
1934 pLed1->BlinkingLedState = LED_OFF;
1935 pLed1->CurrLedState = LED_OFF;
1936
1937 if(pLed1->bLedOn)
1938 mod_timer(&(pLed1->BlinkTimer), 0);
1939 }
1940 }
1941
1942 if( pLed->bLedNoLinkBlinkInProgress == FALSE )
1943 {
1944 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1945 {
1946 return;
1947 }
1948 if(pLed->bLedBlinkInProgress ==TRUE)
1949 {
1950 del_timer_sync(&(pLed->BlinkTimer));
1951 pLed->bLedBlinkInProgress = FALSE;
1952 }
1953
1954 pLed->bLedNoLinkBlinkInProgress = TRUE;
1955 pLed->CurrLedState = LED_BLINK_SLOWLY;
1956 if( pLed->bLedOn )
1957 pLed->BlinkingLedState = LED_OFF;
1958 else
1959 pLed->BlinkingLedState = LED_ON;
1960 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1961 }
1962
1963 break;
1964
1965 case LED_CTL_SITE_SURVEY:
1966 if((priv->ieee80211->LinkDetectInfo.bBusyTraffic) && (priv->ieee80211->state == IEEE80211_LINKED))
1967 ;
1968 else if(pLed->bLedScanBlinkInProgress ==FALSE)
1969 {
1970 if(IS_LED_WPS_BLINKING(pLed))
1971 return;
1972
1973 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
1974 {
1975 del_timer_sync(&(pLed->BlinkTimer));
1976 pLed->bLedNoLinkBlinkInProgress = FALSE;
1977 }
1978 if(pLed->bLedBlinkInProgress ==TRUE)
1979 {
1980 del_timer_sync(&(pLed->BlinkTimer));
1981 pLed->bLedBlinkInProgress = FALSE;
1982 }
1983 pLed->bLedScanBlinkInProgress = TRUE;
1984 pLed->CurrLedState = LED_SCAN_BLINK;
1985 pLed->BlinkTimes = 24;
1986 if( pLed->bLedOn )
1987 pLed->BlinkingLedState = LED_OFF;
1988 else
1989 pLed->BlinkingLedState = LED_ON;
1990 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
1991
1992 }
1993 break;
1994
1995 case LED_CTL_TX:
1996 case LED_CTL_RX:
1997 if(pLed->bLedBlinkInProgress ==FALSE)
1998 {
1999 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
2000 {
2001 return;
2002 }
2003 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
2004 {
2005 del_timer_sync(&(pLed->BlinkTimer));
2006 pLed->bLedNoLinkBlinkInProgress = FALSE;
2007 }
2008 pLed->bLedBlinkInProgress = TRUE;
2009 pLed->CurrLedState = LED_TXRX_BLINK;
2010 pLed->BlinkTimes = 2;
2011 if( pLed->bLedOn )
2012 pLed->BlinkingLedState = LED_OFF;
2013 else
2014 pLed->BlinkingLedState = LED_ON;
2015 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA));
2016 }
2017 break;
2018
2019 case LED_CTL_START_WPS:
2020 case LED_CTL_START_WPS_BOTTON:
2021 if(pLed1->bLedWPSBlinkInProgress)
2022 {
2023 pLed1->bLedWPSBlinkInProgress = FALSE;
2024 del_timer_sync(&(pLed1->BlinkTimer));
2025
2026 pLed1->BlinkingLedState = LED_OFF;
2027 pLed1->CurrLedState = LED_OFF;
2028
2029 if(pLed1->bLedOn)
2030 mod_timer(&(pLed1->BlinkTimer), 0);
2031 }
2032
2033 if(pLed->bLedWPSBlinkInProgress ==FALSE)
2034 {
2035 if(pLed->bLedNoLinkBlinkInProgress == TRUE)
2036 {
2037 del_timer_sync(&(pLed->BlinkTimer));
2038 pLed->bLedNoLinkBlinkInProgress = FALSE;
2039 }
2040 if(pLed->bLedBlinkInProgress ==TRUE)
2041 {
2042 del_timer_sync(&(pLed->BlinkTimer));
2043 pLed->bLedBlinkInProgress = FALSE;
2044 }
2045 if(pLed->bLedScanBlinkInProgress ==TRUE)
2046 {
2047 del_timer_sync(&(pLed->BlinkTimer));
2048 pLed->bLedScanBlinkInProgress = FALSE;
2049 }
2050 pLed->bLedWPSBlinkInProgress = TRUE;
2051 pLed->CurrLedState = LED_BLINK_WPS;
2052 if( pLed->bLedOn )
2053 {
2054 pLed->BlinkingLedState = LED_OFF;
2055 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL));
2056 }
2057 else
2058 {
2059 pLed->BlinkingLedState = LED_ON;
2060 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL));
2061 }
2062
2063 }
2064 break;
2065
2066 case LED_CTL_STOP_WPS:
2067 if(pLed->bLedWPSBlinkInProgress)
2068 {
2069 del_timer_sync(&(pLed->BlinkTimer));
2070 pLed->bLedWPSBlinkInProgress = FALSE;
2071 }
2072
2073 pLed->bLedNoLinkBlinkInProgress = TRUE;
2074 pLed->CurrLedState = LED_BLINK_SLOWLY;
2075 if( pLed->bLedOn )
2076 pLed->BlinkingLedState = LED_OFF;
2077 else
2078 pLed->BlinkingLedState = LED_ON;
2079 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
2080
2081 break;
2082
2083 case LED_CTL_STOP_WPS_FAIL:
2084 if(pLed->bLedWPSBlinkInProgress)
2085 {
2086 del_timer_sync(&(pLed->BlinkTimer));
2087 pLed->bLedWPSBlinkInProgress = FALSE;
2088 }
2089
2090 pLed->bLedNoLinkBlinkInProgress = TRUE;
2091 pLed->CurrLedState = LED_BLINK_SLOWLY;
2092 if( pLed->bLedOn )
2093 pLed->BlinkingLedState = LED_OFF;
2094 else
2095 pLed->BlinkingLedState = LED_ON;
2096 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
2097
2098 if(pLed1->bLedWPSBlinkInProgress)
2099 del_timer_sync(&(pLed1->BlinkTimer));
2100 else
2101 pLed1->bLedWPSBlinkInProgress = TRUE;
2102
2103 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
2104 if( pLed1->bLedOn )
2105 pLed1->BlinkingLedState = LED_OFF;
2106 else
2107 pLed1->BlinkingLedState = LED_ON;
2108 mod_timer(&(pLed1->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL));
2109
2110 break;
2111
2112 case LED_CTL_STOP_WPS_FAIL_OVERLAP:
2113 if(pLed->bLedWPSBlinkInProgress)
2114 {
2115 del_timer_sync(&(pLed->BlinkTimer));
2116 pLed->bLedWPSBlinkInProgress = FALSE;
2117 }
2118
2119 pLed->bLedNoLinkBlinkInProgress = TRUE;
2120 pLed->CurrLedState = LED_BLINK_SLOWLY;
2121 if( pLed->bLedOn )
2122 pLed->BlinkingLedState = LED_OFF;
2123 else
2124 pLed->BlinkingLedState = LED_ON;
2125 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
2126
2127 if(pLed1->bLedWPSBlinkInProgress)
2128 del_timer_sync(&(pLed1->BlinkTimer));
2129 else
2130 pLed1->bLedWPSBlinkInProgress = TRUE;
2131
2132 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
2133 pLed1->BlinkTimes = 10;
2134 if( pLed1->bLedOn )
2135 pLed1->BlinkingLedState = LED_OFF;
2136 else
2137 pLed1->BlinkingLedState = LED_ON;
2138 mod_timer(&(pLed1->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL));
2139
2140 break;
2141
2142 case LED_CTL_POWER_OFF:
2143 pLed->CurrLedState = LED_OFF;
2144 pLed->BlinkingLedState = LED_OFF;
2145
2146 if( pLed->bLedNoLinkBlinkInProgress)
2147 {
2148 del_timer_sync(&(pLed->BlinkTimer));
2149 pLed->bLedNoLinkBlinkInProgress = FALSE;
2150 }
2151 if( pLed->bLedLinkBlinkInProgress)
2152 {
2153 del_timer_sync(&(pLed->BlinkTimer));
2154 pLed->bLedLinkBlinkInProgress = FALSE;
2155 }
2156 if( pLed->bLedBlinkInProgress)
2157 {
2158 del_timer_sync(&(pLed->BlinkTimer));
2159 pLed->bLedBlinkInProgress = FALSE;
2160 }
2161 if( pLed->bLedWPSBlinkInProgress )
2162 {
2163 del_timer_sync(&(pLed->BlinkTimer));
2164 pLed->bLedWPSBlinkInProgress = FALSE;
2165 }
2166 if( pLed->bLedScanBlinkInProgress)
2167 {
2168 del_timer_sync(&(pLed->BlinkTimer));
2169 pLed->bLedScanBlinkInProgress = FALSE;
2170 }
2171 if( pLed->bLedStartToLinkBlinkInProgress)
2172 {
2173 del_timer_sync(&(pLed->BlinkTimer));
2174 pLed->bLedStartToLinkBlinkInProgress = FALSE;
2175 }
2176
2177 if( pLed1->bLedWPSBlinkInProgress )
2178 {
2179 del_timer_sync(&(pLed1->BlinkTimer));
2180 pLed1->bLedWPSBlinkInProgress = FALSE;
2181 }
2182
2183
2184 pLed1->BlinkingLedState = LED_UNKNOWN;
2185 SwLedOff(dev, pLed);
2186 SwLedOff(dev, pLed1);
2187 break;
2188
2189 default:
2190 break;
2191
2192 }
2193
2194 RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState);
2195}
2196
2197
2198
2199void
2200SwLedControlMode5(
2201 struct net_device *dev,
2202 LED_CTL_MODE LedAction
2203)
2204{
2205 struct r8192_priv *priv = ieee80211_priv(dev);
2206 PLED_819xUsb pLed = &(priv->SwLed0);
2207
2208 if(priv->CustomerID == RT_CID_819x_CAMEO)
2209 pLed = &(priv->SwLed1);
2210
2211 switch(LedAction)
2212 {
2213 case LED_CTL_POWER_ON:
2214 case LED_CTL_NO_LINK:
2215 case LED_CTL_LINK:
2216 if(pLed->CurrLedState == LED_SCAN_BLINK)
2217 {
2218 return;
2219 }
2220 pLed->CurrLedState = LED_ON;
2221 pLed->BlinkingLedState = LED_ON;
2222 pLed->bLedBlinkInProgress = FALSE;
2223 mod_timer(&(pLed->BlinkTimer), 0);
2224 break;
2225
2226 case LED_CTL_SITE_SURVEY:
2227 if((priv->ieee80211->LinkDetectInfo.bBusyTraffic) && (priv->ieee80211->state == IEEE80211_LINKED))
2228 ;
2229 else if(pLed->bLedScanBlinkInProgress ==FALSE)
2230 {
2231 if(pLed->bLedBlinkInProgress ==TRUE)
2232 {
2233 del_timer_sync(&(pLed->BlinkTimer));
2234 pLed->bLedBlinkInProgress = FALSE;
2235 }
2236 pLed->bLedScanBlinkInProgress = TRUE;
2237 pLed->CurrLedState = LED_SCAN_BLINK;
2238 pLed->BlinkTimes = 24;
2239 if( pLed->bLedOn )
2240 pLed->BlinkingLedState = LED_OFF;
2241 else
2242 pLed->BlinkingLedState = LED_ON;
2243 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA));
2244
2245 }
2246 break;
2247
2248 case LED_CTL_TX:
2249 case LED_CTL_RX:
2250 if(pLed->bLedBlinkInProgress ==FALSE)
2251 {
2252 if(pLed->CurrLedState == LED_SCAN_BLINK)
2253 {
2254 return;
2255 }
2256 pLed->bLedBlinkInProgress = TRUE;
2257 pLed->CurrLedState = LED_TXRX_BLINK;
2258 pLed->BlinkTimes = 2;
2259 if( pLed->bLedOn )
2260 pLed->BlinkingLedState = LED_OFF;
2261 else
2262 pLed->BlinkingLedState = LED_ON;
2263 mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA));
2264 }
2265 break;
2266
2267 case LED_CTL_POWER_OFF:
2268 pLed->CurrLedState = LED_OFF;
2269 pLed->BlinkingLedState = LED_OFF;
2270
2271 if( pLed->bLedBlinkInProgress)
2272 {
2273 del_timer_sync(&(pLed->BlinkTimer));
2274 pLed->bLedBlinkInProgress = FALSE;
2275 }
2276
2277 SwLedOff(dev, pLed);
2278 break;
2279
2280 default:
2281 break;
2282
2283 }
2284
2285 RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState);
2286}
2287
2288
2289void
2290LedControl8192SUsb(
2291 struct net_device *dev,
2292 LED_CTL_MODE LedAction
2293 )
2294{
2295 struct r8192_priv *priv = ieee80211_priv(dev);
2296
2297 if( priv->bRegUseLed == FALSE)
2298 return;
2299
2300 if (!priv->up)
2301 return;
2302
2303 if(priv->bInHctTest)
2304 return;
2305
2306 if( priv->ieee80211->eRFPowerState != eRfOn &&
2307 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
2308 LedAction == LED_CTL_SITE_SURVEY ||
2309 LedAction == LED_CTL_LINK ||
2310 LedAction == LED_CTL_NO_LINK ||
2311 LedAction == LED_CTL_POWER_ON) )
2312 {
2313 return;
2314 }
2315
2316 switch(priv->LedStrategy)
2317 {
2318 case SW_LED_MODE0:
2319 break;
2320
2321 case SW_LED_MODE1:
2322 SwLedControlMode1(dev, LedAction);
2323 break;
2324 case SW_LED_MODE2:
2325 SwLedControlMode2(dev, LedAction);
2326 break;
2327
2328 case SW_LED_MODE3:
2329 SwLedControlMode3(dev, LedAction);
2330 break;
2331
2332 case SW_LED_MODE4:
2333 SwLedControlMode4(dev, LedAction);
2334 break;
2335
2336 case SW_LED_MODE5:
2337 SwLedControlMode5(dev, LedAction);
2338 break;
2339
2340 default:
2341 break;
2342 }
2343
2344 RT_TRACE(COMP_LED, "LedStrategy:%d, LedAction %d\n", priv->LedStrategy,LedAction);
2345}
2346
2347
diff --git a/drivers/staging/rtl8192su/r8192SU_led.h b/drivers/staging/rtl8192su/r8192SU_led.h
new file mode 100644
index 000000000000..acedae4a59ca
--- /dev/null
+++ b/drivers/staging/rtl8192su/r8192SU_led.h
@@ -0,0 +1,93 @@
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#ifndef __INC_HAL8192USBLED_H
20#define __INC_HAL8192USBLED_H
21
22#include <linux/types.h>
23#include <linux/timer.h>
24
25typedef enum _LED_STATE_819xUsb{
26 LED_UNKNOWN = 0,
27 LED_ON = 1,
28 LED_OFF = 2,
29 LED_BLINK_NORMAL = 3,
30 LED_BLINK_SLOWLY = 4,
31 LED_POWER_ON_BLINK = 5,
32 LED_SCAN_BLINK = 6,
33 LED_NO_LINK_BLINK = 7,
34 LED_BLINK_StartToBlink = 8,
35 LED_BLINK_WPS = 9,
36 LED_TXRX_BLINK = 10,
37 LED_BLINK_WPS_STOP = 11,
38 LED_BLINK_WPS_STOP_OVERLAP = 12,
39
40}LED_STATE_819xUsb;
41
42#define IS_LED_WPS_BLINKING(_LED_819xUsb) (((PLED_819xUsb)_LED_819xUsb)->CurrLedState==LED_BLINK_WPS \
43 || ((PLED_819xUsb)_LED_819xUsb)->CurrLedState==LED_BLINK_WPS_STOP \
44 || ((PLED_819xUsb)_LED_819xUsb)->bLedWPSBlinkInProgress)
45
46#define IS_LED_BLINKING(_LED_819xUsb) (((PLED_819xUsb)_LED_819xUsb)->bLedWPSBlinkInProgress \
47 ||((PLED_819xUsb)_LED_819xUsb)->bLedScanBlinkInProgress)
48
49typedef enum _LED_PIN_819xUsb{
50 LED_PIN_GPIO0,
51 LED_PIN_LED0,
52 LED_PIN_LED1
53}LED_PIN_819xUsb;
54
55typedef enum _LED_STRATEGY_819xUsb{
56 SW_LED_MODE0, /* SW control 1 LED via GPIO0. It is default option. */
57 SW_LED_MODE1, /* SW control for PCI Express */
58 SW_LED_MODE2, /* SW control for Cameo. */
59 SW_LED_MODE3, /* SW contorl for RunTop. */
60 SW_LED_MODE4, /* SW control for Netcore */
61 SW_LED_MODE5,
62 HW_LED, /* HW control 2 LEDs, LED0 and LED1 (there are 4 different control modes) */
63}LED_STRATEGY_819xUsb, *PLED_STRATEGY_819xUsb;
64
65typedef struct _LED_819xUsb{
66 struct net_device *dev;
67
68 LED_PIN_819xUsb LedPin;
69
70 LED_STATE_819xUsb CurrLedState;
71 bool bLedOn;
72
73 bool bSWLedCtrl;
74
75 bool bLedBlinkInProgress;
76 bool bLedNoLinkBlinkInProgress;
77 bool bLedLinkBlinkInProgress;
78 bool bLedStartToLinkBlinkInProgress;
79 bool bLedScanBlinkInProgress;
80 bool bLedWPSBlinkInProgress;
81
82 u32 BlinkTimes;
83 LED_STATE_819xUsb BlinkingLedState;
84
85 struct timer_list BlinkTimer;
86} LED_819xUsb, *PLED_819xUsb;
87
88void InitSwLeds(struct net_device *dev);
89void DeInitSwLeds(struct net_device *dev);
90void LedControl8192SUsb(struct net_device *dev,LED_CTL_MODE LedAction);
91
92#endif
93
diff --git a/drivers/staging/rtl8192su/r8192U.h b/drivers/staging/rtl8192su/r8192U.h
index 4112e149a327..eccf4478fba8 100644
--- a/drivers/staging/rtl8192su/r8192U.h
+++ b/drivers/staging/rtl8192su/r8192U.h
@@ -43,6 +43,7 @@
43#include "ieee80211/ieee80211.h" 43#include "ieee80211/ieee80211.h"
44 44
45#include "r8192S_firmware.h" 45#include "r8192S_firmware.h"
46#include "r8192SU_led.h"
46 47
47/* EEPROM defs for use with linux/eeprom_93cx6.h */ 48/* EEPROM defs for use with linux/eeprom_93cx6.h */
48#define RTL819X_EEPROM_CMD_READ (1 << 0) 49#define RTL819X_EEPROM_CMD_READ (1 << 0)
@@ -1067,19 +1068,6 @@ typedef enum _RT_CUSTOMER_ID
1067 RT_CID_PRONET = 13, 1068 RT_CID_PRONET = 13,
1068}RT_CUSTOMER_ID, *PRT_CUSTOMER_ID; 1069}RT_CUSTOMER_ID, *PRT_CUSTOMER_ID;
1069 1070
1070//================================================================================
1071// LED customization.
1072//================================================================================
1073
1074typedef enum _LED_STRATEGY_8190{
1075 SW_LED_MODE0, // SW control 1 LED via GPIO0. It is default option.
1076 SW_LED_MODE1, // SW control for PCI Express
1077 SW_LED_MODE2, // SW control for Cameo.
1078 SW_LED_MODE3, // SW contorl for RunTop.
1079 SW_LED_MODE4, // SW control for Netcore
1080 HW_LED, // HW control 2 LEDs, LED0 and LED1 (there are 4 different control modes)
1081}LED_STRATEGY_8190, *PLED_STRATEGY_8190;
1082
1083typedef enum _RESET_TYPE { 1071typedef enum _RESET_TYPE {
1084 RESET_TYPE_NORESET = 0x00, 1072 RESET_TYPE_NORESET = 0x00,
1085 RESET_TYPE_NORMAL = 0x01, 1073 RESET_TYPE_NORMAL = 0x01,
@@ -1131,7 +1119,7 @@ typedef struct r8192_priv
1131 u8 eeprom_SubCustomerID; 1119 u8 eeprom_SubCustomerID;
1132 u8 eeprom_ChannelPlan; 1120 u8 eeprom_ChannelPlan;
1133 RT_CUSTOMER_ID CustomerID; 1121 RT_CUSTOMER_ID CustomerID;
1134 LED_STRATEGY_8190 LedStrategy; 1122 LED_STRATEGY_819xUsb LedStrategy;
1135 u8 txqueue_to_outpipemap[9]; 1123 u8 txqueue_to_outpipemap[9];
1136 u8 RtOutPipes[16]; 1124 u8 RtOutPipes[16];
1137 u8 RtInPipes[16]; 1125 u8 RtInPipes[16];
@@ -1501,8 +1489,17 @@ typedef struct r8192_priv
1501 u8 MinSpaceCfg; 1489 u8 MinSpaceCfg;
1502 1490
1503 u16 rf_pathmap; 1491 u16 rf_pathmap;
1504//#endif
1505 1492
1493 /* added for led control */
1494 PLED_819xUsb pLed;
1495 LED_819xUsb SwLed0;
1496 LED_819xUsb SwLed1;
1497 u8 bRegUseLed;
1498 struct work_struct BlinkWorkItem;
1499 /* added for led control */
1500 u16 FwCmdIOMap;
1501 u32 FwCmdIOParam;
1502 u8 DMFlag;
1506 1503
1507 1504
1508 1505
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-18 01:24:17 -0400