linux-vybrid_public/drivers/net/wireless/libertas/ioctl.c

/**
  * This file contains ioctl functions
  */

#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/if.h>
#include <linux/if_arp.h>
#include <linux/wireless.h>

#include <net/iw_handler.h>
#include <net/ieee80211.h>

#include "host.h"
#include "radiotap.h"
#include "decl.h"
#include "defs.h"
#include "dev.h"
#include "join.h"
#include "wext.h"

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

#define WAIT_FOR_SCAN_RRESULT_MAX_TIME (10 * HZ)

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

	lbs_pr_debug(1, "SET RX Antenna mode to 0x%04x\n", adapter->rxantennamode);

	ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
				    cmd_act_set_rx,
				    cmd_option_waitforrsp, 0,
				    &adapter->rxantennamode);
	return ret;
}

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

	lbs_pr_debug(1, "SET TX Antenna mode to 0x%04x\n", adapter->txantennamode);

	ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
				    cmd_act_set_tx,
				    cmd_option_waitforrsp, 0,
				    &adapter->txantennamode);

	return ret;
}

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

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

	ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
				    cmd_act_get_rx,
				    cmd_option_waitforrsp, 0, NULL);

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

	lbs_pr_debug(1, "Get Rx Antenna mode:0x%04x\n", adapter->rxantennamode);

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

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

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

	ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_antenna,
				    cmd_act_get_tx,
				    cmd_option_waitforrsp, 0, NULL);

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

	lbs_pr_debug(1, "Get Tx Antenna mode:0x%04x\n", adapter->txantennamode);

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

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

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

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

	if (libertas_set_regiontable(priv, priv->adapter->regioncode, 0)) {
		LEAVE();
		return -EINVAL;
	}

	return 0;
}

/**
 *  @brief Get/Set Firmware wakeup method
 *
 *  @param priv		A pointer to wlan_private structure
 *  @param wrq	   	A pointer to user data
 *  @return 	   	0--success, otherwise fail
 */
static int wlan_txcontrol(wlan_private * priv, struct iwreq *wrq)
{
	wlan_adapter *adapter = priv->adapter;
	int data;
	ENTER();

	if ((int)wrq->u.data.length == 0) {
		if (copy_to_user
		    (wrq->u.data.pointer, &adapter->pkttxctrl, sizeof(u32))) {
			lbs_pr_alert("copy_to_user failed!\n");
			return -EFAULT;
		}
	} else {
		if ((int)wrq->u.data.length > 1) {
			lbs_pr_alert("ioctl too many args!\n");
			return -EFAULT;
		}
		if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
			lbs_pr_alert("Copy from user failed\n");
			return -EFAULT;
		}

		adapter->pkttxctrl = (u32) data;
	}

	wrq->u.data.length = 1;

	LEAVE();
	return 0;
}

/**
 *  @brief Get/Set NULL Package generation interval
 *
 *  @param priv		A pointer to wlan_private structure
 *  @param wrq	   	A pointer to user data
 *  @return 	   	0--success, otherwise fail
 */
static int wlan_null_pkt_interval(wlan_private * priv, struct iwreq *wrq)
{
	wlan_adapter *adapter = priv->adapter;
	int data;
	ENTER();

	if ((int)wrq->u.data.length == 0) {
		data = adapter->nullpktinterval;

		if (copy_to_user(wrq->u.data.pointer, &data, sizeof(int))) {
			lbs_pr_alert( "copy_to_user failed!\n");
			return -EFAULT;
		}
	} else {
		if ((int)wrq->u.data.length > 1) {
			lbs_pr_alert( "ioctl too many args!\n");
			return -EFAULT;
		}
		if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
			lbs_pr_debug(1, "Copy from user failed\n");
			return -EFAULT;
		}

		adapter->nullpktinterval = data;
	}

	wrq->u.data.length = 1;

	LEAVE();
	return 0;
}

static int wlan_get_rxinfo(wlan_private * priv, struct iwreq *wrq)
{
	wlan_adapter *adapter = priv->adapter;
	int data[2];
	ENTER();
	data[0] = adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
	data[1] = adapter->rxpd_rate;
	if (copy_to_user(wrq->u.data.pointer, data, sizeof(int) * 2)) {
		lbs_pr_debug(1, "Copy to user failed\n");
		return -EFAULT;
	}
	wrq->u.data.length = 2;
	LEAVE();
	return 0;
}

static int wlan_get_snr(wlan_private * priv, struct iwreq *wrq)
{
	int ret = 0;
	wlan_adapter *adapter = priv->adapter;
	int data[4];

	ENTER();
	memset(data, 0, sizeof(data));
	if (wrq->u.data.length) {
		if (copy_from_user(data, wrq->u.data.pointer,
		     min_t(size_t, wrq->u.data.length, 4) * sizeof(int)))
			return -EFAULT;
	}
	if ((wrq->u.data.length == 0) || (data[0] == 0) || (data[0] == 1)) {
		if (adapter->connect_status == libertas_connected) {
			ret = libertas_prepare_and_send_command(priv,
						    cmd_802_11_rssi,
						    0,
						    cmd_option_waitforrsp,
						    0, NULL);

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

	if (wrq->u.data.length == 0) {
		data[0] = adapter->SNR[TYPE_BEACON][TYPE_NOAVG];
		data[1] = adapter->SNR[TYPE_BEACON][TYPE_AVG];
		data[2] = adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
		data[3] = adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
		if (copy_to_user(wrq->u.data.pointer, data, sizeof(int) * 4))
			return -EFAULT;
		wrq->u.data.length = 4;
	} else if (data[0] == 0) {
		data[0] = adapter->SNR[TYPE_BEACON][TYPE_NOAVG];
		if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
			return -EFAULT;
		wrq->u.data.length = 1;
	} else if (data[0] == 1) {
		data[0] = adapter->SNR[TYPE_BEACON][TYPE_AVG];
		if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
			return -EFAULT;
		wrq->u.data.length = 1;
	} else if (data[0] == 2) {
		data[0] = adapter->SNR[TYPE_RXPD][TYPE_NOAVG];
		if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
			return -EFAULT;
		wrq->u.data.length = 1;
	} else if (data[0] == 3) {
		data[0] = adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
		if (copy_to_user(wrq->u.data.pointer, data, sizeof(int)))
			return -EFAULT;
		wrq->u.data.length = 1;
	} else
		return -ENOTSUPP;

	LEAVE();
	return 0;
}

static int wlan_beacon_interval(wlan_private * priv, struct iwreq *wrq)
{
	int data;
	wlan_adapter *adapter = priv->adapter;

	if (wrq->u.data.length > 0) {
		if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int)))
			return -EFAULT;

		lbs_pr_debug(1, "WLAN SET BEACON INTERVAL: %d\n", data);
		if ((data > MRVDRV_MAX_BEACON_INTERVAL)
		    || (data < MRVDRV_MIN_BEACON_INTERVAL))
			return -ENOTSUPP;
		adapter->beaconperiod = data;
	}
	data = adapter->beaconperiod;
	if (copy_to_user(wrq->u.data.pointer, &data, sizeof(int)))
		return -EFAULT;

	wrq->u.data.length = 1;

	return 0;
}

static int wlan_get_rssi(wlan_private * priv, struct iwreq *wrq)
{
	int ret = 0;
	wlan_adapter *adapter = priv->adapter;
	int temp;
	int data = 0;
	int *val;

	ENTER();
	data = SUBCMD_DATA(wrq);
	if ((data == 0) || (data == 1)) {
		ret = libertas_prepare_and_send_command(priv,
					    cmd_802_11_rssi,
					    0, cmd_option_waitforrsp,
					    0, NULL);
		if (ret) {
			LEAVE();
			return ret;
		}
	}

	switch (data) {
	case 0:

		temp = CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
				adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
		break;
	case 1:
		temp = CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_AVG],
				adapter->NF[TYPE_BEACON][TYPE_AVG]);
		break;
	case 2:
		temp = CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_NOAVG],
				adapter->NF[TYPE_RXPD][TYPE_NOAVG]);
		break;
	case 3:
		temp = CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE,
				adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE);
		break;
	default:
		return -ENOTSUPP;
	}
	val = (int *)wrq->u.name;
	*val = temp;

	LEAVE();
	return 0;
}

static int wlan_get_nf(wlan_private * priv, struct iwreq *wrq)
{
	int ret = 0;
	wlan_adapter *adapter = priv->adapter;
	int temp;
	int data = 0;
	int *val;

	data = SUBCMD_DATA(wrq);
	if ((data == 0) || (data == 1)) {
		ret = libertas_prepare_and_send_command(priv,
					    cmd_802_11_rssi,
					    0, cmd_option_waitforrsp,
					    0, NULL);

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

	switch (data) {
	case 0:
		temp = adapter->NF[TYPE_BEACON][TYPE_NOAVG];
		break;
	case 1:
		temp = adapter->NF[TYPE_BEACON][TYPE_AVG];
		break;
	case 2:
		temp = adapter->NF[TYPE_RXPD][TYPE_NOAVG];
		break;
	case 3:
		temp = adapter->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
		break;
	default:
		return -ENOTSUPP;
	}

	temp = CAL_NF(temp);

	lbs_pr_debug(1, "%s: temp = %d\n", __FUNCTION__, temp);
	val = (int *)wrq->u.name;
	*val = temp;
	return 0;
}

static int wlan_get_txrate_ioctl(wlan_private * priv, struct ifreq *req)
{
	wlan_adapter *adapter = priv->adapter;
	int *pdata;
	struct iwreq *wrq = (struct iwreq *)req;
	int ret = 0;
	adapter->txrate = 0;
	lbs_pr_debug(1, "wlan_get_txrate_ioctl\n");
	ret = libertas_prepare_and_send_command(priv, cmd_802_11_tx_rate_query,
				    cmd_act_get, cmd_option_waitforrsp,
				    0, NULL);
	if (ret)
		return ret;

	pdata = (int *)wrq->u.name;
	*pdata = (int)adapter->txrate;
	return 0;
}

static int wlan_get_adhoc_status_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	char status[64];
	wlan_adapter *adapter = priv->adapter;

	memset(status, 0, sizeof(status));

	switch (adapter->mode) {
	case IW_MODE_ADHOC:
		if (adapter->connect_status == libertas_connected) {
			if (adapter->adhoccreate)
				memcpy(&status, "AdhocStarted", sizeof(status));
			else
				memcpy(&status, "AdhocJoined", sizeof(status));
		} else {
			memcpy(&status, "AdhocIdle", sizeof(status));
		}
		break;
	case IW_MODE_INFRA:
		memcpy(&status, "Inframode", sizeof(status));
		break;
	default:
		memcpy(&status, "AutoUnknownmode", sizeof(status));
		break;
	}

	lbs_pr_debug(1, "status = %s\n", status);
	wrq->u.data.length = strlen(status) + 1;

	if (wrq->u.data.pointer) {
		if (copy_to_user(wrq->u.data.pointer,
				 &status, wrq->u.data.length))
			return -EFAULT;
	}

	LEAVE();
	return 0;
}

/**
 *  @brief Set Auto prescan
 *  @param priv                 A pointer to wlan_private structure
 *  @param wrq			A pointer to iwreq structure
 *  @return 	   		0 --success, otherwise fail
 */
static int wlan_subcmd_setprescan_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	int data;
	wlan_adapter *adapter = priv->adapter;
	int *val;

	data = SUBCMD_DATA(wrq);
	lbs_pr_debug(1, "WLAN_SUBCMD_SET_PRESCAN %d\n", data);
	adapter->prescan = data;

	val = (int *)wrq->u.name;
	*val = data;
	return 0;
}

static int wlan_set_multiple_dtim_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	u32 mdtim;
	int idata;
	int ret = -EINVAL;

	ENTER();

	idata = SUBCMD_DATA(wrq);
	mdtim = (u32) idata;
	if (((mdtim >= MRVDRV_MIN_MULTIPLE_DTIM)
	     && (mdtim <= MRVDRV_MAX_MULTIPLE_DTIM))
	    || (mdtim == MRVDRV_IGNORE_MULTIPLE_DTIM)) {
		priv->adapter->multipledtim = mdtim;
		ret = 0;
	}
	if (ret)
		lbs_pr_debug(1, "Invalid parameter, multipledtim not changed.\n");

	LEAVE();
	return ret;
}

static void adjust_mtu(wlan_private * priv)
{
	int mtu_increment = 0;

	if (priv->adapter->linkmode == WLAN_LINKMODE_802_11)
		mtu_increment += sizeof(struct ieee80211_hdr_4addr);

	if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP)
		mtu_increment += max(sizeof(struct tx_radiotap_hdr),
				     sizeof(struct rx_radiotap_hdr));
	priv->wlan_dev.netdev->mtu = ETH_FRAME_LEN
	    - sizeof(struct ethhdr)
	    + mtu_increment;
}

/**
 *  @brief Set Link-Layer Layer mode
 *  @param priv                 A pointer to wlan_private structure
 *  @param req			A pointer to ifreq structure
 *  @return 	   		0 --success, otherwise fail
 */
static int wlan_set_linkmode_ioctl(wlan_private * priv, struct ifreq *req)
{
	int mode;

	mode = (int)((struct ifreq *)((u8 *) req + 4))->ifr_data;

	switch (mode) {
	case WLAN_LINKMODE_802_3:
		priv->adapter->linkmode = mode;
		break;
	case WLAN_LINKMODE_802_11:
		priv->adapter->linkmode = mode;
		break;
	default:
		lbs_pr_info("usb8388-5: invalid link-layer mode (%#x)\n",
		       mode);
		return -EINVAL;
		break;
	}
	lbs_pr_debug(1, "usb8388-5: link-layer mode is %#x\n", mode);

	adjust_mtu(priv);

	return 0;
}

/**
 *  @brief Set Radio header mode
 *  @param priv                 A pointer to wlan_private structure
 *  @param req			A pointer to ifreq structure
 *  @return 	   		0 --success, otherwise fail
 */
static int wlan_set_radiomode_ioctl(wlan_private * priv, struct ifreq *req)
{
	int mode;

	mode = (int)((struct ifreq *)((u8 *) req + 4))->ifr_data;

	switch (mode) {
	case WLAN_RADIOMODE_NONE:
		priv->adapter->radiomode = mode;
		break;
	case WLAN_RADIOMODE_RADIOTAP:
		priv->adapter->radiomode = mode;
		break;
	default:
		lbs_pr_debug(1, "usb8388-5: invalid radio header mode (%#x)\n",
		       mode);
		return -EINVAL;
	}
	lbs_pr_debug(1, "usb8388-5: radio-header mode is %#x\n", mode);

	adjust_mtu(priv);
	return 0;
}

/**
 *  @brief Set Debug header mode
 *  @param priv                 A pointer to wlan_private structure
 *  @param req			A pointer to ifreq structure
 *  @return 	   		0 --success, otherwise fail
 */
static int wlan_set_debugmode_ioctl(wlan_private * priv, struct ifreq *req)
{
	priv->adapter->debugmode = (int)((struct ifreq *)
					 ((u8 *) req + 4))->ifr_data;
	return 0;
}

static int wlan_subcmd_getrxantenna_ioctl(wlan_private * priv,
					  struct ifreq *req)
{
	int len;
	char buf[8];
	struct iwreq *wrq = (struct iwreq *)req;

	lbs_pr_debug(1, "WLAN_SUBCMD_GETRXANTENNA\n");
	len = getrxantenna(priv, buf);

	wrq->u.data.length = len;
	if (wrq->u.data.pointer) {
		if (copy_to_user(wrq->u.data.pointer, &buf, len)) {
			lbs_pr_debug(1, "CopyToUser failed\n");
			return -EFAULT;
		}
	}

	return 0;
}

static int wlan_subcmd_gettxantenna_ioctl(wlan_private * priv,
					  struct ifreq *req)
{
	int len;
	char buf[8];
	struct iwreq *wrq = (struct iwreq *)req;

	lbs_pr_debug(1, "WLAN_SUBCMD_GETTXANTENNA\n");
	len = gettxantenna(priv, buf);

	wrq->u.data.length = len;
	if (wrq->u.data.pointer) {
		if (copy_to_user(wrq->u.data.pointer, &buf, len)) {
			lbs_pr_debug(1, "CopyToUser failed\n");
			return -EFAULT;
		}
	}
	return 0;
}

/**
 *  @brief Get the MAC TSF value from the firmware
 *
 *  @param priv         A pointer to wlan_private structure
 *  @param wrq          A pointer to iwreq structure containing buffer
 *                      space to store a TSF value retrieved from the firmware
 *
 *  @return             0 if successful; IOCTL error code otherwise
 */
static int wlan_get_tsf_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	u64 tsfval;
	int ret;

	ret = libertas_prepare_and_send_command(priv,
				    cmd_get_tsf,
				    0, cmd_option_waitforrsp, 0, &tsfval);

	lbs_pr_debug(1, "IOCTL: Get TSF = 0x%016llx\n", tsfval);

	if (ret != 0) {
		lbs_pr_debug(1, "IOCTL: Get TSF; command exec failed\n");
		ret = -EFAULT;
	} else {
		if (copy_to_user(wrq->u.data.pointer,
				 &tsfval,
				 min_t(size_t, wrq->u.data.length,
				     sizeof(tsfval))) != 0) {

			lbs_pr_debug(1, "IOCTL: Get TSF; Copy to user failed\n");
			ret = -EFAULT;
		} else {
			ret = 0;
		}
	}
	return ret;
}

/**
 *  @brief Get/Set adapt rate
 *  @param priv                 A pointer to wlan_private structure
 *  @param wrq			A pointer to iwreq structure
 *  @return 	   		0 --success, otherwise fail
 */
static int wlan_adapt_rateset(wlan_private * priv, struct iwreq *wrq)
{
	int ret;
	wlan_adapter *adapter = priv->adapter;
	int data[2];

	memset(data, 0, sizeof(data));
	if (!wrq->u.data.length) {
		lbs_pr_debug(1, "Get ADAPT RATE SET\n");
		ret = libertas_prepare_and_send_command(priv,
					    cmd_802_11_rate_adapt_rateset,
					    cmd_act_get,
					    cmd_option_waitforrsp, 0, NULL);
		data[0] = adapter->enablehwauto;
		data[1] = adapter->ratebitmap;
		if (copy_to_user(wrq->u.data.pointer, data, sizeof(int) * 2)) {
			lbs_pr_debug(1, "Copy to user failed\n");
			return -EFAULT;
		}
#define GET_TWO_INT	2
		wrq->u.data.length = GET_TWO_INT;
	} else {
		lbs_pr_debug(1, "Set ADAPT RATE SET\n");
		if (wrq->u.data.length > 2)
			return -EINVAL;
		if (copy_from_user
		    (data, wrq->u.data.pointer,
		     sizeof(int) * wrq->u.data.length)) {
			lbs_pr_debug(1, "Copy from user failed\n");
			return -EFAULT;
		}

		adapter->enablehwauto = data[0];
		adapter->ratebitmap = data[1];
		ret = libertas_prepare_and_send_command(priv,
					    cmd_802_11_rate_adapt_rateset,
					    cmd_act_set,
					    cmd_option_waitforrsp, 0, NULL);
	}
	return ret;
}

/**
 *  @brief Get/Set inactivity timeout
 *  @param priv                 A pointer to wlan_private structure
 *  @param wrq			A pointer to iwreq structure
 *  @return 	   		0 --success, otherwise fail
 */
static int wlan_inactivity_timeout(wlan_private * priv, struct iwreq *wrq)
{
	int ret;
	int data = 0;
	u16 timeout = 0;

	ENTER();
	if (wrq->u.data.length > 1)
		return -ENOTSUPP;

	if (wrq->u.data.length == 0) {
		/* Get */
		ret = libertas_prepare_and_send_command(priv,
					    cmd_802_11_inactivity_timeout,
					    cmd_act_get,
					    cmd_option_waitforrsp, 0,
					    &timeout);
		data = timeout;
		if (copy_to_user(wrq->u.data.pointer, &data, sizeof(int))) {
			lbs_pr_debug(1, "Copy to user failed\n");
			return -EFAULT;
		}
	} else {
		/* Set */
		if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
			lbs_pr_debug(1, "Copy from user failed\n");
			return -EFAULT;
		}

		timeout = data;
		ret = libertas_prepare_and_send_command(priv,
					    cmd_802_11_inactivity_timeout,
					    cmd_act_set,
					    cmd_option_waitforrsp, 0,
					    &timeout);
	}

	wrq->u.data.length = 1;

	LEAVE();
	return ret;
}

static int wlan_do_getlog_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	int ret;
	char buf[GETLOG_BUFSIZE - 1];
	wlan_adapter *adapter = priv->adapter;

	lbs_pr_debug(1, " GET STATS\n");

	ret = libertas_prepare_and_send_command(priv, cmd_802_11_get_log,
				    0, cmd_option_waitforrsp, 0, NULL);

	if (ret) {
		return ret;
	}

	if (wrq->u.data.pointer) {
		sprintf(buf, "\n  mcasttxframe %u failed %u retry %u "
			"multiretry %u framedup %u "
			"rtssuccess %u rtsfailure %u ackfailure %u\n"
			"rxfrag %u mcastrxframe %u fcserror %u "
			"txframe %u wepundecryptable %u ",
			adapter->logmsg.mcasttxframe,
			adapter->logmsg.failed,
			adapter->logmsg.retry,
			adapter->logmsg.multiretry,
			adapter->logmsg.framedup,
			adapter->logmsg.rtssuccess,
			adapter->logmsg.rtsfailure,
			adapter->logmsg.ackfailure,
			adapter->logmsg.rxfrag,
			adapter->logmsg.mcastrxframe,
			adapter->logmsg.fcserror,
			adapter->logmsg.txframe,
			adapter->logmsg.wepundecryptable);
		wrq->u.data.length = strlen(buf) + 1;
		if (copy_to_user(wrq->u.data.pointer, buf, wrq->u.data.length)) {
			lbs_pr_debug(1, "Copy to user failed\n");
			return -EFAULT;
		}
	}

	return 0;
}

static int wlan_scan_type_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	u8 buf[12];
	u8 *option[] = { "active", "passive", "get", };
	int i, max_options = (sizeof(option) / sizeof(option[0]));
	int ret = 0;
	wlan_adapter *adapter = priv->adapter;

	if (priv->adapter->enable11d) {
		lbs_pr_debug(1, "11D: Cannot set scantype when 11D enabled\n");
		return -EFAULT;
	}

	memset(buf, 0, sizeof(buf));

	if (copy_from_user(buf, wrq->u.data.pointer, min_t(size_t, sizeof(buf),
							 wrq->u.data.length)))
		return -EFAULT;

	lbs_pr_debug(1, "Scan type Option = %s\n", buf);

	buf[sizeof(buf) - 1] = '\0';

	for (i = 0; i < max_options; i++) {
		if (!strcmp(buf, option[i]))
			break;
	}

	switch (i) {
	case 0:
		adapter->scantype = cmd_scan_type_active;
		break;
	case 1:
		adapter->scantype = cmd_scan_type_passive;
		break;
	case 2:
		wrq->u.data.length = strlen(option[adapter->scantype]) + 1;

		if (copy_to_user(wrq->u.data.pointer,
				 option[adapter->scantype],
				 wrq->u.data.length)) {
			lbs_pr_debug(1, "Copy to user failed\n");
			ret = -EFAULT;
		}

		break;
	default:
		lbs_pr_debug(1, "Invalid Scan type Ioctl Option\n");
		ret = -EINVAL;
		break;
	}

	return ret;
}

static int wlan_scan_mode_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	wlan_adapter *adapter = priv->adapter;
	u8 buf[12];
	u8 *option[] = { "bss", "ibss", "any", "get" };
	int i, max_options = (sizeof(option) / sizeof(option[0]));
	int ret = 0;

	ENTER();

	memset(buf, 0, sizeof(buf));

	if (copy_from_user(buf, wrq->u.data.pointer, min_t(size_t, sizeof(buf),
							 wrq->u.data.length))) {
		lbs_pr_debug(1, "Copy from user failed\n");
		return -EFAULT;
	}

	lbs_pr_debug(1, "Scan mode Option = %s\n", buf);

	buf[sizeof(buf) - 1] = '\0';

	for (i = 0; i < max_options; i++) {
		if (!strcmp(buf, option[i]))
			break;
	}

	switch (i) {

	case 0:
		adapter->scanmode = cmd_bss_type_bss;
		break;
	case 1:
		adapter->scanmode = cmd_bss_type_ibss;
		break;
	case 2:
		adapter->scanmode = cmd_bss_type_any;
		break;
	case 3:

		wrq->u.data.length = strlen(option[adapter->scanmode - 1]) + 1;

		lbs_pr_debug(1, "Get Scan mode Option = %s\n",
		       option[adapter->scanmode - 1]);

		lbs_pr_debug(1, "Scan mode length %d\n", wrq->u.data.length);

		if (copy_to_user(wrq->u.data.pointer,
				 option[adapter->scanmode - 1],
				 wrq->u.data.length)) {
			lbs_pr_debug(1, "Copy to user failed\n");
			ret = -EFAULT;
		}
		lbs_pr_debug(1, "GET Scan type Option after copy = %s\n",
		       (char *)wrq->u.data.pointer);

		break;

	default:
		lbs_pr_debug(1, "Invalid Scan mode Ioctl Option\n");
		ret = -EINVAL;
		break;
	}

	LEAVE();
	return ret;
}

/**
 *  @brief Get/Set Adhoc G Rate
 *
 *  @param priv		A pointer to wlan_private structure
 *  @param wrq	   	A pointer to user data
 *  @return 	   	0--success, otherwise fail
 */
static int wlan_do_set_grate_ioctl(wlan_private * priv, struct iwreq *wrq)
{
	wlan_adapter *adapter = priv->adapter;
	int data, data1;
	int *val;

	ENTER();

	data1 = SUBCMD_DATA(wrq);
	switch (data1) {
	case 0:
		adapter->adhoc_grate_enabled = 0;
		break;
	case 1:
		adapter->adhoc_grate_enabled = 1;
		break;
	case 2:
		break;
	default:
		return -EINVAL;
	}
	data = adapter->adhoc_grate_enabled;
	val = (int *)wrq->u.name;
	*val = data;
	LEAVE();
	return 0;
}

static inline int hex2int(char c)
{
	if (c >= '0' && c <= '9')
		return (c - '0');
	if (c >= 'a' && c <= 'f')
		return (c - 'a' + 10);
	if (c >= 'A' && c <= 'F')
		return (c - 'A' + 10);
	return -1;
}

/* Convert a string representation of a MAC address ("xx:xx:xx:xx:xx:xx")
   into binary format (6 bytes).

   This function expects that each byte is represented with 2 characters
   (e.g., 11:2:11:11:11:11 is invalid)

 */
static char *eth_str2addr(char *ethstr, u8 * addr)
{
	int i, val, val2;
	char *pos = ethstr;

	/* get rid of initial blanks */
	while (*pos == ' ' || *pos == '\t')
		++pos;

	for (i = 0; i < 6; i++) {
		val = hex2int(*pos++);
		if (val < 0)
			return NULL;
		val2 = hex2int(*pos++);
		if (val2 < 0)
			return NULL;
		addr[i] = (val * 16 + val2) & 0xff;

		if (i < 5 && *pos++ != ':')
			return NULL;
	}
	return pos;
}

/* this writes xx:xx:xx:xx:xx:xx into ethstr
   (ethstr must have space for 18 chars) */
static int eth_addr2str(u8 * addr, char *ethstr)
{
	int i;
	char *pos = ethstr;

	for (i = 0; i < 6; i++) {
		sprintf(pos, "%02x", addr[i] & 0xff);
		pos += 2;
		if (i < 5)
			*pos++ = ':';
	}
	return 17;
}

/**
 *  @brief          Add an entry to the BT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_bt_add_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char ethaddrs_str[18];
	char *pos;
	u8 ethaddr[ETH_ALEN];

	ENTER();
	if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
			   sizeof(ethaddrs_str)))
		return -EFAULT;

	if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
		lbs_pr_info("BT_ADD: Invalid MAC address\n");
		return -EINVAL;
	}

	lbs_pr_debug(1, "BT: adding %s\n", ethaddrs_str);
	LEAVE();
	return (libertas_prepare_and_send_command(priv, cmd_bt_access,
				      cmd_act_bt_access_add,
				      cmd_option_waitforrsp, 0, ethaddr));
}

/**
 *  @brief          Delete an entry from the BT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_bt_del_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char ethaddrs_str[18];
	u8 ethaddr[ETH_ALEN];
	char *pos;

	ENTER();
	if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
			   sizeof(ethaddrs_str)))
		return -EFAULT;

	if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
		lbs_pr_info("Invalid MAC address\n");
		return -EINVAL;
	}

	lbs_pr_debug(1, "BT: deleting %s\n", ethaddrs_str);

	return (libertas_prepare_and_send_command(priv,
				      cmd_bt_access,
				      cmd_act_bt_access_del,
				      cmd_option_waitforrsp, 0, ethaddr));
	LEAVE();
	return 0;
}

/**
 *  @brief          Reset all entries from the BT table
 *  @param priv     A pointer to wlan_private structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_bt_reset_ioctl(wlan_private * priv)
{
	ENTER();

	lbs_pr_alert( "BT: resetting\n");

	return (libertas_prepare_and_send_command(priv,
				      cmd_bt_access,
				      cmd_act_bt_access_reset,
				      cmd_option_waitforrsp, 0, NULL));

	LEAVE();
	return 0;
}

/**
 *  @brief          List an entry from the BT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_bt_list_ioctl(wlan_private * priv, struct ifreq *req)
{
	int pos;
	char *addr1;
	struct iwreq *wrq = (struct iwreq *)req;
	/* used to pass id and store the bt entry returned by the FW */
	union {
		int id;
		char addr1addr2[2 * ETH_ALEN];
	} param;
	static char outstr[64];
	char *pbuf = outstr;
	int ret;

	ENTER();

	if (copy_from_user(outstr, wrq->u.data.pointer, sizeof(outstr))) {
		lbs_pr_debug(1, "Copy from user failed\n");
		return -1;
	}
	param.id = simple_strtoul(outstr, NULL, 10);
	pos = sprintf(pbuf, "%d: ", param.id);
	pbuf += pos;

	ret = libertas_prepare_and_send_command(priv, cmd_bt_access,
				    cmd_act_bt_access_list,
				    cmd_option_waitforrsp, 0,
				    (char *)&param);

	if (ret == 0) {
		addr1 = param.addr1addr2;

		pos = sprintf(pbuf, "ignoring traffic from ");
		pbuf += pos;
		pos = eth_addr2str(addr1, pbuf);
		pbuf += pos;
	} else {
		sprintf(pbuf, "(null)");
		pbuf += pos;
	}

	wrq->u.data.length = strlen(outstr);
	if (copy_to_user(wrq->u.data.pointer, (char *)outstr,
			 wrq->u.data.length)) {
		lbs_pr_debug(1, "BT_LIST: Copy to user failed!\n");
		return -EFAULT;
	}

	LEAVE();
	return 0;
}

/**
 *  @brief          Find the next parameter in an input string
 *  @param ptr      A pointer to the input parameter string
 *  @return         A pointer to the next parameter, or 0 if no parameters left.
 */
static char * next_param(char * ptr)
{
	if (!ptr) return NULL;
	while (*ptr == ' ' || *ptr == '\t') ++ptr;
	return (*ptr == '\0') ? NULL : ptr;
}

/**
 *  @brief          Add an entry to the FWT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_add_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char in_str[128];
	static struct cmd_ds_fwt_access fwt_access;
	char *ptr;

	ENTER();
	if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
		return -EFAULT;

	if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
		lbs_pr_alert( "FWT_ADD: Invalid MAC address 1\n");
		return -EINVAL;
	}

	if ((ptr = eth_str2addr(ptr, fwt_access.ra)) == NULL) {
		lbs_pr_alert( "FWT_ADD: Invalid MAC address 2\n");
		return -EINVAL;
	}

	if ((ptr = next_param(ptr)))
		fwt_access.metric =
			cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
	else
		fwt_access.metric = FWT_DEFAULT_METRIC;

	if ((ptr = next_param(ptr)))
		fwt_access.dir = (u8)simple_strtoul(ptr, &ptr, 10);
	else
		fwt_access.dir = FWT_DEFAULT_DIR;

	if ((ptr = next_param(ptr)))
		fwt_access.ssn =
			cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
	else
		fwt_access.ssn = FWT_DEFAULT_SSN;

	if ((ptr = next_param(ptr)))
		fwt_access.dsn =
			cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
	else
		fwt_access.dsn = FWT_DEFAULT_DSN;

	if ((ptr = next_param(ptr)))
		fwt_access.hopcount = simple_strtoul(ptr, &ptr, 10);
	else
		fwt_access.hopcount = FWT_DEFAULT_HOPCOUNT;

	if ((ptr = next_param(ptr)))
		fwt_access.ttl = simple_strtoul(ptr, &ptr, 10);
	else
		fwt_access.ttl = FWT_DEFAULT_TTL;

	if ((ptr = next_param(ptr)))
		fwt_access.expiration =
			cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
	else
		fwt_access.expiration = FWT_DEFAULT_EXPIRATION;

	if ((ptr = next_param(ptr)))
		fwt_access.sleepmode = (u8)simple_strtoul(ptr, &ptr, 10);
	else
		fwt_access.sleepmode = FWT_DEFAULT_SLEEPMODE;

	if ((ptr = next_param(ptr)))
		fwt_access.snr =
			cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
	else
		fwt_access.snr = FWT_DEFAULT_SNR;

#ifdef DEBUG
	{
		char ethaddr1_str[18], ethaddr2_str[18];
		eth_addr2str(fwt_access.da, ethaddr1_str);
		eth_addr2str(fwt_access.ra, ethaddr2_str);
		lbs_pr_debug(1, "FWT_ADD: adding (da:%s,%i,ra:%s)\n", ethaddr1_str,
		       fwt_access.dir, ethaddr2_str);
		lbs_pr_debug(1, "FWT_ADD: ssn:%u dsn:%u met:%u hop:%u ttl:%u exp:%u slp:%u snr:%u\n",
		       fwt_access.ssn, fwt_access.dsn, fwt_access.metric,
		       fwt_access.hopcount, fwt_access.ttl, fwt_access.expiration,
		       fwt_access.sleepmode, fwt_access.snr);
	}
#endif

	LEAVE();
	return (libertas_prepare_and_send_command(priv, cmd_fwt_access,
						  cmd_act_fwt_access_add,
						  cmd_option_waitforrsp, 0,
						  (void *)&fwt_access));
}

/**
 *  @brief          Delete an entry from the FWT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_del_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char in_str[64];
	static struct cmd_ds_fwt_access fwt_access;
	char *ptr;

	ENTER();
	if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
		return -EFAULT;

	if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
		lbs_pr_alert( "FWT_DEL: Invalid MAC address 1\n");
		return -EINVAL;
	}

	if ((ptr = eth_str2addr(ptr, fwt_access.ra)) == NULL) {
		lbs_pr_alert( "FWT_DEL: Invalid MAC address 2\n");
		return -EINVAL;
	}

	if ((ptr = next_param(ptr)))
		fwt_access.dir = (u8)simple_strtoul(ptr, &ptr, 10);
	else
		fwt_access.dir = FWT_DEFAULT_DIR;

#ifdef DEBUG
	{
		char ethaddr1_str[18], ethaddr2_str[18];
		lbs_pr_debug(1, "FWT_DEL: line is %s\n", in_str);
		eth_addr2str(fwt_access.da, ethaddr1_str);
		eth_addr2str(fwt_access.ra, ethaddr2_str);
		lbs_pr_debug(1, "FWT_DEL: removing (da:%s,ra:%s,dir:%d)\n", ethaddr1_str,
		       ethaddr2_str, fwt_access.dir);
	}
#endif

	LEAVE();
	return (libertas_prepare_and_send_command(priv,
						  cmd_fwt_access,
						  cmd_act_fwt_access_del,
						  cmd_option_waitforrsp, 0,
						  (void *)&fwt_access));
}


/**
 *  @brief             Print route parameters
 *  @param fwt_access  struct cmd_ds_fwt_access with route info
 *  @param buf         destination buffer for route info
 */
static void print_route(struct cmd_ds_fwt_access fwt_access, char *buf)
{
	buf += sprintf(buf, " ");
	buf += eth_addr2str(fwt_access.da, buf);
	buf += sprintf(buf, " ");
	buf += eth_addr2str(fwt_access.ra, buf);
	buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.metric));
	buf += sprintf(buf, " %u", fwt_access.dir);
	buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.ssn));
	buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.dsn));
	buf += sprintf(buf, " %u", fwt_access.hopcount);
	buf += sprintf(buf, " %u", fwt_access.ttl);
	buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.expiration));
	buf += sprintf(buf, " %u", fwt_access.sleepmode);
	buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.snr));
}

/**
 *  @brief          Lookup an entry in the FWT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_lookup_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char in_str[64];
	char *ptr;
	static struct cmd_ds_fwt_access fwt_access;
	static char out_str[128];
	int ret;

	ENTER();
	if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
		return -EFAULT;

	if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
		lbs_pr_alert( "FWT_LOOKUP: Invalid MAC address\n");
		return -EINVAL;
	}

#ifdef DEBUG
	{
		char ethaddr1_str[18];
		lbs_pr_debug(1, "FWT_LOOKUP: line is %s\n", in_str);
		eth_addr2str(fwt_access.da, ethaddr1_str);
		lbs_pr_debug(1, "FWT_LOOKUP: looking for (da:%s)\n", ethaddr1_str);
	}
#endif

	ret = libertas_prepare_and_send_command(priv,
						cmd_fwt_access,
						cmd_act_fwt_access_lookup,
						cmd_option_waitforrsp, 0,
						(void *)&fwt_access);

	if (ret == 0)
		print_route(fwt_access, out_str);
	else
		sprintf(out_str, "(null)");

	wrq->u.data.length = strlen(out_str);
	if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
			 wrq->u.data.length)) {
		lbs_pr_debug(1, "FWT_LOOKUP: Copy to user failed!\n");
		return -EFAULT;
	}

	LEAVE();
	return 0;
}

/**
 *  @brief          Reset all entries from the FWT table
 *  @param priv     A pointer to wlan_private structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_reset_ioctl(wlan_private * priv)
{
	lbs_pr_debug(1, "FWT: resetting\n");

	return (libertas_prepare_and_send_command(priv,
				      cmd_fwt_access,
				      cmd_act_fwt_access_reset,
				      cmd_option_waitforrsp, 0, NULL));
}

/**
 *  @brief          List an entry from the FWT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_list_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char in_str[8];
	static struct cmd_ds_fwt_access fwt_access;
	char *ptr = in_str;
	static char out_str[128];
	char *pbuf = out_str;
	int ret;

	ENTER();
	if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
		return -EFAULT;

	fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));

#ifdef DEBUG
	{
		lbs_pr_debug(1, "FWT_LIST: line is %s\n", in_str);
		lbs_pr_debug(1, "FWT_LIST: listing id:%i\n", le32_to_cpu(fwt_access.id));
	}
#endif

	ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
				    cmd_act_fwt_access_list,
				    cmd_option_waitforrsp, 0, (void *)&fwt_access);

	if (ret == 0)
		print_route(fwt_access, pbuf);
	else
		pbuf += sprintf(pbuf, " (null)");

	wrq->u.data.length = strlen(out_str);
	if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
			 wrq->u.data.length)) {
		lbs_pr_debug(1, "FWT_LIST: Copy to user failed!\n");
		return -EFAULT;
	}

	LEAVE();
	return 0;
}

/**
 *  @brief          List an entry from the FRT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_list_route_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char in_str[64];
	static struct cmd_ds_fwt_access fwt_access;
	char *ptr = in_str;
	static char out_str[128];
	char *pbuf = out_str;
	int ret;

	ENTER();
	if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
		return -EFAULT;

	fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));

#ifdef DEBUG
	{
		lbs_pr_debug(1, "FWT_LIST_ROUTE: line is %s\n", in_str);
		lbs_pr_debug(1, "FWT_LIST_ROUTE: listing id:%i\n", le32_to_cpu(fwt_access.id));
	}
#endif

	ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
				    cmd_act_fwt_access_list_route,
				    cmd_option_waitforrsp, 0, (void *)&fwt_access);

	if (ret == 0) {
		pbuf += sprintf(pbuf, " ");
		pbuf += eth_addr2str(fwt_access.da, pbuf);
		pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.metric));
		pbuf += sprintf(pbuf, " %u", fwt_access.dir);
		/* note that the firmware returns the nid in the id field */
		pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.id));
		pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.ssn));
		pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.dsn));
		pbuf += sprintf(pbuf, "  hop %u", fwt_access.hopcount);
		pbuf += sprintf(pbuf, "  ttl %u", fwt_access.ttl);
		pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.expiration));
	} else
		pbuf += sprintf(pbuf, " (null)");

	wrq->u.data.length = strlen(out_str);
	if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
			 wrq->u.data.length)) {
		lbs_pr_debug(1, "FWT_LIST_ROUTE: Copy to user failed!\n");
		return -EFAULT;
	}

	LEAVE();
	return 0;
}

/**
 *  @brief          List an entry from the FNT table
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_list_neighbor_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct iwreq *wrq = (struct iwreq *)req;
	char in_str[8];
	static struct cmd_ds_fwt_access fwt_access;
	char *ptr = in_str;
	static char out_str[128];
	char *pbuf = out_str;
	int ret;

	ENTER();
	if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
		return -EFAULT;

	memset(&fwt_access, 0, sizeof(fwt_access));
	fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));

#ifdef DEBUG
	{
		lbs_pr_debug(1, "FWT_LIST_NEIGHBOR: line is %s\n", in_str);
		lbs_pr_debug(1, "FWT_LIST_NEIGHBOR: listing id:%i\n", le32_to_cpu(fwt_access.id));
	}
#endif

	ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
				    cmd_act_fwt_access_list_neighbor,
				    cmd_option_waitforrsp, 0,
				    (void *)&fwt_access);

	if (ret == 0) {
		pbuf += sprintf(pbuf, " ra ");
		pbuf += eth_addr2str(fwt_access.ra, pbuf);
		pbuf += sprintf(pbuf, "  slp %u", fwt_access.sleepmode);
		pbuf += sprintf(pbuf, "  snr %u", le32_to_cpu(fwt_access.snr));
		pbuf += sprintf(pbuf, "  ref %u", le32_to_cpu(fwt_access.references));
	} else
		pbuf += sprintf(pbuf, " (null)");

	wrq->u.data.length = strlen(out_str);
	if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
			 wrq->u.data.length)) {
		lbs_pr_debug(1, "FWT_LIST_NEIGHBOR: Copy to user failed!\n");
		return -EFAULT;
	}

	LEAVE();
	return 0;
}

/**
 *  @brief          Cleans up the route (FRT) and neighbor (FNT) tables
 *                  (Garbage Collection)
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_cleanup_ioctl(wlan_private * priv, struct ifreq *req)
{
	static struct cmd_ds_fwt_access fwt_access;
	int ret;

	ENTER();

	lbs_pr_debug(1, "FWT: cleaning up\n");

	memset(&fwt_access, 0, sizeof(fwt_access));

	ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
				    cmd_act_fwt_access_cleanup,
				    cmd_option_waitforrsp, 0,
				    (void *)&fwt_access);

	if (ret == 0)
		req->ifr_data = (char *)(le32_to_cpu(fwt_access.references));
	else
		return -EFAULT;

	LEAVE();
	return 0;
}

/**
 *  @brief          Gets firmware internal time (debug purposes)
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_fwt_time_ioctl(wlan_private * priv, struct ifreq *req)
{
	static struct cmd_ds_fwt_access fwt_access;
	int ret;

	ENTER();

	lbs_pr_debug(1, "FWT: getting time\n");

	memset(&fwt_access, 0, sizeof(fwt_access));

	ret = libertas_prepare_and_send_command(priv, cmd_fwt_access,
				    cmd_act_fwt_access_time,
				    cmd_option_waitforrsp, 0,
				    (void *)&fwt_access);

	if (ret == 0)
		req->ifr_data = (char *)(le32_to_cpu(fwt_access.references));
	else
		return -EFAULT;

	LEAVE();
	return 0;
}

/**
 *  @brief          Gets mesh ttl from firmware
 *  @param priv     A pointer to wlan_private structure
 *  @param req      A pointer to ifreq structure
 *  @return         0 --success, otherwise fail
 */
static int wlan_mesh_get_ttl_ioctl(wlan_private * priv, struct ifreq *req)
{
	struct cmd_ds_mesh_access mesh_access;
	int ret;

	ENTER();

	memset(&mesh_access, 0, sizeof(mesh_access));

	ret = libertas_prepare_and_send_command(priv, cmd_mesh_access,
				    cmd_act_mesh_get_ttl,
				    cmd_option_waitforrsp, 0,
				    (void *)&mesh_access);

	if (ret == 0) {
		req->ifr_data = (char *)(le32_to_cpu(mesh_access.data[0]));
	}
	else
		return -EFAULT;

	LEAVE();
	return 0;
}

/**
 *  @brief          Gets mesh ttl from firmware
 *  @param priv     A pointer to wlan_private structure
 *  @param ttl      New ttl value
 *  @return         0 --success, otherwise fail
 */
static int wlan_mesh_set_ttl_ioctl(wlan_private * priv, int ttl)
{
	struct cmd_ds_mesh_access mesh_access;
	int ret;

	ENTER();

	if( (ttl > 0xff) || (ttl < 0) )
		return -EINVAL;

	memset(&mesh_access, 0, sizeof(mesh_access));
	mesh_access.data[0] = ttl;

	ret = libertas_prepare_and_send_command(priv, cmd_mesh_access,
						cmd_act_mesh_set_ttl,
						cmd_option_waitforrsp, 0,
						(void *)&mesh_access);

	if (ret != 0)
		ret = -EFAULT;

	LEAVE();
	return ret;
}

/**
 *  @brief ioctl function - entry point
 *
 *  @param dev		A pointer to net_device structure
 *  @param req	   	A pointer to ifreq structure
 *  @param cmd 		command
 *  @return 	   	0--success, otherwise fail
 */
int libertas_do_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
{
	int subcmd = 0;
	int idata = 0;
	int *pdata;
	int ret = 0;
	wlan_private *priv = dev->priv;
	wlan_adapter *adapter = priv->adapter;
	struct iwreq *wrq = (struct iwreq *)req;

	ENTER();

	lbs_pr_debug(1, "libertas_do_ioctl: ioctl cmd = 0x%x\n", cmd);
	switch (cmd) {
	case WLANSCAN_TYPE:
		lbs_pr_debug(1, "Scan type Ioctl\n");
		ret = wlan_scan_type_ioctl(priv, wrq);
		break;

	case WLAN_SETNONE_GETNONE:	/* set WPA mode on/off ioctl #20 */
		switch (wrq->u.data.flags) {
		case WLANDEAUTH:
			lbs_pr_debug(1, "Deauth\n");
			libertas_send_deauth(priv);
			break;

		case WLANADHOCSTOP:
			lbs_pr_debug(1, "Adhoc stop\n");
			ret = libertas_do_adhocstop_ioctl(priv);
			break;

		case WLANRADIOON:
			wlan_radio_ioctl(priv, 1);
			break;

		case WLANRADIOOFF:
			wlan_radio_ioctl(priv, 0);
			break;
		case WLANWLANIDLEON:
			libertas_idle_on(priv);
			break;
		case WLANWLANIDLEOFF:
			libertas_idle_off(priv);
			break;
		case WLAN_SUBCMD_BT_RESET:	/* bt_reset */
			wlan_bt_reset_ioctl(priv);
			break;
		case WLAN_SUBCMD_FWT_RESET:	/* fwt_reset */
			wlan_fwt_reset_ioctl(priv);
			break;
		}		/* End of switch */
		break;

	case WLAN_SETINT_GETINT:
		/* The first 4 bytes of req->ifr_data is sub-ioctl number
		 * after 4 bytes sits the payload.
		 */
		subcmd = (int)req->ifr_data;	//from iwpriv subcmd
		switch (subcmd) {
		case WLANNF:
			ret = wlan_get_nf(priv, wrq);
			break;
		case WLANRSSI:
			ret = wlan_get_rssi(priv, wrq);
			break;
		case WLANENABLE11D:
			ret = libertas_cmd_enable_11d(priv, wrq);
			break;
		case WLANADHOCGRATE:
			ret = wlan_do_set_grate_ioctl(priv, wrq);
			break;
		case WLAN_SUBCMD_SET_PRESCAN:
			ret = wlan_subcmd_setprescan_ioctl(priv, wrq);
			break;
		}
		break;

	case WLAN_SETONEINT_GETONEINT:
		switch (wrq->u.data.flags) {
		case WLAN_BEACON_INTERVAL:
			ret = wlan_beacon_interval(priv, wrq);
			break;

		case WLAN_LISTENINTRVL:
			if (!wrq->u.data.length) {
				int data;
				lbs_pr_debug(1, "Get locallisteninterval value\n");
#define GET_ONE_INT	1
				data = adapter->locallisteninterval;
				if (copy_to_user(wrq->u.data.pointer,
						 &data, sizeof(int))) {
					lbs_pr_debug(1, "Copy to user failed\n");
					return -EFAULT;
				}

				wrq->u.data.length = GET_ONE_INT;
			} else {
				int data;
				if (copy_from_user
				    (&data, wrq->u.data.pointer, sizeof(int))) {
					lbs_pr_debug(1, "Copy from user failed\n");
					return -EFAULT;
				}

				lbs_pr_debug(1, "Set locallisteninterval = %d\n",
				       data);
#define MAX_U16_VAL	65535
				if (data > MAX_U16_VAL) {
					lbs_pr_debug(1, "Exceeds U16 value\n");
					return -EINVAL;
				}
				adapter->locallisteninterval = data;
			}
			break;
		case WLAN_TXCONTROL:
			ret = wlan_txcontrol(priv, wrq);	//adds for txcontrol ioctl
			break;

		case WLAN_NULLPKTINTERVAL:
			ret = wlan_null_pkt_interval(priv, wrq);
			break;

		default:
			ret = -EOPNOTSUPP;
			break;
		}
		break;

	case WLAN_SETONEINT_GETNONE:
		/* The first 4 bytes of req->ifr_data is sub-ioctl number
		 * after 4 bytes sits the payload.
		 */
		subcmd = wrq->u.data.flags;	//from wpa_supplicant subcmd

		if (!subcmd)
			subcmd = (int)req->ifr_data;	//from iwpriv subcmd

		switch (subcmd) {
		case WLAN_SUBCMD_SETRXANTENNA:	/* SETRXANTENNA */
			idata = SUBCMD_DATA(wrq);
			ret = setrxantenna(priv, idata);
			break;
		case WLAN_SUBCMD_SETTXANTENNA:	/* SETTXANTENNA */
			idata = SUBCMD_DATA(wrq);
			ret = settxantenna(priv, idata);
			break;
		case WLAN_SET_ATIM_WINDOW:
			adapter->atimwindow = SUBCMD_DATA(wrq);
			adapter->atimwindow = min_t(__u16, adapter->atimwindow, 50);
			break;
		case WLANSETBCNAVG:
			adapter->bcn_avg_factor = SUBCMD_DATA(wrq);
			if (adapter->bcn_avg_factor == 0)
				adapter->bcn_avg_factor =
				    DEFAULT_BCN_AVG_FACTOR;
			if (adapter->bcn_avg_factor > DEFAULT_BCN_AVG_FACTOR)
				adapter->bcn_avg_factor =
				    DEFAULT_BCN_AVG_FACTOR;
			break;
		case WLANSETDATAAVG:
			adapter->data_avg_factor = SUBCMD_DATA(wrq);
			if (adapter->data_avg_factor == 0)
				adapter->data_avg_factor =
				    DEFAULT_DATA_AVG_FACTOR;
			if (adapter->data_avg_factor > DEFAULT_DATA_AVG_FACTOR)
				adapter->data_avg_factor =
				    DEFAULT_DATA_AVG_FACTOR;
			break;
		case WLANSETREGION:
			idata = SUBCMD_DATA(wrq);
			ret = wlan_set_region(priv, (u16) idata);
			break;

		case WLAN_SET_LISTEN_INTERVAL:
			idata = SUBCMD_DATA(wrq);
			adapter->listeninterval = (u16) idata;
			break;

		case WLAN_SET_MULTIPLE_DTIM:
			ret = wlan_set_multiple_dtim_ioctl(priv, req);
			break;

		case WLAN_SET_LINKMODE:
			ret = wlan_set_linkmode_ioctl(priv, req);
			break;

		case WLAN_SET_RADIOMODE:
			ret = wlan_set_radiomode_ioctl(priv, req);
			break;

		case WLAN_SET_DEBUGMODE:
			ret = wlan_set_debugmode_ioctl(priv, req);
			break;

		case WLAN_SUBCMD_MESH_SET_TTL:
			idata = SUBCMD_DATA(wrq);
			ret = wlan_mesh_set_ttl_ioctl(priv, idata);
			break;

		default:
			ret = -EOPNOTSUPP;
			break;
		}

		break;

	case WLAN_SETNONE_GETTWELVE_CHAR:	/* Get Antenna settings */
		/*
		 * We've not used IW_PRIV_TYPE_FIXED so sub-ioctl number is
		 * in flags of iwreq structure, otherwise it will be in
		 * mode member of iwreq structure.
		 */
		switch ((int)wrq->u.data.flags) {
		case WLAN_SUBCMD_GETRXANTENNA:	/* Get Rx Antenna */
			ret = wlan_subcmd_getrxantenna_ioctl(priv, req);
			break;

		case WLAN_SUBCMD_GETTXANTENNA:	/* Get Tx Antenna */
			ret = wlan_subcmd_gettxantenna_ioctl(priv, req);
			break;

		case WLAN_GET_TSF:
			ret = wlan_get_tsf_ioctl(priv, wrq);
			break;
		}
		break;

	case WLAN_SET128CHAR_GET128CHAR:
		switch ((int)wrq->u.data.flags) {

		case WLANSCAN_MODE:
			lbs_pr_debug(1, "Scan mode Ioctl\n");
			ret = wlan_scan_mode_ioctl(priv, wrq);
			break;

		case WLAN_GET_ADHOC_STATUS:
			ret = wlan_get_adhoc_status_ioctl(priv, wrq);
			break;
		case WLAN_SUBCMD_BT_ADD:
			ret = wlan_bt_add_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_BT_DEL:
			ret = wlan_bt_del_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_BT_LIST:
			ret = wlan_bt_list_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_ADD:
			ret = wlan_fwt_add_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_DEL:
			ret = wlan_fwt_del_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_LOOKUP:
			ret = wlan_fwt_lookup_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_LIST_NEIGHBOR:
			ret = wlan_fwt_list_neighbor_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_LIST:
			ret = wlan_fwt_list_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_LIST_ROUTE:
			ret = wlan_fwt_list_route_ioctl(priv, req);
			break;
		}
		break;

	case WLAN_SETNONE_GETONEINT:
		switch ((int)req->ifr_data) {
		case WLANGETBCNAVG:
			pdata = (int *)wrq->u.name;
			*pdata = (int)adapter->bcn_avg_factor;
			break;

		case WLANGETREGION:
			pdata = (int *)wrq->u.name;
			*pdata = (int)adapter->regioncode;
			break;

		case WLAN_GET_LISTEN_INTERVAL:
			pdata = (int *)wrq->u.name;
			*pdata = (int)adapter->listeninterval;
			break;

		case WLAN_GET_LINKMODE:
			req->ifr_data = (char *)((u32) adapter->linkmode);
			break;

		case WLAN_GET_RADIOMODE:
			req->ifr_data = (char *)((u32) adapter->radiomode);
			break;

		case WLAN_GET_DEBUGMODE:
			req->ifr_data = (char *)((u32) adapter->debugmode);
			break;

		case WLAN_GET_MULTIPLE_DTIM:
			pdata = (int *)wrq->u.name;
			*pdata = (int)adapter->multipledtim;
			break;
		case WLAN_GET_TX_RATE:
			ret = wlan_get_txrate_ioctl(priv, req);
			break;
		case WLAN_SUBCMD_FWT_CLEANUP:	/* fwt_cleanup */
			ret = wlan_fwt_cleanup_ioctl(priv, req);
			break;

		case WLAN_SUBCMD_FWT_TIME:	/* fwt_time */
			ret = wlan_fwt_time_ioctl(priv, req);
			break;

		case WLAN_SUBCMD_MESH_GET_TTL:
			ret = wlan_mesh_get_ttl_ioctl(priv, req);
			break;

		default:
			ret = -EOPNOTSUPP;

		}

		break;

	case WLANGETLOG:
		ret = wlan_do_getlog_ioctl(priv, wrq);
		break;

	case WLAN_SET_GET_SIXTEEN_INT:
		switch ((int)wrq->u.data.flags) {
		case WLAN_TPCCFG:
			{
				int data[5];
				struct cmd_ds_802_11_tpc_cfg cfg;
				memset(&cfg, 0, sizeof(cfg));
				if ((wrq->u.data.length > 1)
				    && (wrq->u.data.length != 5))
					return -1;

				if (wrq->u.data.length == 0) {
					cfg.action =
					    cpu_to_le16
					    (cmd_act_get);
				} else {
					if (copy_from_user
					    (data, wrq->u.data.pointer,
					     sizeof(int) * 5)) {
						lbs_pr_debug(1,
						       "Copy from user failed\n");
						return -EFAULT;
					}

					cfg.action =
					    cpu_to_le16
					    (cmd_act_set);
					cfg.enable = data[0];
					cfg.usesnr = data[1];
					cfg.P0 = data[2];
					cfg.P1 = data[3];
					cfg.P2 = data[4];
				}

				ret =
				    libertas_prepare_and_send_command(priv,
							  cmd_802_11_tpc_cfg,
							  0,
							  cmd_option_waitforrsp,
							  0, (void *)&cfg);

				data[0] = cfg.enable;
				data[1] = cfg.usesnr;
				data[2] = cfg.P0;
				data[3] = cfg.P1;
				data[4] = cfg.P2;
				if (copy_to_user
				    (wrq->u.data.pointer, data,
				     sizeof(int) * 5)) {
					lbs_pr_debug(1, "Copy to user failed\n");
					return -EFAULT;
				}

				wrq->u.data.length = 5;
			}
			break;

		case WLAN_POWERCFG:
			{
				int data[4];
				struct cmd_ds_802_11_pwr_cfg cfg;
				memset(&cfg, 0, sizeof(cfg));
				if ((wrq->u.data.length > 1)
				    && (wrq->u.data.length != 4))
					return -1;
				if (wrq->u.data.length == 0) {
					cfg.action =
					    cpu_to_le16
					    (cmd_act_get);
				} else {
					if (copy_from_user
					    (data, wrq->u.data.pointer,
					     sizeof(int) * 4)) {
						lbs_pr_debug(1,
						       "Copy from user failed\n");
						return -EFAULT;
					}

					cfg.action =
					    cpu_to_le16
					    (cmd_act_set);
					cfg.enable = data[0];
					cfg.PA_P0 = data[1];
					cfg.PA_P1 = data[2];
					cfg.PA_P2 = data[3];
				}
				ret =
				    libertas_prepare_and_send_command(priv,
							  cmd_802_11_pwr_cfg,
							  0,
							  cmd_option_waitforrsp,
							  0, (void *)&cfg);
				data[0] = cfg.enable;
				data[1] = cfg.PA_P0;
				data[2] = cfg.PA_P1;
				data[3] = cfg.PA_P2;
				if (copy_to_user
				    (wrq->u.data.pointer, data,
				     sizeof(int) * 4)) {
					lbs_pr_debug(1, "Copy to user failed\n");
					return -EFAULT;
				}

				wrq->u.data.length = 4;
			}
			break;
		case WLAN_AUTO_FREQ_SET:
			{
				int data[3];
				struct cmd_ds_802_11_afc afc;
				memset(&afc, 0, sizeof(afc));
				if (wrq->u.data.length != 3)
					return -1;
				if (copy_from_user
				    (data, wrq->u.data.pointer,
				     sizeof(int) * 3)) {
					lbs_pr_debug(1, "Copy from user failed\n");
					return -EFAULT;
				}
				afc.afc_auto = data[0];

				if (afc.afc_auto != 0) {
					afc.threshold = data[1];
					afc.period = data[2];
				} else {
					afc.timing_offset = data[1];
					afc.carrier_offset = data[2];
				}
				ret =
				    libertas_prepare_and_send_command(priv,
							  cmd_802_11_set_afc,
							  0,
							  cmd_option_waitforrsp,
							  0, (void *)&afc);
			}
			break;
		case WLAN_AUTO_FREQ_GET:
			{
				int data[3];
				struct cmd_ds_802_11_afc afc;
				memset(&afc, 0, sizeof(afc));
				ret =
				    libertas_prepare_and_send_command(priv,
							  cmd_802_11_get_afc,
							  0,
							  cmd_option_waitforrsp,
							  0, (void *)&afc);
				data[0] = afc.afc_auto;
				data[1] = afc.timing_offset;
				data[2] = afc.carrier_offset;
				if (copy_to_user
				    (wrq->u.data.pointer, data,
				     sizeof(int) * 3)) {
					lbs_pr_debug(1, "Copy to user failed\n");
					return -EFAULT;
				}

				wrq->u.data.length = 3;
			}
			break;
		case WLAN_SCANPROBES:
			{
				int data;
				if (wrq->u.data.length > 0) {
					if (copy_from_user
					    (&data, wrq->u.data.pointer,
					     sizeof(int))) {
						lbs_pr_debug(1,
						       "Copy from user failed\n");
						return -EFAULT;
					}

					adapter->scanprobes = data;
				} else {
					data = adapter->scanprobes;
					if (copy_to_user
					    (wrq->u.data.pointer, &data,
					     sizeof(int))) {
						lbs_pr_debug(1,
						       "Copy to user failed\n");
						return -EFAULT;
					}
				}
				wrq->u.data.length = 1;
			}
			break;
		case WLAN_LED_GPIO_CTRL:
			{
				int i;
				int data[16];

				struct cmd_ds_802_11_led_ctrl ctrl;
				struct mrvlietypes_ledgpio *gpio =
				    (struct mrvlietypes_ledgpio *) ctrl.data;

				memset(&ctrl, 0, sizeof(ctrl));
				if (wrq->u.data.length > MAX_LEDS * 2)
					return -ENOTSUPP;
				if ((wrq->u.data.length % 2) != 0)
					return -ENOTSUPP;
				if (wrq->u.data.length == 0) {
					ctrl.action =
					    cpu_to_le16
					    (cmd_act_get);
				} else {
					if (copy_from_user
					    (data, wrq->u.data.pointer,
					     sizeof(int) *
					     wrq->u.data.length)) {
						lbs_pr_debug(1,
						       "Copy from user failed\n");
						return -EFAULT;
					}

					ctrl.action =
					    cpu_to_le16
					    (cmd_act_set);
					ctrl.numled = cpu_to_le16(0);
					gpio->header.type =
					    cpu_to_le16(TLV_TYPE_LED_GPIO);
					gpio->header.len = wrq->u.data.length;
					for (i = 0; i < wrq->u.data.length;
					     i += 2) {
						gpio->ledpin[i / 2].led =
						    data[i];
						gpio->ledpin[i / 2].pin =
						    data[i + 1];
					}
				}
				ret =
				    libertas_prepare_and_send_command(priv,
							  cmd_802_11_led_gpio_ctrl,
							  0,
							  cmd_option_waitforrsp,
							  0, (void *)&ctrl);
				for (i = 0; i < gpio->header.len; i += 2) {
					data[i] = gpio->ledpin[i / 2].led;
					data[i + 1] = gpio->ledpin[i / 2].pin;
				}
				if (copy_to_user(wrq->u.data.pointer, data,
						 sizeof(int) *
						 gpio->header.len)) {
					lbs_pr_debug(1, "Copy to user failed\n");
					return -EFAULT;
				}

				wrq->u.data.length = gpio->header.len;
			}
			break;
		case WLAN_ADAPT_RATESET:
			ret = wlan_adapt_rateset(priv, wrq);
			break;
		case WLAN_INACTIVITY_TIMEOUT:
			ret = wlan_inactivity_timeout(priv, wrq);
			break;
		case WLANSNR:
			ret = wlan_get_snr(priv, wrq);
			break;
		case WLAN_GET_RXINFO:
			ret = wlan_get_rxinfo(priv, wrq);
		}
		break;

	default:
		ret = -EINVAL;
		break;
	}
	LEAVE();
	return ret;
}