wlan_wext.c

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

	
	// clear it, so we will know if the value 
	// returned below is correct or not.
	Adapter->TxAntennaMode = 0;	

	ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_RF_ANTENNA,
			HostCmd_ACT_GET_TX, HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
			, 0, HostCmd_PENDING_ON_NONE, NULL);		

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

	PRINTK1("Get Tx Antenna Mode:0x%04x\n", Adapter->TxAntennaMode);

	LEAVE();

	return sprintf(buf, "0x%04x", Adapter->TxAntennaMode) + 1;
}

int wlan_send_deauth(wlan_private *priv)
{
	int		ret = 0;
	wlan_adapter	*Adapter = priv->adapter;
	
	ENTER();
	
    	if (Adapter->InfrastructureMode == Wlan802_11Infrastructure &&
		Adapter->MediaConnectStatus == WlanMediaStateConnected) {
		
		ret = SendDeauthentication(priv, HostCmd_PENDING_ON_NONE);

	} else {
		LEAVE();
		return -ENOTSUPP;
	}

	LEAVE();
	return ret;
}

int wlan_do_adhocstop_ioctl(wlan_private *priv)
{
	int		ret = 0;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

	if (Adapter->InfrastructureMode == Wlan802_11IBSS && 
		Adapter->MediaConnectStatus == WlanMediaStateConnected) {

		ret = StopAdhocNetwork(priv, HostCmd_PENDING_ON_NONE);

	} else {
		LEAVE();
		return -ENOTSUPP;
	}

	LEAVE();
	
	return 0;
		
}

int wlan_radio_ioctl(wlan_private *priv, u8 option)
{
	int		ret = 0;
	wlan_adapter	*Adapter	= priv->adapter;

	ENTER();

	if (Adapter->RadioOn != option) {
		PRINTK1("Switching %s the Radio\n", option ? "On" : "Off");
		Adapter->RadioOn = option;
		
		ret = PrepareAndSendCommand(priv,
				HostCmd_CMD_802_11_RADIO_CONTROL,
				HostCmd_ACT_GEN_SET, HostCmd_OPTION_USE_INT
				| HostCmd_OPTION_WAITFORRSP
			      	, 0, HostCmd_PENDING_ON_GET_OID, NULL);
	}

	LEAVE();
	return ret;
}

#ifdef REASSOCIATION
int reassociation_on(wlan_private *priv)
{
	wlan_adapter	*Adapter	= priv->adapter;

	ENTER();

#ifdef DEEP_SLEEP
	if ((Adapter->IsDeepSleep == TRUE)) {
		printk("<1>():%s IOCTLS called when station is"
					" in DeepSleep\n",__FUNCTION__);
		return -EBUSY;
	}
#endif

	Adapter->Reassoc_on = TRUE;

	LEAVE();
	return 0;
}

int reassociation_off(wlan_private *priv)
{
	wlan_adapter		*Adapter = priv->adapter;

	ENTER();

#ifdef DEEP_SLEEP
	if ((Adapter->IsDeepSleep == TRUE)) {
		printk("<1>():%s IOCTLS called when station is"
					" in DeepSleep\n",__FUNCTION__);
		return -EBUSY;
	}
#endif
	
	if (Adapter->TimerIsSet == TRUE) {
		CancelTimer(&Adapter->MrvDrvTimer);
		Adapter->TimerIsSet = FALSE;
	}	

	Adapter->Reassoc_on = FALSE;
	
	LEAVE();
	return 0;
}
#endif /* REASSOCIATION */

int wlanidle_off(wlan_private *priv)
{
	int			ret = 0;
	wlan_adapter		*Adapter = priv->adapter;
	WLAN_802_11_SSID	*AdhocSsid;

	ENTER();

	if (Adapter->MediaConnectStatus == WlanMediaStateDisconnected 
			&& Adapter->PreviousSSID.Ssid[0] != '\0') {
		if (Adapter->InfrastructureMode == Wlan802_11Infrastructure) {
			PRINTK1("Previous SSID = %s\n", 
					Adapter->PreviousSSID.Ssid);
			
			ret = wlan_associate(priv, &Adapter->PreviousSSID);

		} else if (Adapter->InfrastructureMode == Wlan802_11IBSS) {
	
			/* Copy the current ssid */
			memcpy(&AdhocSsid, &Adapter->PreviousSSID, 
						sizeof(WLAN_802_11_SSID));
			ret = PrepareAndSendCommand(priv,
				HostCmd_CMD_802_11_AD_HOC_START,
				0, HostCmd_OPTION_USE_INT
				| HostCmd_OPTION_WAITFORRSP
				, 0, HostCmd_PENDING_ON_SET_OID, AdhocSsid);
		}
	}
	/* else it is connected */
	
	PRINTK("\nwlanidle is off");
	LEAVE();
	return ret;
}

int wlanidle_on(wlan_private *priv)
{
	int			ret = 0;
	wlan_adapter		*Adapter = priv->adapter;

	ENTER();

	if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
		if (Adapter->InfrastructureMode == Wlan802_11Infrastructure) {
			PRINTK1("Previous SSID = %s\n", 
					Adapter->PreviousSSID.Ssid);
			memmove(&Adapter->PreviousSSID, 
					&Adapter->CurBssParams.ssid,
						sizeof(WLAN_802_11_SSID));
 			wlan_send_deauth(priv);
		
		} else if (Adapter->InfrastructureMode == Wlan802_11IBSS) {
			
			ret = StopAdhocNetwork(priv, HostCmd_PENDING_ON_NONE);

		}

	}

#ifdef REASSOCIATION
	if (Adapter->TimerIsSet == TRUE) {
		CancelTimer(&Adapter->MrvDrvTimer);
		Adapter->TimerIsSet = FALSE;
	}	
#endif /* REASSOCIATION */

	PRINTK("\nwlanidle is on");

	LEAVE();
	return ret;
}

int wlan_set_region(wlan_private *priv, u16 region_code)
{
	int i;

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

	// if it's unidentified region code
	if (i >= MRVDRV_MAX_REGION_CODE) {
		PRINTK1("Region Code not identified\n");
		LEAVE();
		return -1;
	}

#ifdef MULTI_BANDS
	if (wlan_set_regiontable(priv, priv->adapter->RegionCode, 
					priv->adapter->config_bands)) {
#else
	if (wlan_set_regiontable(priv, priv->adapter->RegionCode, 0)) {
#endif
		LEAVE();
		return -EINVAL;
	}

	LEAVE();
	return 0;
}
int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
		struct iw_point *dwrq, char *extra)
{
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();
	/*
	 * Note : if dwrq->flags != 0, we should get the relevant SSID from
	 * the SSID list... 
	 */

	/*
	 * Get the current SSID 
	 */
	if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
		memcpy(extra, Adapter->CurBssParams.ssid.Ssid,
				Adapter->CurBssParams.ssid.SsidLength);
		extra[Adapter->CurBssParams.ssid.SsidLength] = '\0';
	} else {
		memset(extra, 0, 32);
		extra[Adapter->CurBssParams.ssid.SsidLength] = '\0';
	}
	/*
	 * If none, we may want to get the one that was set 
	 */

	/* To make the driver backward compatible with WPA supplicant v0.2.4 */
	if (dwrq->length == 32)  /* check with WPA supplicant buffer size */
		dwrq->length = MIN(Adapter->CurBssParams.ssid.SsidLength, 
							IW_ESSID_MAX_SIZE);
	else 		
		dwrq->length = Adapter->CurBssParams.ssid.SsidLength + 1;

	dwrq->flags = 1;		/* active */

	LEAVE1();
	return 0;
}

static inline int CopyRates(u8 *dest, int pos, u8 *src, int len)
{
	int	i;

	for (i = 0; i < len && src[i]; i++, pos++) {
		if (pos >= sizeof(WLAN_802_11_RATES))
			break;
		dest[pos] = src[i];
	}

	return pos;
}

static int get_active_data_rates(wlan_adapter *Adapter, WLAN_802_11_RATES rates)
{
	int	k = 0;

	ENTER();
	
	if (Adapter->MediaConnectStatus != WlanMediaStateConnected) {
		if (Adapter->InfrastructureMode == Wlan802_11Infrastructure) {	
			//Infra. mode
#ifdef	MULTI_BANDS
			if (Adapter->config_bands & BAND_G) {
				PRINTK("Infra mBAND_G=%#x\n", BAND_G);
				k = CopyRates(rates, k, SupportedRates_G, 
						sizeof(SupportedRates_G));
			} else {
				if (Adapter->config_bands & BAND_B) {
					PRINTK("Infra mBAND_B=%#x\n", BAND_B);
					k = CopyRates(rates, k, 
						SupportedRates_B, 
						sizeof(SupportedRates_B));
				}
				if (Adapter->config_bands & BAND_A) {
					PRINTK("Infra mBAND_A=%#x\n", BAND_A);
					k = CopyRates(rates, k, 
						SupportedRates_A, 
						sizeof(SupportedRates_A));
				}
			}
#else //MULTI_BANDS
			PRINTK("Infra\n");
			k = CopyRates(rates, k, SupportedRates, 
						sizeof(SupportedRates));
#endif //MULTI_BANDS
		} else {
			//ad-hoc mode
#ifdef	MULTI_BANDS
			if (Adapter->config_bands & BAND_G) {
				PRINTK("Adhoc mBAND_G=%#x\n", BAND_G);
				k = CopyRates(rates, k, AdhocRates_G, 
							sizeof(AdhocRates_G));
			} else if (Adapter->config_bands & BAND_B) {
				PRINTK("Adhoc mBAND_B=%#x\n", BAND_B);
				k = CopyRates(rates, k, AdhocRates_B, 
							sizeof(AdhocRates_B));
			}
			if (Adapter->config_bands & BAND_A) {
				PRINTK("Adhoc mBAND_A=%#x\n", BAND_A);
				k = CopyRates(rates, k, AdhocRates_A, 
							sizeof(AdhocRates_A));
			}
#else //MULTI_BANDS
#ifdef G_RATE
			PRINTK("Adhoc G\n");
			k = CopyRates(rates, k, AdhocRates_G, 
							sizeof(AdhocRates_G));
#else //G_RATE
			PRINTK("Adhoc B\n");
			k = CopyRates(rates, k, AdhocRates_B, 
							sizeof(AdhocRates_B));
#endif //G_RATE
#endif //MULTI_BANDS
		}
	} else {
		k = CopyRates(rates, 0, Adapter->CurBssParams.DataRates, 
					Adapter->CurBssParams.NumOfRates);
	}

	LEAVE();

	return k;
}


#ifdef	linux
#include	"wlan_version.h"

#define GETLOG_BUFSIZE  300

#define MAX_SCAN_CELL_SIZE      (IW_EV_ADDR_LEN + \
				MRVDRV_MAX_SSID_LENGTH + \
				IW_EV_UINT_LEN + IW_EV_FREQ_LEN + \
				IW_EV_QUAL_LEN + MRVDRV_MAX_SSID_LENGTH + \
				IW_EV_PARAM_LEN + 40) /* 40 for WPAIE */

void get_version(wlan_adapter *adapter, char *version, int maxlen)
{
	union {
		u32	l;
		u8	c[4];
	} ver;
	char	fwver[32];

	ver.l = adapter->FWReleaseNumber;
	if(ver.c[3] == 0)
		sprintf(fwver, "%u.%u.%u",
			ver.c[2], ver.c[1], ver.c[0]);
	else
		sprintf(fwver, "%u.%u.%u.p%u",
			ver.c[2], ver.c[1], ver.c[0],ver.c[3]);

	snprintf(version, maxlen, driver_version, fwver);
}

/*
 * Commit handler: called after a bunch of SET operations 
 */
static int wlan_config_commit(struct net_device *dev, 
		struct iw_request_info *info, 
		char *cwrq, char *extra)
{
	ENTER();

	LEAVE();
	return 0;
}

/*
 * Wireless Handler: get protocol name 
 */
static int wlan_get_name(struct net_device *dev, struct iw_request_info *info, 
		char *cwrq, char *extra)
{
	const char *cp;
	char comm[6] = {"COMM-"};
	char mrvl[6] = {"MRVL-"};
	int cnt;

	ENTER();

	strcpy(cwrq, mrvl);

	cp = strstr(driver_version, comm);
	if (cp == driver_version)	//skip leading "COMM-"
		cp = driver_version + strlen(comm);
	else
		cp = driver_version;

	cnt = strlen(mrvl);
	cwrq += cnt;
	while (cnt < 16 && (*cp != '-')) {
		*cwrq++ = toupper(*cp++);
		cnt++;
	}
	*cwrq = '\0';

	LEAVE();

	return 0;
}

static int wlan_get_freq(struct net_device *dev, struct iw_request_info *info, 
		struct iw_freq *fwrq, char *extra)
{
	wlan_private		*priv = dev->priv;
	wlan_adapter		*Adapter = priv->adapter;
	CHANNEL_FREQ_POWER	*cfp;

	ENTER();

#ifdef DEEP_SLEEP
	if ((Adapter->IsDeepSleep == TRUE)) {
		printk("<1>SIOCGIWFREQ: IOCTLS called when station is"
							" in DeepSleep\n");
		return -EBUSY;
	}
#endif

#ifdef MULTI_BANDS
	cfp = find_cfp_by_band_and_channel(Adapter, Adapter->CurBssParams.band, 
						Adapter->CurBssParams.channel);
#else
	cfp = find_cfp_by_band_and_channel(Adapter, 0, 
						Adapter->CurBssParams.channel);
#endif
	
	if (!cfp) {
		if (Adapter->CurBssParams.channel)
			PRINTK("Invalid channel=%d\n", 
					Adapter->CurBssParams.channel);
		return -EINVAL;
	} 
	
	fwrq->m = (long) cfp->Freq * 100000;
	fwrq->e = 1;

	PRINTK("freq=%u\n",fwrq->m);

	LEAVE1();
	return 0;
}


static int wlan_set_wap(struct net_device *dev,	struct iw_request_info *info,
		struct sockaddr *awrq, char *extra)
{
	int			ret = 0;
	wlan_private		*priv = dev->priv;
	wlan_adapter		*Adapter = priv->adapter;
	static const u8 	bcast[ETH_ALEN] = 
					{ 255, 255, 255, 255, 255, 255 };
	WLAN_802_11_SSID	SSID;
	u8			reqBSSID[ETH_ALEN];	
	int 			i = 0;
	
	ENTER();

#ifdef DEEP_SLEEP
	if ((Adapter->IsDeepSleep == TRUE)) {
		printk("<1>SIOCSIWAP: IOCTLS called when station is"
							" in DeepSleep\n");
		return -EBUSY;
	}
#endif

	if (awrq->sa_family != ARPHRD_ETHER)
		return -EINVAL;			

	PRINTK1("sa_data: %02x:%02x:%02x:%02x:%02x:%02x\n",
			awrq->sa_data[0], awrq->sa_data[1],
			awrq->sa_data[2], awrq->sa_data[3],
			awrq->sa_data[4], awrq->sa_data[5]);
	
#ifdef REASSOCIATION
	// cancel re-association timer if there's one
	if (Adapter->TimerIsSet == TRUE) {
		CancelTimer(&Adapter->MrvDrvTimer);
		Adapter->TimerIsSet = FALSE;
	}
#endif /* REASSOCIATION */

	memset(&SSID, 0, sizeof(WLAN_802_11_SSID));
	
	if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
		i = FindBestSSIDInList(Adapter);
		if (i >= 0) {
			memcpy(reqBSSID, Adapter->BSSIDList[i].MacAddress, 
					ETH_ALEN);
		}
	} else {
		memcpy(reqBSSID, awrq->sa_data, ETH_ALEN);

		PRINTK1("Required bssid = %x:%x:%x:%x:%x:%x\n", 
				reqBSSID[0], reqBSSID[1],
				reqBSSID[2], reqBSSID[3],
				reqBSSID[4], reqBSSID[5]);
		
		// Search for index position in list for requested MAC
		i = FindBSSIDInList(Adapter, reqBSSID, 
				Adapter->InfrastructureMode);
  
		// If BSSID not found, do scan one more time.
		if (i < 0)
		{
			wlan_scan_networks(priv, HostCmd_PENDING_ON_SET_OID);

  			i = FindBSSIDInList(Adapter, reqBSSID, 
				Adapter->InfrastructureMode);
		}
	}	
	
	if (i >= 0) {
		memcpy(&SSID, &Adapter->BSSIDList[i].Ssid, sizeof(SSID.Ssid));
	} else {
		PRINTK1("MAC address not found in BSSID List\n");
		return i;
	}

	if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
		ret = SendDeauthentication(priv, HostCmd_PENDING_ON_NONE);

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