[deliverable/linux.git] / drivers / staging / rtl8188eu / core / rtw_led.c

/******************************************************************************
 *
 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 *
 ******************************************************************************/

#include <drv_types.h>
#include "rtw_led.h"

/*  */
/*	Description: */
/*		Callback function of LED BlinkTimer, */
/*		it just schedules to corresponding BlinkWorkItem/led_blink_hdl */
/*  */
void BlinkTimerCallback(unsigned long data)
{
	struct LED_871x *pLed = (struct LED_871x *)data;
	struct adapter *padapter = pLed->padapter;

	if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped))
		return;

	schedule_work(&(pLed->BlinkWorkItem));
}

/*  */
/*	Description: */
/*		Callback function of LED BlinkWorkItem. */
/*  */
void BlinkWorkItemCallback(struct work_struct *work)
{
	struct LED_871x *pLed = container_of(work, struct LED_871x, BlinkWorkItem);
	BlinkHandler(pLed);
}

/*  */
/*	Description: */
/*		Reset status of LED_871x object. */
/*  */
void ResetLedStatus(struct LED_871x *pLed)
{
	pLed->CurrLedState = RTW_LED_OFF; /*  Current LED state. */
	pLed->bLedOn = false; /*  true if LED is ON, false if LED is OFF. */

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

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

	pLed->bLedNoLinkBlinkInProgress = false;
	pLed->bLedLinkBlinkInProgress = false;
	pLed->bLedStartToLinkBlinkInProgress = false;
	pLed->bLedScanBlinkInProgress = false;
}

/*Description: */
/*		Initialize an LED_871x object. */
void InitLed871x(struct adapter *padapter, struct LED_871x *pLed)
{
	pLed->padapter = padapter;

	ResetLedStatus(pLed);

	setup_timer(&(pLed->BlinkTimer), BlinkTimerCallback,
		    (unsigned long)pLed);

	INIT_WORK(&(pLed->BlinkWorkItem), BlinkWorkItemCallback);
}


/*  */
/*	Description: */
/*		DeInitialize an LED_871x object. */
/*  */
void DeInitLed871x(struct LED_871x *pLed)
{
	cancel_work_sync(&(pLed->BlinkWorkItem));
	del_timer_sync(&(pLed->BlinkTimer));
	ResetLedStatus(pLed);
}

/*  */
/*	Description: */
/*		Implementation of LED blinking behavior. */
/*		It toggle off LED and schedule corresponding timer if necessary. */
/*  */

static void SwLedBlink1(struct LED_871x *pLed)
{
	struct adapter *padapter = pLed->padapter;
	struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
	u8 bStopBlinking = false;

	/*  Change LED according to BlinkingLedState specified. */
	if (pLed->BlinkingLedState == RTW_LED_ON) {
		SwLedOn(padapter, pLed);
		RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
	} else {
		SwLedOff(padapter, pLed);
		RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
	}

	if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
		SwLedOff(padapter, pLed);
		ResetLedStatus(pLed);
		return;
	}

	switch (pLed->CurrLedState) {
	case LED_BLINK_SLOWLY:
		if (pLed->bLedOn)
			pLed->BlinkingLedState = RTW_LED_OFF;
		else
			pLed->BlinkingLedState = RTW_LED_ON;
		mod_timer(&pLed->BlinkTimer, jiffies +
			  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
		break;
	case LED_BLINK_NORMAL:
		if (pLed->bLedOn)
			pLed->BlinkingLedState = RTW_LED_OFF;
		else
			pLed->BlinkingLedState = RTW_LED_ON;
		mod_timer(&pLed->BlinkTimer, jiffies +
			  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
		break;
	case LED_BLINK_SCAN:
		pLed->BlinkTimes--;
		if (pLed->BlinkTimes == 0)
			bStopBlinking = true;
		if (bStopBlinking) {
			if (check_fwstate(pmlmepriv, _FW_LINKED)) {
				pLed->bLedLinkBlinkInProgress = true;
				pLed->CurrLedState = LED_BLINK_NORMAL;
				if (pLed->bLedOn)
					pLed->BlinkingLedState = RTW_LED_OFF;
				else
					pLed->BlinkingLedState = RTW_LED_ON;
				mod_timer(&pLed->BlinkTimer, jiffies +
					  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
				RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
			} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
				pLed->bLedNoLinkBlinkInProgress = true;
				pLed->CurrLedState = LED_BLINK_SLOWLY;
				if (pLed->bLedOn)
					pLed->BlinkingLedState = RTW_LED_OFF;
				else
					pLed->BlinkingLedState = RTW_LED_ON;
				mod_timer(&pLed->BlinkTimer, jiffies +
					  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
				RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
			}
			pLed->bLedScanBlinkInProgress = false;
		} else {
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
		}
		break;
	case LED_BLINK_TXRX:
		pLed->BlinkTimes--;
		if (pLed->BlinkTimes == 0)
			bStopBlinking = true;
		if (bStopBlinking) {
			if (check_fwstate(pmlmepriv, _FW_LINKED)) {
				pLed->bLedLinkBlinkInProgress = true;
				pLed->CurrLedState = LED_BLINK_NORMAL;
				if (pLed->bLedOn)
					pLed->BlinkingLedState = RTW_LED_OFF;
				else
					pLed->BlinkingLedState = RTW_LED_ON;
				mod_timer(&pLed->BlinkTimer, jiffies +
					  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
				RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
			} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
				pLed->bLedNoLinkBlinkInProgress = true;
				pLed->CurrLedState = LED_BLINK_SLOWLY;
				if (pLed->bLedOn)
					pLed->BlinkingLedState = RTW_LED_OFF;
				else
					pLed->BlinkingLedState = RTW_LED_ON;
				mod_timer(&pLed->BlinkTimer, jiffies +
					  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
				RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
			}
			pLed->BlinkTimes = 0;
			pLed->bLedBlinkInProgress = false;
		} else {
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
		}
		break;
	case LED_BLINK_WPS:
		if (pLed->bLedOn)
			pLed->BlinkingLedState = RTW_LED_OFF;
		else
			pLed->BlinkingLedState = RTW_LED_ON;
		mod_timer(&pLed->BlinkTimer, jiffies +
			  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
		break;
	case LED_BLINK_WPS_STOP:	/* WPS success */
		if (pLed->BlinkingLedState == RTW_LED_ON)
			bStopBlinking = false;
		else
			bStopBlinking = true;

		if (bStopBlinking) {
			pLed->bLedLinkBlinkInProgress = true;
			pLed->CurrLedState = LED_BLINK_NORMAL;
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
			RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));

			pLed->bLedWPSBlinkInProgress = false;
		} else {
			pLed->BlinkingLedState = RTW_LED_OFF;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
		}
		break;
	default:
		break;
	}
}

 /* ALPHA, added by chiyoko, 20090106 */
static void SwLedControlMode1(struct adapter *padapter, enum LED_CTL_MODE LedAction)
{
	struct led_priv *ledpriv = &(padapter->ledpriv);
	struct LED_871x *pLed = &(ledpriv->SwLed0);
	struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);

	switch (LedAction) {
	case LED_CTL_POWER_ON:
	case LED_CTL_START_TO_LINK:
	case LED_CTL_NO_LINK:
		if (!pLed->bLedNoLinkBlinkInProgress) {
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
				return;
			if (pLed->bLedLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedLinkBlinkInProgress = false;
			}
			if (pLed->bLedBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedBlinkInProgress = false;
			}

			pLed->bLedNoLinkBlinkInProgress = true;
			pLed->CurrLedState = LED_BLINK_SLOWLY;
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
		}
		break;
	case LED_CTL_LINK:
		if (!pLed->bLedLinkBlinkInProgress) {
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
				return;
			if (pLed->bLedNoLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedNoLinkBlinkInProgress = false;
			}
			if (pLed->bLedBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedBlinkInProgress = false;
			}
			pLed->bLedLinkBlinkInProgress = true;
			pLed->CurrLedState = LED_BLINK_NORMAL;
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
		}
		break;
	case LED_CTL_SITE_SURVEY:
		if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
			;
		} else if (!pLed->bLedScanBlinkInProgress) {
			if (IS_LED_WPS_BLINKING(pLed))
				return;
			if (pLed->bLedNoLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedNoLinkBlinkInProgress = false;
			}
			if (pLed->bLedLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				 pLed->bLedLinkBlinkInProgress = false;
			}
			if (pLed->bLedBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedBlinkInProgress = false;
			}
			pLed->bLedScanBlinkInProgress = true;
			pLed->CurrLedState = LED_BLINK_SCAN;
			pLed->BlinkTimes = 24;
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
		 }
		break;
	case LED_CTL_TX:
	case LED_CTL_RX:
		if (!pLed->bLedBlinkInProgress) {
			if (pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
				return;
			if (pLed->bLedNoLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedNoLinkBlinkInProgress = false;
			}
			if (pLed->bLedLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedLinkBlinkInProgress = false;
			}
			pLed->bLedBlinkInProgress = true;
			pLed->CurrLedState = LED_BLINK_TXRX;
			pLed->BlinkTimes = 2;
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
		}
		break;
	case LED_CTL_START_WPS: /* wait until xinpin finish */
	case LED_CTL_START_WPS_BOTTON:
		 if (!pLed->bLedWPSBlinkInProgress) {
			if (pLed->bLedNoLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedNoLinkBlinkInProgress = false;
			}
			if (pLed->bLedLinkBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				 pLed->bLedLinkBlinkInProgress = false;
			}
			if (pLed->bLedBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedBlinkInProgress = false;
			}
			if (pLed->bLedScanBlinkInProgress) {
				del_timer_sync(&(pLed->BlinkTimer));
				pLed->bLedScanBlinkInProgress = false;
			}
			pLed->bLedWPSBlinkInProgress = true;
			pLed->CurrLedState = LED_BLINK_WPS;
			if (pLed->bLedOn)
				pLed->BlinkingLedState = RTW_LED_OFF;
			else
				pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
		 }
		break;
	case LED_CTL_STOP_WPS:
		if (pLed->bLedNoLinkBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedNoLinkBlinkInProgress = false;
		}
		if (pLed->bLedLinkBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			 pLed->bLedLinkBlinkInProgress = false;
		}
		if (pLed->bLedBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedBlinkInProgress = false;
		}
		if (pLed->bLedScanBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedScanBlinkInProgress = false;
		}
		if (pLed->bLedWPSBlinkInProgress)
			del_timer_sync(&(pLed->BlinkTimer));
		else
			pLed->bLedWPSBlinkInProgress = true;
		pLed->CurrLedState = LED_BLINK_WPS_STOP;
		if (pLed->bLedOn) {
			pLed->BlinkingLedState = RTW_LED_OFF;
			mod_timer(&pLed->BlinkTimer, jiffies +
				  msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
		} else {
			pLed->BlinkingLedState = RTW_LED_ON;
			mod_timer(&pLed->BlinkTimer,
				  jiffies + msecs_to_jiffies(0));
		}
		break;
	case LED_CTL_STOP_WPS_FAIL:
		if (pLed->bLedWPSBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedWPSBlinkInProgress = false;
		}
		pLed->bLedNoLinkBlinkInProgress = true;
		pLed->CurrLedState = LED_BLINK_SLOWLY;
		if (pLed->bLedOn)
			pLed->BlinkingLedState = RTW_LED_OFF;
		else
			pLed->BlinkingLedState = RTW_LED_ON;
		mod_timer(&pLed->BlinkTimer, jiffies +
			  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
		break;
	case LED_CTL_POWER_OFF:
		pLed->CurrLedState = RTW_LED_OFF;
		pLed->BlinkingLedState = RTW_LED_OFF;
		if (pLed->bLedNoLinkBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedNoLinkBlinkInProgress = false;
		}
		if (pLed->bLedLinkBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedLinkBlinkInProgress = false;
		}
		if (pLed->bLedBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedBlinkInProgress = false;
		}
		if (pLed->bLedWPSBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedWPSBlinkInProgress = false;
		}
		if (pLed->bLedScanBlinkInProgress) {
			del_timer_sync(&(pLed->BlinkTimer));
			pLed->bLedScanBlinkInProgress = false;
		}
		SwLedOff(padapter, pLed);
		break;
	default:
		break;
	}

	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led %d\n", pLed->CurrLedState));
}

/*  */
/*	Description: */
/*		Handler function of LED Blinking. */
/*  */
void BlinkHandler(struct LED_871x *pLed)
{
	struct adapter *padapter = pLed->padapter;

	if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped))
		return;

	SwLedBlink1(pLed);
}

void LedControl8188eu(struct adapter *padapter, enum LED_CTL_MODE LedAction)
{
	struct led_priv *ledpriv = &(padapter->ledpriv);

	if ((padapter->bSurpriseRemoved) || (padapter->bDriverStopped) ||
	   (!padapter->hw_init_completed))
		return;

	if (!ledpriv->bRegUseLed)
		return;

	if ((padapter->pwrctrlpriv.rf_pwrstate != rf_on &&
	     padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) &&
	    (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
	     LedAction == LED_CTL_SITE_SURVEY ||
	     LedAction == LED_CTL_LINK ||
	     LedAction == LED_CTL_NO_LINK ||
	     LedAction == LED_CTL_POWER_ON))
		return;

	SwLedControlMode1(padapter, LedAction);
}
Commit	Line	Data
7b464c9f LF	1	/******************************************************************************
	2	*
	3	* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
	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	*
7b464c9f LF	14	*
	15	******************************************************************************/
	16
	17	#include <drv_types.h>
	18	#include "rtw_led.h"
	19
	20	/* */
	21	/* Description: */
	22	/* Callback function of LED BlinkTimer, */
	23	/* it just schedules to corresponding BlinkWorkItem/led_blink_hdl */
	24	/* */
28af7ea8	25	void BlinkTimerCallback(unsigned long data)
7b464c9f	26	{
28af7ea8	27	struct LED_871x pLed = (struct LED_871x )data;
7b464c9f LF	28	struct adapter *padapter = pLed->padapter;
	29
	30	if ((padapter->bSurpriseRemoved) \|\| (padapter->bDriverStopped))
	31	return;
	32
f87028f4	33	schedule_work(&(pLed->BlinkWorkItem));
7b464c9f LF	34	}
	35
	36	/* */
	37	/* Description: */
	38	/* Callback function of LED BlinkWorkItem. */
7b464c9f LF	39	/* */
	40	void BlinkWorkItemCallback(struct work_struct *work)
	41	{
	42	struct LED_871x *pLed = container_of(work, struct LED_871x, BlinkWorkItem);
	43	BlinkHandler(pLed);
	44	}
	45
	46	/* */
	47	/* Description: */
	48	/* Reset status of LED_871x object. */
	49	/* */
	50	void ResetLedStatus(struct LED_871x *pLed)
	51	{
	52	pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
	53	pLed->bLedOn = false; /* true if LED is ON, false if LED is OFF. */
	54
	55	pLed->bLedBlinkInProgress = false; /* true if it is blinking, false o.w.. */
	56	pLed->bLedWPSBlinkInProgress = false;
	57
	58	pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
	59	pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
	60
	61	pLed->bLedNoLinkBlinkInProgress = false;
	62	pLed->bLedLinkBlinkInProgress = false;
	63	pLed->bLedStartToLinkBlinkInProgress = false;
	64	pLed->bLedScanBlinkInProgress = false;
	65	}
	66
	67	/Description: /
	68	/* Initialize an LED_871x object. */
373b61b6	69	void InitLed871x(struct adapter padapter, struct LED_871x pLed)
7b464c9f LF	70	{
7b464c9f LF	71	pLed->padapter = padapter;
7b464c9f LF	72
	73	ResetLedStatus(pLed);
	74
28af7ea8 VT	75	setup_timer(&(pLed->BlinkTimer), BlinkTimerCallback,
28af7ea8 VT	76	(unsigned long)pLed);
7b464c9f	77
1781709b	78	INIT_WORK(&(pLed->BlinkWorkItem), BlinkWorkItemCallback);
7b464c9f LF	79	}
	80
	81
	82	/* */
	83	/* Description: */
	84	/* DeInitialize an LED_871x object. */
	85	/* */
	86	void DeInitLed871x(struct LED_871x *pLed)
	87	{
dee7c7f8	88	cancel_work_sync(&(pLed->BlinkWorkItem));
c495fc9e	89	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	90	ResetLedStatus(pLed);
	91	}
	92
	93	/* */
	94	/* Description: */
	95	/* Implementation of LED blinking behavior. */
	96	/* It toggle off LED and schedule corresponding timer if necessary. */
	97	/* */
	98
7b464c9f LF	99	static void SwLedBlink1(struct LED_871x *pLed)
	100	{
	101	struct adapter *padapter = pLed->padapter;
	102	struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
	103	u8 bStopBlinking = false;
	104
	105	/* Change LED according to BlinkingLedState specified. */
	106	if (pLed->BlinkingLedState == RTW_LED_ON) {
	107	SwLedOn(padapter, pLed);
	108	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
	109	} else {
	110	SwLedOff(padapter, pLed);
	111	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
	112	}
	113
	114	if (padapter->pwrctrlpriv.rf_pwrstate != rf_on) {
	115	SwLedOff(padapter, pLed);
	116	ResetLedStatus(pLed);
	117	return;
	118	}
	119
	120	switch (pLed->CurrLedState) {
	121	case LED_BLINK_SLOWLY:
	122	if (pLed->bLedOn)
	123	pLed->BlinkingLedState = RTW_LED_OFF;
	124	else
	125	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	126	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	127	msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
7b464c9f LF	128	break;
	129	case LED_BLINK_NORMAL:
	130	if (pLed->bLedOn)
	131	pLed->BlinkingLedState = RTW_LED_OFF;
	132	else
	133	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	134	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	135	msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
7b464c9f LF	136	break;
	137	case LED_BLINK_SCAN:
	138	pLed->BlinkTimes--;
	139	if (pLed->BlinkTimes == 0)
	140	bStopBlinking = true;
	141	if (bStopBlinking) {
	142	if (check_fwstate(pmlmepriv, _FW_LINKED)) {
	143	pLed->bLedLinkBlinkInProgress = true;
	144	pLed->CurrLedState = LED_BLINK_NORMAL;
	145	if (pLed->bLedOn)
	146	pLed->BlinkingLedState = RTW_LED_OFF;
	147	else
	148	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	149	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	150	msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
7b464c9f LF	151	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
	152	} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
	153	pLed->bLedNoLinkBlinkInProgress = true;
	154	pLed->CurrLedState = LED_BLINK_SLOWLY;
	155	if (pLed->bLedOn)
	156	pLed->BlinkingLedState = RTW_LED_OFF;
	157	else
	158	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	159	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	160	msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
7b464c9f LF	161	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
	162	}
	163	pLed->bLedScanBlinkInProgress = false;
	164	} else {
	165	if (pLed->bLedOn)
	166	pLed->BlinkingLedState = RTW_LED_OFF;
	167	else
	168	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	169	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	170	msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
7b464c9f LF	171	}
	172	break;
	173	case LED_BLINK_TXRX:
	174	pLed->BlinkTimes--;
	175	if (pLed->BlinkTimes == 0)
	176	bStopBlinking = true;
	177	if (bStopBlinking) {
	178	if (check_fwstate(pmlmepriv, _FW_LINKED)) {
	179	pLed->bLedLinkBlinkInProgress = true;
	180	pLed->CurrLedState = LED_BLINK_NORMAL;
	181	if (pLed->bLedOn)
	182	pLed->BlinkingLedState = RTW_LED_OFF;
	183	else
	184	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	185	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	186	msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
7b464c9f LF	187	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
	188	} else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
	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;
4d4efe3e VT	195	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	196	msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
7b464c9f LF	197	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
	198	}
	199	pLed->BlinkTimes = 0;
	200	pLed->bLedBlinkInProgress = false;
87e28d69	201	} else {
	202	if (pLed->bLedOn)
	203	pLed->BlinkingLedState = RTW_LED_OFF;
	204	else
	205	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	206	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	207	msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
7b464c9f	208	}
87e28d69	209	break;
	210	case LED_BLINK_WPS:
	211	if (pLed->bLedOn)
	212	pLed->BlinkingLedState = RTW_LED_OFF;
	213	else
	214	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	215	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	216	msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
87e28d69	217	break;
	218	case LED_BLINK_WPS_STOP: /* WPS success */
	219	if (pLed->BlinkingLedState == RTW_LED_ON)
	220	bStopBlinking = false;
	221	else
	222	bStopBlinking = true;
	223
	224	if (bStopBlinking) {
	225	pLed->bLedLinkBlinkInProgress = true;
	226	pLed->CurrLedState = LED_BLINK_NORMAL;
	227	if (pLed->bLedOn)
	228	pLed->BlinkingLedState = RTW_LED_OFF;
	229	else
	230	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	231	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	232	msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
87e28d69	233	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("CurrLedState %d\n", pLed->CurrLedState));
87e28d69	234
7b464c9f	235	pLed->bLedWPSBlinkInProgress = false;
87e28d69	236	} else {
87e28d69	237	pLed->BlinkingLedState = RTW_LED_OFF;
4d4efe3e VT	238	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	239	msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
7b464c9f	240	}
7b464c9f LF	241	break;
	242	default:
	243	break;
	244	}
7b464c9f LF	245	}
7b464c9f LF	246
87e28d69	247	/* ALPHA, added by chiyoko, 20090106 */
87e28d69	248	static void SwLedControlMode1(struct adapter *padapter, enum LED_CTL_MODE LedAction)
7b464c9f LF	249	{
7b464c9f LF	250	struct led_priv *ledpriv = &(padapter->ledpriv);
7b464c9f	251	struct LED_871x *pLed = &(ledpriv->SwLed0);
87e28d69	252	struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
7b464c9f LF	253
7b464c9f LF	254	switch (LedAction) {
87e28d69	255	case LED_CTL_POWER_ON:
7b464c9f	256	case LED_CTL_START_TO_LINK:
87e28d69	257	case LED_CTL_NO_LINK:
87e28d69	258	if (!pLed->bLedNoLinkBlinkInProgress) {
7b464c9f LF	259	if (pLed->CurrLedState == LED_BLINK_SCAN \|\| IS_LED_WPS_BLINKING(pLed))
7b464c9f LF	260	return;
87e28d69	261	if (pLed->bLedLinkBlinkInProgress) {
c495fc9e	262	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	263	pLed->bLedLinkBlinkInProgress = false;
7b464c9f	264	}
87e28d69	265	if (pLed->bLedBlinkInProgress) {
c495fc9e	266	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	267	pLed->bLedBlinkInProgress = false;
7b464c9f LF	268	}
7b464c9f LF	269
87e28d69	270	pLed->bLedNoLinkBlinkInProgress = true;
	271	pLed->CurrLedState = LED_BLINK_SLOWLY;
	272	if (pLed->bLedOn)
7b464c9f	273	pLed->BlinkingLedState = RTW_LED_OFF;
87e28d69	274	else
7b464c9f	275	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	276	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	277	msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
7b464c9f LF	278	}
	279	break;
	280	case LED_CTL_LINK:
87e28d69	281	if (!pLed->bLedLinkBlinkInProgress) {
7b464c9f LF	282	if (pLed->CurrLedState == LED_BLINK_SCAN \|\| IS_LED_WPS_BLINKING(pLed))
7b464c9f LF	283	return;
87e28d69	284	if (pLed->bLedNoLinkBlinkInProgress) {
c495fc9e	285	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	286	pLed->bLedNoLinkBlinkInProgress = false;
87e28d69	287	}
7b464c9f	288	if (pLed->bLedBlinkInProgress) {
c495fc9e	289	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	290	pLed->bLedBlinkInProgress = false;
7b464c9f LF	291	}
87e28d69	292	pLed->bLedLinkBlinkInProgress = true;
87e28d69	293	pLed->CurrLedState = LED_BLINK_NORMAL;
7b464c9f LF	294	if (pLed->bLedOn)
	295	pLed->BlinkingLedState = RTW_LED_OFF;
	296	else
	297	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	298	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	299	msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
7b464c9f LF	300	}
	301	break;
	302	case LED_CTL_SITE_SURVEY:
	303	if ((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED))) {
87e28d69	304	;
7b464c9f LF	305	} else if (!pLed->bLedScanBlinkInProgress) {
	306	if (IS_LED_WPS_BLINKING(pLed))
	307	return;
7b464c9f	308	if (pLed->bLedNoLinkBlinkInProgress) {
c495fc9e	309	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	310	pLed->bLedNoLinkBlinkInProgress = false;
7b464c9f LF	311	}
87e28d69	312	if (pLed->bLedLinkBlinkInProgress) {
c495fc9e	313	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	314	pLed->bLedLinkBlinkInProgress = false;
87e28d69	315	}
7b464c9f	316	if (pLed->bLedBlinkInProgress) {
c495fc9e	317	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	318	pLed->bLedBlinkInProgress = false;
	319	}
	320	pLed->bLedScanBlinkInProgress = true;
	321	pLed->CurrLedState = LED_BLINK_SCAN;
	322	pLed->BlinkTimes = 24;
	323	if (pLed->bLedOn)
	324	pLed->BlinkingLedState = RTW_LED_OFF;
	325	else
	326	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	327	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	328	msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
87e28d69	329	}
7b464c9f LF	330	break;
	331	case LED_CTL_TX:
	332	case LED_CTL_RX:
	333	if (!pLed->bLedBlinkInProgress) {
	334	if (pLed->CurrLedState == LED_BLINK_SCAN \|\| IS_LED_WPS_BLINKING(pLed))
	335	return;
	336	if (pLed->bLedNoLinkBlinkInProgress) {
c495fc9e	337	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	338	pLed->bLedNoLinkBlinkInProgress = false;
7b464c9f LF	339	}
87e28d69	340	if (pLed->bLedLinkBlinkInProgress) {
c495fc9e	341	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	342	pLed->bLedLinkBlinkInProgress = false;
87e28d69	343	}
7b464c9f LF	344	pLed->bLedBlinkInProgress = true;
	345	pLed->CurrLedState = LED_BLINK_TXRX;
	346	pLed->BlinkTimes = 2;
	347	if (pLed->bLedOn)
	348	pLed->BlinkingLedState = RTW_LED_OFF;
	349	else
	350	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	351	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	352	msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
7b464c9f LF	353	}
	354	break;
	355	case LED_CTL_START_WPS: /* wait until xinpin finish */
	356	case LED_CTL_START_WPS_BOTTON:
87e28d69	357	if (!pLed->bLedWPSBlinkInProgress) {
7b464c9f	358	if (pLed->bLedNoLinkBlinkInProgress) {
c495fc9e	359	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	360	pLed->bLedNoLinkBlinkInProgress = false;
7b464c9f LF	361	}
87e28d69	362	if (pLed->bLedLinkBlinkInProgress) {
c495fc9e	363	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	364	pLed->bLedLinkBlinkInProgress = false;
87e28d69	365	}
7b464c9f	366	if (pLed->bLedBlinkInProgress) {
c495fc9e	367	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	368	pLed->bLedBlinkInProgress = false;
	369	}
	370	if (pLed->bLedScanBlinkInProgress) {
c495fc9e	371	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	372	pLed->bLedScanBlinkInProgress = false;
	373	}
	374	pLed->bLedWPSBlinkInProgress = true;
	375	pLed->CurrLedState = LED_BLINK_WPS;
87e28d69	376	if (pLed->bLedOn)
7b464c9f	377	pLed->BlinkingLedState = RTW_LED_OFF;
87e28d69	378	else
7b464c9f	379	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	380	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	381	msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
87e28d69	382	}
7b464c9f	383	break;
87e28d69	384	case LED_CTL_STOP_WPS:
87e28d69	385	if (pLed->bLedNoLinkBlinkInProgress) {
c495fc9e	386	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	387	pLed->bLedNoLinkBlinkInProgress = false;
7b464c9f	388	}
87e28d69	389	if (pLed->bLedLinkBlinkInProgress) {
c495fc9e	390	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	391	pLed->bLedLinkBlinkInProgress = false;
7b464c9f	392	}
87e28d69	393	if (pLed->bLedBlinkInProgress) {
c495fc9e	394	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	395	pLed->bLedBlinkInProgress = false;
	396	}
	397	if (pLed->bLedScanBlinkInProgress) {
c495fc9e	398	del_timer_sync(&(pLed->BlinkTimer));
87e28d69	399	pLed->bLedScanBlinkInProgress = false;
	400	}
	401	if (pLed->bLedWPSBlinkInProgress)
c495fc9e	402	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f	403	else
87e28d69	404	pLed->bLedWPSBlinkInProgress = true;
	405	pLed->CurrLedState = LED_BLINK_WPS_STOP;
	406	if (pLed->bLedOn) {
	407	pLed->BlinkingLedState = RTW_LED_OFF;
4d4efe3e VT	408	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	409	msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
87e28d69	410	} else {
7b464c9f	411	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	412	mod_timer(&pLed->BlinkTimer,
4d4efe3e VT	413	jiffies + msecs_to_jiffies(0));
87e28d69	414	}
7b464c9f	415	break;
87e28d69	416	case LED_CTL_STOP_WPS_FAIL:
7b464c9f	417	if (pLed->bLedWPSBlinkInProgress) {
c495fc9e	418	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	419	pLed->bLedWPSBlinkInProgress = false;
	420	}
	421	pLed->bLedNoLinkBlinkInProgress = true;
	422	pLed->CurrLedState = LED_BLINK_SLOWLY;
	423	if (pLed->bLedOn)
	424	pLed->BlinkingLedState = RTW_LED_OFF;
	425	else
	426	pLed->BlinkingLedState = RTW_LED_ON;
4d4efe3e VT	427	mod_timer(&pLed->BlinkTimer, jiffies +
4d4efe3e VT	428	msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
7b464c9f LF	429	break;
	430	case LED_CTL_POWER_OFF:
	431	pLed->CurrLedState = RTW_LED_OFF;
	432	pLed->BlinkingLedState = RTW_LED_OFF;
7b464c9f	433	if (pLed->bLedNoLinkBlinkInProgress) {
c495fc9e	434	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	435	pLed->bLedNoLinkBlinkInProgress = false;
	436	}
	437	if (pLed->bLedLinkBlinkInProgress) {
c495fc9e	438	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	439	pLed->bLedLinkBlinkInProgress = false;
	440	}
	441	if (pLed->bLedBlinkInProgress) {
c495fc9e	442	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	443	pLed->bLedBlinkInProgress = false;
	444	}
	445	if (pLed->bLedWPSBlinkInProgress) {
c495fc9e	446	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	447	pLed->bLedWPSBlinkInProgress = false;
	448	}
	449	if (pLed->bLedScanBlinkInProgress) {
c495fc9e	450	del_timer_sync(&(pLed->BlinkTimer));
7b464c9f LF	451	pLed->bLedScanBlinkInProgress = false;
7b464c9f LF	452	}
7b464c9f LF	453	SwLedOff(padapter, pLed);
	454	break;
	455	default:
	456	break;
	457	}
	458
	459	RT_TRACE(_module_rtl8712_led_c_, _drv_info_, ("Led %d\n", pLed->CurrLedState));
	460	}
	461
7b464c9f LF	462	/* */
	463	/* Description: */
	464	/* Handler function of LED Blinking. */
7b464c9f LF	465	/* */
	466	void BlinkHandler(struct LED_871x *pLed)
	467	{
	468	struct adapter *padapter = pLed->padapter;
7b464c9f LF	469
	470	if ((padapter->bSurpriseRemoved) \|\| (padapter->bDriverStopped))
	471	return;
	472
87e28d69	473	SwLedBlink1(pLed);
7b464c9f LF	474	}
7b464c9f LF	475
d33b128e	476	void LedControl8188eu(struct adapter *padapter, enum LED_CTL_MODE LedAction)
7b464c9f LF	477	{
	478	struct led_priv *ledpriv = &(padapter->ledpriv);
	479
bfee7c96	480	if ((padapter->bSurpriseRemoved) \|\| (padapter->bDriverStopped) \|\|
7b464c9f LF	481	(!padapter->hw_init_completed))
	482	return;
	483
	484	if (!ledpriv->bRegUseLed)
	485	return;
	486
	487	if ((padapter->pwrctrlpriv.rf_pwrstate != rf_on &&
	488	padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) &&
	489	(LedAction == LED_CTL_TX \|\| LedAction == LED_CTL_RX \|\|
	490	LedAction == LED_CTL_SITE_SURVEY \|\|
	491	LedAction == LED_CTL_LINK \|\|
	492	LedAction == LED_CTL_NO_LINK \|\|
	493	LedAction == LED_CTL_POWER_ON))
	494	return;
	495
87e28d69	496	SwLedControlMode1(padapter, LedAction);
7b464c9f	497	}