wlan_cmdresp.c

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

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)
{
	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;
}

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 WPA
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)
{
	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,sizeof(HostCmd_DS_802_11_DATA_RATE));

	Dot11DataRate = pDataRate->DataRate[0];
	if (pDataRate->Action == HostCmd_ACT_GET_TX_RATE) 
	{
		memcpy(Adapter->SupportedRates, pDataRate->DataRate,
				sizeof(Adapter->SupportedRates));
	}
	Adapter->DataRate = index_to_data_rate(Dot11DataRate);

	PRINTK("Data Rate = %d\n", Adapter->DataRate);
    
	LEAVE();
	return 0;
}

static int wlan_ret_802_11_rf_channel(wlan_private * priv, 
		HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_RF_CHANNEL	*rfchannel = &resp->params.rfchannel;
	wlan_adapter			*Adapter = priv->adapter;
	u16				Action = wlan_le16_to_cpu(rfchannel->Action);

	ENTER();

	if (Action == RF_GET) {
		Adapter->Channel = wlan_le16_to_cpu(rfchannel->CurrentChannel);
	}

	LEAVE();
	return 0;
}

static int wlan_ret_802_11_rssi(wlan_private * priv, 
		HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_RSSI_RSP	*rssirsp = &resp->params.rssirsp;
	wlan_adapter		*Adapter = priv->adapter;

	/* store the non average value */
	Adapter->SNR[TYPE_BEACON][TYPE_NOAVG]	= wlan_le16_to_cpu(rssirsp->SNR);
	Adapter->NF[TYPE_BEACON][TYPE_NOAVG]	= wlan_le16_to_cpu(rssirsp->NoiseFloor);
	    
	Adapter->SNR[TYPE_BEACON][TYPE_AVG] = wlan_le16_to_cpu(rssirsp->AvgSNR);
	Adapter->NF[TYPE_BEACON][TYPE_AVG] = wlan_le16_to_cpu(rssirsp->AvgNoiseFloor);

	Adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = 
		CAL_RSSI(Adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
				Adapter->NF[TYPE_BEACON][TYPE_NOAVG]);

	Adapter->RSSI[TYPE_BEACON][TYPE_AVG] = 
		CAL_RSSI(Adapter->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
			Adapter->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
    
	PRINTK1("Beacon RSSI value = 0x%x\n", 
		Adapter->RSSI[TYPE_BEACON][TYPE_AVG]);

	return 0;
}

#ifdef	MANF_CMD_SUPPORT
static int wlan_ret_mfg_cmd(wlan_private * priv, HostCmd_DS_COMMAND * resp)
{
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

	if (Adapter->mfg_cmd_flag == 1) {
		// enough buffer for the response
		if (priv->wlan_dev.upld_len <= Adapter->mfg_cmd_len) {
			memcpy(Adapter->mfg_cmd,
					Adapter->CurCmd->BufVirtualAddr,
					priv->wlan_dev.upld_len);
			Adapter->mfg_cmd_resp_len = priv->wlan_dev.upld_len;
		} else {
			memset(Adapter->mfg_cmd, 0, Adapter->mfg_cmd_len);
			Adapter->mfg_cmd_resp_len = -1;
		}
		wake_up_interruptible(&(Adapter->mfg_cmd_q));
		Adapter->mfg_cmd_flag = 0;
	}

	LEAVE();
	return 0;
}
#endif

#ifdef MULTI_BANDS
static int wlan_ret_802_11_band_config(wlan_private *priv,
			      HostCmd_DS_COMMAND *resp) 
{
	ENTER();
	
	HEXDUMP("802_11a CmdResp",(char *) resp, wlan_le16_to_cpu(resp->Size));

	LEAVE();
	return 0;
}
#endif

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

	memcpy(Adapter -> pRdeeprom, (u8 *) &resp -> params.rdeeprom.Value, 
				wlan_le16_to_cpu(resp -> params.rdeeprom.ByteCount));
	HEXDUMP("Adapter", Adapter -> pRdeeprom, wlan_le16_to_cpu(resp -> params.rdeeprom.ByteCount));

	return 0;
}

#ifdef GSPI83xx
static int wlan_ret_cmd_gspi_bus_config(wlan_private *priv,
			      HostCmd_DS_COMMAND *resp) 
{
	ENTER();
	
	HEXDUMP("802_11a CmdResp",(char *) resp, wlan_le16_to_cpu(resp->Size));

	LEAVE();
	return 0;
}
#endif /* GSPI83xx */

#ifdef ATIMGEN			
int wlan_ret_802_11_generate_atim(wlan_private *priv,
	       			HostCmd_DS_COMMAND *resp)	
{
	HostCmd_DS_802_11_GENERATE_ATIM *pAtim = &resp->params.genatim;
	wlan_adapter *Adapter = priv->adapter;

	ENTER();
	
	if (wlan_le16_to_cpu(pAtim->Enable))
		Adapter->ATIMEnabled = wlan_le16_to_cpu(pAtim->Enable);
	
	LEAVE();
	return 0;
}
#endif

/* Handle get_log response */
int HandleGetLogResponse(wlan_private *priv, HostCmd_DS_COMMAND *resp)
{
	PHostCmd_DS_802_11_GET_LOG  LogMessage = 
			(PHostCmd_DS_802_11_GET_LOG)&resp->params.glog;
	wlan_adapter 	*Adapter = priv->adapter;

	ENTER();

	/* TODO Convert it to Big Endian before copy */
	memcpy(&Adapter->LogMsg, LogMessage, 
					sizeof(HostCmd_DS_802_11_GET_LOG));
#ifdef DEBUG	
	HEXDUMP(" Get Log Response", (u8*)&Adapter->LogMsg, sizeof (Adapter->LogMsg));
#endif
#ifdef BIG_ENDIAN
	endian_convert_GET_LOG(Adapter->LogMsg);
#endif

	LEAVE();
	return 0;
}

/*
 * This function is called whenever a command response is received.
 */
int wlan_process_rx_command(wlan_private * priv)
{
	u16			RespCmd;
	HostCmd_DS_COMMAND	*resp;
	wlan_adapter		*Adapter = priv->adapter;
	int			ret = 0;
	u32			flags;
	u16			Result;

	ENTER();

	PRINTK1("Cmd Resp @ %lu\n", os_time_get());

	// Now we got response from FW, cancel the command timer
	if (Adapter->CommandTimerIsSet) {
		CancelTimer(&Adapter->MrvDrvCommandTimer);
		Adapter->CommandTimerIsSet = FALSE;
		Adapter->isCommandTimerExpired = FALSE;
	}

	if (!Adapter->CurCmd) {
		printk("wlan_process_rx_cmd(): NULL CurCmd=%p\n", Adapter->CurCmd);
		return -1;
	}

	resp = (HostCmd_DS_COMMAND *) (Adapter->CurCmd->BufVirtualAddr);

	HEXDUMP("Cmd Rsp", Adapter->CurCmd->BufVirtualAddr,
						priv->wlan_dev.upld_len);

	RespCmd = wlan_le16_to_cpu(resp->Command);

	Result = wlan_le16_to_cpu(resp->Result);

	PRINTK("Received Command: %x Result: %d Length: %d\n", RespCmd,
			Result, priv->wlan_dev.upld_len);
	
	PRINTK1("Jiffies = %lu\n", os_time_get());

	if (!(RespCmd & 0x8000)) {
		PRINTK("Invalid response to command!");
		Adapter->CurCmd->retcode = WLAN_STATUS_FAILURE;
		CleanupAndInsertCmd(priv, Adapter->CurCmd);
		spin_lock_irqsave(&Adapter->QueueSpinLock, flags);
		Adapter->CurCmd = NULL;
		spin_unlock_irqrestore(&Adapter->QueueSpinLock, flags);
		return -1;
	}

	/* Store the response code in the CmdNode. 
	 * Note: CmdNode->retcode should not be reset in CleanUpCmdCtrlNode()*/
	Adapter->CurCmd->retcode = wlan_le16_to_cpu(resp->Result);

#ifdef  PS_REQUIRED
	if (RespCmd == HostCmd_RET_802_11_PS_MODE) {
		HostCmd_DS_802_11_PS_MODE *psmode;

		psmode = &resp->params.psmode;
		PRINTK1("hwacproc: PS_MODE cmd reply result=%#x action=0x%X\n",
						resp->Result, psmode->Action);

		if (Result) {
			PRINTK1("PS command failed: %#x \n", resp->Result);
			if (Adapter->InfrastructureMode == Wlan802_11IBSS) {
				/* 
				 * We should not re-try enter-ps command in 
				 * ad-hoc mode. It takes place in 
				 * ExecuteNextCommand().
				 */
				if (psmode->Action == HostCmd_SubCmd_Enter_PS)
					Adapter->PSMode = 
						Wlan802_11PowerModeCAM;
			}
		} else if (psmode->Action == HostCmd_SubCmd_Enter_PS) {
			Adapter->NeedToWakeup = FALSE;
			Adapter->PSState = PS_STATE_AWAKE;
			PRINTK1("Enter_PS command response\n");
		} else if (psmode->Action == HostCmd_SubCmd_Exit_PS) {
			Adapter->NeedToWakeup = FALSE;
			Adapter->PSState = PS_STATE_FULL_POWER;
			PRINTK1("Exit_PS command response\n");
		} else if (psmode->Action == HostCmd_SubCmd_Sleep_Confirmed) {
			/* Should never get cmd response for Sleep Confirm */
			PRINTK1("Sleep_Confirmed_PS command response\n");
		} else {
			PRINTK1("PS: Action=0x%X\n",psmode->Action);
		}

		CleanupAndInsertCmd(priv, Adapter->CurCmd);
		spin_lock_irqsave(&Adapter->QueueSpinLock, flags);
		Adapter->CurCmd = NULL;
		spin_unlock_irqrestore(&Adapter->QueueSpinLock, flags);
		return 0;
	}
#endif

#ifdef STDCMD
	if (Adapter->CurCmd->CmdFlags & CMD_F_STDCMD) {
		/* Copy the response back to response buffer */
		memcpy(Adapter->CurCmd->InformationBuffer,
				resp, resp->Size);

		Adapter->CurCmd->CmdFlags &= ~CMD_F_STDCMD;
	}
#endif
    
	/* If the command is not successful, cleanup and return failure */
	if ((Result != HostCmd_RESULT_OK || !(RespCmd & 0x8000))) {