wlan_wext.c

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

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

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

	LEAVE();
	return 0;
}

#ifdef WPA
int wlan_set_encode_wpa(struct net_device *dev, 
			struct iw_request_info *info,
				struct iw_point *dwrq, char *extra)
{
	int			ret = 0;
	wlan_private		*priv = dev->priv;
#ifdef DEEP_SLEEP
	wlan_adapter		*Adapter = priv->adapter;
#endif
	PWLAN_802_11_KEY	pKey;

	ENTER();

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

	pKey = (PWLAN_802_11_KEY) extra;

	HEXDUMP("Key buffer: ", extra, dwrq->length);

	HEXDUMP("KeyMaterial: ", (unsigned char *) pKey->KeyMaterial,
			pKey->KeyLength);

	// current driver only supports key length of up to 32 bytes
	if (pKey->KeyLength > MRVL_MAX_WPA_KEY_LENGTH) {
		PRINTK1(" Error in key length \n");
		return -1;
	}

	ret = PrepareAndSendCommand(priv,
		HostCmd_CMD_802_11_KEY_MATERIAL,
		HostCmd_ACT_SET,
		HostCmd_OPTION_USE_INT
		| HostCmd_OPTION_WAITFORRSP
		, KEY_INFO_ENABLED, HostCmd_PENDING_ON_SET_OID,
		pKey);
	if (ret) {
		LEAVE();
		return ret;
	}

	LEAVE();
	return ret;
}
#endif

/*
 *  iwconfig ethX key on:	WEPEnabled;
 *  iwconfig ethX key off:	WEPDisabled;
 *  iwconfig ethX key [x]:	CurrentWepKeyIndex = x; WEPEnabled;
 *  iwconfig ethX key [x] kstr:	WepKey[x] = kstr;
 *  iwconfig ethX key kstr:	WepKey[CurrentWepKeyIndex] = kstr;
 *
 *  all:			Send command SET_WEP;
 				SetMacPacketFilter;
 */

int wlan_set_encode_nonwpa(struct net_device *dev,
			       struct iw_request_info *info,
				       struct iw_point *dwrq, char *extra)
{
	int			ret = 0;
	wlan_private		*priv = dev->priv;
	wlan_adapter		*Adapter = priv->adapter;
	MRVL_WEP_KEY		*pWep;
	WLAN_802_11_SSID	ssid;
	int			index, PrevAuthMode;

	ENTER();

	pWep = &Adapter->WepKey[Adapter->CurrentWepKeyIndex];
	PrevAuthMode = Adapter->SecInfo.AuthenticationMode;

	index = (dwrq->flags & IW_ENCODE_INDEX) - 1;

	if(index >= 4) {
		PRINTK("Key index #%d out of range.\n", index + 1);
		return -EINVAL;
	}

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

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

	if (dwrq->length > 0) {
		/* iwconfig ethX key [n] xxxxxxxxxxx 
		 * Key has been provided by the user 
		 */

		/*
		 * Check the size of the key 
		 */

		if (dwrq->length > MAX_KEY_SIZE) {
			return -EINVAL;
		}

		/*
		 * Check the index (none -> use current) 
		 */

		if (index < 0 || index > 3)		//invalid index or no index
			index = Adapter->CurrentWepKeyIndex;
		else					//index is given & valid
			pWep = &Adapter->WepKey[index];

		/*
		 * Check if the key is not marked as invalid 
		 */
		if (!(dwrq->flags & IW_ENCODE_NOKEY)) {
			/* Cleanup */
			memset(pWep, 0, sizeof(MRVL_WEP_KEY));

			/* Copy the key in the driver */
			memcpy(pWep->KeyMaterial, extra, dwrq->length);

			/* Set the length */
			if (dwrq->length > MIN_KEY_SIZE) {
				pWep->KeyLength = MAX_KEY_SIZE;
			} else {
				if (dwrq->length > 0) {
					pWep->KeyLength = MIN_KEY_SIZE;
				} else {
					/* Disable the key */
					pWep->KeyLength = 0;
				}
			}
			pWep->KeyIndex = index;

			if(Adapter->SecInfo.WEPStatus != Wlan802_11WEPEnabled) {
				/*
				 * The status is set as Key Absent 
				 * so as to make sure we display the 
				 * keys when iwlist ethX key is 
				 * used - MPS 
				 */

				Adapter->SecInfo.WEPStatus = 
					Wlan802_11WEPKeyAbsent;
			}

			PRINTK1("KeyIndex=%u KeyLength=%u\n", 
					pWep->KeyIndex,
					pWep->KeyLength);
			HEXDUMP("WepKey", (u8 *) pWep->KeyMaterial, 
					pWep->KeyLength);
		}
	} else {
		/*
		 * No key provided so it is either enable key, 
		 * on or off */
		if (dwrq->flags & IW_ENCODE_DISABLED) {
			PRINTK1("******** iwconfig ethX key off **********\n");

			Adapter->SecInfo.WEPStatus = Wlan802_11WEPDisabled;
			if (Adapter->SecInfo.AuthenticationMode == Wlan802_11AuthModeShared)
				Adapter->SecInfo.AuthenticationMode = Wlan802_11AuthModeOpen;
		} else {
			/* iwconfig ethX key [n]
			 * iwconfig ethX key on 
			 * Do we want to just set the transmit key index ? 
			 */

			if (index < 0 || index > 3) {
				PRINTK1("******** iwconfig ethX key on **********\n");
				index = Adapter->CurrentWepKeyIndex;
			}
			else {
				PRINTK1("******** iwconfig ethX key [x=%d] **********\n",index);
				Adapter->CurrentWepKeyIndex = index;
			}

			/* Copy the required key as the current key */
			pWep = &Adapter->WepKey[index];

			if (!pWep->KeyLength) {
				PRINTK1("Key not set,so cannot enable it\n");
				return -EPERM;
			}
	    
			Adapter->SecInfo.WEPStatus = Wlan802_11WEPEnabled;

			HEXDUMP("KeyMaterial", (u8 *) pWep->KeyMaterial,
					pWep->KeyLength);
		}
	}

	if(pWep->KeyLength) {
		ret = PrepareAndSendCommand(priv,
			HostCmd_CMD_802_11_SET_WEP,
			0, HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
			, OID_802_11_ADD_WEP,
			HostCmd_PENDING_ON_SET_OID, NULL);

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

	if (Adapter->SecInfo.WEPStatus == Wlan802_11WEPEnabled) {
		Adapter->CurrentPacketFilter |= HostCmd_ACT_MAC_WEP_ENABLE;
	} else {
		Adapter->CurrentPacketFilter &= ~HostCmd_ACT_MAC_WEP_ENABLE;
	}

	SetMacPacketFilter(priv);

	// PRINTK ("Flags %x\n", dwrq->flags);
	if (dwrq->flags & IW_ENCODE_RESTRICTED) {
		/* iwconfig ethX restricted key [1] */
		Adapter->SecInfo.AuthenticationMode = Wlan802_11AuthModeShared;
		PRINTK1("Authentication mode restricted!\n");
	} else if (dwrq->flags & IW_ENCODE_OPEN) {
		/* iwconfig ethX key [2] open */
		Adapter->SecInfo.AuthenticationMode = Wlan802_11AuthModeOpen;
		PRINTK1("Authentication mode open!\n");
	}

	/*
	 * If authentication mode changed - de-authenticate, set authentication
	 * method and re-associate if we were previously associated.
	 */
	if (Adapter->SecInfo.AuthenticationMode != PrevAuthMode) {
		if (Adapter->MediaConnectStatus == WlanMediaStateConnected &&
				Adapter->InfrastructureMode == 
				Wlan802_11Infrastructure) {

			/* keep a copy of the ssid associated with */
			memcpy(&ssid, &Adapter->CurBssParams.ssid, sizeof(ssid));

			/*
			 * De-authenticate from AP 
			 */
				
			ret = SendDeauthentication(priv, 
						HostCmd_PENDING_ON_SET_OID);

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

		} else {
			/* reset ssid */
			memset(&ssid, 0, sizeof(ssid));
		}
	}

	LEAVE();
	return 0;
}

int wlan_set_encode(struct net_device *dev,
		struct iw_request_info *info,
		struct iw_point *dwrq, char *extra)
{

	PWLAN_802_11_KEY pKey = NULL;

	ENTER();
	
	if (dwrq->length > MAX_KEY_SIZE) {
		pKey = (PWLAN_802_11_KEY) extra;

		if(pKey->KeyLength <= MAX_KEY_SIZE) {
			//dynamic WEP
			dwrq->length = pKey->KeyLength;
			dwrq->flags = pKey->KeyIndex + 1;
			return wlan_set_encode_nonwpa(dev, info, dwrq, 
					pKey->KeyMaterial);
		}
		else {
#ifdef	WPA
			//WPA
			return wlan_set_encode_wpa(dev, info, dwrq, extra);
#endif
		}
	}
	else {
		//static WEP
		PRINTK1("Setting WEP\n");
		return wlan_set_encode_nonwpa(dev, info, dwrq, extra);
	}

	return -EINVAL;
}

int wlan_set_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;

	int wlan_radio_ioctl(wlan_private *priv, u8 option);

	u16	dbm;
	
	ENTER();

#ifdef DEEP_SLEEP
	if ((Adapter->IsDeepSleep == TRUE)) {
		printk("<1>SIOCSIWTXPOW: IOCTLS called when station is"
							" in DeepSleep\n");
		return -EBUSY;
	}
#endif
	
	if(vwrq->disabled) {
		wlan_radio_ioctl(priv, RADIO_OFF);
		return 0;
	}

	Adapter->Preamble = HostCmd_TYPE_AUTO_PREAMBLE;

	wlan_radio_ioctl(priv, RADIO_ON);

#if WIRELESS_EXT > 14
	if ((vwrq->flags & IW_TXPOW_TYPE) == IW_TXPOW_MWATT) {
		dbm = (u16) mw_to_dbm(vwrq->value);
	}
	else
#endif
		dbm = (u16) vwrq->value;


	/* auto tx power control */

	if (vwrq->fixed == 0)
		dbm = 0xffff;

  	PRINTK1("<1>TXPOWER SET %d dbm.\n", dbm);

	ret = PrepareAndSendCommand(priv, 
		HostCmd_CMD_802_11_RF_TX_POWER,
		HostCmd_ACT_TX_POWER_OPT_SET_LOW,
		HostCmd_OPTION_USE_INT | HostCmd_OPTION_WAITFORRSP,
		0,
		HostCmd_PENDING_ON_GET_OID,
		(void *) &dbm);

	LEAVE();
	return ret;
}

int wlan_scan_networks(wlan_private *priv, u16 pending_info)
{
	wlan_adapter	*Adapter = priv->adapter;
	int 		i;
	int		ret = 0;

	ENTER();

	Adapter->ulNumOfBSSIDs = 0;

#ifdef BG_SCAN
	if(priv->adapter->bgScanConfig->Enable == TRUE) {
		wlan_bg_scan_enable(priv, FALSE);
	}
#endif /* BG_SCAN */

	for (i = 0; i < sizeof(Adapter->region_channel) / 
			sizeof(Adapter->region_channel[0]); i++) {

#ifdef ENABLE_802_11D
		if( wlan_get_state_11d( priv) == ENABLE_11D &&
			Adapter->MediaConnectStatus != WlanMediaStateConnected) {
/* Scan all the supported chan for the first scan */
			if (!Adapter->universal_channel[i].Valid)
				continue;
			Adapter->cur_region_channel = 
				&(Adapter->universal_channel[i]);

/* clear the parsed_region_chan for the first scan  */
			memset( &Adapter->parsed_region_chan, 0,
					sizeof(parsed_region_chan_11d_t) );
			
		}
		else
#endif
		{
			if (!Adapter->region_channel[i].Valid)
				continue;
			Adapter->cur_region_channel = 
					&(Adapter->region_channel[i]);
		}

		PRINTK2("cur_region_channel: NrCFP=%d\n", 
				Adapter->cur_region_channel->NrCFP );

		ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_SCAN,
				0, HostCmd_OPTION_USE_INT, 0,
					pending_info, NULL);

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

		if (interruptible_sleep_on_timeout(&Adapter->scan_q,
				       			WAIT_FOR_SCAN_RRESULT_MAX_TIME) == 0)
			printk("Adapter->scan_q: timer expired\n");
	}

#ifdef BG_SCAN
	if(priv->adapter->bgScanConfig->Enable == TRUE) {
		wlan_bg_scan_enable(priv, TRUE);
	}
#endif /* BG_SCAN */

	LEAVE();
	return 0;
}

/*
 * Wireless Handler: Initiate scan 
 */
int wlan_set_scan(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;
	union iwreq_data	wrqu;

	ENTER();

#ifdef BG_SCAN
	/* Return immediately if BG_SCAN is enabled */
	if(priv->adapter->bgScanConfig->Enable) 
		return 0;
#endif /* BG_SCAN */

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

	if (!Adapter->bIsScanInProgress) {
		memset(Adapter->BSSIDList, 0,
			sizeof(WLAN_802_11_BSSID) * 
			MRVDRV_MAX_BSSID_LIST);

		Adapter->bAutoAssociation = FALSE;
		if (!wlan_scan_networks(priv, HostCmd_PENDING_ON_NONE)) {
			memset(&wrqu, 0, sizeof(union iwreq_data));
#ifdef linux
			wireless_send_event(priv->wlan_dev.netdev, SIOCGIWSCAN, &wrqu , NULL);
#endif
		}
	}

	if (Adapter->SurpriseRemoved)
		return -1;

	LEAVE();
	return 0;
}

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

	if (Mode != RF_ANTENNA_1 && Mode != RF_ANTENNA_2
					&& Mode != RF_ANTENNA_AUTO) {
		return -EINVAL;
	}

	Adapter->RxAntennaMode = Mode;

	PRINTK1("SET RX Antenna Mode to 0x%04x\n", Adapter->RxAntennaMode);
			
	ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_RF_ANTENNA,
			HostCmd_ACT_SET_RX, HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
			, 0, HostCmd_PENDING_ON_NONE, &Adapter->RxAntennaMode);
	return ret;
}

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

	if ((Mode != RF_ANTENNA_1) && (Mode != RF_ANTENNA_2)
			&& (Mode != RF_ANTENNA_AUTO)) {
		return -EINVAL;
	}
		
	Adapter->TxAntennaMode = Mode; 

	PRINTK1("SET TX Antenna Mode to 0x%04x\n", Adapter->TxAntennaMode);

	ret = PrepareAndSendCommand(priv, HostCmd_CMD_802_11_RF_ANTENNA,
			HostCmd_ACT_SET_TX, HostCmd_OPTION_USE_INT
			| HostCmd_OPTION_WAITFORRSP
			, 0, HostCmd_PENDING_ON_NONE, &Adapter->TxAntennaMode);

	return ret;
}

int GetRxAntenna(wlan_private *priv, char *buf)
{
	int		ret = 0;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();

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

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

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

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

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

int GetTxAntenna(wlan_private *priv, char *buf)
{
	int		ret = 0;
	wlan_adapter	*Adapter = priv->adapter;

	ENTER();