wlan_cmdresp.c

marvell wifi driver GSPI-8385-LINUX-OMAP1510-5.0.10.p0-144-src.rar

/*
 * File : wlan_cmdresp.c 
 */

#include	"include.h"

#ifdef FW_WAKEUP_TIME
unsigned long wt_pwrup_sending=0L, wt_pwrup_sent=0L, wt_int=0L, wt_wakeup_event=0L, wt_awake_confirmrsp=0L;
#endif

static void HandleDisconnectEvent(wlan_private * priv)
{
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();
	
	if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
		MacEventDisconnected(priv);
#ifdef REASSOCIATION
		if (Adapter->Reassoc_on == TRUE ) {
			Adapter->TimerIsSet = TRUE;
			PRINTK1("Going to trigger the timer immediately\n");
			ModTimer(&Adapter->MrvDrvTimer, 0);
		}
#endif /* REASSOCIATION */
	}
}

#ifdef WPA
static inline void HandleMICFailureEvent(wlan_private *priv, int event)
{
	unsigned char		buf[50];
	
	ENTER();

	memset(buf, 0, sizeof(buf));
	
	sprintf(buf, "%s", "MLME-MICHAELMICFAILURE.indication ");
	
	if (event == MACREG_INT_CODE_MIC_ERR_UNICAST) {
		strcat(buf, "unicast ");
	} else {
		strcat(buf, "multicast ");
	}
	
	send_iwevcustom_event(priv, buf);

	LEAVE();
}
#endif

#ifdef BG_SCAN
static inline int sendBgScanQueryCmd(wlan_private *priv)
{
	wlan_adapter    *Adapter = priv->adapter;
	int		ret = 0;

	/* Clear the previous scan result */
	Adapter->ulNumOfBSSIDs = 0;
	memset(Adapter->BSSIDList, 0, 
		sizeof(WLAN_802_11_BSSID) * MRVDRV_MAX_BSSID_LIST);

	ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_BG_SCAN_QUERY,
			0, HostCmd_OPTION_USE_INT,
			0, HostCmd_PENDING_ON_NONE, NULL);

	return ret;
}
#endif /* BG_SCAN */

#ifdef SUBSCRIBE_EVENT_CTRL
static int wlan_cmd_ret_802_11_subscribe_events(wlan_private *priv,
						HostCmd_DS_COMMAND *resp)
{
	HostCmd_DS_802_11_SUBSCRIBE_EVENT	*subevent = 
						&resp->params.events;
	wlan_adapter				*Adapter = priv->adapter;

	ENTER();

	if (subevent->Action == HostCmd_ACT_GET) {
		PRINTK("Get Subscribed Events\n");
		Adapter->GetEvents = subevent->Events;
	}
	
	return 0;
	LEAVE();
}
#endif

int wlan_process_event(wlan_private * priv)
{
	int		ret = 0;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

	/*
	* The Device scratch register 2 tells us the event! 
	* shifting them by 8 to reach there ??
	*/

	PRINTK1("EVENT Cause %x\n", Adapter->EventCause);

	switch (Adapter->EventCause >> SBI_EVENT_CAUSE_SHIFT) {
		case MACREG_INT_CODE_LINK_SENSED:
			PRINTK1("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
			break;

		case MACREG_INT_CODE_DEAUTHENTICATED:
			PRINTK1("EVENT: HWAC - Deauthenticated Actually\n");
			HandleDisconnectEvent(priv);
			break;

		case MACREG_INT_CODE_DISASSOCIATED:
			PRINTK1("EVENT: HWAC - Disassociated\n");
			HandleDisconnectEvent(priv);
			break;

		case MACREG_INT_CODE_LINK_LOSE_NO_SCAN:
			PRINTK("EVENT:  HWAC - Link lost ***\n");
			HandleDisconnectEvent(priv);
			break;

		case MACREG_INT_CODE_DUMMY_PKT:
			priv->wlan_dev.dnld_sent = DNLD_RES_RECEIVED;
			TXRX_DEBUG_GET_ALL(0x40, 0xff, 0xff);
			TXRX_DEBUG_GET_TIME(6);

			PRINTK1("EVENT: recieved tx done interrupt"
						" calling Send Single\n");
			break;

		/*
		 * Before going to sleep 
		 * 	a) Test if any packets are there to
		 * 		send, since we have only a single buffer 
		 * 		just wake up the thread which pushes the 
		 * 		data out (if the data is not pushed)
		 * 	b) When waking up , check if there is any data to 
		 * 		be pushed out! Else go back to sleep again 
		 */
#ifdef PS_REQUIRED
		case MACREG_INT_CODE_PS_SLEEP:
			PRINTK1("EVENT: SLEEP\n");
			PRINTK("_");
#ifdef	DEBUG
			Adapter->SleepCounter++;

			/* Reset consecutive WAKE Counter */
			Adapter->ConsecutiveAwake = 0;
#endif

			/* handle unexpected PS SLEEP event */
			if (Adapter->PSState == PS_STATE_FULL_POWER) {
				PRINTK1("In FULL POWER mode - ignore PS SLEEP\n");
				break;
			}

#ifdef PS_PRESLEEP
			Adapter->PSState = PS_STATE_PRE_SLEEP;
#endif

			PSConfirmSleep(priv, (u16) Adapter->PSMode);

#ifdef	DEBUG
			PRINTK1("SleepCounter: %u ConfirmCounter: %u\n",
			Adapter->SleepCounter, Adapter->ConfirmCounter);
#endif
			break;

		case MACREG_INT_CODE_PS_AWAKE:
			PRINTK1("EVENT: AWAKE \n");
			PRINTK("|");

#ifdef	DEBUG
			/*
			 * Did we get 2 consecutive AWAKE events 
			 */
			if (++Adapter->ConsecutiveAwake > 1) {
				Adapter->NumConsecutiveAwakes++;
				PRINTK1("ERROR: Received %u consecutive"
						" AWAKE events (Total:%u)!",
						Adapter->ConsecutiveAwake, 
						Adapter->NumConsecutiveAwakes);
			}
#endif

			/* handle unexpected PS AWAKE event */
			if (Adapter->PSState == PS_STATE_FULL_POWER) {
				PRINTK1("In FULL POWER mode - ignore PS AWAKE\n");
				break;
			}

#ifdef WMM_UAPSD
			if ((Adapter->CurBssParams.wmm_uapsd_enabled == TRUE) && (Adapter->wmm.qosinfo != 0))
			{
				if (wmm_lists_empty(priv) && (Adapter->sleep_period.period != 0))
				{
					if ( Adapter->wmm.gen_null_pkg ) {
				 		SendNullPacket(priv, 
							MRVDRV_TxPD_POWER_MGMT_NULL_PACKET | 
							MRVDRV_TxPD_POWER_MGMT_LAST_PACKET);
					}
					Adapter->wmm.no_more_packet = 1;
				}
				else
				{
					Adapter->wmm.no_more_packet = 0;
				}
			}
#endif
			Adapter->PSState = PS_STATE_AWAKE;

			if (Adapter->NeedToWakeup == TRUE) {
				// wait for the command processing to finish
				// before resuming sending 
				// Adapter->NeedToWakeup will be set to FALSE 
				// in PSWakup()
				PRINTK1("Waking up...\n");
				PSWakeup(priv, 0);
			}
			break;
#endif	/* PS_REQURIED */

#ifdef DEEP_SLEEP
		case MACREG_INT_CODE_DEEP_SLEEP_AWAKE:
		        sbi_reset_deepsleep_wakeup(priv);
			PRINTK1("DEEP SLEEP AWAKE Event!\n");

			Adapter->IsDeepSleep = FALSE;
			if (netif_queue_stopped(priv->wlan_dev.netdev))
				netif_wake_queue(priv->wlan_dev.netdev);

			wake_up_interruptible(&Adapter->ds_awake_q);
			break;
#endif // DEEP_SLEEP

#ifdef HOST_WAKEUP
		case MACREG_INT_CODE_HOST_WAKE_UP:
			Adapter->bHostWakeupDevRequired = FALSE;
			Adapter->WakeupTries = 0;
#ifdef FW_WAKEUP_TIME
			wt_wakeup_event = get_utimeofday();
#endif
#ifdef DEEP_SLEEP
		        sbi_reset_deepsleep_wakeup(priv);
			PRINTK("HOST WAKE UP Event!\n");

			// in BG SCAN mode w/ deep sleep, WAKE UP event
			// will be sent directly, no Deep Sleep Awake will
			// be sent. so we need to wakeup ds_awake_q here
			wake_up_interruptible(&Adapter->ds_awake_q); 
#endif // DEEP_SLEEP
			ret = PrepareAndSendCommand(priv,
					HostCmd_CMD_802_11_HOST_AWAKE_CONFIRM,
					0, HostCmd_OPTION_USE_INT, 0,
					HostCmd_PENDING_ON_NONE, NULL);
			break;
#endif // HOST_WAKEUP

#ifdef WPA
		case MACREG_INT_CODE_MIC_ERR_UNICAST:
			PRINTK1("EVENT: UNICAST MIC ERROR\n");
			HandleMICFailureEvent(priv, 
					MACREG_INT_CODE_MIC_ERR_UNICAST);
			break;
		
		case MACREG_INT_CODE_MIC_ERR_MULTICAST:
			PRINTK1("EVENT: MULTICAST MIC ERROR\n");
			HandleMICFailureEvent(priv, 
					MACREG_INT_CODE_MIC_ERR_MULTICAST);
			break;
#endif
		case MACREG_INT_CODE_MIB_CHANGED:
		case MACREG_INT_CODE_INIT_DONE:
			break;

		case MACREG_INT_CODE_ADHOC_BCN_LOST:
			PRINTK1("EVENT: HWAC - ADHOC BCN LOST\n");		
			break;
#ifdef BG_SCAN
		case MACREG_INT_CODE_BG_SCAN_REPORT:
			PRINTK1("EVENT: Background SCAN Report\n");		
			ret = sendBgScanQueryCmd(priv);
			break;
#endif /* BG_SCAN */ 
#ifdef WMM
		case MACREG_INT_CODE_WMM_STATUS_CHANGE:
			printk("EVENT: WMM status changed\n");		
			if(!netif_carrier_ok(priv->wlan_dev.netdev) &&
					(priv->adapter->MediaConnectStatus ==
					  WlanMediaStateConnected))
				netif_carrier_on(priv->wlan_dev.netdev);

			ret = sendWMMStatusChangeCmd(priv);
			break;
#endif /* WMM */

#ifdef SUBSCRIBE_EVENT_CTRL
		case MACREG_INT_CODE_RSSI_LOW:
			printk(KERN_ALERT "EVENT: RSSI_LOW\n");		
			break;
		case MACREG_INT_CODE_SNR_LOW:
			printk(KERN_ALERT "EVENT: SNR_LOW\n");		
			break;
		case MACREG_INT_CODE_MAX_FAIL:
			printk(KERN_ALERT "EVENT: MAX_FAIL\n");		
			break;
#endif

		default:
			PRINTK("EVENT: unknown event id: %#x\n",
				Adapter->EventCause >> SBI_EVENT_CAUSE_SHIFT);
			break;
	}

	Adapter->EventCause = 0;
	LEAVE();
	return ret;
}

/*The function needs to update for Ver4 new Scan Resp format*/
int InterpretBSSDescriptionWithIE(wlan_private * priv,
			      void *RetCommandBuffer,
			      u32 ulBSSDescriptionListSize,
			      int next_bssid_index)
{

	wlan_adapter			*Adapter = priv->adapter;
	u8				*pCurrentPtr, *pNextBeacon;
	u32				nBytesLeft;
	u32				ulBSSIDIndex = next_bssid_index;

	PWLAN_802_11_BSSID		pBSSIDList;
	IEEEtypes_ElementId_e		nElemID;
	IEEEtypes_FhParamSet_t		*pFH;
	IEEEtypes_DsParamSet_t		*pDS;
	IEEEtypes_CfParamSet_t		*pCF;
	IEEEtypes_IbssParamSet_t	*pIbss;
	IEEEtypes_CapInfo_t		*pCap;

	/* store the BSSID's information element */
	MRV_BSSID_IE_LIST       	IEBuffer;
	WLAN_802_11_FIXED_IEs		*pFixedIE;
	WLAN_802_11_VARIABLE_IEs	*pVariableIE;

	u16				usBeaconSize;
	u16				usBytesLeftForCurrentBeacon;
	u8				ucElemLen, ucRateSize = 0;
	BOOLEAN				bFoundDataRateIE;
	u16				usNumLineToPrint;

#ifdef WPA
	PWPA_SUPPLICANT			pwpa_supplicant;
#ifdef WPA2
	PWPA_SUPPLICANT			pwpa2_supplicant;
#endif //WPA2
	IE_WPA				*pIe;
	u8				oui01[4] = { 0x00, 0x50, 0xf2, 0x01 };
#endif //WPA
#ifdef WMM
	static u8 oui02[4] = { 0x00, 0x50, 0xf2, 0x02 };
#endif /* WMM */

#ifdef ENABLE_802_11D
	IEEEtypes_CountryInfoSet_t 	*pcountryinfo;
#endif
	
	ENTER();

	// Initialize the current pointer to the Command buffer
	pNextBeacon = pCurrentPtr = (u8 *) RetCommandBuffer;

	if (!next_bssid_index) {
		// Clean up the current BSSID List
		memset(Adapter->BSSIDList, 0,
		sizeof(WLAN_802_11_BSSID) * MRVDRV_MAX_BSSID_LIST);
	}
    
	// At the beginning, nBytesLeft is the total BSSDescription List
	nBytesLeft = (LONG) ulBSSDescriptionListSize;

	// expected format :

	// Length - 2 bytes
	// BSSId - 6 bytes
	// IE - variable length

	while (nBytesLeft > 0 && ulBSSIDIndex < Adapter->ulNumOfBSSIDs) {

		pCurrentPtr = pNextBeacon;

		memcpy(&usBeaconSize, pCurrentPtr, sizeof(u16));

		usBeaconSize = wlan_le16_to_cpu(usBeaconSize);
		
		usBytesLeftForCurrentBeacon = usBeaconSize;

		if (usBeaconSize > nBytesLeft) {
			Adapter->ulNumOfBSSIDs = ulBSSIDIndex;
			return -1;
		}
		usNumLineToPrint = (usBeaconSize + 15) >> 4;

		pCurrentPtr += sizeof(usBeaconSize);

		pNextBeacon = pCurrentPtr + usBeaconSize;

		pBSSIDList = &Adapter->BSSIDList[ulBSSIDIndex];
		pFixedIE = &IEBuffer.FixedIE;
		
		pBSSIDList->IELength = wlan_le32_to_cpu(pBSSIDList->IELength);
		PRINTK1("(In WithIE fun)pFixedIE->Capabilities=0x%X\n", pFixedIE->Capabilities);

		pVariableIE = (PWLAN_802_11_VARIABLE_IEs)IEBuffer.VariableIE;

#ifdef WPA
		pwpa_supplicant = &Adapter->BSSIDList[ulBSSIDIndex].wpa_supplicant;
#ifdef WPA2
		pwpa2_supplicant = &Adapter->BSSIDList[ulBSSIDIndex].wpa2_supplicant;
#endif //WPA2
#endif //WPA
		memcpy(pBSSIDList->MacAddress, pCurrentPtr, 
							MRVDRV_ETH_ADDR_LEN);
		PRINTK1("AP MAC Addr: %x:%x:%x:%x:%x:%x\n",
			pBSSIDList->MacAddress[0], pBSSIDList->MacAddress[1],
			pBSSIDList->MacAddress[2], pBSSIDList->MacAddress[3],
			pBSSIDList->MacAddress[4], pBSSIDList->MacAddress[5]);

		pCurrentPtr += MRVDRV_ETH_ADDR_LEN;
		usBytesLeftForCurrentBeacon -= MRVDRV_ETH_ADDR_LEN;
		pBSSIDList->Configuration.Length =
					sizeof(WLAN_802_11_CONFIGURATION);

		if (usBytesLeftForCurrentBeacon < 12) {
			PRINTK1("Not enough bytes left\n");
			Adapter->ulNumOfBSSIDs = ulBSSIDIndex;
			return -1;
		}
		
		// rest of the current buffer are IE's
		pBSSIDList->IELength = usBytesLeftForCurrentBeacon;
		PRINTK1("IELength for this AP = %d\n", 
						(u32) pBSSIDList->IELength);

#ifdef TLV_SCAN
		pBSSIDList->Rssi = wlan_le32_to_cpu((LONG) (*pCurrentPtr)) + 
						MRVDRV_RSSI_DEFAULT_NOISE_VALUE;
		PRINTK("Enable RSSI(1byte): %02X\n", *pCurrentPtr );
		pCurrentPtr +=1;
		usBytesLeftForCurrentBeacon -= 1;
#endif /*TLV_SCAN*/