wlan_cmd.c

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

#define TLV_PAYLOAD_SIZE	2	

	cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SUBSCRIBE_EVENT);
	
	events->Action = wlan_cpu_to_le16(SubscribeEvent->Action);
	events->Events = wlan_cpu_to_le16(SubscribeEvent->Events);

	Rssi = (MrvlIEtypes_RssiParamSet_t *)((char *)events + ActualPos);
	Rssi->Header.Type = wlan_cpu_to_le16(TLV_TYPE_RSSI);
	Rssi->Header.Len = wlan_cpu_to_le16(TLV_PAYLOAD_SIZE);
	Rssi->RSSIValue = SubscribeEvent->RSSIValue;
	Rssi->RSSIFreq = SubscribeEvent->RSSIFreq;
	
	ActualPos += sizeof(MrvlIEtypesHeader_t) + Rssi->Header.Len;

	Snr = (MrvlIEtypes_SnrThreshold_t *)((char *)events + ActualPos);
	Snr->Header.Type = wlan_cpu_to_le16(TLV_TYPE_SNR);
	Snr->Header.Len = wlan_cpu_to_le16(TLV_PAYLOAD_SIZE);
	Snr->SNRValue = SubscribeEvent->SNRValue;
	Snr->SNRFreq = SubscribeEvent->SNRFreq;

	ActualPos += sizeof(MrvlIEtypesHeader_t) + Snr->Header.Len;

	FailCnt = (MrvlIEtypes_FailureCount_t *)((char *)events + ActualPos);
	FailCnt->Header.Type = TLV_TYPE_FAILCOUNT;
        FailCnt->Header.Len = TLV_PAYLOAD_SIZE;
	FailCnt->FailValue = SubscribeEvent->FailValue;
	FailCnt->FailFreq = SubscribeEvent->FailFreq;
	
	ActualPos += sizeof(MrvlIEtypesHeader_t) + FailCnt->Header.Len;

	BcnMiss = (MrvlIEtypes_BeaconsMissed_t *)((char *)events + ActualPos);
	BcnMiss->Header.Type = wlan_cpu_to_le16(TLV_TYPE_BCNMISS);
	BcnMiss->Header.Len = wlan_cpu_to_le16(TLV_PAYLOAD_SIZE);
	BcnMiss->BeaconMissed = SubscribeEvent->BcnMissed;
	BcnMiss->Reserved = 0;

	ActualPos += sizeof(MrvlIEtypesHeader_t) + BcnMiss->Header.Len;

	cmd->Size = wlan_cpu_to_le16(ActualPos + S_DS_GEN);

	PRINTK("ActualPos = %d\n", ActualPos);
	
	LEAVE();
	return 0;	
}
#endif

static inline int wlan_cmd_802_11_sleep_period(wlan_private * priv,
		HostCmd_DS_COMMAND * cmd, u16 cmd_option, void *InfoBuf)
{
	cmd->Command =	wlan_cpu_to_le16(HostCmd_CMD_802_11_SLEEP_PERIOD);
	cmd->Size = wlan_cpu_to_le16(sizeof(HostCmd_DS_802_11_SLEEP_PERIOD) + 
								S_DS_GEN);
	memmove(&cmd->params.ps_sleeppd, InfoBuf,
			sizeof(HostCmd_DS_802_11_SLEEP_PERIOD));

	return 0;
}

static inline int wlan_cmd_802_11_sleep_params(wlan_private *priv,
					HostCmd_DS_COMMAND *cmd, u16 CmdOption)
{
	wlan_adapter *Adapter = priv->adapter;
	HostCmd_DS_802_11_SLEEP_PARAMS *sp = &cmd->params.sleep_params;

	ENTER();

	cmd->Size = wlan_cpu_to_le16((sizeof(HostCmd_DS_802_11_SLEEP_PARAMS)) +
								S_DS_GEN);
	cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SLEEP_PARAMS);

	if (CmdOption == HostCmd_ACT_GEN_GET) {
		memset(&Adapter->sp, 0, sizeof(SleepParams));
		memset(sp, 0, sizeof(HostCmd_DS_802_11_SLEEP_PARAMS));
		sp->Action = wlan_cpu_to_le16(CmdOption);
	} else if (CmdOption == HostCmd_ACT_GEN_SET) {
		sp->Action = wlan_cpu_to_le16(CmdOption);
		sp->Error = wlan_cpu_to_le16(Adapter->sp.sp_error);
		sp->Offset = wlan_cpu_to_le16(Adapter->sp.sp_offset);
		sp->StableTime = wlan_cpu_to_le16(Adapter->sp.sp_stabletime);
		sp->CalControl = (u8) Adapter->sp.sp_calcontrol;
		sp->ExternalSleepClk = (u8) Adapter->sp.sp_extsleepclk;
		sp->Reserved = wlan_cpu_to_le16(Adapter->sp.sp_reserved);
	}

	LEAVE();
	return 0;
}

/*
 * Function: Scan Command 
 */

#ifdef TLV_SCAN
static inline int wlan_cmd_802_11_scan(wlan_private * priv,
		HostCmd_DS_COMMAND * cmd)
{
#ifdef	PROGRESSIVE_SCAN
	int				j = 0;
#endif
	int				i = 0;
	wlan_adapter			*Adapter = priv->adapter;
	HostCmd_DS_802_11_SCAN 		*scan = &cmd->params.scan;
	CHANNEL_FREQ_POWER		*cfp;

	MrvlIEtypes_SsIdParamSet_t	*ssid;
	MrvlIEtypes_ChanListParamSet_t  *chan;
	MrvlIEtypes_RatesParamSet_t	*rates;
	MrvlIEtypes_NumProbes_t *scanprobes;

	u8				scanType;
	int ssidPos, chanPos, ratesPos, probPos =0;
#ifdef MULTI_BANDS
	int 				ret=0;
	HostCmd_DS_802_11_BAND_CONFIG	bc;
#endif /* MULTI BANDS*/

	ENTER();

	cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SCAN);
	
	ssidPos = 1+ MRVDRV_ETH_ADDR_LEN;

	scan->BSSType = Adapter->ScanMode;

	memcpy(scan->BSSID, Adapter->SpecificScanBSSID, ETH_ALEN);

	/*SetSsIdParamSet*/
	ssid = (MrvlIEtypes_SsIdParamSet_t *)( (char *)scan + ssidPos );

 	ssid->Header.Type = wlan_cpu_to_le16(TLV_TYPE_SSID); /*0x0000; */
	ssid->Header.Len = 0; 

	if (Adapter->SetSpecificScanSSID) {
		PRINTK2("Setting SpecificScanSSID to %s\n",
			Adapter->SpecificScanSSID.Ssid);

		PRINTK2("Length of SpecificScanSSID is %u\n",
		       Adapter->SpecificScanSSID.SsidLength);

		/*Setup specific Ssid TLV*/
		ssid->Header.Len = Adapter->SpecificScanSSID.SsidLength;
		memcpy(ssid->SsId, Adapter->SpecificScanSSID.Ssid,
				Adapter->SpecificScanSSID.SsidLength);
		scanType = HostCmd_SCAN_TYPE_ACTIVE;
	} else {
		scanType = Adapter->ScanType;
	}


	chanPos = ssidPos + ssid->Header.Len + sizeof( MrvlIEtypesHeader_t ); 
	chan = (MrvlIEtypes_ChanListParamSet_t *)( (char*)scan + chanPos );
	chan->Header.Type = wlan_cpu_to_le16(TLV_TYPE_CHANLIST); /*0x0101*/
	chan->Header.Len = 0;

#ifdef	PROGRESSIVE_SCAN
	{
		int k;

		if (Adapter->SetSpecificScanSSID == TRUE) 
 			k= MRVDRV_MAX_CHANNELS_PER_SCAN;
		else
			k = MRVDRV_CHANNELS_PER_SCAN;
		

		if (Adapter->ScanChannelsLeft <= 0) {
			Adapter->ScanChannelsLeft = 
				Adapter->cur_region_channel->NrCFP;
		}

		j = ((Adapter->ScanChannelsLeft - 1) / k) * k;

		cfp = Adapter->cur_region_channel->CFP;
		
		cfp = cfp + j;
		{ 
		int i;
		for ( i = 0; i < Adapter->cur_region_channel->NrCFP; i++ ) 
			PRINTK2("%x::ChNo:%x\n", i, 
				(Adapter->cur_region_channel->CFP+i)->Channel);
		}

		
		PRINTK2("============================\n");
		PRINTK2("k = %x j=%x NrCFP=%x Left=%x\n", k, j, 
				Adapter->cur_region_channel->NrCFP,
				Adapter->ScanChannelsLeft );	
		for (i = j; (((i - j) < k) && 
				(i < Adapter->cur_region_channel->NrCFP));
								i++, cfp++) {
#ifdef MULTI_BANDS
			if ( Adapter->cur_region_channel->Band == BAND_B || 
				Adapter->cur_region_channel->Band == BAND_G ) {
				chan->ChanScanParam[i-j].RadioType = 
					HostCmd_SCAN_RADIO_TYPE_BG; /*BG*/
			}
			else
				chan->ChanScanParam[i-j].RadioType = 
					HostCmd_SCAN_RADIO_TYPE_A;
#else
			chan->ChanScanParam[i-j].RadioType = 
				HostCmd_SCAN_RADIO_TYPE_BG; /*BG*/
#endif

#ifdef ENABLE_802_11D
			if( wlan_get_state_11d( priv) == ENABLE_11D ) {
				scanType = wlan_get_scan_type_11d(
						cfp->Channel, 
						&Adapter->parsed_region_chan
						);
			}

#endif
			chan->ChanScanParam[i-j].ScanType = scanType;
		
			if ( scanType == HostCmd_SCAN_TYPE_PASSIVE ) 
				chan->ChanScanParam[i-j].MaxScanTime = 
				   wlan_cpu_to_le16(HostCmd_SCAN_PASSIVE_MAX_CH_TIME);
			else
				chan->ChanScanParam[i-j].MaxScanTime = 
				   wlan_cpu_to_le16(HostCmd_SCAN_MAX_CH_TIME);
		
			chan->ChanScanParam[i-j].ChanNumber = cfp->Channel;
			
			chan->Header.Len += sizeof( ChanScanParamSet_t);

			PRINTK2("ch[%d] ScanType=%d\n", cfp->Channel, scanType);

			PRINTK2("TLV Scan: Max=%d\n", chan->ChanScanParam[i-j].MaxScanTime );
	
			PRINTK2("chan=%d len=%d(i=%d, j=%d)\n", i-j, 
						chan->Header.Len, i, j );
		}
		
		Adapter->ScanChannelsLeft = j;
	}
#endif

	probPos = chanPos + chan->Header.Len + sizeof(MrvlIEtypesHeader_t);
	scanprobes = (MrvlIEtypes_NumProbes_t *)( (char *)scan + probPos );
  scanprobes->Header.Len = wlan_cpu_to_le16(0);

	/* Handle number of probes */

	if (Adapter->ScanProbes != 0)
  {
		scanprobes->Header.Type = wlan_cpu_to_le16(TLV_TYPE_NUMPROBES); /*0x0102*/
		scanprobes->Header.Len = wlan_cpu_to_le16(2);
		scanprobes->NumProbes = wlan_cpu_to_le16(Adapter->ScanProbes);
	}

	/* Handle the Rates */
	ratesPos = probPos+ scanprobes->Header.Len + sizeof(MrvlIEtypesHeader_t);
	rates = (MrvlIEtypes_RatesParamSet_t *)( (char *)scan + ratesPos );
	rates->Header.Type = wlan_cpu_to_le16(TLV_TYPE_RATES); /*0x0001*/

#ifdef MULTI_BANDS
	if (Adapter->cur_region_channel->Band == BAND_A) {
		memcpy(rates->Rates, SupportedRates_A, 
						sizeof(SupportedRates_A));
		rates-> Header.Len  = wlan_cpu_to_le16(sizeof ( SupportedRates_A )); 
	} else if (Adapter->cur_region_channel->Band == BAND_B) {
		memcpy(rates->Rates, SupportedRates_B, 
						sizeof(SupportedRates_B));
		rates-> Header.Len  = wlan_cpu_to_le16(sizeof ( SupportedRates_B )); 
	} else if (Adapter->cur_region_channel->Band == BAND_G) {
		memcpy(rates->Rates, SupportedRates_G, 
						sizeof(SupportedRates_G));
		rates-> Header.Len  = wlan_cpu_to_le16(sizeof ( SupportedRates_G )); 
	}

	/* We had to send BAND_CONFIG for every scan command */
	if (Adapter->is_multiband) {
		bc.BandSelection = Adapter->cur_region_channel->Band;
		
		if ((Adapter->MediaConnectStatus == WlanMediaStateConnected) &&
			(Adapter->CurBssParams.band == bc.BandSelection))
			bc.Channel = Adapter->CurBssParams.channel;
		else
			bc.Channel = Adapter->cur_region_channel->CFP->Channel;

		ret = PrepareAndSendCommand(priv, 
					HostCmd_CMD_802_11_BAND_CONFIG,
					HostCmd_ACT_SET, HostCmd_OPTION_USE_INT 
					, 0, HostCmd_PENDING_ON_NONE, &bc);

		if (ret) {
			LEAVE();
			return ret;
		}
	}

#else
	memcpy(rates->Rates, SupportedRates, sizeof(SupportedRates));
	rates-> Header.Len  = wlan_cpu_to_le16(sizeof ( SupportedRates )); 
#endif /* MULTI_BAND */

	cmd->Size = wlan_cpu_to_le16(ratesPos + rates->Header.Len + 
				sizeof( MrvlIEtypesHeader_t ) + S_DS_GEN);

	PRINTK2("cmd->Size=%x\n", cmd->Size );

	Adapter->bIsScanInProgress = TRUE;

        /* Flush all the packets upto the OS before stopping */
	wlan_send_rxskbQ(priv);
	os_carrier_off(priv);

	PRINTK2("ssidPos=%d chanPos=%d Rates=%d\n", ssidPos, chanPos, ratesPos);
	HEXDUMP( "TLV Scan Cmd:", (u8 *)cmd, (int)cmd->Size );

	PRINTK1("Printing all the values\n");
	PRINTK1("Command=%x\n", cmd->Command);
	PRINTK1("Size=%x\n", cmd->Size);
	PRINTK1("Sequence Num=%x\n", cmd->SeqNum);

	PRINTK1("HWAC - SCAN command is ready\n");

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

#ifndef TLV_SCAN
static inline int wlan_cmd_802_11_scan(wlan_private * priv,
		HostCmd_DS_COMMAND * cmd)
{
#ifdef	PROGRESSIVE_SCAN
	int				j = 0;
#endif
	int				i = 0;
	wlan_adapter			*Adapter = priv->adapter;
	HostCmd_DS_802_11_SCAN 		*scan = &cmd->params.scan;
	CHANNEL_FREQ_POWER		*cfp;
#ifdef MULTI_BANDS
	int 				ret=0;
	HostCmd_DS_802_11_BAND_CONFIG	bc;
#endif /* MULTI BANDS*/

	ENTER();

	cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SCAN);
	cmd->Size = wlan_cpu_to_le16(sizeof(HostCmd_DS_802_11_SCAN) + S_DS_GEN);

#if 0 
	scan->IsAutoAssociation = wlan_cpu_to_le16((u16) (adapter->bAutoAssociation));
	PRINTK1("Is Autoassociation %u\n", scan->IsAutoAssociation);
#endif

	scan->IsAutoAssociation = 0;

	/* ScanMode to support the ScanMode private command */
	scan->BSSType = Adapter->ScanMode;

	memcpy(scan->BSSID, Adapter->SpecificScanBSSID, ETH_ALEN);

	memset(scan->SSID, 0, MRVDRV_MAX_SSID_LENGTH);

	if (Adapter->SetSpecificScanSSID) {
		PRINTK1("Setting SpecificScanSSID to %s\n",
				Adapter->SpecificScanSSID.Ssid);

		PRINTK1("Length of SpecificScanSSID is %u\n",
			       Adapter->SpecificScanSSID.SsidLength);

		memcpy(scan->SSID, Adapter->SpecificScanSSID.Ssid,
		Adapter->SpecificScanSSID.SsidLength);
		scan->ScanType = HostCmd_SCAN_TYPE_ACTIVE;
	} else {
		scan->ScanType = Adapter->ScanType;
	}

	scan->ProbeDelay = wlan_cpu_to_le16(HostCmd_SCAN_PROBE_DELAY_TIME);
	scan->MinCHTime = wlan_cpu_to_le16(HostCmd_SCAN_MIN_CH_TIME);

#ifdef MULTI_BANDS
	if ((Adapter->SetSpecificScanSSID == TRUE) && Adapter->is_multiband)
		scan->MaxCHTime = 
			wlan_cpu_to_le16(HostCmd_SCAN_MAX_CH_TIME_MULTI_BANDS);
	else
#endif
		scan->MaxCHTime = wlan_cpu_to_le16(HostCmd_SCAN_MAX_CH_TIME);

	/* Use the region code to determine channel numbers */
	memset(scan->CHList, 0, sizeof(scan->CHList));

#ifdef	PROGRESSIVE_SCAN
	{
		int k;

		if (Adapter->SetSpecificScanSSID == TRUE) 
 			k= MRVDRV_MAX_CHANNELS_PER_SCAN;
		else
			k = MRVDRV_CHANNELS_PER_SCAN;
		

		if (Adapter->ScanChannelsLeft <= 0) {
			Adapter->ScanChannelsLeft = 
				Adapter->cur_region_channel->NrCFP;
		}

		j = ((Adapter->ScanChannelsLeft - 1) / k) * k;

		cfp = Adapter->cur_region_channel->CFP;
		
		memset(scan->CHList, 0, sizeof(scan->CHList));

		cfp = cfp + j;
		
		for (i = j; (((i - j) < k) && 
				(i < Adapter->cur_region_channel->NrCFP));
								i++, cfp++) {
			scan->CHList[i - j] = cfp->Channel;
		}
		
		Adapter->ScanChannelsLeft = j;
	}
#else
	/*
	 * Old SCAN all channels with a MAX of 14 channels coming in
	 * on the scan list
	 */      
	{
		cfp = Adapter->cur_region_channel->CFP;
	
		memset(scan->CHList, 0, sizeof(scan->CHList));

		for (i = 0; i < MIN(Adapter->cur_region_channel->NrCFP, 
			MRVDRV_MAX_CHANNEL_SIZE); i++) {
			scan->CHList[i] = (cfp->Channel);
			cfp++;
		}
	}
#endif

	memset(scan->DataRate, 0, sizeof(scan->DataRate));
#ifdef MULTI_BANDS
	if (Adapter->cur_region_channel->Band == BAND_A) {
		memcpy(scan->DataRate, SupportedRates_A, 
						sizeof(SupportedRates_A));
	} else if (Adapter->cur_region_channel->Band == BAND_B) {