wlan_cmdresp.c

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

	Adapter->AdHocCreated = FALSE;

#ifdef WMM
	if(Adapter->wmm.enabled) {
		Adapter->wmm.enabled = FALSE;
		wmm_cleanup_queues(priv);
	}
#endif /* WMM */
		
#ifdef WPA
	Adapter->SecInfo.WPAEnabled = FALSE;
#ifdef WPA2
	Adapter->SecInfo.WPA2Enabled = FALSE;
#endif
#endif

	Adapter->MediaConnectStatus = WlanMediaStateDisconnected;
	Adapter->LinkSpeed = MRVDRV_LINK_SPEED_1mbps;
		
	// memorize the previous SSID and BSSID
	memcpy(&(Adapter->PreviousSSID), &(Adapter->CurBssParams.ssid),
			sizeof(WLAN_802_11_SSID));
	memcpy(Adapter->PreviousBSSID, Adapter->CurrentBSSID,
			MRVDRV_ETH_ADDR_LEN);

	memcpy(&Adapter->SpecificScanSSID, &Adapter->PreviousSSID,
		sizeof(WLAN_802_11_SSID));

	// need to erase the current SSID and BSSID info
	Adapter->ulCurrentBSSIDIndex = 0;
	memset(&Adapter->CurBssParams, 0, sizeof(Adapter->CurBssParams));
	memset(Adapter->CurrentBSSID, 0, MRVDRV_ETH_ADDR_LEN);
	memset(&(Adapter->CurrentBSSIDDescriptor), 0,
			sizeof(WLAN_802_11_BSSID));

#ifdef	PS_REQUIRED
	if (Adapter->PSState != PS_STATE_FULL_POWER) {
		// need to wake up the firmware
		PRINTK1("Going to invoke PSWakeup\n");
		PSWakeup(priv, 0);
	}
#endif

	LEAVE();
}

/*
 * Command Response Proceesing 
 */
static inline int wlan_ret_get_hw_spec(wlan_private * priv, 
		HostCmd_DS_COMMAND * resp)
{
	int			i;
	HostCmd_DS_GET_HW_SPEC	*hwspec = &resp->params.hwspec;
	wlan_adapter		*Adapter = priv->adapter;

	ENTER();

	Adapter->HardwareStatus = WlanHardwareStatusReady;
	Adapter->fwCapInfo = wlan_le32_to_cpu(hwspec->fwCapInfo);

#ifdef MULTI_BANDS
	if (IS_SUPPORT_MULTI_BANDS(Adapter)) {
		Adapter->fw_bands		= GET_FW_DEFAULT_BANDS(Adapter);
		Adapter->is_multiband		= 1;
	} else {
		Adapter->adhoc_start_band	= BAND_B;
		Adapter->fw_bands		= BAND_B;
		Adapter->is_multiband		= 0;
	}

	Adapter->config_bands = Adapter->fw_bands; 

	memset(&SupportedRates, 0, sizeof(SupportedRates));

	if (Adapter->fw_bands & BAND_A) {
		Adapter->Channel = DEFAULT_CHANNEL_A;	// default
		Adapter->adhoc_start_band = BAND_A;
		Adapter->AdhocChannel	  = DEFAULT_AD_HOC_CHANNEL_A;
	} else if (Adapter->fw_bands & BAND_G) {
		Adapter->Channel = DEFAULT_CHANNEL;	// default
		Adapter->adhoc_start_band = BAND_G;
		Adapter->AdhocChannel	  = DEFAULT_AD_HOC_CHANNEL;
	} else if (Adapter->fw_bands & BAND_B) {
		Adapter->Channel = DEFAULT_CHANNEL;	// default
		Adapter->adhoc_start_band = BAND_B;
		Adapter->AdhocChannel	  = DEFAULT_AD_HOC_CHANNEL;
	}
#endif

	// permanent address should only be set once at start up
	if (Adapter->PermanentAddr[0] == 0xff) {
		// permanent address has not been set yet, set it
		memcpy(Adapter->PermanentAddr, hwspec->PermanentAddr,
							MRVDRV_ETH_ADDR_LEN);
	}

	memcpy(priv->wlan_dev.netdev->dev_addr, hwspec->PermanentAddr,
								ETH_ALEN);
	Adapter->FWReleaseNumber = hwspec->FWReleaseNumber;

	PRINTK1("FWReleaseVersion: 0x%X\n", Adapter->FWReleaseNumber);
	PRINTK1("Permanent addr: %2x:%2x:%2x:%2x:%2x:%2x\n",
			hwspec->PermanentAddr[0], hwspec->PermanentAddr[1],
			hwspec->PermanentAddr[2], hwspec->PermanentAddr[3],
			hwspec->PermanentAddr[4], hwspec->PermanentAddr[5]);
	PRINTK("HWIfVersion=0x%X  Version=0x%X\n",hwspec->HWIfVersion,
							hwspec->Version);

#ifdef HARDCODED_REGION_CODE
	Adapter->RegionTableIndex = 0;
	Adapter->RegionCode = 0x10;
#else
	Adapter->RegionCode = wlan_le16_to_cpu(hwspec->RegionCode) >> 8;
#endif

	for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
		// use the region code to search for the index
		if (Adapter->RegionCode == RegionCodeToIndex[i]) {
			Adapter->RegionTableIndex = (u16) i;
			break;
		}
	}

	// if it's unidentified region code, use the default (USA)
	if (i >= MRVDRV_MAX_REGION_CODE) {
		Adapter->RegionCode = 0x10;
		Adapter->RegionTableIndex = 0;
	}

	if (Adapter->CurrentAddr[0] == 0xff) {
		memmove(Adapter->CurrentAddr, hwspec->PermanentAddr,
				MRVDRV_ETH_ADDR_LEN);
	}

#ifdef MULTI_BANDS
	if (wlan_set_regiontable(priv, Adapter->RegionCode, 
							Adapter->fw_bands)) {
		LEAVE();
		return -EINVAL;
	}

#ifdef ENABLE_802_11D
	if (wlan_set_universaltable(priv, Adapter->fw_bands)) {
		LEAVE();
		return -EINVAL;
	}
#endif /*ENABLE_802_11D*/

#else
	if (wlan_set_regiontable(priv, Adapter->RegionCode, 0)) {
		LEAVE();
		return -EINVAL;
	}

#ifdef ENABLE_802_11D
	if (wlan_set_universaltable(priv, 0)) {
		LEAVE();
		return -EINVAL;
	}
#endif /*ENABLE_802_11D*/

#endif /*MULTI_BANDS*/

	// Config for extended scan
	if (Adapter->ExtendedScan) {
		Adapter->pExtendedScanParams->ucNumValidChannel = 
			(u8)	(Adapter->cur_region_channel->NrCFP - 1);
		PRINTK1("ExtendedScan: there are %d valid channels\n",
				Adapter->pExtendedScanParams->
				ucNumValidChannel);
	}

	LEAVE();
	return 0;
}

#ifdef PS_REQUIRED
static inline int wlan_ret_802_11_ps_mode(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	ENTER();
	
	LEAVE();
	return 0;
}

#ifdef FW_WAKEUP_METHOD
static inline int wlan_ret_fw_wakeup_method(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	wlan_adapter				*Adapter = priv->adapter;
	HostCmd_DS_802_11_FW_WAKEUP_METHOD	*fwwm = &resp->params.fwwakeupmethod;
	u16					action;

	ENTER();

	action = wlan_le16_to_cpu(fwwm->Action);

	switch (action) {
	case HostCmd_ACT_GET:
	case HostCmd_ACT_SET:
		Adapter->fwWakeupMethod = wlan_le16_to_cpu(fwwm->Method);
		break;
	default:
		break;
	}

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

static inline void AppendCurrentSSID(wlan_private *priv, int i)
{
	wlan_adapter	*Adapter = priv->adapter;

	if (Adapter->SetSpecificScanSSID != TRUE) {
		
		PRINTK1("HWAC-Append current SSID to " "SCAN list\n");

		if (i < MRVDRV_MAX_BSSID_LIST) {
			
			Adapter->ulCurrentBSSIDIndex = i;
			Adapter->ulNumOfBSSIDs++;
			memcpy(&Adapter->BSSIDList[i],
					&Adapter->CurrentBSSIDDescriptor,
					sizeof(WLAN_802_11_BSSID));

#ifdef MULTI_BANDS
			Adapter->BSSIDList[i].bss_band = Adapter->CurBssParams.band;
#endif
			Adapter->BSSIDList[i].Channel = Adapter->CurBssParams.channel;

			if (Adapter->SecInfo.WEPStatus == Wlan802_11WEPEnabled) {
				Adapter->BSSIDList[i].Privacy = 
					Wlan802_11PrivFilter8021xWEP;
			} else {
				Adapter->BSSIDList[i].Privacy =
					Wlan802_11PrivFilterAcceptAll;
			}

		}
	}
} // end of AppendCurrentSSID

static int wlan_ret_802_11_sleep_params(wlan_private * priv,
			      			HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_SLEEP_PARAMS 	*sp = &resp->params.sleep_params;
	wlan_adapter   			*Adapter = priv->adapter;

	ENTER();

	PRINTK("error=%x offset=%x stabletime=%x calcontrol=%x\n" 
			" extsleepclk=%x\n", sp->Error, sp->Offset, 
			sp->StableTime, sp->CalControl, sp->ExternalSleepClk);
	Adapter->sp.sp_error = wlan_le16_to_cpu(sp->Error);
	Adapter->sp.sp_offset = wlan_le16_to_cpu(sp->Offset);
	Adapter->sp.sp_stabletime = wlan_le16_to_cpu(sp->StableTime);
	Adapter->sp.sp_calcontrol = wlan_le16_to_cpu(sp->CalControl);
	Adapter->sp.sp_extsleepclk = wlan_le16_to_cpu(sp->ExternalSleepClk);
	Adapter->sp.sp_reserved = wlan_le16_to_cpu(sp->Reserved);

	LEAVE();
	return 0;
}

static int wlan_ret_802_11_sleep_period(wlan_private * priv,
			      			HostCmd_DS_COMMAND * resp)
{
	HostCmd_DS_802_11_SLEEP_PERIOD	*sp_period = &resp->params.ps_sleeppd;
	wlan_adapter   			*Adapter = priv->adapter;

	ENTER();

	Adapter->sleep_period.period = wlan_le16_to_cpu(sp_period->Period);
	
	LEAVE();
	return 0;
}

#ifdef BCA
static int wlan_ret_802_11_bca_timeshare(wlan_private *priv, 
					HostCmd_DS_COMMAND *resp)
{
	HostCmd_DS_802_11_BCA_TIMESHARE	*bca_ts = &resp->params.bca_timeshare;
	wlan_adapter   			*Adapter = priv->adapter;

	ENTER();

	printk("TrafficType=%x TimeShareInterva=%x BTTime=%x\n", 
			bca_ts->TrafficType, bca_ts->TimeShareInterval, 
			bca_ts->BTTime);
	
	Adapter->bca_ts.TrafficType = wlan_le16_to_cpu(bca_ts->TrafficType);
	Adapter->bca_ts.TimeShareInterval = wlan_le32_to_cpu(bca_ts->TimeShareInterval);
	Adapter->bca_ts.BTTime = wlan_le32_to_cpu(bca_ts->BTTime);

	LEAVE();
	return 0;
}
#endif

static void discard_bad_ssid(wlan_adapter *a)
{
  int bad_count = 0;
  int i;
  int j;

  for (i = 0; i < a->ulNumOfBSSIDs; i++)
  {
    for (j = 0; j < a->BSSIDList[i].Ssid.SsidLength; j++)
    {
      if (a->BSSIDList[i].Ssid.Ssid[j] < 0x20)
      {
        bad_count ++;
        break;
      }
    }

    if ((j == a->BSSIDList[i].Ssid.SsidLength) && (bad_count > 0))
    {
      memmove(
        &a->BSSIDList[i - bad_count], 
        &a->BSSIDList[i], 
        sizeof(WLAN_802_11_BSSID)
        );
    }
  }

  a->ulNumOfBSSIDs -= bad_count;
  memset(&a->BSSIDList[a->ulNumOfBSSIDs], 0, sizeof(WLAN_802_11_BSSID));
  return;
}

static inline int wlan_ret_802_11_scan(wlan_private * priv, 
						HostCmd_DS_COMMAND * resp)
{
	int				i, j;
	int				ndStat;
	HostCmd_DS_802_11_SCAN_RSP	*scan; 
	wlan_adapter			*Adapter = priv->adapter;
	u16				BSSDescriptSize;
	u16				IncrementSize = 8;

	ENTER();

#ifdef BG_SCAN
	if (priv->adapter->bgScanConfig->Enable) {
		scan = &resp->params.bgscanqueryresp.scanresp;
		IncrementSize += sizeof(HostCmd_DS_802_11_BG_SCAN_QUERY_RSP);
        } else {
#endif /* BG_SCAN */
                scan = &resp->params.scanresp;
		IncrementSize += sizeof(HostCmd_DS_802_11_SCAN_RSP);
#ifdef BG_SCAN
	}
#endif /* BG_SCAN */

	BSSDescriptSize = wlan_le16_to_cpu(scan->BSSDescriptSize);

	PRINTK1("BSSDescriptSize %d\n", BSSDescriptSize);
	PRINTK1("IncrementSize %d\n", IncrementSize);
	PRINTK1("Scan returned %d AP before parsing\n", scan->NumberOfSets);

	if (scan->NumberOfSets > MRVDRV_MAX_BSSID_LIST) {
		PRINTK1("Invalid number of AP returned!!\n");
		return -1;
	}
	
	// Get number of BSS Descriptors
	i = Adapter->ulNumOfBSSIDs;
	Adapter->ulNumOfBSSIDs += scan->NumberOfSets;
	ndStat = InterpretBSSDescription(priv,
			(Adapter->CurCmd->BufVirtualAddr + IncrementSize),
			BSSDescriptSize, i);

	if (ndStat != WLAN_STATUS_SUCCESS) {
		PRINTK1("ERROR: InterpretBSSDescription returned ERROR");
	}
	
#ifndef TLV_SCAN 
	for (j = 0; i < Adapter->ulNumOfBSSIDs; j++,i++) {
		Adapter->BSSIDList[i].Rssi =
			(LONG) (scan->RSSI[j]) + 
			MRVDRV_RSSI_DEFAULT_NOISE_VALUE;
#ifdef MULTI_BANDS
		Adapter->BSSIDList[i].bss_band = Adapter->cur_region_channel->Band;
#endif
	}
#endif /*TLV_SCAN*/

#ifdef TLV_SCAN
	for (j = 0; j < scan->NumberOfSets; j++, i++) {
#ifdef MULTI_BANDS
#ifdef BG_SCAN
	    if (priv->adapter->bgScanConfig->Enable) {
		// remove this after f/w add band info. in scan response
		MrvlIEtypes_ChanListParamSet_t	*chanList;
		ChanScanParamSet_t		*chanScan = NULL;
		u8				band = BAND_G;	

		chanList = (MrvlIEtypes_ChanListParamSet_t *)((u8 *)Adapter->bgScanConfig + 
					sizeof(HostCmd_DS_802_11_BG_SCAN_CONFIG));
		while (!chanScan &&
			((u8 *)chanList < (u8 *)Adapter->bgScanConfig + Adapter->bgScanConfigSize)) {
			PRINTK("Header type=%#x  len=%d\n",chanList->Header.Type,chanList->Header.Len);
			if (chanList->Header.Type == TLV_TYPE_CHANLIST) {
				chanScan = chanList->ChanScanParam;
				break;
			} else {
				chanList = (MrvlIEtypes_ChanListParamSet_t *)
					((u8 *)chanList + chanList->Header.Len + sizeof(chanList->Header));
			}
		}

		if (chanScan) {
			PRINTK("radio_type=%#x  chan=%#x\n",chanScan->RadioType,chanScan->ChanNumber);
			if (chanScan->RadioType == HostCmd_SCAN_RADIO_TYPE_A)
				band = BAND_A;
			else
				band = BAND_G;
		} else {
			printk("Cannot find valid radio_type/channel info. in channel list\n");
		}

 		Adapter->BSSIDList[i].bss_band = band;
	    } else {
#endif /* BG_SCAN */
 		Adapter->BSSIDList[i].bss_band = Adapter->cur_region_channel->Band;
#ifdef BG_SCAN
	    }
#endif /* BG_SCAN */
#endif /* MULTI_BANDS */
	}
#endif /*TLV_SCAN*/

	PRINTK1("Scan Results: number of BSSID: %d\n", Adapter->ulNumOfBSSIDs);
    
#if DEBUG
#ifdef PROGRESSIVE_SCAN
	if (Adapter->ScanChannelsLeft <= 0) {
#endif
		for (i = 0; i < Adapter->ulNumOfBSSIDs; i++) {
			PRINTK1("%2d:%32s-%02x:%02x:%02x:%02x:%02x:%02x "
					"RSSI=%d SR=%x\n", i,
					Adapter->BSSIDList[i].Ssid.Ssid,
					Adapter->BSSIDList[i].MacAddress[0],
					Adapter->BSSIDList[i].MacAddress[1],
					Adapter->BSSIDList[i].MacAddress[2],
					Adapter->BSSIDList[i].MacAddress[3],