wlan_wext.c

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

	}
	
	Adapter->RequestViaBSSID = TRUE;
	memcpy(Adapter->RequestedBSSID, reqBSSID, ETH_ALEN);
	
	if (Adapter->InfrastructureMode == Wlan802_11Infrastructure) {
		ret = wlan_associate(priv, &SSID);

		if (ret) {
			LEAVE();
			return ret;
		}
	} else {
		if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
			/* Exit Adhoc mode */
			ret = StopAdhocNetwork(priv, HostCmd_PENDING_ON_NONE);

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

		JoinAdhocNetwork(priv, &SSID, i);
	}

	LEAVE();
	return 0;
}

static int wlan_get_wap(struct net_device *dev, struct iw_request_info *info, 
		struct sockaddr *awrq, char *extra)
{
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

	if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
		memcpy(awrq->sa_data, Adapter->CurrentBSSID, ETH_ALEN);
	} else {
		memset(awrq->sa_data, 0, ETH_ALEN);
	}
	awrq->sa_family = ARPHRD_ETHER;

	LEAVE1();
	return 0;
}

static int wlan_set_nick(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();

	/*
	 * Check the size of the string 
	 */
	
	if (dwrq->length > 16) {
		return -E2BIG;
	}

	memset(Adapter->nodeName, 0, sizeof(Adapter->nodeName));
	memcpy(Adapter->nodeName, extra, dwrq->length);

	LEAVE();
	return 0;
}

static int wlan_get_nick(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();

	/*
	 * Get the Nick Name saved 
	 */

	strncpy(extra, Adapter->nodeName, 16);

	extra[16] = '\0';

	/*
	 * If none, we may want to get the one that was set 
	 */

	/*
	 * Push it out ! 
	 */
	dwrq->length = strlen(extra) + 1;

	LEAVE1();
	return 0;
}

static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info, 
		struct iw_param *vwrq, char *extra)
{
	int		ret = 0;
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;
	int		rthr = vwrq->value;

	ENTER();

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

	if (vwrq->disabled) {
		Adapter->RTSThsd = rthr = MRVDRV_RTS_MAX_VALUE;
	} else {
		if (rthr < MRVDRV_RTS_MIN_VALUE || rthr > MRVDRV_RTS_MAX_VALUE)
			return -EINVAL;
		Adapter->RTSThsd = rthr;
	}

	ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_SNMP_MIB,
			0, HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
			, OID_802_11_RTS_THRESHOLD,
			HostCmd_PENDING_ON_SET_OID, &rthr);

	LEAVE();
	return ret;
}

static int wlan_get_rts(struct net_device *dev, struct iw_request_info *info, 
		struct iw_param *vwrq, char *extra)
{
	int		ret = 0;
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

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

	if (!Adapter->RTSThsd) {
		ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_SNMP_MIB,
				0, HostCmd_OPTION_USE_INT
				| HostCmd_OPTION_WAITFORRSP
				, OID_802_11_RTS_THRESHOLD,
				HostCmd_PENDING_ON_GET_OID, NULL);
		if (ret) {
			LEAVE();
			return ret;
		}
	}

	vwrq->value = Adapter->RTSThsd;
	vwrq->disabled = ((vwrq->value < MRVDRV_RTS_MIN_VALUE)
			 || (vwrq->value > MRVDRV_RTS_MAX_VALUE));
	vwrq->fixed = 1;

	LEAVE();
	return 0;
}

static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info, 
		struct iw_param *vwrq, char *extra)
{
	int		ret = 0;
	int		fthr = vwrq->value;
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

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

	if (vwrq->disabled) {
		Adapter->FragThsd = fthr = MRVDRV_FRAG_MAX_VALUE;
	} else {
		if (fthr < MRVDRV_FRAG_MIN_VALUE || fthr > MRVDRV_FRAG_MAX_VALUE)
			return -EINVAL;
		Adapter->FragThsd = fthr;
	}

	ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_SNMP_MIB,
			0, HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
			, OID_802_11_FRAGMENTATION_THRESHOLD,
			HostCmd_PENDING_ON_SET_OID, &fthr);
	LEAVE();
	return ret;
}

static int wlan_get_frag(struct net_device *dev, struct iw_request_info *info, 
		struct iw_param *vwrq, char *extra)
{
	int		ret = 0;
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

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

	if (!Adapter->FragThsd) {
		ret = PrepareAndSendCommand(priv,
				HostCmd_CMD_802_11_SNMP_MIB, 0,
				HostCmd_OPTION_USE_INT
				| HostCmd_OPTION_WAITFORRSP
				, OID_802_11_FRAGMENTATION_THRESHOLD,
				HostCmd_PENDING_ON_GET_OID, NULL);

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

	vwrq->value = Adapter->FragThsd;
	vwrq->disabled = ((vwrq->value < MRVDRV_FRAG_MIN_VALUE)
			 || (vwrq->value > MRVDRV_FRAG_MAX_VALUE));
	vwrq->fixed = 1;

	LEAVE();
	return ret;
}

static int wlan_get_mode(struct net_device *dev,
	      struct iw_request_info *info, u32 * uwrq, char *extra)
{
	wlan_private	*priv = dev->priv;
	wlan_adapter	*adapter = priv->adapter;

	ENTER();

	switch (adapter->InfrastructureMode) {
		case Wlan802_11IBSS:
			*uwrq = IW_MODE_ADHOC;
			break;

		case Wlan802_11Infrastructure:
			*uwrq = IW_MODE_INFRA;
			break;

		default:
		case Wlan802_11AutoUnknown:
			*uwrq = IW_MODE_AUTO;
			break;
	}

	LEAVE1();
	return 0;
}

static int wlan_get_encode(struct net_device *dev,
			struct iw_request_info *info,
				struct iw_point *dwrq, u8 * extra)
{

	wlan_private	*priv = dev->priv;
	wlan_adapter	*adapter = priv->adapter;
	int		index = (dwrq->flags & IW_ENCODE_INDEX);

	ENTER();

	PRINTK1("flags=0x%x index=%d length=%d CurrentWepKeyIndex=%d\n", 
			dwrq->flags, index, dwrq->length, 
			adapter->CurrentWepKeyIndex);

	dwrq->flags = 0;

	/*
	 * Check encryption mode 
	 */

	switch (adapter->SecInfo.AuthenticationMode) {
		case Wlan802_11AuthModeOpen:
			dwrq->flags = IW_ENCODE_OPEN;
			break;

		case Wlan802_11AuthModeShared:
		case Wlan802_11AuthModeNetworkEAP:
			dwrq->flags = IW_ENCODE_RESTRICTED;
			break;
		default:
			dwrq->flags = IW_ENCODE_DISABLED | IW_ENCODE_OPEN;
			break;
	}

	if ((adapter->SecInfo.WEPStatus == Wlan802_11WEPEnabled)
		|| (adapter->SecInfo.WEPStatus == Wlan802_11WEPKeyAbsent)
#ifdef WPA
		|| adapter->SecInfo.WPAEnabled
#ifdef WPA2
		|| adapter->SecInfo.WPA2Enabled
#endif
#endif
		) {
		dwrq->flags &= ~IW_ENCODE_DISABLED;
	} else {
		dwrq->flags |= IW_ENCODE_DISABLED;
	}

	memset(extra, 0, 16);

	if (!index) {
		/* Handle current key request	*/
		if ((adapter->WepKey[adapter->CurrentWepKeyIndex].KeyLength) &&
				(adapter->SecInfo.WEPStatus == Wlan802_11WEPEnabled)) {
			index = adapter->WepKey[adapter->CurrentWepKeyIndex].KeyIndex;
			memcpy(extra, adapter->WepKey[index].KeyMaterial,
					adapter->WepKey[index].KeyLength);
			dwrq->length = adapter->WepKey[index].KeyLength;
			/* return current key */
			dwrq->flags |= (index + 1);
			/* return WEP enabled */
			dwrq->flags &= ~IW_ENCODE_DISABLED;
#ifdef WPA
		} else if ((adapter->SecInfo.WPAEnabled)
#ifdef WPA2
		|| (adapter->SecInfo.WPA2Enabled)
#endif
		) {
			/* return WPA enabled */
			dwrq->flags &= ~IW_ENCODE_DISABLED;
#endif
		} else {
			dwrq->flags |= IW_ENCODE_DISABLED;
		}
	} else {
		/* Handle specific key requests */
		index--;
		if (adapter->WepKey[index].KeyLength) {
			memcpy(extra, adapter->WepKey[index].KeyMaterial,
					adapter->WepKey[index].KeyLength);
			dwrq->length = adapter->WepKey[index].KeyLength;
			/* return current key */
			dwrq->flags |= (index + 1);
			/* return WEP enabled */
			dwrq->flags &= ~IW_ENCODE_DISABLED;
#ifdef WPA
		} else if ((adapter->SecInfo.WPAEnabled)
#ifdef WPA2
		|| (adapter->SecInfo.WPA2Enabled)
#endif
		) {
			/* return WPA enabled */
			dwrq->flags &= ~IW_ENCODE_DISABLED;
#endif
		} else {
			dwrq->flags |= IW_ENCODE_DISABLED;
		}
	}

	dwrq->flags |= IW_ENCODE_NOKEY;

	PRINTK1("Key:%02x:%02x:%02x:%02x:%02x:%02x KeyLen=%d\n",
			extra[0], extra[1], extra[2],
			extra[3], extra[4], extra[5], dwrq->length);

#ifdef WPA
	if (adapter->EncryptionStatus == Wlan802_11Encryption2Enabled
			&& !dwrq->length) {
		dwrq->length = MAX_KEY_SIZE;
	}
#endif

	PRINTK1("Return flags=0x%x\n", dwrq->flags);

	LEAVE();
	return 0;
}

static int wlan_get_txpow(struct net_device *dev,
			   struct iw_request_info *info,
			   struct iw_param *vwrq, char *extra)
{
	int		ret = 0;
	wlan_private	*priv = dev->priv;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

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

	ret = PrepareAndSendCommand(priv, 
			HostCmd_CMD_802_11_RF_TX_POWER,
			HostCmd_ACT_TX_POWER_OPT_GET,
			HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
		      	, 0, HostCmd_PENDING_ON_GET_OID, NULL);

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

  	PRINTK1("TXPOWER GET %d dbm.\n", Adapter->TxPowerLevel);
	vwrq->value = Adapter->TxPowerLevel;
	vwrq->fixed = 1;
	if (Adapter->RadioOn) {
		vwrq->disabled = 0;
		vwrq->flags = IW_TXPOW_DBM;
	} else {
		vwrq->disabled = 1;
	}

	LEAVE();
	return 0;
}

static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
	       struct iw_param *vwrq, char *extra)
{
	int		ret = 0;
	wlan_private   *priv = dev->priv;
	wlan_adapter   *adapter = priv->adapter;

	ENTER();

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

	if (vwrq->flags == IW_RETRY_LIMIT) {
		/* The MAC has a 4-bit Total_Tx_Count register
		   Total_Tx_Count = 1 + Tx_Retry_Count */
#define TX_RETRY_MIN 0
#define TX_RETRY_MAX 14
		if (vwrq->value < TX_RETRY_MIN || vwrq->value > TX_RETRY_MAX)
			return -EINVAL;

		/* Adding 1 to convert retry count to try count */
		adapter->TxRetryCount = vwrq->value + 1;

		ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_SNMP_MIB, 
				0, HostCmd_OPTION_USE_INT
				| HostCmd_OPTION_WAITFORRSP
				, OID_802_11_TX_RETRYCOUNT,
				HostCmd_PENDING_ON_SET_OID, NULL);

		if (ret) {
			LEAVE();
			return ret;
		}
	} else {
		return -EOPNOTSUPP;
	}

	LEAVE();
	return 0;
}

static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
		struct iw_param *vwrq, char *extra)
{
	wlan_private   *priv = dev->priv;
	wlan_adapter   *adapter = priv->adapter;

	ENTER();

	vwrq->disabled = 0;
	if (!vwrq->flags) {
		vwrq->flags = IW_RETRY_LIMIT;
		/* Subtract 1 to convert try count to retry count */
		vwrq->value = adapter->TxRetryCount - 1;
	}

	LEAVE1();
	return 0;
}

static inline void sort_channels(struct iw_freq *freq, int num)
{
	int i, j;
	struct iw_freq temp;

	for (i = 0; i < num; i++)
		for (j = i + 1; j < num; j++)
			if (freq[i].i > freq[j].i) {
				temp.i = freq[i].i;
				temp.m = freq[i].m;
				
				freq[i].i = freq[j].i;
				freq[i].m = freq[j].m;
				
				freq[j].i = temp.i;	
				freq[j].m = temp.m;	
			}
}

/* data rate listing
	MULTI_BANDS:
		abg		a	b	b/g
   Infra 	G(12)		A(8)	B(4)	G(12)
   Adhoc 	A+B(12)		A(8)	B(4)	B(4)

	non-MULTI_BANDS:
		   		 	b	b/g
   Infra 	     		    	B(4)	G(12)
   Adhoc 	      		    	B(4)	B(4)
 */
static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
		struct iw_point *dwrq, char *extra)
{
	int			i, j;
	wlan_private		*priv = dev->priv;
	wlan_adapter		*Adapter = priv->adapter;
	struct iw_range		*range = (struct iw_range *) extra;
	CHANNEL_FREQ_POWER	*cfp;
	WLAN_802_11_RATES	rates;

#ifdef ENABLE_802_11D
	BOOLEAN		flag = FALSE;
#endif

	ENTER();

	dwrq->length = sizeof(struct iw_range);
	memset(range, 0, sizeof(struct iw_range));

	range->min_nwid = 0;
	range->max_nwid = 0;

	memset(rates, 0, sizeof(rates));
	range->num_bitrates = get_active_data_rates(Adapter, rates);

	for (i=0; i < MIN(range->num_bitrates,IW_MAX_BITRATES) && rates[i]; i++) {
		range->bitrate[i] = (rates[i] & 0x7f) * 500000;
	}
	range->num_bitrates = i;
	PRINTK("IW_MAX_BITRATE