wlan_wext.c

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

#endif
		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, 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;
#ifdef MULTI_BANDS
	HostCmd_DS_802_11_BAND_CONFIG bc;
#endif /* MULTI BANDS*/

	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 MULTI_BANDS
	/* To set the band, back to the current operating band */
	/* Need to remove it once the new firmware can handle this */
	if ((Adapter->MediaConnectStatus == WlanMediaStateConnected) &&
							Adapter->is_multiband) {
		bc.BandSelection = Adapter->CurBssParams.band;
		bc.Channel = Adapter->CurBssParams.channel;

		ret = PrepareAndSendCommand(priv, 
				HostCmd_CMD_802_11_BAND_CONFIG,
				HostCmd_ACT_SET, HostCmd_OPTION_USE_INT 
				| HostCmd_OPTION_WAITFORRSP
				, 0, HostCmd_PENDING_ON_NONE, &bc);

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

	}
#endif /* MULTI_BANDS*/

#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
#ifdef CONFIG_MARVELL_PM
	if ((Adapter->DeepSleep_State == DEEP_SLEEP_USER_ENABLED) || 
		(Adapter->DeepSleep_State == DEEP_SLEEP_OS_ENABLED)) {
#else
	if ((Adapter->IsDeepSleep == TRUE)) {
#endif
		printk("<1>SIOCSIWSCAN: IOCTLS called when station is"
							" in DeepSleep\n");
		return -EBUSY;
	}
#endif

	if (!Adapter->bIsScanInProgress) {
//		Adapter->ulNumOfBSSIDs = 0;

		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;
}

/* Added for Subcommand Implementation MPS 2004/08/16. */

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();
	
	// 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;
}

/* End of Addition for Subcommand Implementation  2004/08/16 MPS */		

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;
}

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

	ENTER();

#ifdef DEEP_SLEEP
#ifdef CONFIG_MARVELL_PM
	if ((Adapter->DeepSleep_State == DEEP_SLEEP_USER_ENABLED) || 
		(Adapter->DeepSleep_State == DEEP_SLEEP_OS_ENABLED)) {
#else
	if ((Adapter->IsDeepSleep == TRUE)) {
#endif
		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
#ifdef CONFIG_MARVELL_PM
	if ((Adapter->DeepSleep_State == DEEP_SLEEP_USER_ENABLED) || 
		(Adapter->DeepSleep_State == DEEP_SLEEP_OS_ENABLED)) {
#else
	if ((Adapter->IsDeepSleep == TRUE)) {
#endif
		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;
}

/* wlanidle is off */
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;
}

/* wlanidle is on */
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);

		}

	}

	if (Adapter->TimerIsSet == TRUE) {
		CancelTimer(&Adapter->MrvDrvTimer);
		Adapter->TimerIsSet = FALSE;
	}	
	PRINTK("\nwlanidle is on");

	LEAVE();
	return ret;
}

int wlan_rfi_txmode(wlan_private *priv, struct iwreq *wrq)
{
	int			ret = 0;
	HostCmd_802_11_RFI	rfi;
		
	ENTER();

	if (wrq->u.data.pointer){
		
		switch ((int)*wrq->u.data.pointer) {

			case TX_MODE_NORMAL :
				rfi.Mode	= TX_MODE_NORMAL;
				ret = PrepareAndSendCommand(priv,
						HostCmd_CMD_802_11_TX_MODE,
						0, HostCmd_OPTION_USE_INT
						| HostCmd_OPTION_WAITFORRSP
						, 0, HostCmd_PENDING_ON_NONE,
						&rfi);
				
				break;
				
			case TX_MODE_CONT :	/* continuous modulated data */
				rfi.Mode	= TX_MODE_CONT;
				ret = PrepareAndSendCommand(priv,
						HostCmd_CMD_802_11_TX_MODE,
						0, HostCmd_OPTION_USE_INT
						| HostCmd_OPTION_WAITFORRSP
						, 0, HostCmd_PENDING_ON_NONE,
						&rfi);
				
				break;
				
			case TX_MODE_CW :	/* contention window */
				rfi.Mode	= TX_MODE_CW;
				ret = PrepareAndSendCommand(priv,
						HostCmd_CMD_802_11_TX_MODE,
						0, HostCmd_OPTION_USE_INT
						| HostCmd_OPTION_WAITFORRSP
						, 0, HostCmd_PENDING_ON_NONE,
						&rfi);
				break;

			default:
				return -ENOTSUPP;
		}

	} else
		return -EINVAL;

	LEAVE();
	return ret;

}

int wlan_rfi_txcontrolmode(wlan_private *priv, struct iwreq *wrq)
{
	int			ret = 0;
	HostCmd_802_11_RFI	rfi;
	int			mode;

	ENTER();

	if (wrq->u.data.pointer){ 
		mode = (int)*wrq->u.data.pointer;
		switch (mode) {
			case TX_MODE_EXIT :	/* exit test mode */
				rfi.Mode	= mode;
				ret = PrepareAndSendCommand(priv,
						HostCmd_CMD_802_11_TX_CONTROL_MODE,
						0, HostCmd_OPTION_USE_INT
						| HostCmd_OPTION_WAITFORRSP
						, 0, HostCmd_PENDING_ON_NONE,