CoCalc -- hal_usb

GitHub Repository: nu11secur1ty/Kali-Linux
Path: blob/master/ALFA-W1F1/RTL8814AU/hal/led/hal_usb_led.c
¹³⁰⁷ views
1
/******************************************************************************
2
 *
3
 * Copyright(c) 2007 - 2017 Realtek Corporation.
4
 *
5
 * This program is free software; you can redistribute it and/or modify it
6
 * under the terms of version 2 of the GNU General Public License as
7
 * published by the Free Software Foundation.
8
 *
9
 * This program is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12
 * more details.
13
 *
14
 *****************************************************************************/
15

16
#include <drv_types.h>
17
#include <hal_data.h>
18
#ifdef CONFIG_RTW_SW_LED
19

20
/*
21
 *	Description:
22
 *		Implementation of LED blinking behavior.
23
 *		It toggle off LED and schedule corresponding timer if necessary.
24
 *   */
25
void
26
SwLedBlink(
27
	PLED_USB			pLed
28
)
29
{
30
	_adapter			*padapter = pLed->padapter;
31
	struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
32
	u8				bStopBlinking = _FALSE;
33

34
	/* Change LED according to BlinkingLedState specified. */
35
	if (pLed->BlinkingLedState == RTW_LED_ON) {
36
		SwLedOn(padapter, pLed);
37
	} else {
38
		SwLedOff(padapter, pLed);
39
	}
40

41
	/* Determine if we shall change LED state again. */
42
	pLed->BlinkTimes--;
43
	switch (pLed->CurrLedState) {
44

45
	case LED_BLINK_NORMAL:
46
		if (pLed->BlinkTimes == 0)
47
			bStopBlinking = _TRUE;
48
		break;
49

50
	case LED_BLINK_StartToBlink:
51
		if (check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
52
			bStopBlinking = _TRUE;
53
		if (check_fwstate(pmlmepriv, _FW_LINKED) &&
54
		    (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
55
			bStopBlinking = _TRUE;
56
		else if (pLed->BlinkTimes == 0)
57
			bStopBlinking = _TRUE;
58
		break;
59

60
	case LED_BLINK_WPS:
61
		if (pLed->BlinkTimes == 0)
62
			bStopBlinking = _TRUE;
63
		break;
64

65

66
	default:
67
		bStopBlinking = _TRUE;
68
		break;
69

70
	}
71

72
	if (bStopBlinking) {
73
		if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
74
			SwLedOff(padapter, pLed);
75
		else if ((check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) && (pLed->bLedOn == _FALSE))
76
			SwLedOn(padapter, pLed);
77
		else if ((check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) &&  pLed->bLedOn == _TRUE)
78
			SwLedOff(padapter, pLed);
79

80
		pLed->BlinkTimes = 0;
81
		pLed->bLedBlinkInProgress = _FALSE;
82
	} else {
83
		/* Assign LED state to toggle. */
84
		if (pLed->BlinkingLedState == RTW_LED_ON)
85
			pLed->BlinkingLedState = RTW_LED_OFF;
86
		else
87
			pLed->BlinkingLedState = RTW_LED_ON;
88

89
		/* Schedule a timer to toggle LED state. */
90
		switch (pLed->CurrLedState) {
91
		case LED_BLINK_NORMAL:
92
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
93
			break;
94

95
		case LED_BLINK_SLOWLY:
96
		case LED_BLINK_StartToBlink:
97
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
98
			break;
99

100
		case LED_BLINK_WPS: 
101
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
102
		        break;
103

104
		default:
105
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
106
			break;
107
		}
108
	}
109
}
110

111
void
112
SwLedBlink1(
113
	PLED_USB			pLed
114
)
115
{
116
	_adapter				*padapter = pLed->padapter;
117
	PHAL_DATA_TYPE		pHalData = GET_HAL_DATA(padapter);
118
	struct led_priv		*ledpriv = adapter_to_led(padapter);
119
	struct mlme_priv		*pmlmepriv = &(padapter->mlmepriv);
120
	PLED_USB			pLed1 = &(ledpriv->SwLed1);
121
	u8					bStopBlinking = _FALSE;
122

123
	u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; /* add by ylb 20121012 for customer led for alpha */
124
	if (pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)
125
		uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;
126

127
	if (pHalData->CustomerID == RT_CID_819x_CAMEO)
128
		pLed = &(ledpriv->SwLed1);
129

130
	/* Change LED according to BlinkingLedState specified. */
131
	if (pLed->BlinkingLedState == RTW_LED_ON) {
132
		SwLedOn(padapter, pLed);
133
	} else {
134
		SwLedOff(padapter, pLed);
135
	}
136

137

138
	if (pHalData->CustomerID == RT_CID_DEFAULT) {
139
		if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
140
			if (!pLed1->bSWLedCtrl) {
141
				SwLedOn(padapter, pLed1);
142
				pLed1->bSWLedCtrl = _TRUE;
143
			} else if (!pLed1->bLedOn)
144
				SwLedOn(padapter, pLed1);
145
		} else {
146
			if (!pLed1->bSWLedCtrl) {
147
				SwLedOff(padapter, pLed1);
148
				pLed1->bSWLedCtrl = _TRUE;
149
			} else if (pLed1->bLedOn)
150
				SwLedOff(padapter, pLed1);
151
		}
152
	}
153

154
	switch (pLed->CurrLedState) {
155
	case LED_BLINK_SLOWLY:
156
		if (pLed->bLedOn)
157
			pLed->BlinkingLedState = RTW_LED_OFF;
158
		else
159
			pLed->BlinkingLedState = RTW_LED_ON;
160
		_set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);/* change by ylb 20121012 for customer led for alpha */
161
		break;
162

163
	case LED_BLINK_NORMAL:
164
		if (pLed->bLedOn)
165
			pLed->BlinkingLedState = RTW_LED_OFF;
166
		else
167
			pLed->BlinkingLedState = RTW_LED_ON;
168
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
169
		break;
170

171
	case LED_BLINK_SCAN:
172
		pLed->BlinkTimes--;
173
		if (pLed->BlinkTimes == 0)
174
			bStopBlinking = _TRUE;
175

176
		if (bStopBlinking) {
177
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
178
				SwLedOff(padapter, pLed);
179
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
180
				pLed->bLedLinkBlinkInProgress = _TRUE;
181
				pLed->CurrLedState = LED_BLINK_NORMAL;
182
				if (pLed->bLedOn)
183
					pLed->BlinkingLedState = RTW_LED_OFF;
184
				else
185
					pLed->BlinkingLedState = RTW_LED_ON;
186
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
187

188
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
189
				pLed->bLedNoLinkBlinkInProgress = _TRUE;
190
				pLed->CurrLedState = LED_BLINK_SLOWLY;
191
				if (pLed->bLedOn)
192
					pLed->BlinkingLedState = RTW_LED_OFF;
193
				else
194
					pLed->BlinkingLedState = RTW_LED_ON;
195
				_set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);
196
			}
197
			pLed->bLedScanBlinkInProgress = _FALSE;
198
		} else {
199
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
200
				SwLedOff(padapter, pLed);
201
			else {
202
				if (pLed->bLedOn)
203
					pLed->BlinkingLedState = RTW_LED_OFF;
204
				else
205
					pLed->BlinkingLedState = RTW_LED_ON;
206
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
207
			}
208
		}
209
		break;
210

211
	case LED_BLINK_TXRX:
212
		pLed->BlinkTimes--;
213
		if (pLed->BlinkTimes == 0)
214
			bStopBlinking = _TRUE;
215
		if (bStopBlinking) {
216
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
217
				SwLedOff(padapter, pLed);
218
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
219
				pLed->bLedLinkBlinkInProgress = _TRUE;
220
				pLed->CurrLedState = LED_BLINK_NORMAL;
221
				if (pLed->bLedOn)
222
					pLed->BlinkingLedState = RTW_LED_OFF;
223
				else
224
					pLed->BlinkingLedState = RTW_LED_ON;
225
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
226
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
227
				pLed->bLedNoLinkBlinkInProgress = _TRUE;
228
				pLed->CurrLedState = LED_BLINK_SLOWLY;
229
				if (pLed->bLedOn)
230
					pLed->BlinkingLedState = RTW_LED_OFF;
231
				else
232
					pLed->BlinkingLedState = RTW_LED_ON;
233
				_set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);
234
			}
235
			pLed->BlinkTimes = 0;
236
			pLed->bLedBlinkInProgress = _FALSE;
237
		} else {
238
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
239
				SwLedOff(padapter, pLed);
240
			else {
241
				if (pLed->bLedOn)
242
					pLed->BlinkingLedState = RTW_LED_OFF;
243
				else
244
					pLed->BlinkingLedState = RTW_LED_ON;
245
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
246
			}
247
		}
248
		break;
249

250
	case LED_BLINK_WPS:
251
		if (pLed->bLedOn)
252
			pLed->BlinkingLedState = RTW_LED_OFF;
253
		else
254
			pLed->BlinkingLedState = RTW_LED_ON;
255
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
256
		break;
257

258
	case LED_BLINK_WPS_STOP:	/* WPS success */
259
		if (pLed->BlinkingLedState == RTW_LED_ON) {
260
			pLed->BlinkingLedState = RTW_LED_OFF;
261
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
262
			bStopBlinking = _FALSE;
263
		} else
264
			bStopBlinking = _TRUE;
265

266
		if (bStopBlinking) {
267
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
268
				SwLedOff(padapter, pLed);
269
			else {
270
				pLed->bLedLinkBlinkInProgress = _TRUE;
271
				pLed->CurrLedState = LED_BLINK_NORMAL;
272
				if (pLed->bLedOn)
273
					pLed->BlinkingLedState = RTW_LED_OFF;
274
				else
275
					pLed->BlinkingLedState = RTW_LED_ON;
276
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
277
			}
278
			pLed->bLedWPSBlinkInProgress = _FALSE;
279
		}
280
		break;
281

282
	default:
283
		break;
284
	}
285

286
}
287

288
void
289
SwLedBlink2(
290
	PLED_USB			pLed
291
)
292
{
293
	_adapter				*padapter = pLed->padapter;
294
	struct mlme_priv		*pmlmepriv = &(padapter->mlmepriv);
295
	u8					bStopBlinking = _FALSE;
296

297
	/* Change LED according to BlinkingLedState specified. */
298
	if (pLed->BlinkingLedState == RTW_LED_ON) {
299
		SwLedOn(padapter, pLed);
300
	} else {
301
		SwLedOff(padapter, pLed);
302
	}
303

304
	switch (pLed->CurrLedState) {
305
	case LED_BLINK_SCAN:
306
		pLed->BlinkTimes--;
307
		if (pLed->BlinkTimes == 0)
308
			bStopBlinking = _TRUE;
309

310
		if (bStopBlinking) {
311
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
312
				SwLedOff(padapter, pLed);
313
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
314
				pLed->CurrLedState = RTW_LED_ON;
315
				pLed->BlinkingLedState = RTW_LED_ON;
316
				SwLedOn(padapter, pLed);
317

318
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
319
				pLed->CurrLedState = RTW_LED_OFF;
320
				pLed->BlinkingLedState = RTW_LED_OFF;
321
				SwLedOff(padapter, pLed);
322
			}
323
			pLed->bLedScanBlinkInProgress = _FALSE;
324
		} else {
325
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
326
				SwLedOff(padapter, pLed);
327
			else {
328
				if (pLed->bLedOn)
329
					pLed->BlinkingLedState = RTW_LED_OFF;
330
				else
331
					pLed->BlinkingLedState = RTW_LED_ON;
332
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
333
			}
334
		}
335
		break;
336

337
	case LED_BLINK_TXRX:
338
		pLed->BlinkTimes--;
339
		if (pLed->BlinkTimes == 0)
340
			bStopBlinking = _TRUE;
341
		if (bStopBlinking) {
342
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
343
				SwLedOff(padapter, pLed);
344
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
345
				pLed->CurrLedState = RTW_LED_ON;
346
				pLed->BlinkingLedState = RTW_LED_ON;
347
				SwLedOn(padapter, pLed);
348

349
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
350
				pLed->CurrLedState = RTW_LED_OFF;
351
				pLed->BlinkingLedState = RTW_LED_OFF;
352
				SwLedOff(padapter, pLed);
353
			}
354
			pLed->bLedBlinkInProgress = _FALSE;
355
		} else {
356
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
357
				SwLedOff(padapter, pLed);
358
			else {
359
				if (pLed->bLedOn)
360
					pLed->BlinkingLedState = RTW_LED_OFF;
361
				else
362
					pLed->BlinkingLedState = RTW_LED_ON;
363
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
364
			}
365
		}
366
		break;
367

368
	default:
369
		break;
370
	}
371

372
}
373

374
void
375
SwLedBlink3(
376
	PLED_USB			pLed
377
)
378
{
379
	_adapter			*padapter = pLed->padapter;
380
	struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
381
	u8				bStopBlinking = _FALSE;
382

383
	/* Change LED according to BlinkingLedState specified. */
384
	if (pLed->BlinkingLedState == RTW_LED_ON) {
385
		SwLedOn(padapter, pLed);
386
	} else {
387
		if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
388
			SwLedOff(padapter, pLed);
389
	}
390

391
	switch (pLed->CurrLedState) {
392
	case LED_BLINK_SCAN:
393
		pLed->BlinkTimes--;
394
		if (pLed->BlinkTimes == 0)
395
			bStopBlinking = _TRUE;
396

397
		if (bStopBlinking) {
398
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
399
				SwLedOff(padapter, pLed);
400
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
401
				pLed->CurrLedState = RTW_LED_ON;
402
				pLed->BlinkingLedState = RTW_LED_ON;
403
				if (!pLed->bLedOn)
404
					SwLedOn(padapter, pLed);
405

406
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
407
				pLed->CurrLedState = RTW_LED_OFF;
408
				pLed->BlinkingLedState = RTW_LED_OFF;
409
				if (pLed->bLedOn)
410
					SwLedOff(padapter, pLed);
411

412
			}
413
			pLed->bLedScanBlinkInProgress = _FALSE;
414
		} else {
415
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
416
				SwLedOff(padapter, pLed);
417
			else {
418
				if (pLed->bLedOn)
419
					pLed->BlinkingLedState = RTW_LED_OFF;
420
				else
421
					pLed->BlinkingLedState = RTW_LED_ON;
422
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
423
			}
424
		}
425
		break;
426

427
	case LED_BLINK_TXRX:
428
		pLed->BlinkTimes--;
429
		if (pLed->BlinkTimes == 0)
430
			bStopBlinking = _TRUE;
431
		if (bStopBlinking) {
432
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
433
				SwLedOff(padapter, pLed);
434
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
435
				pLed->CurrLedState = RTW_LED_ON;
436
				pLed->BlinkingLedState = RTW_LED_ON;
437

438
				if (!pLed->bLedOn)
439
					SwLedOn(padapter, pLed);
440

441
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
442
				pLed->CurrLedState = RTW_LED_OFF;
443
				pLed->BlinkingLedState = RTW_LED_OFF;
444

445
				if (pLed->bLedOn)
446
					SwLedOff(padapter, pLed);
447

448

449
			}
450
			pLed->bLedBlinkInProgress = _FALSE;
451
		} else {
452
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
453
				SwLedOff(padapter, pLed);
454
			else {
455
				if (pLed->bLedOn)
456
					pLed->BlinkingLedState = RTW_LED_OFF;
457
				else
458
					pLed->BlinkingLedState = RTW_LED_ON;
459
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
460
			}
461
		}
462
		break;
463

464
	case LED_BLINK_WPS:
465
		if (pLed->bLedOn)
466
			pLed->BlinkingLedState = RTW_LED_OFF;
467
		else
468
			pLed->BlinkingLedState = RTW_LED_ON;
469
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
470
		break;
471

472
	case LED_BLINK_WPS_STOP:	/* WPS success */
473
		if (pLed->BlinkingLedState == RTW_LED_ON) {
474
			pLed->BlinkingLedState = RTW_LED_OFF;
475
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
476
			bStopBlinking = _FALSE;
477
		} else
478
			bStopBlinking = _TRUE;
479

480
		if (bStopBlinking) {
481
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
482
				SwLedOff(padapter, pLed);
483
			else {
484
				pLed->CurrLedState = RTW_LED_ON;
485
				pLed->BlinkingLedState = RTW_LED_ON;
486
				SwLedOn(padapter, pLed);
487
			}
488
			pLed->bLedWPSBlinkInProgress = _FALSE;
489
		}
490
		break;
491

492

493
	default:
494
		break;
495
	}
496

497
}
498

499

500
void
501
SwLedBlink4(
502
	PLED_USB			pLed
503
)
504
{
505
	_adapter			*padapter = pLed->padapter;
506
	struct led_priv	*ledpriv = adapter_to_led(padapter);
507
	struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
508
	PLED_USB		pLed1 = &(ledpriv->SwLed1);
509
	u8				bStopBlinking = _FALSE;
510

511
	/* Change LED according to BlinkingLedState specified. */
512
	if (pLed->BlinkingLedState == RTW_LED_ON) {
513
		SwLedOn(padapter, pLed);
514
	} else {
515
		SwLedOff(padapter, pLed);
516
	}
517

518
	if (!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN) {
519
		pLed1->BlinkingLedState = RTW_LED_OFF;
520
		pLed1->CurrLedState = RTW_LED_OFF;
521
		SwLedOff(padapter, pLed1);
522
	}
523

524
	switch (pLed->CurrLedState) {
525
	case LED_BLINK_SLOWLY:
526
		if (pLed->bLedOn)
527
			pLed->BlinkingLedState = RTW_LED_OFF;
528
		else
529
			pLed->BlinkingLedState = RTW_LED_ON;
530
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
531
		break;
532

533
	case LED_BLINK_StartToBlink:
534
		if (pLed->bLedOn) {
535
			pLed->BlinkingLedState = RTW_LED_OFF;
536
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
537
		} else {
538
			pLed->BlinkingLedState = RTW_LED_ON;
539
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
540
		}
541
		break;
542

543
	case LED_BLINK_SCAN:
544
		pLed->BlinkTimes--;
545
		if (pLed->BlinkTimes == 0)
546
			bStopBlinking = _FALSE;
547
#if 0
548

549
		if (bStopBlinking) {
550
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
551
				SwLedOff(padapter, pLed);
552
			else {
553
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
554
				pLed->CurrLedState = LED_BLINK_SLOWLY;
555
				if (pLed->bLedOn)
556
					pLed->BlinkingLedState = RTW_LED_OFF;
557
				else
558
					pLed->BlinkingLedState = RTW_LED_ON;
559
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
560
			}
561
			pLed->bLedScanBlinkInProgress = _FALSE;
562
		} else 
563
#endif 
564
		{
565
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
566
				SwLedOff(padapter, pLed);
567
			else {
568
				if (pLed->bLedOn)
569
					pLed->BlinkingLedState = RTW_LED_OFF;
570
				else
571
					pLed->BlinkingLedState = RTW_LED_ON;
572
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
573
			}
574
		}
575

576
		break;
577

578
	case LED_BLINK_TXRX:
579
		pLed->BlinkTimes--;
580
		if (pLed->BlinkTimes == 0)
581
			bStopBlinking = _TRUE;
582
		if (bStopBlinking) {
583
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
584
				SwLedOff(padapter, pLed);
585
			else {
586
				pLed->bLedNoLinkBlinkInProgress = _TRUE;
587
				pLed->CurrLedState = LED_BLINK_SLOWLY;
588
				if (pLed->bLedOn)
589
					pLed->BlinkingLedState = RTW_LED_OFF;
590
				else
591
					pLed->BlinkingLedState = RTW_LED_ON;
592
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
593
			}
594
			pLed->bLedBlinkInProgress = _FALSE;
595
		} else {
596
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
597
				SwLedOff(padapter, pLed);
598
			else {
599

600
				if (pLed->bLedOn)
601
					pLed->BlinkingLedState = RTW_LED_OFF;
602
				else
603
					pLed->BlinkingLedState = RTW_LED_ON;
604

605
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
606
			}
607
		}
608
		break;
609

610
	case LED_BLINK_WPS:
611
		if (pLed->bLedOn) {
612
			pLed->BlinkingLedState = RTW_LED_OFF;
613
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
614
		} else {
615
			pLed->BlinkingLedState = RTW_LED_ON;
616
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
617
		}
618
		break;
619

620
	case LED_BLINK_WPS_STOP:	/* WPS authentication fail */
621
		if (pLed->bLedOn)
622
			pLed->BlinkingLedState = RTW_LED_OFF;
623
		else
624
			pLed->BlinkingLedState = RTW_LED_ON;
625

626
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
627
		break;
628

629
	case LED_BLINK_WPS_STOP_OVERLAP:	/* WPS session overlap */
630
		pLed->BlinkTimes--;
631
		if (pLed->BlinkTimes == 0) {
632
			if (pLed->bLedOn)
633
				pLed->BlinkTimes = 1;
634
			else
635
				bStopBlinking = _TRUE;
636
		}
637

638
		if (bStopBlinking) {
639
			pLed->BlinkTimes = 10;
640
			pLed->BlinkingLedState = RTW_LED_ON;
641
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
642
		} else {
643
			if (pLed->bLedOn)
644
				pLed->BlinkingLedState = RTW_LED_OFF;
645
			else
646
				pLed->BlinkingLedState = RTW_LED_ON;
647

648
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
649
		}
650
		break;
651

652
	case LED_BLINK_ALWAYS_ON:
653
		pLed->BlinkTimes--;
654
		if (pLed->BlinkTimes == 0)
655
			bStopBlinking = _TRUE;
656
		if (bStopBlinking) {
657
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
658
				SwLedOff(padapter, pLed);
659
			else {
660
				pLed->bLedNoLinkBlinkInProgress = _TRUE;
661
				pLed->CurrLedState = LED_BLINK_SLOWLY;
662
				if (pLed->bLedOn)
663
					pLed->BlinkingLedState = RTW_LED_OFF;
664
				else
665
					pLed->BlinkingLedState = RTW_LED_ON;
666

667
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
668
			}
669
			pLed->bLedBlinkInProgress = _FALSE;
670
		} else {
671
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
672
				SwLedOff(padapter, pLed);
673
			} else {
674
				if (pLed->bLedOn)
675
					pLed->BlinkingLedState = RTW_LED_OFF;
676
				else
677
					pLed->BlinkingLedState = RTW_LED_ON;
678

679
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
680
			}
681
		}
682
		break;
683

684
	default:
685
		break;
686
	}
687

688

689

690
}
691

692
void
693
SwLedBlink5(
694
	PLED_USB			pLed
695
)
696
{
697
	_adapter			*padapter = pLed->padapter;
698
	struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
699
	u8				bStopBlinking = _FALSE;
700

701
	/* Change LED according to BlinkingLedState specified. */
702
	if (pLed->BlinkingLedState == RTW_LED_ON) {
703
		SwLedOn(padapter, pLed);
704
	} else {
705
		SwLedOff(padapter, pLed);
706
	}
707

708
	switch (pLed->CurrLedState) {
709
	case LED_BLINK_SCAN:
710
		pLed->BlinkTimes--;
711
		if (pLed->BlinkTimes == 0)
712
			bStopBlinking = _TRUE;
713

714
		if (bStopBlinking) {
715
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
716
				pLed->CurrLedState = RTW_LED_OFF;
717
				pLed->BlinkingLedState = RTW_LED_OFF;
718
				if (pLed->bLedOn)
719
					SwLedOff(padapter, pLed);
720
			} else {
721
				pLed->CurrLedState = RTW_LED_ON;
722
				pLed->BlinkingLedState = RTW_LED_ON;
723
				if (!pLed->bLedOn)
724
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
725
			}
726

727
			pLed->bLedScanBlinkInProgress = _FALSE;
728
		} else {
729
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
730
				SwLedOff(padapter, pLed);
731
			else {
732
				if (pLed->bLedOn)
733
					pLed->BlinkingLedState = RTW_LED_OFF;
734
				else
735
					pLed->BlinkingLedState = RTW_LED_ON;
736
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
737
			}
738
		}
739
		break;
740

741

742
	case LED_BLINK_TXRX:
743
		pLed->BlinkTimes--;
744
		if (pLed->BlinkTimes == 0)
745
			bStopBlinking = _TRUE;
746

747
		if (bStopBlinking) {
748
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) {
749
				pLed->CurrLedState = RTW_LED_OFF;
750
				pLed->BlinkingLedState = RTW_LED_OFF;
751
				if (pLed->bLedOn)
752
					SwLedOff(padapter, pLed);
753
			} else {
754
				pLed->CurrLedState = RTW_LED_ON;
755
				pLed->BlinkingLedState = RTW_LED_ON;
756
				if (!pLed->bLedOn)
757
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
758
			}
759

760
			pLed->bLedBlinkInProgress = _FALSE;
761
		} else {
762
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
763
				SwLedOff(padapter, pLed);
764
			else {
765
				if (pLed->bLedOn)
766
					pLed->BlinkingLedState = RTW_LED_OFF;
767
				else
768
					pLed->BlinkingLedState = RTW_LED_ON;
769
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
770
			}
771
		}
772
		break;
773

774
	default:
775
		break;
776
	}
777

778

779

780
}
781

782
void
783
SwLedBlink6(
784
	PLED_USB			pLed
785
)
786
{
787
	_adapter			*padapter = pLed->padapter;
788
	struct mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
789
	u8				bStopBlinking = _FALSE;
790

791
	/* Change LED according to BlinkingLedState specified. */
792
	if (pLed->BlinkingLedState == RTW_LED_ON) {
793
		SwLedOn(padapter, pLed);
794
	} else {
795
		SwLedOff(padapter, pLed);
796
	}
797

798
}
799

800
void
801
SwLedBlink7(
802
	PLED_USB			pLed
803
)
804
{
805
	PADAPTER Adapter = pLed->padapter;
806
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
807
	BOOLEAN bStopBlinking = _FALSE;
808

809
	/* Change LED according to BlinkingLedState specified. */
810
	if (pLed->BlinkingLedState == RTW_LED_ON) {
811
		SwLedOn(Adapter, pLed);
812
	} else {
813
		if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
814
			SwLedOff(Adapter, pLed);
815
	}
816

817
	switch (pLed->CurrLedState) {
818
	case LED_BLINK_SCAN:
819
		pLed->BlinkTimes--;
820
		if (pLed->BlinkTimes == 0)
821
			bStopBlinking = _TRUE;
822

823
		if (bStopBlinking) {
824
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
825
				SwLedOff(Adapter, pLed);
826
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
827
				pLed->CurrLedState = RTW_LED_ON;
828
				pLed->BlinkingLedState = RTW_LED_ON;
829
				if (!pLed->bLedOn)
830
					SwLedOn(Adapter, pLed);
831

832
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
833
				pLed->CurrLedState = RTW_LED_OFF;
834
				pLed->BlinkingLedState = RTW_LED_OFF;
835
				if (pLed->bLedOn)
836
					SwLedOff(Adapter, pLed);
837

838
			}
839
			pLed->bLedScanBlinkInProgress = _FALSE;
840
		} else {
841
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
842
				SwLedOff(Adapter, pLed);
843
			else {
844
				if (pLed->bLedOn)
845
					pLed->BlinkingLedState = RTW_LED_OFF;
846
				else
847
					pLed->BlinkingLedState = RTW_LED_ON;
848
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
849
			}
850
		}
851
		break;
852

853
	case LED_BLINK_WPS:
854
		if (pLed->bLedOn)
855
			pLed->BlinkingLedState = RTW_LED_OFF;
856
		else
857
			pLed->BlinkingLedState = RTW_LED_ON;
858
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
859
		break;
860

861
	case LED_BLINK_WPS_STOP:	/* WPS success */
862
		if (pLed->BlinkingLedState == RTW_LED_ON) {
863
			pLed->BlinkingLedState = RTW_LED_OFF;
864
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
865
			bStopBlinking = _FALSE;
866
		} else
867
			bStopBlinking = _TRUE;
868

869
		if (bStopBlinking) {
870
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
871
				SwLedOff(Adapter, pLed);
872
			else {
873
				pLed->CurrLedState = RTW_LED_ON;
874
				pLed->BlinkingLedState = RTW_LED_ON;
875
				SwLedOn(Adapter, pLed);
876
			}
877
			pLed->bLedWPSBlinkInProgress = _FALSE;
878
		}
879
		break;
880

881

882
	default:
883
		break;
884
	}
885

886

887
}
888

889
void
890
SwLedBlink8(
891
	PLED_USB			pLed
892
)
893
{
894
	PADAPTER Adapter = pLed->padapter;
895

896
	/* Change LED according to BlinkingLedState specified. */
897
	if (pLed->BlinkingLedState == RTW_LED_ON) {
898
		SwLedOn(Adapter, pLed);
899
	} else {
900
		SwLedOff(Adapter, pLed);
901
	}
902

903

904
}
905

906
/* page added for Belkin AC950. 20120813 */
907
void
908
SwLedBlink9(
909
	PLED_USB			pLed
910
)
911
{
912
	PADAPTER Adapter = pLed->padapter;
913
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
914
	BOOLEAN bStopBlinking = _FALSE;
915

916
	/* Change LED according to BlinkingLedState specified. */
917
	if (pLed->BlinkingLedState == RTW_LED_ON) {
918
		SwLedOn(Adapter, pLed);
919
	} else {
920
		SwLedOff(Adapter, pLed);
921
	}
922
	/* RTW_INFO("%s, pLed->CurrLedState=%d, pLed->BlinkingLedState=%d\n", __FUNCTION__, pLed->CurrLedState, pLed->BlinkingLedState); */
923

924

925
	switch (pLed->CurrLedState) {
926
	case RTW_LED_ON:
927
		SwLedOn(Adapter, pLed);
928
		break;
929

930
	case RTW_LED_OFF:
931
		SwLedOff(Adapter, pLed);
932
		break;
933

934
	case LED_BLINK_SLOWLY:
935
		if (pLed->bLedOn)
936
			pLed->BlinkingLedState = RTW_LED_OFF;
937
		else
938
			pLed->BlinkingLedState = RTW_LED_ON;
939
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
940
		break;
941

942
	case LED_BLINK_StartToBlink:
943
		if (pLed->bLedOn) {
944
			pLed->BlinkingLedState = RTW_LED_OFF;
945
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
946
		} else {
947
			pLed->BlinkingLedState = RTW_LED_ON;
948
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
949
		}
950
		break;
951

952
	case LED_BLINK_SCAN:
953
		pLed->BlinkTimes--;
954
		if (pLed->BlinkTimes == 0)
955
			bStopBlinking = _TRUE;
956

957
		if (bStopBlinking) {
958
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
959
				SwLedOff(Adapter, pLed);
960
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
961
				pLed->bLedLinkBlinkInProgress = _TRUE;
962
				pLed->CurrLedState = LED_BLINK_SLOWLY;
963

964
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
965
			} else if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
966
				pLed->bLedNoLinkBlinkInProgress = _TRUE;
967
				pLed->CurrLedState = LED_BLINK_SLOWLY;
968
				if (pLed->bLedOn)
969
					pLed->BlinkingLedState = RTW_LED_OFF;
970
				else
971
					pLed->BlinkingLedState = RTW_LED_ON;
972
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
973
			}
974
			pLed->BlinkTimes = 0;
975
			pLed->bLedBlinkInProgress = _FALSE;
976
		} else {
977
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
978
				SwLedOff(Adapter, pLed);
979
			else {
980
				if (pLed->bLedOn)
981
					pLed->BlinkingLedState = RTW_LED_OFF;
982
				else
983
					pLed->BlinkingLedState = RTW_LED_ON;
984
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
985
			}
986
		}
987
		break;
988

989
	case LED_BLINK_TXRX:
990
		pLed->BlinkTimes--;
991
		if (pLed->BlinkTimes == 0)
992
			bStopBlinking = _TRUE;
993
		if (bStopBlinking) {
994
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
995
				SwLedOff(Adapter, pLed);
996
			else {
997
				pLed->CurrLedState = LED_BLINK_SLOWLY;
998
				if (pLed->bLedOn)
999
					pLed->BlinkingLedState = RTW_LED_OFF;
1000
				else
1001
					pLed->BlinkingLedState = RTW_LED_ON;
1002
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1003
			}
1004
			pLed->bLedBlinkInProgress = _FALSE;
1005
		} else {
1006
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1007
				SwLedOff(Adapter, pLed);
1008
			else {
1009
				if (pLed->bLedOn)
1010
					pLed->BlinkingLedState = RTW_LED_OFF;
1011
				else
1012
					pLed->BlinkingLedState = RTW_LED_ON;
1013

1014
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1015
			}
1016
		}
1017
		break;
1018

1019
	case LED_BLINK_WPS:
1020
		if (pLed->bLedOn) {
1021
			pLed->BlinkingLedState = RTW_LED_OFF;
1022
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1023
		} else {
1024
			pLed->BlinkingLedState = RTW_LED_ON;
1025
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1026
		}
1027
		break;
1028

1029
	case LED_BLINK_WPS_STOP:	/* WPS authentication fail */
1030
		if (pLed->bLedOn)
1031
			pLed->BlinkingLedState = RTW_LED_OFF;
1032
		else
1033
			pLed->BlinkingLedState = RTW_LED_ON;
1034

1035
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1036
		break;
1037

1038
	case LED_BLINK_WPS_STOP_OVERLAP:	/* WPS session overlap		 */
1039
		pLed->BlinkTimes--;
1040
		pLed->BlinkCounter--;
1041
		if (pLed->BlinkCounter == 0) {
1042
			pLed->BlinkingLedState = RTW_LED_OFF;
1043
			pLed->CurrLedState = RTW_LED_OFF;
1044
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1045
		} else {
1046
			if (pLed->BlinkTimes == 0) {
1047
				if (pLed->bLedOn)
1048
					pLed->BlinkTimes = 1;
1049
				else
1050
					bStopBlinking = _TRUE;
1051
			}
1052

1053
			if (bStopBlinking) {
1054
				pLed->BlinkTimes = 10;
1055
				pLed->BlinkingLedState = RTW_LED_ON;
1056
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1057
			} else {
1058
				if (pLed->bLedOn)
1059
					pLed->BlinkingLedState = RTW_LED_OFF;
1060
				else
1061
					pLed->BlinkingLedState = RTW_LED_ON;
1062

1063
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1064
			}
1065
		}
1066
		break;
1067

1068
	case LED_BLINK_ALWAYS_ON:
1069
		pLed->BlinkTimes--;
1070
		if (pLed->BlinkTimes == 0)
1071
			bStopBlinking = _TRUE;
1072
		if (bStopBlinking) {
1073
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1074
				SwLedOff(Adapter, pLed);
1075
			else {
1076
				if (IS_HARDWARE_TYPE_8812AU(Adapter)) {
1077
					pLed->BlinkingLedState = RTW_LED_ON;
1078
					pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
1079
				} else {
1080
					pLed->bLedNoLinkBlinkInProgress = _TRUE;
1081
					pLed->CurrLedState = LED_BLINK_SLOWLY;
1082
					if (pLed->bLedOn)
1083
						pLed->BlinkingLedState = RTW_LED_OFF;
1084
					else
1085
						pLed->BlinkingLedState = RTW_LED_ON;
1086
				}
1087
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1088
			}
1089
			pLed->bLedBlinkInProgress = _FALSE;
1090
		} else {
1091
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
1092
				SwLedOff(Adapter, pLed);
1093
			} else {
1094
				if (IS_HARDWARE_TYPE_8812AU(Adapter))
1095
					pLed->BlinkingLedState = RTW_LED_ON;
1096
				else {
1097
					if (pLed->bLedOn)
1098
						pLed->BlinkingLedState = RTW_LED_OFF;
1099
					else
1100
						pLed->BlinkingLedState = RTW_LED_ON;
1101
				}
1102
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1103
			}
1104
		}
1105
		break;
1106

1107
	case LED_BLINK_LINK_IN_PROCESS:
1108
		if (pLed->bLedOn) {
1109
			pLed->BlinkingLedState = RTW_LED_OFF;
1110
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);
1111
		} else {
1112
			pLed->BlinkingLedState = RTW_LED_ON;
1113
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);
1114
		}
1115
		break;
1116

1117
	case LED_BLINK_AUTH_ERROR:
1118
		pLed->BlinkTimes--;
1119
		if (pLed->BlinkTimes == 0)
1120
			bStopBlinking = _TRUE;
1121
		if (bStopBlinking == _FALSE) {
1122
			if (pLed->bLedOn) {
1123
				pLed->BlinkingLedState = RTW_LED_OFF;
1124
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1125
			} else {
1126
				pLed->BlinkingLedState = RTW_LED_ON;
1127
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1128
			}
1129
		} else {
1130
			pLed->CurrLedState = RTW_LED_OFF;
1131
			pLed->BlinkingLedState = RTW_LED_OFF;
1132
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1133
		}
1134
		break;
1135

1136
	default:
1137
		break;
1138
	}
1139

1140
}
1141

1142
/* page added for Netgear A6200V2. 20120827 */
1143
void
1144
SwLedBlink10(
1145
	PLED_USB			pLed
1146
)
1147
{
1148
	PADAPTER Adapter = pLed->padapter;
1149
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
1150
	BOOLEAN bStopBlinking = _FALSE;
1151

1152
	/* Change LED according to BlinkingLedState specified. */
1153
	if (pLed->BlinkingLedState == RTW_LED_ON) {
1154
		SwLedOn(Adapter, pLed);
1155
	} else {
1156
		SwLedOff(Adapter, pLed);
1157
	}
1158

1159

1160
	switch (pLed->CurrLedState) {
1161
	case RTW_LED_ON:
1162
		SwLedOn(Adapter, pLed);
1163
		break;
1164

1165
	case RTW_LED_OFF:
1166
		SwLedOff(Adapter, pLed);
1167
		break;
1168

1169
	case LED_BLINK_SLOWLY:
1170
		if (pLed->bLedOn)
1171
			pLed->BlinkingLedState = RTW_LED_OFF;
1172
		else
1173
			pLed->BlinkingLedState = RTW_LED_ON;
1174
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1175
		break;
1176

1177
	case LED_BLINK_StartToBlink:
1178
		if (pLed->bLedOn) {
1179
			pLed->BlinkingLedState = RTW_LED_OFF;
1180
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1181
		} else {
1182
			pLed->BlinkingLedState = RTW_LED_ON;
1183
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1184
		}
1185
		break;
1186

1187
	case LED_BLINK_SCAN:
1188
		pLed->BlinkTimes--;
1189
		if (pLed->BlinkTimes == 0)
1190
			bStopBlinking = _TRUE;
1191

1192
		if (bStopBlinking) {
1193
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
1194
				SwLedOff(Adapter, pLed);
1195
			else if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
1196
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
1197
				pLed->CurrLedState = RTW_LED_OFF;
1198
				pLed->BlinkingLedState = RTW_LED_OFF;
1199

1200
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1201
			}
1202
			pLed->BlinkTimes = 0;
1203
			pLed->bLedBlinkInProgress = _FALSE;
1204
		} else {
1205
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1206
				SwLedOff(Adapter, pLed);
1207
			else {
1208
				if (pLed->bLedOn) {
1209
					pLed->BlinkingLedState = RTW_LED_OFF;
1210
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1211
				} else {
1212
					pLed->BlinkingLedState = RTW_LED_ON;
1213
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR + LED_BLINK_LINK_INTERVAL_NETGEAR);
1214
				}
1215
			}
1216
		}
1217
		break;
1218

1219
	case LED_BLINK_WPS:
1220
		if (pLed->bLedOn) {
1221
			pLed->BlinkingLedState = RTW_LED_OFF;
1222
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1223
		} else {
1224
			pLed->BlinkingLedState = RTW_LED_ON;
1225
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL + LED_BLINK_LINK_INTERVAL_NETGEAR);
1226
		}
1227
		break;
1228

1229
	case LED_BLINK_WPS_STOP:	/* WPS authentication fail */
1230
		if (pLed->bLedOn)
1231
			pLed->BlinkingLedState = RTW_LED_OFF;
1232
		else
1233
			pLed->BlinkingLedState = RTW_LED_ON;
1234

1235
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1236
		break;
1237

1238
	case LED_BLINK_WPS_STOP_OVERLAP:	/* WPS session overlap */
1239
		pLed->BlinkTimes--;
1240
		pLed->BlinkCounter--;
1241
		if (pLed->BlinkCounter == 0) {
1242
			pLed->BlinkingLedState = RTW_LED_OFF;
1243
			pLed->CurrLedState = RTW_LED_OFF;
1244
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1245
		} else {
1246
			if (pLed->BlinkTimes == 0) {
1247
				if (pLed->bLedOn)
1248
					pLed->BlinkTimes = 1;
1249
				else
1250
					bStopBlinking = _TRUE;
1251
			}
1252

1253
			if (bStopBlinking) {
1254
				pLed->BlinkTimes = 10;
1255
				pLed->BlinkingLedState = RTW_LED_ON;
1256
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1257
			} else {
1258
				if (pLed->bLedOn)
1259
					pLed->BlinkingLedState = RTW_LED_OFF;
1260
				else
1261
					pLed->BlinkingLedState = RTW_LED_ON;
1262

1263
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1264
			}
1265
		}
1266
		break;
1267

1268
	case LED_BLINK_ALWAYS_ON:
1269
		pLed->BlinkTimes--;
1270
		if (pLed->BlinkTimes == 0)
1271
			bStopBlinking = _TRUE;
1272
		if (bStopBlinking) {
1273
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1274
				SwLedOff(Adapter, pLed);
1275
			else {
1276
				if (IS_HARDWARE_TYPE_8812AU(Adapter)) {
1277
					pLed->BlinkingLedState = RTW_LED_ON;
1278
					pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
1279
				} else {
1280
					pLed->bLedNoLinkBlinkInProgress = _TRUE;
1281
					pLed->CurrLedState = LED_BLINK_SLOWLY;
1282
					if (pLed->bLedOn)
1283
						pLed->BlinkingLedState = RTW_LED_OFF;
1284
					else
1285
						pLed->BlinkingLedState = RTW_LED_ON;
1286
				}
1287
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1288
			}
1289
			pLed->bLedBlinkInProgress = _FALSE;
1290
		} else {
1291
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
1292
				SwLedOff(Adapter, pLed);
1293
			} else {
1294
				if (IS_HARDWARE_TYPE_8812AU(Adapter))
1295
					pLed->BlinkingLedState = RTW_LED_ON;
1296
				else {
1297
					if (pLed->bLedOn)
1298
						pLed->BlinkingLedState = RTW_LED_OFF;
1299
					else
1300
						pLed->BlinkingLedState = RTW_LED_ON;
1301
				}
1302
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1303
			}
1304
		}
1305
		break;
1306

1307
	case LED_BLINK_LINK_IN_PROCESS:
1308
		if (pLed->bLedOn) {
1309
			pLed->BlinkingLedState = RTW_LED_OFF;
1310
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);
1311
		} else {
1312
			pLed->BlinkingLedState = RTW_LED_ON;
1313
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);
1314
		}
1315
		break;
1316

1317
	case LED_BLINK_AUTH_ERROR:
1318
		pLed->BlinkTimes--;
1319
		if (pLed->BlinkTimes == 0)
1320
			bStopBlinking = _TRUE;
1321
		if (bStopBlinking == _FALSE) {
1322
			if (pLed->bLedOn) {
1323
				pLed->BlinkingLedState = RTW_LED_OFF;
1324
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1325
			} else {
1326
				pLed->BlinkingLedState = RTW_LED_ON;
1327
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1328
			}
1329
		} else {
1330
			pLed->CurrLedState = RTW_LED_OFF;
1331
			pLed->BlinkingLedState = RTW_LED_OFF;
1332
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1333
		}
1334
		break;
1335

1336
	default:
1337
		break;
1338
	}
1339

1340

1341
}
1342

1343
void
1344
SwLedBlink11(
1345
	PLED_USB			pLed
1346
)
1347
{
1348
	PADAPTER Adapter = pLed->padapter;
1349
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
1350
	BOOLEAN bStopBlinking = _FALSE;
1351

1352
	/* Change LED according to BlinkingLedState specified. */
1353
	if (pLed->BlinkingLedState == RTW_LED_ON) {
1354
		SwLedOn(Adapter, pLed);
1355
	} else {
1356
		SwLedOff(Adapter, pLed);
1357
	}
1358

1359
	switch (pLed->CurrLedState) {
1360
	case LED_BLINK_TXRX:
1361
		if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1362
			SwLedOff(Adapter, pLed);
1363
		else {
1364
			if (pLed->bLedOn)
1365
				pLed->BlinkingLedState = RTW_LED_OFF;
1366
			else
1367
				pLed->BlinkingLedState = RTW_LED_ON;
1368
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1369
		}
1370

1371
		break;
1372

1373
	case LED_BLINK_WPS:
1374
		if (pLed->BlinkTimes == 5) {
1375
			SwLedOn(Adapter, pLed);
1376
			_set_timer(&(pLed->BlinkTimer), LED_CM11_LINK_ON_INTERVEL);
1377
		} else {
1378
			if (pLed->bLedOn) {
1379
				pLed->BlinkingLedState = RTW_LED_OFF;
1380
				_set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1381
			} else {
1382
				pLed->BlinkingLedState = RTW_LED_ON;
1383
				_set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1384
			}
1385
		}
1386
		pLed->BlinkTimes--;
1387
		if (pLed->BlinkTimes == 0)
1388
			bStopBlinking = _TRUE;
1389
		if (bStopBlinking == _TRUE)
1390
			pLed->BlinkTimes = 5;
1391
		break;
1392

1393
	case LED_BLINK_WPS_STOP:	/* WPS authentication fail */
1394
		if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
1395
			if (pLed->bLedOn)
1396
				pLed->BlinkingLedState = RTW_LED_OFF;
1397
			else
1398
				pLed->BlinkingLedState = RTW_LED_ON;
1399
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1400
		} else {
1401
			pLed->CurrLedState = RTW_LED_ON;
1402
			pLed->BlinkingLedState = RTW_LED_ON;
1403
			SwLedOn(Adapter, pLed);
1404
			_set_timer(&(pLed->BlinkTimer), 0);
1405
		}
1406
		break;
1407

1408
	default:
1409
		break;
1410
	}
1411

1412
}
1413

1414
void
1415
SwLedBlink12(
1416
	PLED_USB			pLed
1417
)
1418
{
1419
	PADAPTER Adapter = pLed->padapter;
1420
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
1421
	BOOLEAN bStopBlinking = _FALSE;
1422

1423
	/* Change LED according to BlinkingLedState specified. */
1424
	if (pLed->BlinkingLedState == RTW_LED_ON) {
1425
		SwLedOn(Adapter, pLed);
1426
	} else {
1427
		SwLedOff(Adapter, pLed);
1428
	}
1429

1430
	switch (pLed->CurrLedState) {
1431
	case LED_BLINK_SLOWLY:
1432
		if (pLed->bLedOn)
1433
			pLed->BlinkingLedState = RTW_LED_OFF;
1434
		else
1435
			pLed->BlinkingLedState = RTW_LED_ON;
1436
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1437
		break;
1438

1439
	case LED_BLINK_TXRX:
1440
		pLed->BlinkTimes--;
1441
		if (pLed->BlinkTimes == 0)
1442
			bStopBlinking = _TRUE;
1443

1444
		if (bStopBlinking) {
1445
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
1446
				pLed->CurrLedState = RTW_LED_OFF;
1447
				pLed->BlinkingLedState = RTW_LED_OFF;
1448
				if (pLed->bLedOn)
1449
					SwLedOff(Adapter, pLed);
1450
			} else {
1451
				pLed->bLedNoLinkBlinkInProgress = _TRUE;
1452
				pLed->CurrLedState = LED_BLINK_SLOWLY;
1453
				if (pLed->bLedOn)
1454
					pLed->BlinkingLedState = RTW_LED_OFF;
1455
				else
1456
					pLed->BlinkingLedState = RTW_LED_ON;
1457
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1458
			}
1459

1460
			pLed->bLedBlinkInProgress = _FALSE;
1461
		} else {
1462
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1463
				SwLedOff(Adapter, pLed);
1464
			else {
1465
				if (pLed->bLedOn)
1466
					pLed->BlinkingLedState = RTW_LED_OFF;
1467
				else
1468
					pLed->BlinkingLedState = RTW_LED_ON;
1469
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1470
			}
1471
		}
1472
		break;
1473

1474
	default:
1475
		break;
1476
	}
1477

1478

1479

1480
}
1481

1482
void
1483
SwLedBlink13(
1484
	PLED_USB			pLed
1485
)
1486
{
1487
	PADAPTER Adapter = pLed->padapter;
1488
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
1489
	BOOLEAN bStopBlinking = _FALSE;
1490
	static u8	LinkBlinkCnt = 0;
1491

1492
	/* Change LED according to BlinkingLedState specified. */
1493
	if (pLed->BlinkingLedState == RTW_LED_ON) {
1494
		SwLedOn(Adapter, pLed);
1495
	} else {
1496
		if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
1497
			SwLedOff(Adapter, pLed);
1498
	}
1499
	switch (pLed->CurrLedState) {
1500
	case LED_BLINK_LINK_IN_PROCESS:
1501
		if (!pLed->bLedWPSBlinkInProgress)
1502
			LinkBlinkCnt++;
1503

1504
		if (LinkBlinkCnt > 15) {
1505
			LinkBlinkCnt = 0;
1506
			pLed->bLedBlinkInProgress = _FALSE;
1507
			break;
1508
		}
1509
		if (pLed->bLedOn) {
1510
			pLed->BlinkingLedState = RTW_LED_OFF;
1511
			_set_timer(&(pLed->BlinkTimer), 500);
1512
		} else {
1513
			pLed->BlinkingLedState = RTW_LED_ON;
1514
			_set_timer(&(pLed->BlinkTimer), 500);
1515
		}
1516

1517
		break;
1518

1519
	case LED_BLINK_WPS:
1520
		if (pLed->bLedOn) {
1521
			pLed->BlinkingLedState = RTW_LED_OFF;
1522
			_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
1523
		} else {
1524
			pLed->BlinkingLedState = RTW_LED_ON;
1525
			_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
1526
		}
1527

1528
		break;
1529

1530
	case LED_BLINK_WPS_STOP:	/* WPS success */
1531
		SwLedOff(Adapter, pLed);
1532
		pLed->bLedWPSBlinkInProgress = _FALSE;
1533
		break;
1534

1535
	default:
1536
		LinkBlinkCnt = 0;
1537
		break;
1538
	}
1539

1540

1541
}
1542

1543
void
1544
SwLedBlink14(
1545
	PLED_USB			pLed
1546
)
1547
{
1548
	PADAPTER Adapter = pLed->padapter;
1549
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
1550
	BOOLEAN bStopBlinking = _FALSE;
1551
	static u8	LinkBlinkCnt = 0;
1552

1553
	/* Change LED according to BlinkingLedState specified. */
1554
	if (pLed->BlinkingLedState == RTW_LED_ON) {
1555
		SwLedOn(Adapter, pLed);
1556
	} else {
1557
		if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
1558
			SwLedOff(Adapter, pLed);
1559
	}
1560
	switch (pLed->CurrLedState) {
1561
	case LED_BLINK_TXRX:
1562
		pLed->BlinkTimes--;
1563
		if (pLed->BlinkTimes == 0)
1564
			bStopBlinking = _TRUE;
1565
		if (bStopBlinking) {
1566
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1567
				SwLedOff(Adapter, pLed);
1568
			else
1569
				SwLedOn(Adapter, pLed);
1570
			pLed->bLedBlinkInProgress = _FALSE;
1571
		} else {
1572
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1573
				SwLedOff(Adapter, pLed);
1574
			else {
1575
				if (pLed->bLedOn) {
1576
					pLed->BlinkingLedState = RTW_LED_OFF;
1577
					if (IS_HARDWARE_TYPE_8812AU(Adapter))
1578
						_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1579
					else
1580
						_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1581
				} else {
1582
					pLed->BlinkingLedState = RTW_LED_ON;
1583
					if (IS_HARDWARE_TYPE_8812AU(Adapter))
1584
						_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1585
					else
1586
						_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1587
				}
1588
			}
1589
		}
1590

1591
		break;
1592

1593
	default:
1594
		LinkBlinkCnt = 0;
1595
		break;
1596
	}
1597

1598
}
1599

1600
void
1601
SwLedBlink15(
1602
	PLED_USB			pLed
1603
)
1604
{
1605
	PADAPTER Adapter = pLed->padapter;
1606
	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);
1607
	BOOLEAN bStopBlinking = _FALSE;
1608
	static u8	LinkBlinkCnt = 0;
1609
	/* Change LED according to BlinkingLedState specified. */
1610

1611
	if (pLed->BlinkingLedState == RTW_LED_ON) {
1612
		SwLedOn(Adapter, pLed);
1613
	} else {
1614
		if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
1615
			SwLedOff(Adapter, pLed);
1616
	}
1617
	switch (pLed->CurrLedState) {
1618
	case LED_BLINK_WPS:
1619
		if (pLed->bLedOn) {
1620
			pLed->BlinkingLedState = RTW_LED_OFF;
1621
			_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_DLINK);
1622
		} else {
1623
			pLed->BlinkingLedState = RTW_LED_ON;
1624
			_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_DLINK);
1625
		}
1626
		break;
1627

1628
	case LED_BLINK_WPS_STOP:	/* WPS success */
1629

1630
		if (pLed->BlinkingLedState == RTW_LED_OFF) {
1631
			pLed->bLedWPSBlinkInProgress = _FALSE;
1632
			return;
1633
		}
1634

1635
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
1636
		pLed->BlinkingLedState = RTW_LED_OFF;
1637

1638
		_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_LINKED_ON_INTERVAL_DLINK);
1639
		break;
1640

1641
	case LED_BLINK_NO_LINK: {
1642
		static BOOLEAN		bLedOn = _TRUE;
1643
		if (bLedOn) {
1644
			bLedOn = _FALSE;
1645
			pLed->BlinkingLedState = RTW_LED_OFF;
1646
		} else {
1647
			bLedOn = _TRUE;
1648
			pLed->BlinkingLedState = RTW_LED_ON;
1649
		}
1650
		pLed->bLedBlinkInProgress = _TRUE;
1651
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL);
1652
	}
1653
	break;
1654

1655
	case LED_BLINK_LINK_IDEL: {
1656
		static BOOLEAN		bLedOn = _TRUE;
1657
		if (bLedOn) {
1658
			bLedOn = _FALSE;
1659
			pLed->BlinkingLedState = RTW_LED_OFF;
1660
		} else {
1661
			bLedOn = _TRUE;
1662
			pLed->BlinkingLedState = RTW_LED_ON;
1663

1664
		}
1665
		pLed->bLedBlinkInProgress = _TRUE;
1666
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_IDEL_INTERVAL);
1667
	}
1668
	break;
1669

1670
	case LED_BLINK_SCAN: {
1671
		static u8	BlinkTime = 0;
1672
		if (BlinkTime % 2 == 0)
1673
			pLed->BlinkingLedState = RTW_LED_ON;
1674
		else
1675
			pLed->BlinkingLedState = RTW_LED_OFF;
1676
		BlinkTime++;
1677

1678
		if (BlinkTime < 24) {
1679
			pLed->bLedBlinkInProgress = _TRUE;
1680

1681
			if (pLed->BlinkingLedState == RTW_LED_ON)
1682
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_OFF_INTERVAL);
1683
			else
1684
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_ON_INTERVAL);
1685
		} else {
1686
			/* if(pLed->OLDLedState ==LED_NO_LINK_BLINK) */
1687
			if (check_fwstate(pmlmepriv, _FW_LINKED) == _FALSE) {
1688
				pLed->CurrLedState = LED_BLINK_NO_LINK;
1689
				pLed->BlinkingLedState = RTW_LED_ON;
1690

1691
				_set_timer(&(pLed->BlinkTimer), 100);
1692
			}
1693
			BlinkTime = 0;
1694
		}
1695
	}
1696
	break;
1697

1698
	case LED_BLINK_TXRX:
1699
		pLed->BlinkTimes--;
1700
		if (pLed->BlinkTimes == 0)
1701
			bStopBlinking = _TRUE;
1702
		if (bStopBlinking) {
1703
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1704
				SwLedOff(Adapter, pLed);
1705
			else
1706
				SwLedOn(Adapter, pLed);
1707
			pLed->bLedBlinkInProgress = _FALSE;
1708
		} else {
1709
			if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1710
				SwLedOff(Adapter, pLed);
1711
			else {
1712
				if (pLed->bLedOn)
1713
					pLed->BlinkingLedState = RTW_LED_OFF;
1714
				else
1715
					pLed->BlinkingLedState = RTW_LED_ON;
1716
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1717
			}
1718
		}
1719
		break;
1720

1721
	default:
1722
		LinkBlinkCnt = 0;
1723
		break;
1724
	}
1725

1726
}
1727

1728
/*
1729
 *	Description:
1730
 *		Handler function of LED Blinking.
1731
 *		We dispatch acture LED blink action according to LedStrategy.
1732
 *   */
1733
void BlinkHandler(PLED_USB pLed)
1734
{
1735
	_adapter		*padapter = pLed->padapter;
1736
	struct led_priv	*ledpriv = adapter_to_led(padapter);
1737

1738
	/* RTW_INFO("%s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); */
1739

1740
	if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
1741
		/*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
1742
		, __func__
1743
		, rtw_is_drv_stopped(padapter)?"True":"False"
1744
		, rtw_is_surprise_removed(padapter)?"True":"False" );*/
1745
		return;
1746
	}
1747
	
1748
	#ifdef CONFIG_SW_LED
1749
	if (padapter->registrypriv.led_ctrl != 1) {
1750
		if (padapter->registrypriv.led_ctrl == 0)
1751
		{
1752
			// Cause LED to be always off
1753
			pLed->BlinkingLedState = RTW_LED_OFF;
1754
		} else {
1755
			// Cause LED to be always on for led_ctrl 2 or greater
1756
			pLed->BlinkingLedState = RTW_LED_ON;
1757
		}
1758
		// Skip various switch cases where SwLedBlink*() called below
1759
		pLed->CurrLedState = LED_UNKNOWN;
1760
	}
1761
	#endif
1762

1763
	switch (ledpriv->LedStrategy) {
1764
	#if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
1765
	case SW_LED_MODE_UC_TRX_ONLY:
1766
		rtw_sw_led_blink_uc_trx_only(pLed);
1767
		break;
1768
	#endif
1769

1770
	case SW_LED_MODE0:
1771
		SwLedBlink(pLed);
1772
		break;
1773

1774
	case SW_LED_MODE1:
1775
		SwLedBlink1(pLed);
1776
		break;
1777

1778
	case SW_LED_MODE2:
1779
		SwLedBlink2(pLed);
1780
		break;
1781

1782
	case SW_LED_MODE3:
1783
		SwLedBlink3(pLed);
1784
		break;
1785

1786
	case SW_LED_MODE4:
1787
		SwLedBlink4(pLed);
1788
		break;
1789

1790
	case SW_LED_MODE5:
1791
		SwLedBlink5(pLed);
1792
		break;
1793

1794
	case SW_LED_MODE6:
1795
		SwLedBlink6(pLed);
1796
		break;
1797

1798
	case SW_LED_MODE7:
1799
		SwLedBlink7(pLed);
1800
		break;
1801

1802
	case SW_LED_MODE8:
1803
		SwLedBlink8(pLed);
1804
		break;
1805

1806
	case SW_LED_MODE9:
1807
		SwLedBlink9(pLed);
1808
		break;
1809

1810
	case SW_LED_MODE10:
1811
		SwLedBlink10(pLed);
1812
		break;
1813

1814
	case SW_LED_MODE11:
1815
		SwLedBlink11(pLed);
1816
		break;
1817

1818
	case SW_LED_MODE12:
1819
		SwLedBlink12(pLed);
1820
		break;
1821

1822
	case SW_LED_MODE13:
1823
		SwLedBlink13(pLed);
1824
		break;
1825

1826
	case SW_LED_MODE14:
1827
		SwLedBlink14(pLed);
1828
		break;
1829

1830
	case SW_LED_MODE15:
1831
		SwLedBlink15(pLed);
1832
		break;
1833

1834
	default:
1835
		/* SwLedBlink(pLed); */
1836
		break;
1837
	}
1838
}
1839

1840
/*
1841
 *	Description:
1842
 *		Callback function of LED BlinkTimer,
1843
 *		it just schedules to corresponding BlinkWorkItem/led_blink_hdl
1844
 *   */
1845
void BlinkTimerCallback(void *data)
1846
{
1847
	PLED_USB	 pLed = (PLED_USB)data;
1848
	_adapter		*padapter = pLed->padapter;
1849

1850
	/* RTW_INFO("%s\n", __FUNCTION__); */
1851

1852
	if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
1853
		/*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
1854
			, __func__
1855
			, rtw_is_drv_stopped(padapter)?"True":"False"
1856
			, rtw_is_surprise_removed(padapter)?"True":"False" );*/
1857
		return;
1858
	}
1859

1860
#ifdef CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD
1861
	rtw_led_blink_cmd(padapter, (void *)pLed);
1862
#else
1863
	_set_workitem(&(pLed->BlinkWorkItem));
1864
#endif
1865
}
1866

1867
/*
1868
 *	Description:
1869
 *		Callback function of LED BlinkWorkItem.
1870
 *		We dispatch acture LED blink action according to LedStrategy.
1871
 *   */
1872
void BlinkWorkItemCallback(_workitem *work)
1873
{
1874
	PLED_USB	 pLed = container_of(work, LED_USB, BlinkWorkItem);
1875
	BlinkHandler(pLed);
1876
}
1877

1878
static void
1879
SwLedControlMode0(
1880
	_adapter		*padapter,
1881
	LED_CTL_MODE		LedAction
1882
)
1883
{
1884
	struct led_priv	*ledpriv = adapter_to_led(padapter);
1885
	PLED_USB	pLed = &(ledpriv->SwLed1);
1886

1887
	/* Decide led state */
1888
	switch (LedAction) {
1889
	case LED_CTL_TX:
1890
	case LED_CTL_RX:
1891
		if (pLed->bLedBlinkInProgress == _FALSE) {
1892
			pLed->bLedBlinkInProgress = _TRUE;
1893

1894
			pLed->CurrLedState = LED_BLINK_NORMAL;
1895
			pLed->BlinkTimes = 2;
1896

1897
			if (pLed->bLedOn)
1898
				pLed->BlinkingLedState = RTW_LED_OFF;
1899
			else
1900
				pLed->BlinkingLedState = RTW_LED_ON;
1901
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1902
		}
1903
		break;
1904

1905
	case LED_CTL_START_TO_LINK:
1906
		if (pLed->bLedBlinkInProgress == _FALSE) {
1907
			pLed->bLedBlinkInProgress = _TRUE;
1908

1909
			pLed->CurrLedState = LED_BLINK_StartToBlink;
1910
			pLed->BlinkTimes = 24;
1911

1912
			if (pLed->bLedOn)
1913
				pLed->BlinkingLedState = RTW_LED_OFF;
1914
			else
1915
				pLed->BlinkingLedState = RTW_LED_ON;
1916
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1917
		} else
1918
			pLed->CurrLedState = LED_BLINK_StartToBlink;
1919
		break;
1920

1921
	case LED_CTL_LINK:
1922
		pLed->CurrLedState = RTW_LED_ON;
1923
		if (pLed->bLedBlinkInProgress == _FALSE) {
1924
			pLed->BlinkingLedState = RTW_LED_ON;
1925
			_set_timer(&(pLed->BlinkTimer), 0);
1926
		}
1927
		break;
1928

1929
	case LED_CTL_NO_LINK:
1930
		pLed->CurrLedState = RTW_LED_OFF;
1931
		if (pLed->bLedBlinkInProgress == _FALSE) {
1932
			pLed->BlinkingLedState = RTW_LED_OFF;
1933
			_set_timer(&(pLed->BlinkTimer), 0);
1934
		}
1935
		break;
1936

1937
	case LED_CTL_POWER_OFF:
1938
		pLed->CurrLedState = RTW_LED_OFF;
1939
		if (pLed->bLedBlinkInProgress) {
1940
			_cancel_timer_ex(&(pLed->BlinkTimer));
1941
			pLed->bLedBlinkInProgress = _FALSE;
1942
		}
1943
		SwLedOff(padapter, pLed);
1944
		break;
1945

1946
	case LED_CTL_START_WPS:
1947
		if (pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState == RTW_LED_ON) {
1948
			pLed->bLedBlinkInProgress = _TRUE;
1949

1950
			pLed->CurrLedState = LED_BLINK_WPS;
1951
			pLed->BlinkTimes = 20;
1952

1953
			if (pLed->bLedOn) {
1954
				pLed->BlinkingLedState = RTW_LED_OFF;
1955
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
1956
			} else {
1957
				pLed->BlinkingLedState = RTW_LED_ON;
1958
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
1959
			}
1960
		}
1961
		break;
1962

1963
	case LED_CTL_STOP_WPS:
1964
		if (pLed->bLedBlinkInProgress) {
1965
			pLed->CurrLedState = RTW_LED_OFF;
1966
			_cancel_timer_ex(&(pLed->BlinkTimer));
1967
			pLed->bLedBlinkInProgress = _FALSE;
1968
		}
1969
		break;
1970

1971

1972
	default:
1973
		break;
1974
	}
1975

1976

1977
}
1978

1979
/* ALPHA, added by chiyoko, 20090106 */
1980
static void
1981
SwLedControlMode1(
1982
	_adapter		*padapter,
1983
	LED_CTL_MODE		LedAction
1984
)
1985
{
1986
	struct led_priv		*ledpriv = adapter_to_led(padapter);
1987
	PLED_USB			pLed = &(ledpriv->SwLed0);
1988
	struct mlme_priv		*pmlmepriv = &(padapter->mlmepriv);
1989
	PHAL_DATA_TYPE		pHalData = GET_HAL_DATA(padapter);
1990

1991
	u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; /* add by ylb 20121012 for customer led for alpha */
1992
	if (pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)
1993
		uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;
1994

1995
	if (pHalData->CustomerID == RT_CID_819x_CAMEO)
1996
		pLed = &(ledpriv->SwLed1);
1997

1998
	switch (LedAction) {
1999
	case LED_CTL_POWER_ON:
2000
	case LED_CTL_START_TO_LINK:
2001
	case LED_CTL_NO_LINK:
2002
		if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
2003
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2004
				return;
2005
			if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2006
				_cancel_timer_ex(&(pLed->BlinkTimer));
2007
				pLed->bLedLinkBlinkInProgress = _FALSE;
2008
			}
2009
			if (pLed->bLedBlinkInProgress == _TRUE) {
2010
				_cancel_timer_ex(&(pLed->BlinkTimer));
2011
				pLed->bLedBlinkInProgress = _FALSE;
2012
			}
2013

2014
			pLed->bLedNoLinkBlinkInProgress = _TRUE;
2015
			pLed->CurrLedState = LED_BLINK_SLOWLY;
2016
			if (pLed->bLedOn)
2017
				pLed->BlinkingLedState = RTW_LED_OFF;
2018
			else
2019
				pLed->BlinkingLedState = RTW_LED_ON;
2020
			_set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);/* change by ylb 20121012 for customer led for alpha */
2021
		}
2022
		break;
2023

2024
	case LED_CTL_LINK:
2025
		if (pLed->bLedLinkBlinkInProgress == _FALSE) {
2026
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2027
				return;
2028
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2029
				_cancel_timer_ex(&(pLed->BlinkTimer));
2030
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2031
			}
2032
			if (pLed->bLedBlinkInProgress == _TRUE) {
2033
				_cancel_timer_ex(&(pLed->BlinkTimer));
2034
				pLed->bLedBlinkInProgress = _FALSE;
2035
			}
2036
			pLed->bLedLinkBlinkInProgress = _TRUE;
2037
			pLed->CurrLedState = LED_BLINK_NORMAL;
2038
			if (pLed->bLedOn)
2039
				pLed->BlinkingLedState = RTW_LED_OFF;
2040
			else
2041
				pLed->BlinkingLedState = RTW_LED_ON;
2042
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
2043
		}
2044
		break;
2045

2046
	case LED_CTL_SITE_SURVEY:
2047
		if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE))
2048
			;
2049
		else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2050
			if (IS_LED_WPS_BLINKING(pLed))
2051
				return;
2052

2053
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2054
				_cancel_timer_ex(&(pLed->BlinkTimer));
2055
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2056
			}
2057
			if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2058
				_cancel_timer_ex(&(pLed->BlinkTimer));
2059
				pLed->bLedLinkBlinkInProgress = _FALSE;
2060
			}
2061
			if (pLed->bLedBlinkInProgress == _TRUE) {
2062
				_cancel_timer_ex(&(pLed->BlinkTimer));
2063
				pLed->bLedBlinkInProgress = _FALSE;
2064
			}
2065
			pLed->bLedScanBlinkInProgress = _TRUE;
2066
			pLed->CurrLedState = LED_BLINK_SCAN;
2067
			pLed->BlinkTimes = 24;
2068
			if (pLed->bLedOn)
2069
				pLed->BlinkingLedState = RTW_LED_OFF;
2070
			else
2071
				pLed->BlinkingLedState = RTW_LED_ON;
2072

2073
			if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason == RF_CHANGE_BY_IPS)
2074
				_set_timer(&(pLed->BlinkTimer), LED_INITIAL_INTERVAL);
2075
			else
2076
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2077

2078
		}
2079
		break;
2080

2081
	case LED_CTL_TX:
2082
	case LED_CTL_RX:
2083
		if (pLed->bLedBlinkInProgress == _FALSE) {
2084
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2085
				return;
2086
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2087
				_cancel_timer_ex(&(pLed->BlinkTimer));
2088
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2089
			}
2090
			if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2091
				_cancel_timer_ex(&(pLed->BlinkTimer));
2092
				pLed->bLedLinkBlinkInProgress = _FALSE;
2093
			}
2094
			pLed->bLedBlinkInProgress = _TRUE;
2095
			pLed->CurrLedState = LED_BLINK_TXRX;
2096
			pLed->BlinkTimes = 2;
2097
			if (pLed->bLedOn)
2098
				pLed->BlinkingLedState = RTW_LED_OFF;
2099
			else
2100
				pLed->BlinkingLedState = RTW_LED_ON;
2101
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2102
		}
2103
		break;
2104

2105
	case LED_CTL_START_WPS: /* wait until xinpin finish */
2106
	case LED_CTL_START_WPS_BOTTON:
2107
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2108
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2109
				_cancel_timer_ex(&(pLed->BlinkTimer));
2110
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2111
			}
2112
			if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2113
				_cancel_timer_ex(&(pLed->BlinkTimer));
2114
				pLed->bLedLinkBlinkInProgress = _FALSE;
2115
			}
2116
			if (pLed->bLedBlinkInProgress == _TRUE) {
2117
				_cancel_timer_ex(&(pLed->BlinkTimer));
2118
				pLed->bLedBlinkInProgress = _FALSE;
2119
			}
2120
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
2121
				_cancel_timer_ex(&(pLed->BlinkTimer));
2122
				pLed->bLedScanBlinkInProgress = _FALSE;
2123
			}
2124
			pLed->bLedWPSBlinkInProgress = _TRUE;
2125
			pLed->CurrLedState = LED_BLINK_WPS;
2126
			if (pLed->bLedOn)
2127
				pLed->BlinkingLedState = RTW_LED_OFF;
2128
			else
2129
				pLed->BlinkingLedState = RTW_LED_ON;
2130
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2131
		}
2132
		break;
2133

2134

2135
	case LED_CTL_STOP_WPS:
2136
		if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2137
			_cancel_timer_ex(&(pLed->BlinkTimer));
2138
			pLed->bLedNoLinkBlinkInProgress = _FALSE;
2139
		}
2140
		if (pLed->bLedLinkBlinkInProgress == _TRUE) {
2141
			_cancel_timer_ex(&(pLed->BlinkTimer));
2142
			pLed->bLedLinkBlinkInProgress = _FALSE;
2143
		}
2144
		if (pLed->bLedBlinkInProgress == _TRUE) {
2145
			_cancel_timer_ex(&(pLed->BlinkTimer));
2146
			pLed->bLedBlinkInProgress = _FALSE;
2147
		}
2148
		if (pLed->bLedScanBlinkInProgress == _TRUE) {
2149
			_cancel_timer_ex(&(pLed->BlinkTimer));
2150
			pLed->bLedScanBlinkInProgress = _FALSE;
2151
		}
2152
		if (pLed->bLedWPSBlinkInProgress)
2153
			_cancel_timer_ex(&(pLed->BlinkTimer));
2154
		else
2155
			pLed->bLedWPSBlinkInProgress = _TRUE;
2156

2157
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
2158
		if (pLed->bLedOn) {
2159
			pLed->BlinkingLedState = RTW_LED_OFF;
2160
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
2161
		} else {
2162
			pLed->BlinkingLedState = RTW_LED_ON;
2163
			_set_timer(&(pLed->BlinkTimer), 0);
2164
		}
2165
		break;
2166

2167
	case LED_CTL_STOP_WPS_FAIL:
2168
		if (pLed->bLedWPSBlinkInProgress) {
2169
			_cancel_timer_ex(&(pLed->BlinkTimer));
2170
			pLed->bLedWPSBlinkInProgress = _FALSE;
2171
		}
2172

2173
		pLed->bLedNoLinkBlinkInProgress = _TRUE;
2174
		pLed->CurrLedState = LED_BLINK_SLOWLY;
2175
		if (pLed->bLedOn)
2176
			pLed->BlinkingLedState = RTW_LED_OFF;
2177
		else
2178
			pLed->BlinkingLedState = RTW_LED_ON;
2179
		_set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);/* change by ylb 20121012 for customer led for alpha */
2180
		break;
2181

2182
	case LED_CTL_POWER_OFF:
2183
		pLed->CurrLedState = RTW_LED_OFF;
2184
		pLed->BlinkingLedState = RTW_LED_OFF;
2185
		if (pLed->bLedNoLinkBlinkInProgress) {
2186
			_cancel_timer_ex(&(pLed->BlinkTimer));
2187
			pLed->bLedNoLinkBlinkInProgress = _FALSE;
2188
		}
2189
		if (pLed->bLedLinkBlinkInProgress) {
2190
			_cancel_timer_ex(&(pLed->BlinkTimer));
2191
			pLed->bLedLinkBlinkInProgress = _FALSE;
2192
		}
2193
		if (pLed->bLedBlinkInProgress) {
2194
			_cancel_timer_ex(&(pLed->BlinkTimer));
2195
			pLed->bLedBlinkInProgress = _FALSE;
2196
		}
2197
		if (pLed->bLedWPSBlinkInProgress) {
2198
			_cancel_timer_ex(&(pLed->BlinkTimer));
2199
			pLed->bLedWPSBlinkInProgress = _FALSE;
2200
		}
2201
		if (pLed->bLedScanBlinkInProgress) {
2202
			_cancel_timer_ex(&(pLed->BlinkTimer));
2203
			pLed->bLedScanBlinkInProgress = _FALSE;
2204
		}
2205

2206
		SwLedOff(padapter, pLed);
2207
		break;
2208

2209
	default:
2210
		break;
2211

2212
	}
2213

2214
}
2215

2216
/* Arcadyan/Sitecom , added by chiyoko, 20090216 */
2217
static void
2218
SwLedControlMode2(
2219
	_adapter				*padapter,
2220
	LED_CTL_MODE		LedAction
2221
)
2222
{
2223
	struct led_priv	*ledpriv = adapter_to_led(padapter);
2224
	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;
2225
	PLED_USB		pLed = &(ledpriv->SwLed0);
2226

2227
	switch (LedAction) {
2228
	case LED_CTL_SITE_SURVEY:
2229
		if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
2230
			;
2231
		else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2232
			if (IS_LED_WPS_BLINKING(pLed))
2233
				return;
2234

2235
			if (pLed->bLedBlinkInProgress == _TRUE) {
2236
				_cancel_timer_ex(&(pLed->BlinkTimer));
2237
				pLed->bLedBlinkInProgress = _FALSE;
2238
			}
2239
			pLed->bLedScanBlinkInProgress = _TRUE;
2240
			pLed->CurrLedState = LED_BLINK_SCAN;
2241
			pLed->BlinkTimes = 24;
2242
			if (pLed->bLedOn)
2243
				pLed->BlinkingLedState = RTW_LED_OFF;
2244
			else
2245
				pLed->BlinkingLedState = RTW_LED_ON;
2246
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2247
		}
2248
		break;
2249

2250
	case LED_CTL_TX:
2251
	case LED_CTL_RX:
2252
		if ((pLed->bLedBlinkInProgress == _FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
2253
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2254
				return;
2255

2256
			pLed->bLedBlinkInProgress = _TRUE;
2257
			pLed->CurrLedState = LED_BLINK_TXRX;
2258
			pLed->BlinkTimes = 2;
2259
			if (pLed->bLedOn)
2260
				pLed->BlinkingLedState = RTW_LED_OFF;
2261
			else
2262
				pLed->BlinkingLedState = RTW_LED_ON;
2263
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2264
		}
2265
		break;
2266

2267
	case LED_CTL_LINK:
2268
		pLed->CurrLedState = RTW_LED_ON;
2269
		pLed->BlinkingLedState = RTW_LED_ON;
2270
		if (pLed->bLedBlinkInProgress) {
2271
			_cancel_timer_ex(&(pLed->BlinkTimer));
2272
			pLed->bLedBlinkInProgress = _FALSE;
2273
		}
2274
		if (pLed->bLedScanBlinkInProgress) {
2275
			_cancel_timer_ex(&(pLed->BlinkTimer));
2276
			pLed->bLedScanBlinkInProgress = _FALSE;
2277
		}
2278

2279
		_set_timer(&(pLed->BlinkTimer), 0);
2280
		break;
2281

2282
	case LED_CTL_START_WPS: /* wait until xinpin finish */
2283
	case LED_CTL_START_WPS_BOTTON:
2284
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2285
			if (pLed->bLedBlinkInProgress == _TRUE) {
2286
				_cancel_timer_ex(&(pLed->BlinkTimer));
2287
				pLed->bLedBlinkInProgress = _FALSE;
2288
			}
2289
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
2290
				_cancel_timer_ex(&(pLed->BlinkTimer));
2291
				pLed->bLedScanBlinkInProgress = _FALSE;
2292
			}
2293
			pLed->bLedWPSBlinkInProgress = _TRUE;
2294
			pLed->CurrLedState = RTW_LED_ON;
2295
			pLed->BlinkingLedState = RTW_LED_ON;
2296
			_set_timer(&(pLed->BlinkTimer), 0);
2297
		}
2298
		break;
2299

2300
	case LED_CTL_STOP_WPS:
2301
		pLed->bLedWPSBlinkInProgress = _FALSE;
2302
		if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on) {
2303
			pLed->CurrLedState = RTW_LED_OFF;
2304
			pLed->BlinkingLedState = RTW_LED_OFF;
2305
			_set_timer(&(pLed->BlinkTimer), 0);
2306
		} else {
2307
			pLed->CurrLedState = RTW_LED_ON;
2308
			pLed->BlinkingLedState = RTW_LED_ON;
2309
			_set_timer(&(pLed->BlinkTimer), 0);
2310
		}
2311
		break;
2312

2313
	case LED_CTL_STOP_WPS_FAIL:
2314
		pLed->bLedWPSBlinkInProgress = _FALSE;
2315
		pLed->CurrLedState = RTW_LED_OFF;
2316
		pLed->BlinkingLedState = RTW_LED_OFF;
2317
		_set_timer(&(pLed->BlinkTimer), 0);
2318
		break;
2319

2320
	case LED_CTL_START_TO_LINK:
2321
	case LED_CTL_NO_LINK:
2322
		if (!IS_LED_BLINKING(pLed)) {
2323
			pLed->CurrLedState = RTW_LED_OFF;
2324
			pLed->BlinkingLedState = RTW_LED_OFF;
2325
			_set_timer(&(pLed->BlinkTimer), 0);
2326
		}
2327
		break;
2328

2329
	case LED_CTL_POWER_OFF:
2330
		pLed->CurrLedState = RTW_LED_OFF;
2331
		pLed->BlinkingLedState = RTW_LED_OFF;
2332
		if (pLed->bLedBlinkInProgress) {
2333
			_cancel_timer_ex(&(pLed->BlinkTimer));
2334
			pLed->bLedBlinkInProgress = _FALSE;
2335
		}
2336
		if (pLed->bLedScanBlinkInProgress) {
2337
			_cancel_timer_ex(&(pLed->BlinkTimer));
2338
			pLed->bLedScanBlinkInProgress = _FALSE;
2339
		}
2340
		if (pLed->bLedWPSBlinkInProgress) {
2341
			_cancel_timer_ex(&(pLed->BlinkTimer));
2342
			pLed->bLedWPSBlinkInProgress = _FALSE;
2343
		}
2344

2345
		SwLedOff(padapter, pLed);
2346
		break;
2347

2348
	default:
2349
		break;
2350

2351
	}
2352

2353
}
2354

2355
/* COREGA, added by chiyoko, 20090316 */
2356
static void
2357
SwLedControlMode3(
2358
	_adapter				*padapter,
2359
	LED_CTL_MODE		LedAction
2360
)
2361
{
2362
	struct led_priv	*ledpriv = adapter_to_led(padapter);
2363
	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;
2364
	PLED_USB		pLed = &(ledpriv->SwLed0);
2365

2366
	switch (LedAction) {
2367
	case LED_CTL_SITE_SURVEY:
2368
		if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
2369
			;
2370
		else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2371
			if (IS_LED_WPS_BLINKING(pLed))
2372
				return;
2373

2374
			if (pLed->bLedBlinkInProgress == _TRUE) {
2375
				_cancel_timer_ex(&(pLed->BlinkTimer));
2376
				pLed->bLedBlinkInProgress = _FALSE;
2377
			}
2378
			pLed->bLedScanBlinkInProgress = _TRUE;
2379
			pLed->CurrLedState = LED_BLINK_SCAN;
2380
			pLed->BlinkTimes = 24;
2381
			if (pLed->bLedOn)
2382
				pLed->BlinkingLedState = RTW_LED_OFF;
2383
			else
2384
				pLed->BlinkingLedState = RTW_LED_ON;
2385
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2386
		}
2387
		break;
2388

2389
	case LED_CTL_TX:
2390
	case LED_CTL_RX:
2391
		if ((pLed->bLedBlinkInProgress == _FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
2392
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2393
				return;
2394

2395
			pLed->bLedBlinkInProgress = _TRUE;
2396
			pLed->CurrLedState = LED_BLINK_TXRX;
2397
			pLed->BlinkTimes = 2;
2398
			if (pLed->bLedOn)
2399
				pLed->BlinkingLedState = RTW_LED_OFF;
2400
			else
2401
				pLed->BlinkingLedState = RTW_LED_ON;
2402
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2403
		}
2404
		break;
2405

2406
	case LED_CTL_LINK:
2407
		if (IS_LED_WPS_BLINKING(pLed))
2408
			return;
2409

2410
		pLed->CurrLedState = RTW_LED_ON;
2411
		pLed->BlinkingLedState = RTW_LED_ON;
2412
		if (pLed->bLedBlinkInProgress) {
2413
			_cancel_timer_ex(&(pLed->BlinkTimer));
2414
			pLed->bLedBlinkInProgress = _FALSE;
2415
		}
2416
		if (pLed->bLedScanBlinkInProgress) {
2417
			_cancel_timer_ex(&(pLed->BlinkTimer));
2418
			pLed->bLedScanBlinkInProgress = _FALSE;
2419
		}
2420

2421
		_set_timer(&(pLed->BlinkTimer), 0);
2422
		break;
2423

2424
	case LED_CTL_START_WPS: /* wait until xinpin finish */
2425
	case LED_CTL_START_WPS_BOTTON:
2426
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2427
			if (pLed->bLedBlinkInProgress == _TRUE) {
2428
				_cancel_timer_ex(&(pLed->BlinkTimer));
2429
				pLed->bLedBlinkInProgress = _FALSE;
2430
			}
2431
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
2432
				_cancel_timer_ex(&(pLed->BlinkTimer));
2433
				pLed->bLedScanBlinkInProgress = _FALSE;
2434
			}
2435
			pLed->bLedWPSBlinkInProgress = _TRUE;
2436
			pLed->CurrLedState = LED_BLINK_WPS;
2437
			if (pLed->bLedOn)
2438
				pLed->BlinkingLedState = RTW_LED_OFF;
2439
			else
2440
				pLed->BlinkingLedState = RTW_LED_ON;
2441
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2442
		}
2443
		break;
2444

2445
	case LED_CTL_STOP_WPS:
2446
		if (pLed->bLedWPSBlinkInProgress) {
2447
			_cancel_timer_ex(&(pLed->BlinkTimer));
2448
			pLed->bLedWPSBlinkInProgress = _FALSE;
2449
		} else
2450
			pLed->bLedWPSBlinkInProgress = _TRUE;
2451

2452
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
2453
		if (pLed->bLedOn) {
2454
			pLed->BlinkingLedState = RTW_LED_OFF;
2455
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
2456
		} else {
2457
			pLed->BlinkingLedState = RTW_LED_ON;
2458
			_set_timer(&(pLed->BlinkTimer), 0);
2459
		}
2460

2461
		break;
2462

2463
	case LED_CTL_STOP_WPS_FAIL:
2464
		if (pLed->bLedWPSBlinkInProgress) {
2465
			_cancel_timer_ex(&(pLed->BlinkTimer));
2466
			pLed->bLedWPSBlinkInProgress = _FALSE;
2467
		}
2468

2469
		pLed->CurrLedState = RTW_LED_OFF;
2470
		pLed->BlinkingLedState = RTW_LED_OFF;
2471
		_set_timer(&(pLed->BlinkTimer), 0);
2472
		break;
2473

2474
	case LED_CTL_START_TO_LINK:
2475
	case LED_CTL_NO_LINK:
2476
		if (!IS_LED_BLINKING(pLed)) {
2477
			pLed->CurrLedState = RTW_LED_OFF;
2478
			pLed->BlinkingLedState = RTW_LED_OFF;
2479
			_set_timer(&(pLed->BlinkTimer), 0);
2480
		}
2481
		break;
2482

2483
	case LED_CTL_POWER_OFF:
2484
		pLed->CurrLedState = RTW_LED_OFF;
2485
		pLed->BlinkingLedState = RTW_LED_OFF;
2486
		if (pLed->bLedBlinkInProgress) {
2487
			_cancel_timer_ex(&(pLed->BlinkTimer));
2488
			pLed->bLedBlinkInProgress = _FALSE;
2489
		}
2490
		if (pLed->bLedScanBlinkInProgress) {
2491
			_cancel_timer_ex(&(pLed->BlinkTimer));
2492
			pLed->bLedScanBlinkInProgress = _FALSE;
2493
		}
2494
		if (pLed->bLedWPSBlinkInProgress) {
2495
			_cancel_timer_ex(&(pLed->BlinkTimer));
2496
			pLed->bLedWPSBlinkInProgress = _FALSE;
2497
		}
2498

2499
		SwLedOff(padapter, pLed);
2500
		break;
2501

2502
	default:
2503
		break;
2504

2505
	}
2506

2507
}
2508

2509

2510
/* Edimax-Belkin, added by chiyoko, 20090413 */
2511
static void
2512
SwLedControlMode4(
2513
	_adapter				*padapter,
2514
	LED_CTL_MODE		LedAction
2515
)
2516
{
2517
	struct led_priv	*ledpriv = adapter_to_led(padapter);
2518
	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;
2519
	PLED_USB		pLed = &(ledpriv->SwLed0);
2520
	PLED_USB		pLed1 = &(ledpriv->SwLed1);
2521

2522
	switch (LedAction) {
2523
	case LED_CTL_START_TO_LINK:
2524
		if (pLed1->bLedWPSBlinkInProgress) {
2525
			pLed1->bLedWPSBlinkInProgress = _FALSE;
2526
			_cancel_timer_ex(&(pLed1->BlinkTimer));
2527

2528
			pLed1->BlinkingLedState = RTW_LED_OFF;
2529
			pLed1->CurrLedState = RTW_LED_OFF;
2530

2531
			if (pLed1->bLedOn)
2532
				_set_timer(&(pLed->BlinkTimer), 0);
2533
		}
2534

2535
		if (pLed->bLedStartToLinkBlinkInProgress == _FALSE) {
2536
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2537
				return;
2538
			if (pLed->bLedBlinkInProgress == _TRUE) {
2539
				_cancel_timer_ex(&(pLed->BlinkTimer));
2540
				pLed->bLedBlinkInProgress = _FALSE;
2541
			}
2542
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2543
				_cancel_timer_ex(&(pLed->BlinkTimer));
2544
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2545
			}
2546

2547
			pLed->bLedStartToLinkBlinkInProgress = _TRUE;
2548
			pLed->CurrLedState = LED_BLINK_StartToBlink;
2549
			if (pLed->bLedOn) {
2550
				pLed->BlinkingLedState = RTW_LED_OFF;
2551
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2552
			} else {
2553
				pLed->BlinkingLedState = RTW_LED_ON;
2554
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2555
			}
2556
		}
2557
		break;
2558

2559
	case LED_CTL_LINK:
2560
	case LED_CTL_NO_LINK:
2561
		/* LED1 settings */
2562
		if (LedAction == LED_CTL_LINK) {
2563
			if (pLed1->bLedWPSBlinkInProgress) {
2564
				pLed1->bLedWPSBlinkInProgress = _FALSE;
2565
				_cancel_timer_ex(&(pLed1->BlinkTimer));
2566

2567
				pLed1->BlinkingLedState = RTW_LED_OFF;
2568
				pLed1->CurrLedState = RTW_LED_OFF;
2569

2570
				if (pLed1->bLedOn)
2571
					_set_timer(&(pLed->BlinkTimer), 0);
2572
			}
2573
		}
2574

2575
		if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
2576
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2577
				return;
2578
			if (pLed->bLedBlinkInProgress == _TRUE) {
2579
				_cancel_timer_ex(&(pLed->BlinkTimer));
2580
				pLed->bLedBlinkInProgress = _FALSE;
2581
			}
2582

2583
			pLed->bLedNoLinkBlinkInProgress = _TRUE;
2584
			pLed->CurrLedState = LED_BLINK_SLOWLY;
2585
			if (pLed->bLedOn)
2586
				pLed->BlinkingLedState = RTW_LED_OFF;
2587
			else
2588
				pLed->BlinkingLedState = RTW_LED_ON;
2589

2590
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2591
		}
2592
		break;
2593

2594
	case LED_CTL_SITE_SURVEY:
2595
		if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE))
2596
			;
2597
		else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2598
			if (IS_LED_WPS_BLINKING(pLed))
2599
				return;
2600

2601
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2602
				_cancel_timer_ex(&(pLed->BlinkTimer));
2603
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2604
			}
2605
			if (pLed->bLedBlinkInProgress == _TRUE) {
2606
				_cancel_timer_ex(&(pLed->BlinkTimer));
2607
				pLed->bLedBlinkInProgress = _FALSE;
2608
			}
2609
			pLed->bLedScanBlinkInProgress = _TRUE;
2610
			pLed->CurrLedState = LED_BLINK_SCAN;
2611
			pLed->BlinkTimes = 24;
2612
			if (pLed->bLedOn)
2613
				pLed->BlinkingLedState = RTW_LED_OFF;
2614
			else
2615
				pLed->BlinkingLedState = RTW_LED_ON;
2616
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2617
		}
2618
		break;
2619

2620
	case LED_CTL_TX:
2621
	case LED_CTL_RX:
2622
		if (pLed->bLedBlinkInProgress == _FALSE) {
2623
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2624
				return;
2625
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2626
				_cancel_timer_ex(&(pLed->BlinkTimer));
2627
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2628
			}
2629
			pLed->bLedBlinkInProgress = _TRUE;
2630
			pLed->CurrLedState = LED_BLINK_TXRX;
2631
			pLed->BlinkTimes = 2;
2632
			if (pLed->bLedOn)
2633
				pLed->BlinkingLedState = RTW_LED_OFF;
2634
			else
2635
				pLed->BlinkingLedState = RTW_LED_ON;
2636
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2637
		}
2638
		break;
2639

2640
	case LED_CTL_START_WPS: /* wait until xinpin finish */
2641
	case LED_CTL_START_WPS_BOTTON:
2642
		if (pLed1->bLedWPSBlinkInProgress) {
2643
			pLed1->bLedWPSBlinkInProgress = _FALSE;
2644
			_cancel_timer_ex(&(pLed1->BlinkTimer));
2645

2646
			pLed1->BlinkingLedState = RTW_LED_OFF;
2647
			pLed1->CurrLedState = RTW_LED_OFF;
2648

2649
			if (pLed1->bLedOn)
2650
				_set_timer(&(pLed->BlinkTimer), 0);
2651
		}
2652

2653
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2654
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2655
				_cancel_timer_ex(&(pLed->BlinkTimer));
2656
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2657
			}
2658
			if (pLed->bLedBlinkInProgress == _TRUE) {
2659
				_cancel_timer_ex(&(pLed->BlinkTimer));
2660
				pLed->bLedBlinkInProgress = _FALSE;
2661
			}
2662
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
2663
				_cancel_timer_ex(&(pLed->BlinkTimer));
2664
				pLed->bLedScanBlinkInProgress = _FALSE;
2665
			}
2666
			pLed->bLedWPSBlinkInProgress = _TRUE;
2667
			pLed->CurrLedState = LED_BLINK_WPS;
2668
			if (pLed->bLedOn) {
2669
				pLed->BlinkingLedState = RTW_LED_OFF;
2670
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2671
			} else {
2672
				pLed->BlinkingLedState = RTW_LED_ON;
2673
				_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2674
			}
2675
		}
2676
		break;
2677

2678
	case LED_CTL_STOP_WPS:	/* WPS connect success */
2679
		if (pLed->bLedWPSBlinkInProgress) {
2680
			_cancel_timer_ex(&(pLed->BlinkTimer));
2681
			pLed->bLedWPSBlinkInProgress = _FALSE;
2682
		}
2683

2684
		pLed->bLedNoLinkBlinkInProgress = _TRUE;
2685
		pLed->CurrLedState = LED_BLINK_SLOWLY;
2686
		if (pLed->bLedOn)
2687
			pLed->BlinkingLedState = RTW_LED_OFF;
2688
		else
2689
			pLed->BlinkingLedState = RTW_LED_ON;
2690
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2691

2692
		break;
2693

2694
	case LED_CTL_STOP_WPS_FAIL:		/* WPS authentication fail */
2695
		if (pLed->bLedWPSBlinkInProgress) {
2696
			_cancel_timer_ex(&(pLed->BlinkTimer));
2697
			pLed->bLedWPSBlinkInProgress = _FALSE;
2698
		}
2699

2700
		pLed->bLedNoLinkBlinkInProgress = _TRUE;
2701
		pLed->CurrLedState = LED_BLINK_SLOWLY;
2702
		if (pLed->bLedOn)
2703
			pLed->BlinkingLedState = RTW_LED_OFF;
2704
		else
2705
			pLed->BlinkingLedState = RTW_LED_ON;
2706
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2707

2708
		/* LED1 settings */
2709
		if (pLed1->bLedWPSBlinkInProgress)
2710
			_cancel_timer_ex(&(pLed1->BlinkTimer));
2711
		else
2712
			pLed1->bLedWPSBlinkInProgress = _TRUE;
2713

2714
		pLed1->CurrLedState = LED_BLINK_WPS_STOP;
2715
		if (pLed1->bLedOn)
2716
			pLed1->BlinkingLedState = RTW_LED_OFF;
2717
		else
2718
			pLed1->BlinkingLedState = RTW_LED_ON;
2719
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2720

2721
		break;
2722

2723
	case LED_CTL_STOP_WPS_FAIL_OVERLAP:	/* WPS session overlap */
2724
		if (pLed->bLedWPSBlinkInProgress) {
2725
			_cancel_timer_ex(&(pLed->BlinkTimer));
2726
			pLed->bLedWPSBlinkInProgress = _FALSE;
2727
		}
2728

2729
		pLed->bLedNoLinkBlinkInProgress = _TRUE;
2730
		pLed->CurrLedState = LED_BLINK_SLOWLY;
2731
		if (pLed->bLedOn)
2732
			pLed->BlinkingLedState = RTW_LED_OFF;
2733
		else
2734
			pLed->BlinkingLedState = RTW_LED_ON;
2735
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2736

2737
		/* LED1 settings */
2738
		if (pLed1->bLedWPSBlinkInProgress)
2739
			_cancel_timer_ex(&(pLed1->BlinkTimer));
2740
		else
2741
			pLed1->bLedWPSBlinkInProgress = _TRUE;
2742

2743
		pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
2744
		pLed1->BlinkTimes = 10;
2745
		if (pLed1->bLedOn)
2746
			pLed1->BlinkingLedState = RTW_LED_OFF;
2747
		else
2748
			pLed1->BlinkingLedState = RTW_LED_ON;
2749
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2750

2751
		break;
2752

2753
	case LED_CTL_POWER_OFF:
2754
		pLed->CurrLedState = RTW_LED_OFF;
2755
		pLed->BlinkingLedState = RTW_LED_OFF;
2756

2757
		if (pLed->bLedNoLinkBlinkInProgress) {
2758
			_cancel_timer_ex(&(pLed->BlinkTimer));
2759
			pLed->bLedNoLinkBlinkInProgress = _FALSE;
2760
		}
2761
		if (pLed->bLedLinkBlinkInProgress) {
2762
			_cancel_timer_ex(&(pLed->BlinkTimer));
2763
			pLed->bLedLinkBlinkInProgress = _FALSE;
2764
		}
2765
		if (pLed->bLedBlinkInProgress) {
2766
			_cancel_timer_ex(&(pLed->BlinkTimer));
2767
			pLed->bLedBlinkInProgress = _FALSE;
2768
		}
2769
		if (pLed->bLedWPSBlinkInProgress) {
2770
			_cancel_timer_ex(&(pLed->BlinkTimer));
2771
			pLed->bLedWPSBlinkInProgress = _FALSE;
2772
		}
2773
		if (pLed->bLedScanBlinkInProgress) {
2774
			_cancel_timer_ex(&(pLed->BlinkTimer));
2775
			pLed->bLedScanBlinkInProgress = _FALSE;
2776
		}
2777
		if (pLed->bLedStartToLinkBlinkInProgress) {
2778
			_cancel_timer_ex(&(pLed->BlinkTimer));
2779
			pLed->bLedStartToLinkBlinkInProgress = _FALSE;
2780
		}
2781

2782
		if (pLed1->bLedWPSBlinkInProgress) {
2783
			_cancel_timer_ex(&(pLed1->BlinkTimer));
2784
			pLed1->bLedWPSBlinkInProgress = _FALSE;
2785
		}
2786

2787
		pLed1->BlinkingLedState = LED_UNKNOWN;
2788
		SwLedOff(padapter, pLed);
2789
		SwLedOff(padapter, pLed1);
2790
		break;
2791

2792
	case LED_CTL_CONNECTION_NO_TRANSFER:
2793
		if (pLed->bLedBlinkInProgress == _FALSE) {
2794
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
2795
				_cancel_timer_ex(&(pLed->BlinkTimer));
2796
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
2797
			}
2798
			pLed->bLedBlinkInProgress = _TRUE;
2799

2800
			pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
2801
			pLed->BlinkingLedState = RTW_LED_ON;
2802
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2803
		}
2804
		break;
2805

2806
	default:
2807
		break;
2808

2809
	}
2810

2811
}
2812

2813

2814

2815
/* Sercomm-Belkin, added by chiyoko, 20090415 */
2816
static void
2817
SwLedControlMode5(
2818
	_adapter				*padapter,
2819
	LED_CTL_MODE		LedAction
2820
)
2821
{
2822
	struct led_priv	*ledpriv = adapter_to_led(padapter);
2823
	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;
2824
	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(padapter);
2825
	PLED_USB		pLed = &(ledpriv->SwLed0);
2826

2827
	if (pHalData->CustomerID == RT_CID_819x_CAMEO)
2828
		pLed = &(ledpriv->SwLed1);
2829

2830
	switch (LedAction) {
2831
	case LED_CTL_POWER_ON:
2832
	case LED_CTL_NO_LINK:
2833
	case LED_CTL_LINK:	/* solid blue */
2834
		pLed->CurrLedState = RTW_LED_ON;
2835
		pLed->BlinkingLedState = RTW_LED_ON;
2836

2837
		_set_timer(&(pLed->BlinkTimer), 0);
2838
		break;
2839

2840
	case LED_CTL_SITE_SURVEY:
2841
		if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE))
2842
			;
2843
		else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2844
			if (pLed->bLedBlinkInProgress == _TRUE) {
2845
				_cancel_timer_ex(&(pLed->BlinkTimer));
2846
				pLed->bLedBlinkInProgress = _FALSE;
2847
			}
2848
			pLed->bLedScanBlinkInProgress = _TRUE;
2849
			pLed->CurrLedState = LED_BLINK_SCAN;
2850
			pLed->BlinkTimes = 24;
2851
			if (pLed->bLedOn)
2852
				pLed->BlinkingLedState = RTW_LED_OFF;
2853
			else
2854
				pLed->BlinkingLedState = RTW_LED_ON;
2855
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2856
		}
2857
		break;
2858

2859
	case LED_CTL_TX:
2860
	case LED_CTL_RX:
2861
		if (pLed->bLedBlinkInProgress == _FALSE) {
2862
			if (pLed->CurrLedState == LED_BLINK_SCAN)
2863
				return;
2864
			pLed->bLedBlinkInProgress = _TRUE;
2865
			pLed->CurrLedState = LED_BLINK_TXRX;
2866
			pLed->BlinkTimes = 2;
2867
			if (pLed->bLedOn)
2868
				pLed->BlinkingLedState = RTW_LED_OFF;
2869
			else
2870
				pLed->BlinkingLedState = RTW_LED_ON;
2871
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2872
		}
2873
		break;
2874

2875
	case LED_CTL_POWER_OFF:
2876
		pLed->CurrLedState = RTW_LED_OFF;
2877
		pLed->BlinkingLedState = RTW_LED_OFF;
2878

2879
		if (pLed->bLedBlinkInProgress) {
2880
			_cancel_timer_ex(&(pLed->BlinkTimer));
2881
			pLed->bLedBlinkInProgress = _FALSE;
2882
		}
2883

2884
		SwLedOff(padapter, pLed);
2885
		break;
2886

2887
	default:
2888
		break;
2889

2890
	}
2891

2892
}
2893

2894
/* WNC-Corega, added by chiyoko, 20090902 */
2895
static void
2896
SwLedControlMode6(
2897
	_adapter				*padapter,
2898
	LED_CTL_MODE		LedAction
2899
)
2900
{
2901
	struct led_priv	*ledpriv = adapter_to_led(padapter);
2902
	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;
2903
	PLED_USB	pLed0 = &(ledpriv->SwLed0);
2904

2905
	switch (LedAction) {
2906
	case LED_CTL_POWER_ON:
2907
	case LED_CTL_LINK:
2908
	case LED_CTL_NO_LINK:
2909
		_cancel_timer_ex(&(pLed0->BlinkTimer));
2910
		pLed0->CurrLedState = RTW_LED_ON;
2911
		pLed0->BlinkingLedState = RTW_LED_ON;
2912
		_set_timer(&(pLed0->BlinkTimer), 0);
2913
		break;
2914

2915
	case LED_CTL_POWER_OFF:
2916
		SwLedOff(padapter, pLed0);
2917
		break;
2918

2919
	default:
2920
		break;
2921
	}
2922

2923
}
2924

2925
/* Netgear, added by sinda, 2011/11/11 */
2926
void
2927
SwLedControlMode7(
2928
	PADAPTER			 Adapter,
2929
	LED_CTL_MODE		 LedAction
2930
)
2931
{
2932
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
2933
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
2934
	PLED_USB	pLed = &(ledpriv->SwLed0);
2935

2936
	switch (LedAction) {
2937
	case LED_CTL_SITE_SURVEY:
2938
		if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
2939
			;
2940
		else if (pLed->bLedScanBlinkInProgress == _FALSE) {
2941
			if (IS_LED_WPS_BLINKING(pLed))
2942
				return;
2943

2944
			if (pLed->bLedBlinkInProgress == _TRUE) {
2945
				_cancel_timer_ex(&(pLed->BlinkTimer));
2946
				pLed->bLedBlinkInProgress = _FALSE;
2947
			}
2948
			pLed->bLedScanBlinkInProgress = _TRUE;
2949
			pLed->CurrLedState = LED_BLINK_SCAN;
2950
			pLed->BlinkTimes = 6;
2951
			if (pLed->bLedOn)
2952
				pLed->BlinkingLedState = RTW_LED_OFF;
2953
			else
2954
				pLed->BlinkingLedState = RTW_LED_ON;
2955
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
2956
		}
2957
		break;
2958

2959
	case LED_CTL_LINK:
2960
		if (IS_LED_WPS_BLINKING(pLed))
2961
			return;
2962

2963
		pLed->CurrLedState = RTW_LED_ON;
2964
		pLed->BlinkingLedState = RTW_LED_ON;
2965
		if (pLed->bLedBlinkInProgress) {
2966
			_cancel_timer_ex(&(pLed->BlinkTimer));
2967
			pLed->bLedBlinkInProgress = _FALSE;
2968
		}
2969
		if (pLed->bLedScanBlinkInProgress) {
2970
			_cancel_timer_ex(&(pLed->BlinkTimer));
2971
			pLed->bLedScanBlinkInProgress = _FALSE;
2972
		}
2973

2974
		_set_timer(&(pLed->BlinkTimer), 0);
2975
		break;
2976

2977
	case LED_CTL_START_WPS: /* wait until xinpin finish */
2978
	case LED_CTL_START_WPS_BOTTON:
2979
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
2980
			if (pLed->bLedBlinkInProgress == _TRUE) {
2981
				_cancel_timer_ex(&(pLed->BlinkTimer));
2982
				pLed->bLedBlinkInProgress = _FALSE;
2983
			}
2984
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
2985
				_cancel_timer_ex(&(pLed->BlinkTimer));
2986
				pLed->bLedScanBlinkInProgress = _FALSE;
2987
			}
2988
			pLed->bLedWPSBlinkInProgress = _TRUE;
2989
			pLed->CurrLedState = LED_BLINK_WPS;
2990
			if (pLed->bLedOn)
2991
				pLed->BlinkingLedState = RTW_LED_OFF;
2992
			else
2993
				pLed->BlinkingLedState = RTW_LED_ON;
2994
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
2995
		}
2996
		break;
2997

2998
	case LED_CTL_STOP_WPS:
2999
		if (pLed->bLedWPSBlinkInProgress) {
3000
			_cancel_timer_ex(&(pLed->BlinkTimer));
3001
			pLed->bLedWPSBlinkInProgress = _FALSE;
3002
		} else
3003
			pLed->bLedWPSBlinkInProgress = _TRUE;
3004

3005
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
3006
		if (pLed->bLedOn) {
3007
			pLed->BlinkingLedState = RTW_LED_OFF;
3008
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
3009
		} else {
3010
			pLed->BlinkingLedState = RTW_LED_ON;
3011
			_set_timer(&(pLed->BlinkTimer), 0);
3012
		}
3013

3014
		break;
3015

3016

3017
	case LED_CTL_STOP_WPS_FAIL:
3018
	case LED_CTL_STOP_WPS_FAIL_OVERLAP:	/* WPS session overlap			 */
3019
		if (pLed->bLedWPSBlinkInProgress) {
3020
			_cancel_timer_ex(&(pLed->BlinkTimer));
3021
			pLed->bLedWPSBlinkInProgress = _FALSE;
3022
		}
3023

3024
		pLed->CurrLedState = RTW_LED_OFF;
3025
		pLed->BlinkingLedState = RTW_LED_OFF;
3026
		_set_timer(&(pLed->BlinkTimer), 0);
3027
		break;
3028

3029
	case LED_CTL_START_TO_LINK:
3030
	case LED_CTL_NO_LINK:
3031
		if (!IS_LED_BLINKING(pLed)) {
3032
			pLed->CurrLedState = RTW_LED_OFF;
3033
			pLed->BlinkingLedState = RTW_LED_OFF;
3034
			_set_timer(&(pLed->BlinkTimer), 0);
3035
		}
3036
		break;
3037

3038
	case LED_CTL_POWER_OFF:
3039
	case LED_CTL_POWER_ON:
3040
		pLed->CurrLedState = RTW_LED_OFF;
3041
		pLed->BlinkingLedState = RTW_LED_OFF;
3042
		if (pLed->bLedBlinkInProgress) {
3043
			_cancel_timer_ex(&(pLed->BlinkTimer));
3044
			pLed->bLedBlinkInProgress = _FALSE;
3045
		}
3046
		if (pLed->bLedScanBlinkInProgress) {
3047
			_cancel_timer_ex(&(pLed->BlinkTimer));
3048
			pLed->bLedScanBlinkInProgress = _FALSE;
3049
		}
3050
		if (pLed->bLedWPSBlinkInProgress) {
3051
			_cancel_timer_ex(&(pLed->BlinkTimer));
3052
			pLed->bLedWPSBlinkInProgress = _FALSE;
3053
		}
3054

3055
		_set_timer(&(pLed->BlinkTimer), 0);
3056
		break;
3057

3058
	default:
3059
		break;
3060

3061
	}
3062

3063
}
3064

3065
void
3066
SwLedControlMode8(
3067
	PADAPTER			Adapter,
3068
	LED_CTL_MODE		LedAction
3069
)
3070
{
3071
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3072
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3073
	PLED_USB	pLed0 = &(ledpriv->SwLed0);
3074

3075
	switch (LedAction) {
3076
	case LED_CTL_LINK:
3077
		_cancel_timer_ex(&(pLed0->BlinkTimer));
3078
		pLed0->CurrLedState = RTW_LED_ON;
3079
		pLed0->BlinkingLedState = RTW_LED_ON;
3080
		_set_timer(&(pLed0->BlinkTimer), 0);
3081
		break;
3082

3083
	case LED_CTL_NO_LINK:
3084
		_cancel_timer_ex(&(pLed0->BlinkTimer));
3085
		pLed0->CurrLedState = RTW_LED_OFF;
3086
		pLed0->BlinkingLedState = RTW_LED_OFF;
3087
		_set_timer(&(pLed0->BlinkTimer), 0);
3088
		break;
3089

3090
	case LED_CTL_POWER_OFF:
3091
		SwLedOff(Adapter, pLed0);
3092
		break;
3093

3094
	default:
3095
		break;
3096
	}
3097

3098

3099
}
3100

3101
/* page added for Belkin AC950, 20120813 */
3102
void
3103
SwLedControlMode9(
3104
		PADAPTER			Adapter,
3105
		LED_CTL_MODE		LedAction
3106
)
3107
{
3108
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3109
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3110
	PLED_USB	pLed = &(ledpriv->SwLed0);
3111
	PLED_USB	pLed1 = &(ledpriv->SwLed1);
3112
	PLED_USB	pLed2 = &(ledpriv->SwLed2);
3113
	BOOLEAN  bWPSOverLap = _FALSE;
3114
	/* RTW_INFO("LedAction=%d\n", LedAction); */
3115
	switch (LedAction) {
3116
	case LED_CTL_START_TO_LINK:
3117
		if (pLed2->bLedBlinkInProgress == _FALSE) {
3118
			pLed2->bLedBlinkInProgress = _TRUE;
3119
			pLed2->BlinkingLedState = RTW_LED_ON;
3120
			pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3121

3122
			_set_timer(&(pLed2->BlinkTimer), 0);
3123
		}
3124
		break;
3125

3126
	case LED_CTL_LINK:
3127
	case LED_CTL_NO_LINK:
3128
		/* LED1 settings */
3129
		if (LedAction == LED_CTL_NO_LINK) {
3130
			/* if(pMgntInfo->AuthStatus == AUTH_STATUS_FAILED) */
3131
			if (0) {
3132
				pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;
3133
				if (pLed1->bLedOn)
3134
					pLed1->BlinkingLedState = RTW_LED_OFF;
3135
				else
3136
					pLed1->BlinkingLedState = RTW_LED_ON;
3137
				_set_timer(&(pLed1->BlinkTimer), 0);
3138
			} else {
3139
				pLed1->CurrLedState = RTW_LED_OFF;
3140
				pLed1->BlinkingLedState = RTW_LED_OFF;
3141
				if (pLed1->bLedOn)
3142
					_set_timer(&(pLed1->BlinkTimer), 0);
3143
			}
3144
		} else {
3145
			pLed1->CurrLedState = RTW_LED_OFF;
3146
			pLed1->BlinkingLedState = RTW_LED_OFF;
3147
			if (pLed1->bLedOn)
3148
				_set_timer(&(pLed1->BlinkTimer), 0);
3149
		}
3150

3151
		/* LED2 settings */
3152
		if (LedAction == LED_CTL_LINK) {
3153
			if (Adapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_) {
3154
				if (pLed2->bLedBlinkInProgress == _TRUE) {
3155
					_cancel_timer_ex(&(pLed2->BlinkTimer));
3156
					pLed2->bLedBlinkInProgress = _FALSE;
3157
				}
3158
				pLed2->CurrLedState = RTW_LED_ON;
3159
				pLed2->bLedNoLinkBlinkInProgress = _TRUE;
3160
				if (!pLed2->bLedOn)
3161
					_set_timer(&(pLed2->BlinkTimer), 0);
3162
			} else {
3163
				if (pLed2->bLedWPSBlinkInProgress != _TRUE) {
3164
					pLed2->CurrLedState = RTW_LED_OFF;
3165
					pLed2->BlinkingLedState = RTW_LED_OFF;
3166
					if (pLed2->bLedOn)
3167
						_set_timer(&(pLed2->BlinkTimer), 0);
3168
				}
3169
			}
3170
		} else { /* NO_LINK */
3171
			if (pLed2->bLedWPSBlinkInProgress == _FALSE) {
3172
				pLed2->CurrLedState = RTW_LED_OFF;
3173
				pLed2->BlinkingLedState = RTW_LED_OFF;
3174
				if (pLed2->bLedOn)
3175
					_set_timer(&(pLed2->BlinkTimer), 0);
3176
			}
3177
		}
3178

3179
		/* LED0 settings			 */
3180
		if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
3181
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3182
				return;
3183
			if (pLed->bLedBlinkInProgress == _TRUE) {
3184
				_cancel_timer_ex(&(pLed->BlinkTimer));
3185
				pLed->bLedBlinkInProgress = _FALSE;
3186
			}
3187

3188
			pLed->bLedNoLinkBlinkInProgress = _TRUE;
3189
			if (IS_HARDWARE_TYPE_8812AU(Adapter)) {
3190
				if (LedAction == LED_CTL_LINK) {
3191
					pLed->BlinkingLedState = RTW_LED_ON;
3192
					pLed->CurrLedState = LED_BLINK_SLOWLY;
3193
				} else {
3194
					pLed->CurrLedState = LED_BLINK_SLOWLY;
3195
					if (pLed->bLedOn)
3196
						pLed->BlinkingLedState = RTW_LED_OFF;
3197
					else
3198
						pLed->BlinkingLedState = RTW_LED_ON;
3199
				}
3200
			} else {
3201
				pLed->CurrLedState = LED_BLINK_SLOWLY;
3202
				if (pLed->bLedOn)
3203
					pLed->BlinkingLedState = RTW_LED_OFF;
3204
				else
3205
					pLed->BlinkingLedState = RTW_LED_ON;
3206
			}
3207
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3208
		}
3209

3210
		break;
3211

3212
	case LED_CTL_SITE_SURVEY:
3213
		if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE))
3214
			;
3215
		else { /* if(pLed->bLedScanBlinkInProgress ==FALSE) */
3216
			if (IS_LED_WPS_BLINKING(pLed))
3217
				return;
3218

3219
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3220
				_cancel_timer_ex(&(pLed->BlinkTimer));
3221
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
3222
			}
3223
			if (pLed->bLedBlinkInProgress == _TRUE) {
3224
				_cancel_timer_ex(&(pLed->BlinkTimer));
3225
				pLed->bLedBlinkInProgress = _FALSE;
3226
			}
3227
			pLed->bLedScanBlinkInProgress = _TRUE;
3228
			pLed->CurrLedState = LED_BLINK_SCAN;
3229
			pLed->BlinkTimes = 24;
3230
			if (pLed->bLedOn)
3231
				pLed->BlinkingLedState = RTW_LED_OFF;
3232
			else
3233
				pLed->BlinkingLedState = RTW_LED_ON;
3234
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3235

3236
		}
3237
		break;
3238

3239
	case LED_CTL_TX:
3240
	case LED_CTL_RX:
3241
		if (pLed->bLedBlinkInProgress == _FALSE) {
3242
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3243
				return;
3244
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3245
				_cancel_timer_ex(&(pLed->BlinkTimer));
3246
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
3247
			}
3248
			pLed->bLedBlinkInProgress = _TRUE;
3249
			pLed->CurrLedState = LED_BLINK_TXRX;
3250
			pLed->BlinkTimes = 2;
3251
			if (pLed->bLedOn)
3252
				pLed->BlinkingLedState = RTW_LED_OFF;
3253
			else
3254
				pLed->BlinkingLedState = RTW_LED_ON;
3255
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3256
		}
3257
		break;
3258

3259
	case LED_CTL_START_WPS: /* wait until xinpin finish */
3260
	case LED_CTL_START_WPS_BOTTON:
3261
		pLed2->bLedBlinkInProgress = _TRUE;
3262
		pLed2->BlinkingLedState = RTW_LED_ON;
3263
		pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3264
		pLed2->bLedWPSBlinkInProgress = _TRUE;
3265

3266
		_set_timer(&(pLed2->BlinkTimer), 500);
3267

3268
		break;
3269

3270
	case LED_CTL_STOP_WPS:	/* WPS connect success	 */
3271
		/* LED2 settings */
3272
		if (pLed2->bLedWPSBlinkInProgress == _TRUE) {
3273
			_cancel_timer_ex(&(pLed2->BlinkTimer));
3274
			pLed2->bLedBlinkInProgress = _FALSE;
3275
			pLed2->bLedWPSBlinkInProgress = _FALSE;
3276
		}
3277
		pLed2->CurrLedState = RTW_LED_ON;
3278
		pLed2->bLedNoLinkBlinkInProgress = _TRUE;
3279
		if (!pLed2->bLedOn)
3280
			_set_timer(&(pLed2->BlinkTimer), 0);
3281

3282
		/* LED1 settings */
3283
		_cancel_timer_ex(&(pLed1->BlinkTimer));
3284
		pLed1->CurrLedState = RTW_LED_OFF;
3285
		pLed1->BlinkingLedState = RTW_LED_OFF;
3286
		if (pLed1->bLedOn)
3287
			_set_timer(&(pLed1->BlinkTimer), 0);
3288

3289

3290
		break;
3291

3292
	case LED_CTL_STOP_WPS_FAIL:		/* WPS authentication fail	 */
3293
		/* LED1 settings */
3294
		/* if(bWPSOverLap == _FALSE) */
3295
	{
3296
		pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;
3297
		pLed1->BlinkTimes = 50;
3298
		if (pLed1->bLedOn)
3299
			pLed1->BlinkingLedState = RTW_LED_OFF;
3300
		else
3301
			pLed1->BlinkingLedState = RTW_LED_ON;
3302
		_set_timer(&(pLed1->BlinkTimer), 0);
3303
	}
3304
		/* else */
3305
		/* { */
3306
		/*	bWPSOverLap = _FALSE; */
3307
		/*	pLed1->CurrLedState = RTW_LED_OFF; */
3308
		/*	pLed1->BlinkingLedState = RTW_LED_OFF;  */
3309
		/*	_set_timer(&(pLed1->BlinkTimer), 0); */
3310
		/* } */
3311

3312
		/* LED2 settings */
3313
	pLed2->CurrLedState = RTW_LED_OFF;
3314
	pLed2->BlinkingLedState = RTW_LED_OFF;
3315
	pLed2->bLedWPSBlinkInProgress = _FALSE;
3316
	if (pLed2->bLedOn)
3317
		_set_timer(&(pLed2->BlinkTimer), 0);
3318

3319
	break;
3320

3321
	case LED_CTL_STOP_WPS_FAIL_OVERLAP:	/* WPS session overlap */
3322
		/* LED1 settings */
3323
		bWPSOverLap = _TRUE;
3324
		pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
3325
		pLed1->BlinkTimes = 10;
3326
		pLed1->BlinkCounter = 50;
3327
		if (pLed1->bLedOn)
3328
			pLed1->BlinkingLedState = RTW_LED_OFF;
3329
		else
3330
			pLed1->BlinkingLedState = RTW_LED_ON;
3331
		_set_timer(&(pLed1->BlinkTimer), 0);
3332

3333
		/* LED2 settings */
3334
		pLed2->CurrLedState = RTW_LED_OFF;
3335
		pLed2->BlinkingLedState = RTW_LED_OFF;
3336
		pLed2->bLedWPSBlinkInProgress = _FALSE;
3337
		if (pLed2->bLedOn)
3338
			_set_timer(&(pLed2->BlinkTimer), 0);
3339

3340
		break;
3341

3342
	case LED_CTL_POWER_OFF:
3343
		pLed->CurrLedState = RTW_LED_OFF;
3344
		pLed->BlinkingLedState = RTW_LED_OFF;
3345

3346
		if (pLed->bLedNoLinkBlinkInProgress) {
3347
			_cancel_timer_ex(&(pLed->BlinkTimer));
3348
			pLed->bLedNoLinkBlinkInProgress = _FALSE;
3349
		}
3350
		if (pLed->bLedLinkBlinkInProgress) {
3351
			_cancel_timer_ex(&(pLed->BlinkTimer));
3352
			pLed->bLedLinkBlinkInProgress = _FALSE;
3353
		}
3354
		if (pLed->bLedBlinkInProgress) {
3355
			_cancel_timer_ex(&(pLed->BlinkTimer));
3356
			pLed->bLedBlinkInProgress = _FALSE;
3357
		}
3358
		if (pLed->bLedWPSBlinkInProgress) {
3359
			_cancel_timer_ex(&(pLed->BlinkTimer));
3360
			pLed->bLedWPSBlinkInProgress = _FALSE;
3361
		}
3362
		if (pLed->bLedScanBlinkInProgress) {
3363
			_cancel_timer_ex(&(pLed->BlinkTimer));
3364
			pLed->bLedScanBlinkInProgress = _FALSE;
3365
		}
3366
		if (pLed->bLedStartToLinkBlinkInProgress) {
3367
			_cancel_timer_ex(&(pLed->BlinkTimer));
3368
			pLed->bLedStartToLinkBlinkInProgress = _FALSE;
3369
		}
3370

3371
		if (pLed1->bLedWPSBlinkInProgress) {
3372
			_cancel_timer_ex(&(pLed1->BlinkTimer));
3373
			pLed1->bLedWPSBlinkInProgress = _FALSE;
3374
		}
3375

3376

3377
		pLed1->BlinkingLedState = LED_UNKNOWN;
3378
		SwLedOff(Adapter, pLed);
3379
		SwLedOff(Adapter, pLed1);
3380
		break;
3381

3382
	case LED_CTL_CONNECTION_NO_TRANSFER:
3383
		if (pLed->bLedBlinkInProgress == _FALSE) {
3384
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3385
				_cancel_timer_ex(&(pLed->BlinkTimer));
3386
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
3387
			}
3388
			pLed->bLedBlinkInProgress = _TRUE;
3389

3390
			pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
3391
			pLed->BlinkingLedState = RTW_LED_ON;
3392
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3393
		}
3394
		break;
3395

3396
	default:
3397
		break;
3398

3399
	}
3400

3401
}
3402

3403
/* page added for Netgear A6200V2, 20120827 */
3404
void
3405
SwLedControlMode10(
3406
	PADAPTER			Adapter,
3407
	LED_CTL_MODE		LedAction
3408
)
3409
{
3410
	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
3411
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3412
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3413
	PLED_USB	pLed = &(ledpriv->SwLed0);
3414
	PLED_USB	pLed1 = &(ledpriv->SwLed1);
3415

3416
	switch (LedAction) {
3417
	case LED_CTL_START_TO_LINK:
3418
		if (pLed1->bLedBlinkInProgress == _FALSE) {
3419
			pLed1->bLedBlinkInProgress = _TRUE;
3420
			pLed1->BlinkingLedState = RTW_LED_ON;
3421
			pLed1->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3422

3423
			_set_timer(&(pLed1->BlinkTimer), 0);
3424
		}
3425
		break;
3426

3427
	case LED_CTL_LINK:
3428
	case LED_CTL_NO_LINK:
3429
		if (LedAction == LED_CTL_LINK) {
3430
			if (pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)
3431
				;
3432
			else {
3433
				if (pHalData->current_band_type == BAND_ON_2_4G)
3434
					/* LED0 settings */
3435
				{
3436
					pLed->CurrLedState = RTW_LED_ON;
3437
					pLed->BlinkingLedState = RTW_LED_ON;
3438
					if (pLed->bLedBlinkInProgress == _TRUE) {
3439
						_cancel_timer_ex(&(pLed->BlinkTimer));
3440
						pLed->bLedBlinkInProgress = _FALSE;
3441
					}
3442
					_set_timer(&(pLed->BlinkTimer), 0);
3443

3444
					pLed1->CurrLedState = RTW_LED_OFF;
3445
					pLed1->BlinkingLedState = RTW_LED_OFF;
3446
					_set_timer(&(pLed1->BlinkTimer), 0);
3447
				} else if (pHalData->current_band_type == BAND_ON_5G)
3448
					/* LED1 settings */
3449
				{
3450
					pLed1->CurrLedState = RTW_LED_ON;
3451
					pLed1->BlinkingLedState = RTW_LED_ON;
3452
					if (pLed1->bLedBlinkInProgress == _TRUE) {
3453
						_cancel_timer_ex(&(pLed1->BlinkTimer));
3454
						pLed1->bLedBlinkInProgress = _FALSE;
3455
					}
3456
					_set_timer(&(pLed1->BlinkTimer), 0);
3457

3458
					pLed->CurrLedState = RTW_LED_OFF;
3459
					pLed->BlinkingLedState = RTW_LED_OFF;
3460
					_set_timer(&(pLed->BlinkTimer), 0);
3461
				}
3462
			}
3463
		} else if (LedAction == LED_CTL_NO_LINK) { /* TODO by page */
3464
			if (pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)
3465
				;
3466
			else {
3467
				pLed->CurrLedState = RTW_LED_OFF;
3468
				pLed->BlinkingLedState = RTW_LED_OFF;
3469
				if (pLed->bLedOn)
3470
					_set_timer(&(pLed->BlinkTimer), 0);
3471

3472
				pLed1->CurrLedState = RTW_LED_OFF;
3473
				pLed1->BlinkingLedState = RTW_LED_OFF;
3474
				if (pLed1->bLedOn)
3475
					_set_timer(&(pLed1->BlinkTimer), 0);
3476
			}
3477
		}
3478

3479
		break;
3480

3481
	case LED_CTL_SITE_SURVEY:
3482
		if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
3483
			;                                                                  /* don't blink when media connect */
3484
		else { /* if(pLed->bLedScanBlinkInProgress ==FALSE) */
3485
			if (IS_LED_WPS_BLINKING(pLed) || IS_LED_WPS_BLINKING(pLed1))
3486
				return;
3487

3488
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3489
				_cancel_timer_ex(&(pLed->BlinkTimer));
3490
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
3491
			}
3492
			if (pLed->bLedBlinkInProgress == _TRUE) {
3493
				_cancel_timer_ex(&(pLed->BlinkTimer));
3494
				pLed->bLedBlinkInProgress = _FALSE;
3495
			}
3496
			pLed->bLedScanBlinkInProgress = _TRUE;
3497
			pLed->CurrLedState = LED_BLINK_SCAN;
3498
			pLed->BlinkTimes = 12;
3499
			pLed->BlinkingLedState = LED_BLINK_SCAN;
3500
			_set_timer(&(pLed->BlinkTimer), 0);
3501

3502
			if (pLed1->bLedNoLinkBlinkInProgress == _TRUE) {
3503
				_cancel_timer_ex(&(pLed1->BlinkTimer));
3504
				pLed1->bLedNoLinkBlinkInProgress = _FALSE;
3505
			}
3506
			if (pLed1->bLedBlinkInProgress == _TRUE) {
3507
				_cancel_timer_ex(&(pLed1->BlinkTimer));
3508
				pLed1->bLedBlinkInProgress = _FALSE;
3509
			}
3510
			pLed1->bLedScanBlinkInProgress = _TRUE;
3511
			pLed1->CurrLedState = LED_BLINK_SCAN;
3512
			pLed1->BlinkTimes = 12;
3513
			pLed1->BlinkingLedState = LED_BLINK_SCAN;
3514
			_set_timer(&(pLed1->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR);
3515

3516
		}
3517
		break;
3518

3519
	case LED_CTL_START_WPS: /* wait until xinpin finish */
3520
	case LED_CTL_START_WPS_BOTTON:
3521
		/* LED0 settings */
3522
		if (pLed->bLedBlinkInProgress == _FALSE) {
3523
			pLed->bLedBlinkInProgress = _TRUE;
3524
			pLed->bLedWPSBlinkInProgress = _TRUE;
3525
			pLed->BlinkingLedState = LED_BLINK_WPS;
3526
			pLed->CurrLedState = LED_BLINK_WPS;
3527
			_set_timer(&(pLed->BlinkTimer), 0);
3528
		}
3529

3530
		/* LED1 settings */
3531
		if (pLed1->bLedBlinkInProgress == _FALSE) {
3532
			pLed1->bLedBlinkInProgress = _TRUE;
3533
			pLed1->bLedWPSBlinkInProgress = _TRUE;
3534
			pLed1->BlinkingLedState = LED_BLINK_WPS;
3535
			pLed1->CurrLedState = LED_BLINK_WPS;
3536
			_set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL + LED_BLINK_LINK_INTERVAL_NETGEAR);
3537
		}
3538

3539

3540
		break;
3541

3542
	case LED_CTL_STOP_WPS:	/* WPS connect success */
3543
		if (pHalData->current_band_type == BAND_ON_2_4G)
3544
			/* LED0 settings */
3545
		{
3546
			pLed->bLedWPSBlinkInProgress = _FALSE;
3547
			pLed->CurrLedState = RTW_LED_ON;
3548
			pLed->BlinkingLedState = RTW_LED_ON;
3549
			if (pLed->bLedBlinkInProgress == _TRUE) {
3550
				_cancel_timer_ex(&(pLed->BlinkTimer));
3551
				pLed->bLedBlinkInProgress = _FALSE;
3552
			}
3553
			_set_timer(&(pLed->BlinkTimer), 0);
3554

3555
			pLed1->CurrLedState = RTW_LED_OFF;
3556
			pLed1->BlinkingLedState = RTW_LED_OFF;
3557
			_set_timer(&(pLed1->BlinkTimer), 0);
3558
		} else if (pHalData->current_band_type == BAND_ON_5G)
3559
			/* LED1 settings */
3560
		{
3561
			pLed1->bLedWPSBlinkInProgress = _FALSE;
3562
			pLed1->CurrLedState = RTW_LED_ON;
3563
			pLed1->BlinkingLedState = RTW_LED_ON;
3564
			if (pLed1->bLedBlinkInProgress == _TRUE) {
3565
				_cancel_timer_ex(&(pLed1->BlinkTimer));
3566
				pLed1->bLedBlinkInProgress = _FALSE;
3567
			}
3568
			_set_timer(&(pLed1->BlinkTimer), 0);
3569

3570
			pLed->CurrLedState = RTW_LED_OFF;
3571
			pLed->BlinkingLedState = RTW_LED_OFF;
3572
			_set_timer(&(pLed->BlinkTimer), 0);
3573
		}
3574

3575
		break;
3576

3577
	case LED_CTL_STOP_WPS_FAIL:		/* WPS authentication fail	 */
3578
		/* LED1 settings */
3579
		pLed1->bLedWPSBlinkInProgress = _FALSE;
3580
		pLed1->CurrLedState = RTW_LED_OFF;
3581
		pLed1->BlinkingLedState = RTW_LED_OFF;
3582
		_set_timer(&(pLed1->BlinkTimer), 0);
3583

3584
		/* LED0 settings */
3585
		pLed->bLedWPSBlinkInProgress = _FALSE;
3586
		pLed->CurrLedState = RTW_LED_OFF;
3587
		pLed->BlinkingLedState = RTW_LED_OFF;
3588
		if (pLed->bLedOn)
3589
			_set_timer(&(pLed->BlinkTimer), 0);
3590

3591
		break;
3592

3593

3594
	default:
3595
		break;
3596

3597
	}
3598

3599
}
3600

3601
/* Edimax-ASUS, added by Page, 20121221 */
3602
void
3603
SwLedControlMode11(
3604
	PADAPTER			Adapter,
3605
	LED_CTL_MODE		LedAction
3606
)
3607
{
3608
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3609
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3610
	PLED_USB	pLed = &(ledpriv->SwLed0);
3611

3612
	switch (LedAction) {
3613
	case LED_CTL_POWER_ON:
3614
	case LED_CTL_START_TO_LINK:
3615
	case LED_CTL_NO_LINK:
3616
		pLed->CurrLedState = RTW_LED_ON;
3617
		pLed->BlinkingLedState = RTW_LED_ON;
3618
		_set_timer(&(pLed->BlinkTimer), 0);
3619
		break;
3620

3621
	case LED_CTL_LINK:
3622
		if (pLed->bLedBlinkInProgress == _TRUE) {
3623
			_cancel_timer_ex(&(pLed->BlinkTimer));
3624
			pLed->bLedBlinkInProgress = _FALSE;
3625
		}
3626
		pLed->bLedBlinkInProgress = _TRUE;
3627
		pLed->CurrLedState = LED_BLINK_TXRX;
3628
		if (pLed->bLedOn)
3629
			pLed->BlinkingLedState = RTW_LED_OFF;
3630
		else
3631
			pLed->BlinkingLedState = RTW_LED_ON;
3632
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3633
		break;
3634

3635
	case LED_CTL_START_WPS: /* wait until xinpin finish */
3636
	case LED_CTL_START_WPS_BOTTON:
3637
		if (pLed->bLedBlinkInProgress == _TRUE) {
3638
			_cancel_timer_ex(&(pLed->BlinkTimer));
3639
			pLed->bLedBlinkInProgress = _FALSE;
3640
		}
3641
		pLed->bLedWPSBlinkInProgress = _TRUE;
3642
		pLed->bLedBlinkInProgress = _TRUE;
3643
		pLed->CurrLedState = LED_BLINK_WPS;
3644
		if (pLed->bLedOn)
3645
			pLed->BlinkingLedState = RTW_LED_OFF;
3646
		else
3647
			pLed->BlinkingLedState = RTW_LED_ON;
3648
		pLed->BlinkTimes = 5;
3649
		_set_timer(&(pLed->BlinkTimer), 0);
3650

3651
		break;
3652

3653

3654
	case LED_CTL_STOP_WPS:
3655
	case LED_CTL_STOP_WPS_FAIL:
3656
		if (pLed->bLedBlinkInProgress == _TRUE) {
3657
			_cancel_timer_ex(&(pLed->BlinkTimer));
3658
			pLed->bLedBlinkInProgress = _FALSE;
3659
		}
3660
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
3661
		_set_timer(&(pLed->BlinkTimer), 0);
3662
		break;
3663

3664
	case LED_CTL_POWER_OFF:
3665
		pLed->CurrLedState = RTW_LED_OFF;
3666
		pLed->BlinkingLedState = RTW_LED_OFF;
3667

3668
		if (pLed->bLedNoLinkBlinkInProgress) {
3669
			_cancel_timer_ex(&(pLed->BlinkTimer));
3670
			pLed->bLedNoLinkBlinkInProgress = _FALSE;
3671
		}
3672
		if (pLed->bLedLinkBlinkInProgress) {
3673
			_cancel_timer_ex(&(pLed->BlinkTimer));
3674
			pLed->bLedLinkBlinkInProgress = _FALSE;
3675
		}
3676
		if (pLed->bLedBlinkInProgress) {
3677
			_cancel_timer_ex(&(pLed->BlinkTimer));
3678
			pLed->bLedBlinkInProgress = _FALSE;
3679
		}
3680
		if (pLed->bLedWPSBlinkInProgress) {
3681
			_cancel_timer_ex(&(pLed->BlinkTimer));
3682
			pLed->bLedWPSBlinkInProgress = _FALSE;
3683
		}
3684
		if (pLed->bLedScanBlinkInProgress) {
3685
			_cancel_timer_ex(&(pLed->BlinkTimer));
3686
			pLed->bLedScanBlinkInProgress = _FALSE;
3687
		}
3688

3689
		SwLedOff(Adapter, pLed);
3690
		break;
3691

3692
	default:
3693
		break;
3694

3695
	}
3696

3697
}
3698

3699
/* page added for NEC */
3700

3701
void
3702
SwLedControlMode12(
3703
	PADAPTER			Adapter,
3704
	LED_CTL_MODE		LedAction
3705
)
3706
{
3707
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3708
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3709
	PLED_USB	pLed = &(ledpriv->SwLed0);
3710

3711
	switch (LedAction) {
3712
	case LED_CTL_POWER_ON:
3713
	case LED_CTL_NO_LINK:
3714
	case LED_CTL_LINK:
3715
	case LED_CTL_SITE_SURVEY:
3716

3717
		if (pLed->bLedNoLinkBlinkInProgress == _FALSE) {
3718
			if (pLed->bLedBlinkInProgress == _TRUE) {
3719
				_cancel_timer_ex(&(pLed->BlinkTimer));
3720
				pLed->bLedBlinkInProgress = _FALSE;
3721
			}
3722

3723
			pLed->bLedNoLinkBlinkInProgress = _TRUE;
3724
			pLed->CurrLedState = LED_BLINK_SLOWLY;
3725
			if (pLed->bLedOn)
3726
				pLed->BlinkingLedState = RTW_LED_OFF;
3727
			else
3728
				pLed->BlinkingLedState = RTW_LED_ON;
3729
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3730
		}
3731
		break;
3732

3733
	case LED_CTL_TX:
3734
	case LED_CTL_RX:
3735
		if (pLed->bLedBlinkInProgress == _FALSE) {
3736
			if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3737
				_cancel_timer_ex(&(pLed->BlinkTimer));
3738
				pLed->bLedNoLinkBlinkInProgress = _FALSE;
3739
			}
3740
			pLed->bLedBlinkInProgress = _TRUE;
3741
			pLed->CurrLedState = LED_BLINK_TXRX;
3742
			pLed->BlinkTimes = 2;
3743
			if (pLed->bLedOn)
3744
				pLed->BlinkingLedState = RTW_LED_OFF;
3745
			else
3746
				pLed->BlinkingLedState = RTW_LED_ON;
3747
			_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3748
		}
3749
		break;
3750

3751
	case LED_CTL_POWER_OFF:
3752
		pLed->CurrLedState = RTW_LED_OFF;
3753
		pLed->BlinkingLedState = RTW_LED_OFF;
3754

3755
		if (pLed->bLedBlinkInProgress) {
3756
			_cancel_timer_ex(&(pLed->BlinkTimer));
3757
			pLed->bLedBlinkInProgress = _FALSE;
3758
		}
3759

3760
		if (pLed->bLedScanBlinkInProgress) {
3761
			_cancel_timer_ex(&(pLed->BlinkTimer));
3762
			pLed->bLedScanBlinkInProgress = _FALSE;
3763
		}
3764

3765
		if (pLed->bLedNoLinkBlinkInProgress == _TRUE) {
3766
			_cancel_timer_ex(&(pLed->BlinkTimer));
3767
			pLed->bLedNoLinkBlinkInProgress = _FALSE;
3768
		}
3769

3770
		SwLedOff(Adapter, pLed);
3771
		break;
3772

3773
	default:
3774
		break;
3775

3776
	}
3777

3778
}
3779

3780
/* Maddest add for NETGEAR R6100 */
3781

3782
void
3783
SwLedControlMode13(
3784
		PADAPTER			Adapter,
3785
		LED_CTL_MODE		LedAction
3786
)
3787
{
3788
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3789
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3790
	PLED_USB	pLed = &(ledpriv->SwLed0);
3791

3792
	switch (LedAction) {
3793
	case LED_CTL_LINK:
3794
		if (pLed->bLedWPSBlinkInProgress)
3795
			return;
3796

3797

3798
		pLed->CurrLedState = RTW_LED_ON;
3799
		pLed->BlinkingLedState = RTW_LED_ON;
3800
		if (pLed->bLedBlinkInProgress) {
3801
			_cancel_timer_ex(&(pLed->BlinkTimer));
3802
			pLed->bLedBlinkInProgress = _FALSE;
3803
		}
3804
		if (pLed->bLedScanBlinkInProgress) {
3805
			_cancel_timer_ex(&(pLed->BlinkTimer));
3806
			pLed->bLedScanBlinkInProgress = _FALSE;
3807
		}
3808

3809
		_set_timer(&(pLed->BlinkTimer), 0);
3810
		break;
3811

3812
	case LED_CTL_START_WPS: /* wait until xinpin finish */
3813
	case LED_CTL_START_WPS_BOTTON:
3814
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
3815
			if (pLed->bLedBlinkInProgress == _TRUE) {
3816
				_cancel_timer_ex(&(pLed->BlinkTimer));
3817
				pLed->bLedBlinkInProgress = _FALSE;
3818
			}
3819
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
3820
				_cancel_timer_ex(&(pLed->BlinkTimer));
3821
				pLed->bLedScanBlinkInProgress = _FALSE;
3822
			}
3823
			pLed->bLedWPSBlinkInProgress = _TRUE;
3824
			pLed->CurrLedState = LED_BLINK_WPS;
3825
			if (pLed->bLedOn) {
3826
				pLed->BlinkingLedState = RTW_LED_OFF;
3827
				_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
3828
			} else {
3829
				pLed->BlinkingLedState = RTW_LED_ON;
3830
				_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
3831
			}
3832
		}
3833
		break;
3834

3835
	case LED_CTL_STOP_WPS:
3836
		if (pLed->bLedWPSBlinkInProgress) {
3837
			_cancel_timer_ex(&(pLed->BlinkTimer));
3838
			pLed->bLedWPSBlinkInProgress = _FALSE;
3839
		} else
3840
			pLed->bLedWPSBlinkInProgress = _TRUE;
3841

3842
		pLed->bLedWPSBlinkInProgress = _FALSE;
3843
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
3844
		if (pLed->bLedOn) {
3845
			pLed->BlinkingLedState = RTW_LED_OFF;
3846

3847
			_set_timer(&(pLed->BlinkTimer), 0);
3848
		}
3849

3850
		break;
3851

3852

3853
	case LED_CTL_STOP_WPS_FAIL:
3854
	case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
3855
		if (pLed->bLedWPSBlinkInProgress) {
3856
			_cancel_timer_ex(&(pLed->BlinkTimer));
3857
			pLed->bLedWPSBlinkInProgress = _FALSE;
3858
		}
3859

3860
		pLed->CurrLedState = RTW_LED_OFF;
3861
		pLed->BlinkingLedState = RTW_LED_OFF;
3862
		_set_timer(&(pLed->BlinkTimer), 0);
3863
		break;
3864

3865
	case LED_CTL_START_TO_LINK:
3866
		if ((pLed->bLedBlinkInProgress == _FALSE) && (pLed->bLedWPSBlinkInProgress == _FALSE)) {
3867
			pLed->bLedBlinkInProgress = _TRUE;
3868
			pLed->BlinkingLedState = RTW_LED_ON;
3869
			pLed->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3870

3871
			_set_timer(&(pLed->BlinkTimer), 0);
3872
		}
3873
		break;
3874

3875
	case LED_CTL_NO_LINK:
3876

3877
		if (pLed->bLedWPSBlinkInProgress)
3878
			return;
3879
		if (pLed->bLedBlinkInProgress) {
3880
			_cancel_timer_ex(&(pLed->BlinkTimer));
3881
			pLed->bLedBlinkInProgress = _FALSE;
3882
		}
3883
		if (pLed->bLedScanBlinkInProgress) {
3884
			_cancel_timer_ex(&(pLed->BlinkTimer));
3885
			pLed->bLedScanBlinkInProgress = _FALSE;
3886
		}
3887
		/* if(!IS_LED_BLINKING(pLed)) */
3888
		{
3889
			pLed->CurrLedState = RTW_LED_OFF;
3890
			pLed->BlinkingLedState = RTW_LED_OFF;
3891
			_set_timer(&(pLed->BlinkTimer), 0);
3892
		}
3893
		break;
3894

3895
	case LED_CTL_POWER_OFF:
3896
	case LED_CTL_POWER_ON:
3897
		pLed->CurrLedState = RTW_LED_OFF;
3898
		pLed->BlinkingLedState = RTW_LED_OFF;
3899
		if (pLed->bLedBlinkInProgress) {
3900
			_cancel_timer_ex(&(pLed->BlinkTimer));
3901
			pLed->bLedBlinkInProgress = _FALSE;
3902
		}
3903
		if (pLed->bLedScanBlinkInProgress) {
3904
			_cancel_timer_ex(&(pLed->BlinkTimer));
3905
			pLed->bLedScanBlinkInProgress = _FALSE;
3906
		}
3907
		if (pLed->bLedWPSBlinkInProgress) {
3908
			_cancel_timer_ex(&(pLed->BlinkTimer));
3909
			pLed->bLedWPSBlinkInProgress = _FALSE;
3910
		}
3911

3912
		if (LedAction == LED_CTL_POWER_ON)
3913
			_set_timer(&(pLed->BlinkTimer), 0);
3914
		else
3915
			SwLedOff(Adapter, pLed);
3916
		break;
3917

3918
	default:
3919
		break;
3920

3921
	}
3922

3923

3924
}
3925

3926
/* Maddest add for DNI Buffalo */
3927

3928
void
3929
SwLedControlMode14(
3930
		PADAPTER			Adapter,
3931
		LED_CTL_MODE		LedAction
3932
)
3933
{
3934
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3935
	PLED_USB	pLed = &(ledpriv->SwLed0);
3936

3937
	switch (LedAction) {
3938
	case LED_CTL_POWER_OFF:
3939
		pLed->CurrLedState = RTW_LED_OFF;
3940
		pLed->BlinkingLedState = RTW_LED_OFF;
3941
		if (pLed->bLedBlinkInProgress) {
3942
			_cancel_timer_ex(&(pLed->BlinkTimer));
3943
			pLed->bLedBlinkInProgress = _FALSE;
3944
		}
3945
		SwLedOff(Adapter, pLed);
3946
		break;
3947

3948
	case LED_CTL_POWER_ON:
3949
		SwLedOn(Adapter, pLed);
3950
		break;
3951

3952
	case LED_CTL_LINK:
3953
	case LED_CTL_NO_LINK:
3954
		if (IS_HARDWARE_TYPE_8812AU(Adapter))
3955
			SwLedOn(Adapter, pLed);
3956
		break;
3957

3958
	case LED_CTL_TX:
3959
	case LED_CTL_RX:
3960
		if (pLed->bLedBlinkInProgress == _FALSE) {
3961
			pLed->bLedBlinkInProgress = _TRUE;
3962
			pLed->CurrLedState = LED_BLINK_TXRX;
3963
			pLed->BlinkTimes = 2;
3964
			if (pLed->bLedOn) {
3965
				pLed->BlinkingLedState = RTW_LED_OFF;
3966
				if (IS_HARDWARE_TYPE_8812AU(Adapter))
3967
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
3968
				else
3969
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3970
			} else {
3971
				pLed->BlinkingLedState = RTW_LED_ON;
3972
				if (IS_HARDWARE_TYPE_8812AU(Adapter))
3973
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
3974
				else
3975
					_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3976
			}
3977
		}
3978
		break;
3979

3980
	default:
3981
		break;
3982
	}
3983
}
3984

3985
/* Maddest add for Dlink */
3986

3987
void
3988
SwLedControlMode15(
3989
		PADAPTER			Adapter,
3990
		LED_CTL_MODE		LedAction
3991
)
3992
{
3993
	struct led_priv	*ledpriv = adapter_to_led(Adapter);
3994
	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
3995
	PLED_USB	pLed = &(ledpriv->SwLed0);
3996

3997
	switch (LedAction) {
3998
	case LED_CTL_START_WPS: /* wait until xinpin finish */
3999
	case LED_CTL_START_WPS_BOTTON:
4000
		if (pLed->bLedWPSBlinkInProgress == _FALSE) {
4001
			if (pLed->bLedBlinkInProgress == _TRUE) {
4002
				_cancel_timer_ex(&(pLed->BlinkTimer));
4003
				pLed->bLedBlinkInProgress = _FALSE;
4004
			}
4005
			if (pLed->bLedScanBlinkInProgress == _TRUE) {
4006
				_cancel_timer_ex(&(pLed->BlinkTimer));
4007
				pLed->bLedScanBlinkInProgress = _FALSE;
4008
			}
4009
			pLed->bLedWPSBlinkInProgress = _TRUE;
4010
			pLed->CurrLedState = LED_BLINK_WPS;
4011
			if (pLed->bLedOn) {
4012
				pLed->BlinkingLedState = RTW_LED_OFF;
4013
				_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
4014
			} else {
4015
				pLed->BlinkingLedState = RTW_LED_ON;
4016
				_set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
4017
			}
4018
		}
4019
		break;
4020

4021
	case LED_CTL_STOP_WPS:
4022
		if (pLed->bLedWPSBlinkInProgress)
4023
			_cancel_timer_ex(&(pLed->BlinkTimer));
4024

4025
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
4026
		/* if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) */
4027
		{
4028
			pLed->BlinkingLedState = RTW_LED_ON;
4029

4030
			_set_timer(&(pLed->BlinkTimer), 0);
4031
		}
4032

4033
		break;
4034

4035
	case LED_CTL_STOP_WPS_FAIL:
4036
	case LED_CTL_STOP_WPS_FAIL_OVERLAP: /* WPS session overlap */
4037
		if (pLed->bLedWPSBlinkInProgress) {
4038
			_cancel_timer_ex(&(pLed->BlinkTimer));
4039
			pLed->bLedWPSBlinkInProgress = _FALSE;
4040
		}
4041

4042
		pLed->CurrLedState = RTW_LED_OFF;
4043
		pLed->BlinkingLedState = RTW_LED_OFF;
4044
		_set_timer(&(pLed->BlinkTimer), 0);
4045
		break;
4046

4047
	case LED_CTL_NO_LINK:
4048
		if (pLed->bLedWPSBlinkInProgress)
4049
			return;
4050

4051
		/*if(Adapter->securitypriv.dot11PrivacyAlgrthm > _NO_PRIVACY_)
4052
		{
4053
			if(SecIsTxKeyInstalled(Adapter, pMgntInfo->Bssid))
4054
			{
4055
			}
4056
			else
4057
			{
4058
				if(pMgntInfo->LEDAssocState ==LED_ASSOC_SECURITY_BEGIN)
4059
					return;
4060
			}
4061
		}*/
4062

4063
		if (pLed->bLedBlinkInProgress) {
4064
			_cancel_timer_ex(&(pLed->BlinkTimer));
4065
			pLed->bLedBlinkInProgress = _FALSE;
4066
		}
4067
		if (pLed->bLedScanBlinkInProgress) {
4068
			_cancel_timer_ex(&(pLed->BlinkTimer));
4069
			pLed->bLedScanBlinkInProgress = _FALSE;
4070
		}
4071
		/* if(!IS_LED_BLINKING(pLed)) */
4072
		{
4073
			pLed->CurrLedState = LED_BLINK_NO_LINK;
4074
			pLed->BlinkingLedState = RTW_LED_ON;
4075
			_set_timer(&(pLed->BlinkTimer), 30);
4076
		}
4077
		break;
4078

4079
	case LED_CTL_LINK:
4080

4081
		if (pLed->bLedWPSBlinkInProgress)
4082
			return;
4083

4084
		if (pLed->bLedBlinkInProgress) {
4085
			_cancel_timer_ex(&(pLed->BlinkTimer));
4086
			pLed->bLedBlinkInProgress = _FALSE;
4087
		}
4088

4089
		pLed->CurrLedState = LED_BLINK_LINK_IDEL;
4090
		pLed->BlinkingLedState = RTW_LED_ON;
4091

4092
		_set_timer(&(pLed->BlinkTimer), 30);
4093
		break;
4094

4095
	case LED_CTL_SITE_SURVEY:
4096
		if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
4097
			return;
4098

4099
		if (pLed->bLedWPSBlinkInProgress == _TRUE)
4100
			return;
4101

4102
		if (pLed->bLedBlinkInProgress) {
4103
			_cancel_timer_ex(&(pLed->BlinkTimer));
4104
			pLed->bLedBlinkInProgress = _FALSE;
4105
		}
4106
		pLed->CurrLedState = LED_BLINK_SCAN;
4107
		pLed->BlinkingLedState = RTW_LED_ON;
4108
		_set_timer(&(pLed->BlinkTimer), 0);
4109
		break;
4110

4111
	case LED_CTL_TX:
4112
	case LED_CTL_RX:
4113
		if (pLed->bLedWPSBlinkInProgress)
4114
			return;
4115

4116
		if (pLed->bLedBlinkInProgress) {
4117
			_cancel_timer_ex(&(pLed->BlinkTimer));
4118
			pLed->bLedBlinkInProgress = _FALSE;
4119
		}
4120

4121
		pLed->bLedBlinkInProgress = _TRUE;
4122
		pLed->CurrLedState = LED_BLINK_TXRX;
4123
		pLed->BlinkTimes = 2;
4124
		if (pLed->bLedOn)
4125
			pLed->BlinkingLedState = RTW_LED_OFF;
4126
		else
4127
			pLed->BlinkingLedState = RTW_LED_ON;
4128
		_set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
4129
		break;
4130

4131
	default:
4132
		break;
4133
	}
4134
}
4135

4136
void
4137
LedControlUSB(
4138
	_adapter				*padapter,
4139
	LED_CTL_MODE		LedAction
4140
)
4141
{
4142
	struct led_priv	*ledpriv = adapter_to_led(padapter);
4143

4144
#if (MP_DRIVER == 1)
4145
	if (padapter->registrypriv.mp_mode == 1)
4146
		return;
4147
#endif
4148

4149
	if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
4150
		/*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
4151
		, __func__
4152
		, rtw_is_drv_stopped(padapter)?"True":"False"
4153
		, rtw_is_surprise_removed(padapter)?"True":"False" );*/
4154
		return;
4155
	}
4156

4157
	if (ledpriv->bRegUseLed == _FALSE)
4158
		return;
4159

4160
	/* if(priv->bInHctTest) */
4161
	/*	return; */
4162

4163
	if ((adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on &&
4164
	     adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&
4165
	    (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
4166
	     LedAction == LED_CTL_SITE_SURVEY ||
4167
	     LedAction == LED_CTL_LINK ||
4168
	     LedAction == LED_CTL_NO_LINK ||
4169
	     LedAction == LED_CTL_POWER_ON))
4170
		return;
4171

4172
	switch (ledpriv->LedStrategy) {
4173
	#if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
4174
	case SW_LED_MODE_UC_TRX_ONLY:
4175
		rtw_sw_led_ctl_mode_uc_trx_only(padapter, LedAction);
4176
		break;
4177
	#endif
4178

4179
	case SW_LED_MODE0:
4180
		SwLedControlMode0(padapter, LedAction);
4181
		break;
4182

4183
	case SW_LED_MODE1:
4184
		SwLedControlMode1(padapter, LedAction);
4185
		break;
4186

4187
	case SW_LED_MODE2:
4188
		SwLedControlMode2(padapter, LedAction);
4189
		break;
4190

4191
	case SW_LED_MODE3:
4192
		SwLedControlMode3(padapter, LedAction);
4193
		break;
4194

4195
	case SW_LED_MODE4:
4196
		SwLedControlMode4(padapter, LedAction);
4197
		break;
4198

4199
	case SW_LED_MODE5:
4200
		SwLedControlMode5(padapter, LedAction);
4201
		break;
4202

4203
	case SW_LED_MODE6:
4204
		SwLedControlMode6(padapter, LedAction);
4205
		break;
4206

4207
	case SW_LED_MODE7:
4208
		SwLedControlMode7(padapter, LedAction);
4209
		break;
4210

4211
	case SW_LED_MODE8:
4212
		SwLedControlMode8(padapter, LedAction);
4213
		break;
4214

4215
	case SW_LED_MODE9:
4216
		SwLedControlMode9(padapter, LedAction);
4217
		break;
4218

4219
	case SW_LED_MODE10:
4220
		SwLedControlMode10(padapter, LedAction);
4221
		break;
4222

4223
	case SW_LED_MODE11:
4224
		SwLedControlMode11(padapter, LedAction);
4225
		break;
4226

4227
	case SW_LED_MODE12:
4228
		SwLedControlMode12(padapter, LedAction);
4229
		break;
4230

4231
	case SW_LED_MODE13:
4232
		SwLedControlMode13(padapter, LedAction);
4233
		break;
4234

4235
	case SW_LED_MODE14:
4236
		SwLedControlMode14(padapter, LedAction);
4237
		break;
4238

4239
	case SW_LED_MODE15:
4240
		SwLedControlMode15(padapter, LedAction);
4241
		break;
4242

4243
	default:
4244
		break;
4245
	}
4246

4247
}
4248

4249
/*
4250
 *	Description:
4251
 *		Reset status of LED_871x object.
4252
 *   */
4253
void ResetLedStatus(PLED_USB pLed)
4254
{
4255

4256
	pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
4257
	pLed->bLedOn = _FALSE; /* true if LED is ON, false if LED is OFF. */
4258

4259
	pLed->bLedBlinkInProgress = _FALSE; /* true if it is blinking, false o.w.. */
4260
	pLed->bLedWPSBlinkInProgress = _FALSE;
4261

4262
	pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
4263
	pLed->BlinkCounter = 0;
4264
	pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
4265

4266
	pLed->bLedNoLinkBlinkInProgress = _FALSE;
4267
	pLed->bLedLinkBlinkInProgress = _FALSE;
4268
	pLed->bLedStartToLinkBlinkInProgress = _FALSE;
4269
	pLed->bLedScanBlinkInProgress = _FALSE;
4270
}
4271

4272
/*
4273
*	Description:
4274
*		Initialize an LED_871x object.
4275
*   */
4276
void
4277
InitLed(
4278
	_adapter			*padapter,
4279
	PLED_USB		pLed,
4280
	LED_PIN			LedPin
4281
)
4282
{
4283
	pLed->padapter = padapter;
4284
	pLed->LedPin = LedPin;
4285

4286
	ResetLedStatus(pLed);
4287
	rtw_init_timer(&(pLed->BlinkTimer), padapter, BlinkTimerCallback, pLed);
4288
	_init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
4289
}
4290

4291

4292
/*
4293
 *	Description:
4294
 *		DeInitialize an LED_871x object.
4295
 *   */
4296
void
4297
DeInitLed(
4298
	PLED_USB		pLed
4299
)
4300
{
4301
	_cancel_workitem_sync(&(pLed->BlinkWorkItem));
4302
	_cancel_timer_ex(&(pLed->BlinkTimer));
4303
	ResetLedStatus(pLed);
4304
}
4305
#endif
4306

4307
Product

Resources

Company
