wlan_cmdresp.c

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

	}

    	LEAVE();
    	return 0;
}
 
void MacEventDisconnected(wlan_private * priv)
{
	wlan_adapter	*Adapter = priv->adapter;
	union iwreq_data wrqu;

	ENTER();

	if (Adapter->MediaConnectStatus != WlanMediaStateConnected)
		return;
	
	memset(wrqu.ap_addr.sa_data, 0x00, ETH_ALEN);
	wrqu.ap_addr.sa_family = ARPHRD_ETHER;

	/*
	 * Send Event to upper layer 
	 */

	/* Cisco AP sends EAP failure and de-auth in less than 0.5 ms.  This
		and that causes problems in the Supplicant */

	os_sched_timeout(1000);
	wireless_send_event(priv->wlan_dev.netdev, SIOCGIWAP, &wrqu, NULL);

	/* Flush all the packets upto the OS before stopping */
	wlan_send_rxskbQ(priv);
	netif_carrier_off(priv->wlan_dev.netdev);

	/* reset SNR/NF/RSSI values */
	memset(Adapter->SNR, 0x00, sizeof(Adapter->SNR));
	memset(Adapter->NF, 0x00, sizeof(Adapter->NF));
	memset(Adapter->SNRNF, 0x00, sizeof(Adapter->SNRNF));
	memset(Adapter->RSSI, 0x00, sizeof(Adapter->RSSI));
	
	PRINTK1("Current SSID=%s, Ssid Length=%u\n",
			Adapter->CurBssParams.ssid.Ssid, 
			Adapter->CurBssParams.ssid.SsidLength);
	PRINTK1("Previous SSID=%s, Ssid Length=%u\n",
			Adapter->PreviousSSID.Ssid, 
			Adapter->PreviousSSID.SsidLength);

	Adapter->AdHocCreated = FALSE;

	PRINTK1("WlanMediaStateDisconnected\n");

#ifdef WMM
	if(Adapter->wmm.enabled) {
		Adapter->wmm.enabled = FALSE;
		wmm_cleanup_queues(priv);
	}
#endif /* WMM */
		
	// indicate to the OS that we are disconnected
	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

#ifdef USER_DOES_PS_AFTER_REASSOCIATION
	/* If the automatic reassociation is turned off 
	 * ( i.e, user does the reassociation, the station is 
	 *  pushed out of the power save ) */
	if (Adapter->Reassoc_on == FALSE) {
		Adapter->PSMode = Wlan802_11PowerModeCAM;
	}
#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;
#ifdef FWVERSION3
	Adapter->fwCapInfo = wlan_le32_to_cpu(hwspec->fwCapInfo);
#endif

#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;
//		memcpy(&SupportedRates, &SupportedRates_A,
//					sizeof(SupportedRates_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;
//		memcpy(&SupportedRates, &SupportedRates_G,
//					sizeof(SupportedRates_G));
	} else if (Adapter->fw_bands & BAND_B) {
		Adapter->Channel = DEFAULT_CHANNEL;	// default
		Adapter->adhoc_start_band = BAND_B;
		Adapter->AdhocChannel	  = DEFAULT_AD_HOC_CHANNEL;
//		memcpy(&SupportedRates, &SupportedRates_B,
//					sizeof(SupportedRates_B));
	}
#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
	// Get the region code 
	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)
        );
#ifndef NEW_ASSOCIATION
      memmove(
        &a->IEBuffer[i - bad_count],
        &a->IEBuffer[i],
        sizeof(MRV_BSSID_IE_LIST)
        );
#endif
    }
  }

  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