wlan_cmd.c

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

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

	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) {
		memcpy(scan->DataRate, SupportedRates_B, 
						sizeof(SupportedRates_B));
	} else if (Adapter->cur_region_channel->Band == BAND_G) {
		memcpy(scan->DataRate,	SupportedRates_G, 
						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(scan->DataRate, SupportedRates, sizeof(SupportedRates));
#endif

	Adapter->bIsScanInProgress = TRUE;
			
	/* Flush all the packets upto the OS before stopping */
	wlan_send_rxskbQ(priv);
	os_carrier_off(priv);

	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("IsAutoAssociation %d\n", scan->ScanType);
	PRINTK1("BSS type  %d\n", scan->BSSType);
	PRINTK1("SpecificScanSSID is %s\n", (Adapter->SetSpecificScanSSID) ?
			(char *) scan->SSID : "NULL");

#ifdef DEBUG_ALL
	{
		int i;

		for (i = 0; i < Adapter->cur_region_channel->NrCFP; i++) {
			PRINTK1("Channel List %d\n", scan->CHList[i]);
		}
    	}
#endif

#ifdef	PROGRESSIVE_SCAN
	PRINTK1("Channel List %d\n", scan->CHList[j]);
#endif
	PRINTK1("Scan Type %d\n", scan->ScanType);

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