wlan_cmdresp.c

marvell cf wifi driver source code CF-8385-linux-x86-5.0.4.p0-132-src.rar

			Adapter->ulNumOfBSSIDs--;
		}

		Adapter->AdHocFailed = TRUE;

		return 0;
	}
	// Now the join cmd should be successful
	// If BSSID has changed use SSID to compare instead of BSSID
	PRINTK1("Associated with %s\n",
			Adapter->BSSIDList[Adapter->
			ulAttemptedBSSIDIndex].Ssid.Ssid);

	if (memcmp(Adapter->CurBssParams.ssid.Ssid,
				Adapter->BSSIDList[Adapter->
				ulAttemptedBSSIDIndex].Ssid.Ssid,
				Adapter->BSSIDList[Adapter->
				ulAttemptedBSSIDIndex].Ssid.SsidLength)) {
		// Send a Media Connected event, according to the Spec
		Adapter->MediaConnectStatus = WlanMediaStateConnected;
		Adapter->LinkSpeed = MRVDRV_LINK_SPEED_11mbps;

		// NOTE: According to spec, WLAN_STATUS_MEDIA_CONNECT should
		// be indicated only when the first client joins, not
		// when the network is started.  Therefore, CONNECT
		// should not be indicated if the command was AD_HOC_START
		// Set the attempted BSSID Index to current
		Adapter->ulCurrentBSSIDIndex = Adapter->ulAttemptedBSSIDIndex;

		// Set the new SSID to current SSID
		memmove(&(Adapter->CurBssParams.ssid), 
				&(Adapter->BSSIDList[Adapter->
					ulCurrentBSSIDIndex].Ssid),
				sizeof(WLAN_802_11_SSID));

		// If it's a Start command, 
		// set the BSSID to the returned value
		if (Command == HostCmd_RET_802_11_AD_HOC_START) {
			memmove(&(Adapter->BSSIDList[Adapter->
						ulCurrentBSSIDIndex].
						MacAddress),
					pAdHocResult->BSSID, 
					MRVDRV_ETH_ADDR_LEN);

			Adapter->AdHocCreated = TRUE;
		}

		if (Adapter->ulCurrentBSSIDIndex < MRVDRV_MAX_BSSID_LIST) {
			// Set the new BSSID (AP's MAC address) to current BSSID
			memmove(Adapter->CurrentBSSID,
					&(Adapter->BSSIDList[Adapter->
						ulCurrentBSSIDIndex].
						MacAddress),
					MRVDRV_ETH_ADDR_LEN);

			// Make a copy of current BSSID descriptor
			memmove(&(Adapter->CurrentBSSIDDescriptor),
					&(Adapter->BSSIDList[Adapter->
						ulCurrentBSSIDIndex]),
					sizeof(WLAN_802_11_BSSID));

			/* Copy adhoc'd bssid into Current BSS State struct */
			memcpy(&Adapter->CurBssParams.bssid, &Adapter->
				BSSIDList[Adapter-> ulCurrentBSSIDIndex],
				sizeof(WLAN_802_11_BSSID));

			// Set the new configuration to the current config
			memmove(&Adapter->CurrentConfiguration,
					&(Adapter->BSSIDList[Adapter->
						ulCurrentBSSIDIndex].
						Configuration), 
					sizeof(WLAN_802_11_CONFIGURATION));
		}
	}
	// if the periodic timer is on, cancel it
	if (Adapter->TimerIsSet == TRUE) {
		CancelTimer(&Adapter->MrvDrvTimer);
		Adapter->TimerIsSet = FALSE;
	}

	Adapter->m_NumAssociationAttemp = 0;

	netif_carrier_on(priv->wlan_dev.netdev);
		
	memset(&wrqu, 0, sizeof(wrqu));
	memcpy(wrqu.ap_addr.sa_data, Adapter->CurrentBSSID, ETH_ALEN);
	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
	wireless_send_event(priv->wlan_dev.netdev, SIOCGIWAP, &wrqu, NULL); 


	PRINTK1("HWAC - Joined/Started Ad Hoc\n");
	PRINTK1("Ad-Hoc Channel = %d\n", Adapter->AdhocChannel);
	PRINTK1("BSSID  %x:%x:%x:%x:%x:%x\n",
			pAdHocResult->BSSID[0], pAdHocResult->BSSID[1],
			pAdHocResult->BSSID[2], pAdHocResult->BSSID[3],
			pAdHocResult->BSSID[4], pAdHocResult->BSSID[5]);

	LEAVE();
	return ret;
}

static int wlan_ret_802_11_reset(wlan_private * priv, HostCmd_DS_COMMAND * resp)
{
	wlan_adapter   *Adapter = priv->adapter;

    	ENTER();
    	PRINTK1("HWAC - Reset command successful\n");

    	// We are going to rely on PreviousSSID to do association again,
    	// so if it's zero, we need to return ResetComplete instead of 
    	// doing more association 

	if (!Adapter->PreviousSSID.SsidLength) {
		// if there is a reset pending
		if (Adapter->bIsPendingReset == TRUE) {
			Adapter->bIsPendingReset = FALSE;
			PRINTK1("HWAC - Sending ResetComplete\n");
			Adapter->HardwareStatus = WlanHardwareStatusReady;
		}
	}

	return 0;
}

static int wlan_ret_802_11_query_traffic(wlan_private * priv,
		HostCmd_DS_COMMAND * resp)
{
	/*
	 * There is nothing to be done here !! 
	 */
	return 0;
}

static int wlan_ret_802_11_status_info(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_QUERY_STATUS	*pStatus = &resp->params.qstatus;
	wlan_adapter			*Adapter = priv->adapter;

	Adapter->HardwareStatus		= WlanHardwareStatusReady;
	Adapter->LinkSpeed		= wlan_le32_to_cpu(pStatus->MaxLinkSpeed);
	Adapter->FWStatus		= wlan_le16_to_cpu(pStatus->FWStatus);
	Adapter->MACStatus		= wlan_le16_to_cpu(pStatus->MACStatus);
	Adapter->RFStatus		= wlan_le16_to_cpu(pStatus->RFStatus);
	Adapter->CurrentChannel		= wlan_le16_to_cpu(pStatus->CurrentChannel);

	return 0;
}

static int wlan_ret_802_11_authenticate(wlan_private * priv,
			     HostCmd_DS_COMMAND * resp)
{
	/*
	 * TODO Further processing of data 
	 */

	return 0;
}

static int wlan_ret_802_11_stat(wlan_private * priv, HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_GET_STAT	*p11Stat = &resp->params.gstat;
	wlan_adapter			*Adapter = priv->adapter;
	
	/* TODO Convert it to Big endian befor copy */
	memcpy(&Adapter->wlan802_11Stat, p11Stat, 
					sizeof(HostCmd_DS_802_11_GET_STAT));
	return 0;
}

/* TODO: Enable this if the firmware supports */
#if 0
static int wlan_ret_802_3_stat(wlan_private * priv, HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_3_GET_STAT	*p3Stat = &resp->params.gstat_8023;
	wlan_adapter			*Adapter = priv->adapter;

	ENTER();

	/* TODO Convert it to Big endian before copy */
	memcpy(&Adapter->wlan802_3Stat, p3Stat, 
			sizeof(HostCmd_DS_802_3_GET_STAT));
	
	PRINTK1("Xmitok = %d\n Rcvok = %d\n XmitErrot %d\n RcvError %d\n" 
			" RcvNoBuffer %d\n RcvCRCError %d\n", 
			Adapter->wlan802_3Stat.XmitOK, 
			Adapter->wlan802_3Stat.RcvOK,        
			Adapter->wlan802_3Stat.XmitError, 
			Adapter->wlan802_3Stat.RcvError,
			Adapter->wlan802_3Stat.RcvNoBuffer, 
			Adapter->wlan802_3Stat.RcvCRCError);
	LEAVE();
	return 0;
}
#endif

static int wlan_ret_802_11_snmp_mib(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
#ifdef DEBUG_LEVEL1
	HostCmd_DS_802_11_SNMP_MIB	*smib = &resp->params.smib;
	wlan_adapter			*Adapter = priv->adapter;
	u16				OID = wlan_le16_to_cpu(smib->OID);
#endif

	ENTER();

	PRINTK1("value of the OID = %x\n", OID);
	PRINTK1("Buf size  = %x\n", wlan_le16_to_cpu(smib->BufSize));

#ifdef DEBUG_LEVEL1
	if (OID == OID_802_11_RTS_THRESHOLD) {
		PRINTK1("Adapter->RTSThsd =%u\n", Adapter->RTSThsd);
	} else if (OID == OID_802_11_FRAGMENTATION_THRESHOLD) {
		PRINTK1("Adapter->FragThsd =%u\n", Adapter->FragThsd);
	} else if (OID == OID_802_11_INFRASTRUCTURE_MODE) {
		PRINTK1("Adapter->InfrastructureMode = %x\n",
				Adapter->InfrastructureMode);
		PRINTK1("set to adhoc /infra mode\n");
	}
#endif

	LEAVE();
	return 0;
}

static int wlan_ret_802_11_radio_control(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	ENTER();

	LEAVE();
	return 0;
}

#ifdef BCA
static int wlan_ret_bca_config(wlan_private * priv,
			      HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_BCA_CONFIG 	*pBca = &resp->params.bca_config;
	wlan_adapter   		*Adapter = priv->adapter;

	ENTER();

	Adapter->bca.Mode = wlan_le16_to_cpu(pBca->Mode);
	Adapter->bca.Antenna = wlan_le16_to_cpu(pBca->Antenna);
	Adapter->bca.BtFreq = wlan_le16_to_cpu(pBca->BtFreq);
	Adapter->bca.TxPriorityLow32 = wlan_le32_to_cpu(pBca->TxPriorityLow32);
	Adapter->bca.TxPriorityHigh32 =wlan_le32_to_cpu(pBca->TxPriorityHigh32);
	Adapter->bca.RxPriorityLow32 = wlan_le32_to_cpu(pBca->RxPriorityLow32);
	Adapter->bca.RxPriorityHigh32 =wlan_le32_to_cpu(pBca->RxPriorityHigh32);

	PRINTK("ret_bca: mode=%X ant=%X btfreq=%X TxL=%X TxH=%X"
			" RxL=%X RxH=%X\n",pBca->Mode,pBca->Antenna,
			pBca->BtFreq,pBca->TxPriorityLow32,
			pBca->TxPriorityHigh32,pBca->RxPriorityLow32,
			pBca->RxPriorityHigh32);
	LEAVE();
	return 0;
}
#endif

#ifdef	PS_REQUIRED
static int wlan_ret_set_pre_tbtt(wlan_private *priv, 
					HostCmd_DS_COMMAND *resp)
{
#ifdef	DEBUG_LEVEL1
	HostCmd_DS_802_11_PRE_TBTT	*pTbtt = &resp->params.pretbtt;
#endif

	ENTER();

	PRINTK1("PS Wakeup Time %d\n", wlan_le16_to_cpu(pTbtt->Value));

	LEAVE();
	return 0;
}
#endif 

#ifdef ADHOCAES
int HandleAdhocEncryptResponse(wlan_private *priv, 
					PHostCmd_DS_802_11_PWK_KEY pEncKey)
{
	ENTER();

	wlan_adapter	*Adapter	= priv->adapter;

	Adapter->pwkkey.Action = pEncKey->Action;

	memcpy(Adapter->pwkkey.TkipEncryptKey, pEncKey->TkipEncryptKey,
					sizeof(pEncKey->TkipEncryptKey));
	memcpy(Adapter->pwkkey.TkipTxMicKey, pEncKey->TkipTxMicKey,
						sizeof(pEncKey->TkipTxMicKey));
	memcpy(Adapter->pwkkey.TkipRxMicKey, pEncKey->TkipRxMicKey,
						sizeof(pEncKey->TkipRxMicKey));

	HEXDUMP("ADHOC KEY", (u8*)Adapter->pwkkey.TkipEncryptKey, 
			sizeof(pEncKey->TkipEncryptKey));

	LEAVE();
	return 0;
}
#endif /* end of ADHOCAES */

#ifdef WPA
static int wlan_ret_802_11_pwk_key(wlan_private * priv,
						HostCmd_DS_COMMAND * resp) 
{
	HostCmd_DS_802_11_PWK_KEY 	*pPwkKey = &resp->params.pwkkey;
	wlan_adapter			*Adapter = priv->adapter;
#ifdef	ADHOCAES	
	u16				Action = wlan_le16_to_cpu(pPwkKey->Action);
	int ret = 0;
#endif
	
	if (Adapter->InfrastructureMode == Wlan802_11Infrastructure) {
		memcpy(Adapter->pwkkey.TkipEncryptKey, pPwkKey->TkipEncryptKey,
				sizeof(pPwkKey->TkipEncryptKey));
		memcpy(Adapter->pwkkey.TkipTxMicKey, pPwkKey->TkipTxMicKey,
				sizeof(pPwkKey->TkipTxMicKey));
		memcpy(Adapter->pwkkey.TkipRxMicKey, pPwkKey->TkipRxMicKey,
				sizeof(pPwkKey->TkipRxMicKey));
	}

#ifdef	ADHOCAES	
	if (Adapter->InfrastructureMode == Wlan802_11IBSS) {
		ret = 	HandleAdhocEncryptResponse(priv, pPwkKey);
					
		if ((Action == HostCmd_ACT_GET) ||
				(Action == HostCmd_ACT_GET + 2))
				wake_up_interruptible(&Adapter->cmd_EncKey);
	}

#endif
	LEAVE();
	return 0;
}
#endif

#ifdef WPA2
static int wlan_ret_802_11_key_material(wlan_private * priv,
						HostCmd_DS_COMMAND * resp) 
{
	HostCmd_DS_802_11_KEY_MATERIAL 	*pKey = &resp->params.keymaterial;
	wlan_adapter			*Adapter = priv->adapter;

	ENTER();

	if ((Adapter->IsGTK_SET == (TRUE + 1)) && (pKey->Action == HostCmd_ACT_SET))
		Adapter->IsGTK_SET = TRUE;

	memcpy(Adapter->aeskey.KeyParamSet.Key, pKey->KeyParamSet.Key,
				sizeof(pKey->KeyParamSet.Key));

	LEAVE();
	return 0;
}
#endif

static int wlan_ret_802_11_mac_address(wlan_private * priv,
						HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_MAC_ADDRESS	*MacAdd = &resp->params.macadd;
	wlan_adapter			*Adapter = priv->adapter;
	
	ENTER();
	
	memcpy(Adapter->CurrentAddr, MacAdd->MacAdd, ETH_ALEN);
	
	LEAVE();
	return 0;
}

static int wlan_ret_802_11_rf_tx_power(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_RF_TX_POWER	*rtp = &resp->params.txp;
	wlan_adapter			*Adapter = priv->adapter;

	ENTER();

	Adapter->TxPowerLevel = wlan_le16_to_cpu(rtp->CurrentLevel); 
 
	PRINTK1("Current TxPower Level = %d\n", Adapter->TxPowerLevel);

	LEAVE();
	return 0;
}

static int wlan_ret_802_11_rf_antenna(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	PHostCmd_DS_802_11_RF_ANTENNA	pAntenna = &resp->params.rant;
	wlan_adapter			*Adapter = priv->adapter;
	u16				Action = wlan_le16_to_cpu(pAntenna->Action);

	if (Action == HostCmd_ACT_GET_RX)
		Adapter->RxAntennaMode = wlan_le16_to_cpu(pAntenna->AntennaMode);

	if (Action == HostCmd_ACT_GET_TX)
		Adapter->TxAntennaMode = wlan_le16_to_cpu(pAntenna->AntennaMode);

	PRINTK1("RET_802_11_RF_ANTENNA: Action = 0x%x, Mode = 0x%04x\n",
			Action, wlan_le16_to_cpu(pAntenna->AntennaMode));

	return 0;
}

static int wlan_ret_mac_multicast_adr(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	/*
	 * TODO: enable multicast handling 
	 */
	return 0;
}

static int wlan_ret_802_11_rate_adapt_rateset(wlan_private *priv,
						HostCmd_DS_COMMAND *resp)
{
	HostCmd_DS_802_11_RATE_ADAPT_RATESET	*rates = 
						&resp->params.rateset;
	wlan_adapter				*Adapter = priv->adapter;

	ENTER();

	if (rates->Action == HostCmd_ACT_GET) {
		Adapter->EnableHwAuto = rates->EnableHwAuto;
		Adapter->RateBitmap = rates->Bitmap;
	}

	LEAVE();

	return 0;
}

static int wlan_ret_802_11_data_rate(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_DATA_RATE	*pDataRate = &resp->params.drate;
	wlan_adapter			*Adapter = priv->adapter;
	u8				Dot11DataRate;

	ENTER();

	HEXDUMP("data_rate: ",
			(u8 *)pDataRate,s