/*
 * Copyright (c) 2010 Broadcom Corporation
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <linux/kthread.h>
#include <linux/semaphore.h>
#include <bcmdefs.h>
#include <linux/netdevice.h>
#include <osl.h>
#include <wlioctl.h>

#include <bcmutils.h>
#include <bcmendian.h>
#include <proto/ethernet.h>

#include <linux/if_arp.h>
#include <asm/uaccess.h>

#include <dngl_stats.h>
#include <dhd.h>
#include <dhdioctl.h>

typedef const struct si_pub si_t;
#include <wlioctl.h>

#include <proto/ethernet.h>
#include <dngl_stats.h>
#include <dhd.h>

#define WL_ERROR(fmt, args...)  printk(fmt, ##args)
#define WL_TRACE(fmt, args...)  no_printk(fmt, ##args)
#define WL_INFORM(fmt, args...) no_printk(fmt, ##args)
#define WL_WSEC(fmt, args...)   no_printk(fmt, ##args)
#define WL_SCAN(fmt, args...)   no_printk(fmt, ##args)

#include <wl_iw.h>

#define IW_WSEC_ENABLED(wsec)   ((wsec) & (WEP_ENABLED |        \
                                         TKIP_ENABLED | AES_ENABLED))

#include <linux/rtnetlink.h>

#define WL_IW_USE_ISCAN  1
#define ENABLE_ACTIVE_PASSIVE_SCAN_SUPPRESS  1

bool g_set_essid_before_scan = true;

#define WL_IW_IOCTL_CALL(func_call) \
        do {                            \
                func_call;              \
        } while (0)

static int g_onoff = G_WLAN_SET_ON;
wl_iw_extra_params_t g_wl_iw_params;

extern bool wl_iw_conn_status_str(u32 event_type, u32 status,
                                  u32 reason, char *stringBuf, uint buflen);

uint wl_msg_level = WL_ERROR_VAL;

#define MAX_WLIW_IOCTL_LEN 1024

#if defined(IL_BIGENDIAN)
#include <bcmendian.h>
#define htod32(i) (bcmswap32(i))
#define htod16(i) (bcmswap16(i))
#define dtoh32(i) (bcmswap32(i))
#define dtoh16(i) (bcmswap16(i))
#define htodchanspec(i) htod16(i)
#define dtohchanspec(i) dtoh16(i)
#else
#define htod32(i) i
#define htod16(i) i
#define dtoh32(i) i
#define dtoh16(i) i
#define htodchanspec(i) i
#define dtohchanspec(i) i
#endif

#ifdef CONFIG_WIRELESS_EXT

extern struct iw_statistics *dhd_get_wireless_stats(struct net_device *dev);
extern int dhd_wait_pend8021x(struct net_device *dev);
#endif

#if WIRELESS_EXT < 19
#define IW_IOCTL_IDX(cmd)       ((cmd) - SIOCIWFIRST)
#define IW_EVENT_IDX(cmd)       ((cmd) - IWEVFIRST)
#endif

static void *g_scan;
static volatile uint g_scan_specified_ssid;
static wlc_ssid_t g_specific_ssid;

static wlc_ssid_t g_ssid;

#if defined(WL_IW_USE_ISCAN)
#define ISCAN_STATE_IDLE   0
#define ISCAN_STATE_SCANING 1

#define WLC_IW_ISCAN_MAXLEN   2048
typedef struct iscan_buf {
        struct iscan_buf *next;
        char iscan_buf[WLC_IW_ISCAN_MAXLEN];
} iscan_buf_t;

typedef struct iscan_info {
        struct net_device *dev;
        struct timer_list timer;
        u32 timer_ms;
        u32 timer_on;
        int iscan_state;
        iscan_buf_t *list_hdr;
        iscan_buf_t *list_cur;

        struct task_struct *sysioc_tsk;
        struct semaphore sysioc_sem;

#if defined CSCAN
        char ioctlbuf[WLC_IOCTL_MEDLEN];
#else
        char ioctlbuf[WLC_IOCTL_SMLEN];
#endif
        wl_iscan_params_t *iscan_ex_params_p;
        int iscan_ex_param_size;
} iscan_info_t;
iscan_info_t *g_iscan;
static void wl_iw_timerfunc(unsigned long data);
static void wl_iw_set_event_mask(struct net_device *dev);
static int wl_iw_iscan(iscan_info_t *iscan, wlc_ssid_t *ssid, u16 action);
#endif                          /* defined(WL_IW_USE_ISCAN) */

static int
wl_iw_set_scan(struct net_device *dev,
               struct iw_request_info *info,
               union iwreq_data *wrqu, char *extra);

static int
wl_iw_get_scan(struct net_device *dev,
               struct iw_request_info *info,
               struct iw_point *dwrq, char *extra);

static uint
wl_iw_get_scan_prep(wl_scan_results_t *list,
                    struct iw_request_info *info, char *extra, short max_size);

static void swap_key_from_BE(wl_wsec_key_t *key)
{
        key->index = htod32(key->index);
        key->len = htod32(key->len);
        key->algo = htod32(key->algo);
        key->flags = htod32(key->flags);
        key->rxiv.hi = htod32(key->rxiv.hi);
        key->rxiv.lo = htod16(key->rxiv.lo);
        key->iv_initialized = htod32(key->iv_initialized);
}

static void swap_key_to_BE(wl_wsec_key_t *key)
{
        key->index = dtoh32(key->index);
        key->len = dtoh32(key->len);
        key->algo = dtoh32(key->algo);
        key->flags = dtoh32(key->flags);
        key->rxiv.hi = dtoh32(key->rxiv.hi);
        key->rxiv.lo = dtoh16(key->rxiv.lo);
        key->iv_initialized = dtoh32(key->iv_initialized);
}

static int dev_wlc_ioctl(struct net_device *dev, int cmd, void *arg, int len)
{
        struct ifreq ifr;
        wl_ioctl_t ioc;
        mm_segment_t fs;
        int ret = -EINVAL;

        if (!dev) {
                WL_ERROR("%s: dev is null\n", __func__);
                return ret;
        }

        WL_INFORM("\n%s, PID:%x: send Local IOCTL -> dhd: cmd:0x%x, buf:%p, len:%d\n",
                  __func__, current->pid, cmd, arg, len);

        if (g_onoff == G_WLAN_SET_ON) {
                memset(&ioc, 0, sizeof(ioc));
                ioc.cmd = cmd;
                ioc.buf = arg;
                ioc.len = len;

                strcpy(ifr.ifr_name, dev->name);
                ifr.ifr_data = (caddr_t)&ioc;

                ret = dev_open(dev);
                if (ret) {
                        WL_ERROR("%s: Error dev_open: %d\n", __func__, ret);
                        return ret;
                }

                fs = get_fs();
                set_fs(get_ds());
                ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
                set_fs(fs);
        } else {
                WL_TRACE("%s: call after driver stop : ignored\n", __func__);
        }
        return ret;
}

static int dev_wlc_intvar_set(struct net_device *dev, char *name, int val)
{
        char buf[WLC_IOCTL_SMLEN];
        uint len;

        val = htod32(val);
        len = bcm_mkiovar(name, (char *)(&val), sizeof(val), buf, sizeof(buf));
        ASSERT(len);

        return dev_wlc_ioctl(dev, WLC_SET_VAR, buf, len);
}

#if defined(WL_IW_USE_ISCAN)
static int
dev_iw_iovar_setbuf(struct net_device *dev,
                    char *iovar,
                    void *param, int paramlen, void *bufptr, int buflen)
{
        int iolen;

        iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
        ASSERT(iolen);

        if (iolen == 0)
                return 0;

        return dev_wlc_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
}

static int
dev_iw_iovar_getbuf(struct net_device *dev,
                    char *iovar,
                    void *param, int paramlen, void *bufptr, int buflen)
{
        int iolen;

        iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
        ASSERT(iolen);

        return dev_wlc_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
}
#endif                          /* defined(WL_IW_USE_ISCAN) */

#if WIRELESS_EXT > 17
static int
dev_wlc_bufvar_set(struct net_device *dev, char *name, char *buf, int len)
{
        static char ioctlbuf[MAX_WLIW_IOCTL_LEN];
        uint buflen;

        buflen = bcm_mkiovar(name, buf, len, ioctlbuf, sizeof(ioctlbuf));
        ASSERT(buflen);

        return dev_wlc_ioctl(dev, WLC_SET_VAR, ioctlbuf, buflen);
}
#endif                          /* WIRELESS_EXT > 17 */

static int
dev_wlc_bufvar_get(struct net_device *dev, char *name, char *buf, int buflen)
{
        static char ioctlbuf[MAX_WLIW_IOCTL_LEN];
        int error;
        uint len;

        len = bcm_mkiovar(name, NULL, 0, ioctlbuf, sizeof(ioctlbuf));
        ASSERT(len);
        error =
            dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)ioctlbuf,
                          MAX_WLIW_IOCTL_LEN);
        if (!error)
                bcopy(ioctlbuf, buf, buflen);

        return error;
}

static int dev_wlc_intvar_get(struct net_device *dev, char *name, int *retval)
{
        union {
                char buf[WLC_IOCTL_SMLEN];
                int val;
        } var;
        int error;

        uint len;
        uint data_null;

        len =
            bcm_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
                        sizeof(var.buf));
        ASSERT(len);
        error = dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)&var, len);

        *retval = dtoh32(var.val);

        return error;
}

#if WIRELESS_EXT < 13
struct iw_request_info {
        __u16 cmd;
        __u16 flags;
};

typedef int (*iw_handler) (struct net_device *dev,
                           struct iw_request_info *info,
                           void *wrqu, char *extra);
#endif

static int
wl_iw_config_commit(struct net_device *dev,
                    struct iw_request_info *info, void *zwrq, char *extra)
{
        wlc_ssid_t ssid;
        int error;
        struct sockaddr bssid;

        WL_TRACE("%s: SIOCSIWCOMMIT\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_SSID, &ssid, sizeof(ssid));
        if (error)
                return error;

        ssid.SSID_len = dtoh32(ssid.SSID_len);

        if (!ssid.SSID_len)
                return 0;

        memset(&bssid, 0, sizeof(struct sockaddr));
        error = dev_wlc_ioctl(dev, WLC_REASSOC, &bssid, ETH_ALEN);
        if (error) {
                WL_ERROR("%s: WLC_REASSOC to %s failed\n",
                         __func__, ssid.SSID);
                return error;
        }

        return 0;
}

static int
wl_iw_get_name(struct net_device *dev,
               struct iw_request_info *info, char *cwrq, char *extra)
{
        WL_TRACE("%s: SIOCGIWNAME\n", dev->name);

        strcpy(cwrq, "IEEE 802.11-DS");

        return 0;
}

static int
wl_iw_set_freq(struct net_device *dev,
               struct iw_request_info *info, struct iw_freq *fwrq, char *extra)
{
        int error, chan;
        uint sf = 0;

        WL_TRACE("\n %s %s: SIOCSIWFREQ\n", __func__, dev->name);

        if (fwrq->e == 0 && fwrq->m < MAXCHANNEL) {
                chan = fwrq->m;
        } else {
                if (fwrq->e >= 6) {
                        fwrq->e -= 6;
                        while (fwrq->e--)
                                fwrq->m *= 10;
                } else if (fwrq->e < 6) {
                        while (fwrq->e++ < 6)
                                fwrq->m /= 10;
                }
                if (fwrq->m > 4000 && fwrq->m < 5000)
                        sf = WF_CHAN_FACTOR_4_G;

                chan = wf_mhz2channel(fwrq->m, sf);
        }
        chan = htod32(chan);

        error = dev_wlc_ioctl(dev, WLC_SET_CHANNEL, &chan, sizeof(chan));
        if (error)
                return error;

        g_wl_iw_params.target_channel = chan;
        return -EINPROGRESS;
}

static int
wl_iw_get_freq(struct net_device *dev,
               struct iw_request_info *info, struct iw_freq *fwrq, char *extra)
{
        channel_info_t ci;
        int error;

        WL_TRACE("%s: SIOCGIWFREQ\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci));
        if (error)
                return error;

        fwrq->m = dtoh32(ci.hw_channel);
        fwrq->e = dtoh32(0);
        return 0;
}

static int
wl_iw_set_mode(struct net_device *dev,
               struct iw_request_info *info, __u32 *uwrq, char *extra)
{
        int infra = 0, ap = 0, error = 0;

        WL_TRACE("%s: SIOCSIWMODE\n", dev->name);

        switch (*uwrq) {
        case IW_MODE_MASTER:
                infra = ap = 1;
                break;
        case IW_MODE_ADHOC:
        case IW_MODE_AUTO:
                break;
        case IW_MODE_INFRA:
                infra = 1;
                break;
        default:
                return -EINVAL;
        }
        infra = htod32(infra);
        ap = htod32(ap);

        error = dev_wlc_ioctl(dev, WLC_SET_INFRA, &infra, sizeof(infra));
        if (error)
                return error;

        error = dev_wlc_ioctl(dev, WLC_SET_AP, &ap, sizeof(ap));
        if (error)
                return error;

        return -EINPROGRESS;
}

static int
wl_iw_get_mode(struct net_device *dev,
               struct iw_request_info *info, __u32 *uwrq, char *extra)
{
        int error, infra = 0, ap = 0;

        WL_TRACE("%s: SIOCGIWMODE\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_INFRA, &infra, sizeof(infra));
        if (error)
                return error;

        error = dev_wlc_ioctl(dev, WLC_GET_AP, &ap, sizeof(ap));
        if (error)
                return error;

        infra = dtoh32(infra);
        ap = dtoh32(ap);
        *uwrq = infra ? ap ? IW_MODE_MASTER : IW_MODE_INFRA : IW_MODE_ADHOC;

        return 0;
}

static int
wl_iw_get_range(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *dwrq, char *extra)
{
        struct iw_range *range = (struct iw_range *)extra;
        wl_u32_list_t *list;
        wl_rateset_t rateset;
        s8 *channels;
        int error, i, k;
        uint sf, ch;

        int phytype;
        int bw_cap = 0, sgi_tx = 0, nmode = 0;
        channel_info_t ci;
        u8 nrate_list2copy = 0;
        u16 nrate_list[4][8] = { {13, 26, 39, 52, 78, 104, 117, 130},
        {14, 29, 43, 58, 87, 116, 130, 144},
        {27, 54, 81, 108, 162, 216, 243, 270},
        {30, 60, 90, 120, 180, 240, 270, 300}
        };

        WL_TRACE("%s: SIOCGIWRANGE\n", dev->name);

        if (!extra)
                return -EINVAL;

        channels = kmalloc((MAXCHANNEL + 1) * 4, GFP_KERNEL);
        if (!channels) {
                WL_ERROR("Could not alloc channels\n");
                return -ENOMEM;
        }
        list = (wl_u32_list_t *) channels;

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

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

        list->count = htod32(MAXCHANNEL);
        error = dev_wlc_ioctl(dev, WLC_GET_VALID_CHANNELS, channels,
                                (MAXCHANNEL + 1) * 4);
        if (error) {
                kfree(channels);
                return error;
        }
        for (i = 0; i < dtoh32(list->count) && i < IW_MAX_FREQUENCIES; i++) {
                range->freq[i].i = dtoh32(list->element[i]);

                ch = dtoh32(list->element[i]);
                if (ch <= CH_MAX_2G_CHANNEL)
                        sf = WF_CHAN_FACTOR_2_4_G;
                else
                        sf = WF_CHAN_FACTOR_5_G;

                range->freq[i].m = wf_channel2mhz(ch, sf);
                range->freq[i].e = 6;
        }
        range->num_frequency = range->num_channels = i;

        range->max_qual.qual = 5;
        range->max_qual.level = 0x100 - 200;
        range->max_qual.noise = 0x100 - 200;
        range->sensitivity = 65535;

#if WIRELESS_EXT > 11
        range->avg_qual.qual = 3;
        range->avg_qual.level = 0x100 + WL_IW_RSSI_GOOD;
        range->avg_qual.noise = 0x100 - 75;
#endif

        error = dev_wlc_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
                                sizeof(rateset));
        if (error) {
                kfree(channels);
                return error;
        }
        rateset.count = dtoh32(rateset.count);
        range->num_bitrates = rateset.count;
        for (i = 0; i < rateset.count && i < IW_MAX_BITRATES; i++)
                range->bitrate[i] = (rateset.rates[i] & 0x7f) * 500000;
        dev_wlc_intvar_get(dev, "nmode", &nmode);
        dev_wlc_ioctl(dev, WLC_GET_PHYTYPE, &phytype, sizeof(phytype));

        if (nmode == 1 && phytype == WLC_PHY_TYPE_SSN) {
                dev_wlc_intvar_get(dev, "mimo_bw_cap", &bw_cap);
                dev_wlc_intvar_get(dev, "sgi_tx", &sgi_tx);
                dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci,
                              sizeof(channel_info_t));
                ci.hw_channel = dtoh32(ci.hw_channel);

                if (bw_cap == 0 || (bw_cap == 2 && ci.hw_channel <= 14)) {
                        if (sgi_tx == 0)
                                nrate_list2copy = 0;
                        else
                                nrate_list2copy = 1;
                }
                if (bw_cap == 1 || (bw_cap == 2 && ci.hw_channel >= 36)) {
                        if (sgi_tx == 0)
                                nrate_list2copy = 2;
                        else
                                nrate_list2copy = 3;
                }
                range->num_bitrates += 8;
                for (k = 0; i < range->num_bitrates; k++, i++) {
                        range->bitrate[i] =
                            (nrate_list[nrate_list2copy][k]) * 500000;
                }
        }

        error = dev_wlc_ioctl(dev, WLC_GET_PHYTYPE, &i, sizeof(i));
        if (error) {
                kfree(channels);
                return error;
        }
        i = dtoh32(i);
        if (i == WLC_PHY_TYPE_A)
                range->throughput = 24000000;
        else
                range->throughput = 1500000;

        range->min_rts = 0;
        range->max_rts = 2347;
        range->min_frag = 256;
        range->max_frag = 2346;

        range->max_encoding_tokens = DOT11_MAX_DEFAULT_KEYS;
        range->num_encoding_sizes = 4;
        range->encoding_size[0] = WEP1_KEY_SIZE;
        range->encoding_size[1] = WEP128_KEY_SIZE;
#if WIRELESS_EXT > 17
        range->encoding_size[2] = TKIP_KEY_SIZE;
#else
        range->encoding_size[2] = 0;
#endif
        range->encoding_size[3] = AES_KEY_SIZE;

        range->min_pmp = 0;
        range->max_pmp = 0;
        range->min_pmt = 0;
        range->max_pmt = 0;
        range->pmp_flags = 0;
        range->pm_capa = 0;

        range->num_txpower = 2;
        range->txpower[0] = 1;
        range->txpower[1] = 255;
        range->txpower_capa = IW_TXPOW_MWATT;

#if WIRELESS_EXT > 10
        range->we_version_compiled = WIRELESS_EXT;
        range->we_version_source = 19;

        range->retry_capa = IW_RETRY_LIMIT;
        range->retry_flags = IW_RETRY_LIMIT;
        range->r_time_flags = 0;
        range->min_retry = 1;
        range->max_retry = 255;
        range->min_r_time = 0;
        range->max_r_time = 0;
#endif

#if WIRELESS_EXT > 17
        range->enc_capa = IW_ENC_CAPA_WPA;
        range->enc_capa |= IW_ENC_CAPA_CIPHER_TKIP;
        range->enc_capa |= IW_ENC_CAPA_CIPHER_CCMP;
        range->enc_capa |= IW_ENC_CAPA_WPA2;

        IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
        IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
        IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
        IW_EVENT_CAPA_SET(range->event_capa, IWEVTXDROP);
        IW_EVENT_CAPA_SET(range->event_capa, IWEVMICHAELMICFAILURE);
        IW_EVENT_CAPA_SET(range->event_capa, IWEVPMKIDCAND);
#endif                          /* WIRELESS_EXT > 17 */

        kfree(channels);

        return 0;
}

static int rssi_to_qual(int rssi)
{
        if (rssi <= WL_IW_RSSI_NO_SIGNAL)
                return 0;
        else if (rssi <= WL_IW_RSSI_VERY_LOW)
                return 1;
        else if (rssi <= WL_IW_RSSI_LOW)
                return 2;
        else if (rssi <= WL_IW_RSSI_GOOD)
                return 3;
        else if (rssi <= WL_IW_RSSI_VERY_GOOD)
                return 4;
        else
                return 5;
}

static int
wl_iw_set_spy(struct net_device *dev,
              struct iw_request_info *info, struct iw_point *dwrq, char *extra)
{
        wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
        struct sockaddr *addr = (struct sockaddr *)extra;
        int i;

        WL_TRACE("%s: SIOCSIWSPY\n", dev->name);

        if (!extra)
                return -EINVAL;

        iw->spy_num = min_t(int, ARRAY_SIZE(iw->spy_addr), dwrq->length);
        for (i = 0; i < iw->spy_num; i++)
                memcpy(&iw->spy_addr[i], addr[i].sa_data, ETH_ALEN);
        memset(iw->spy_qual, 0, sizeof(iw->spy_qual));

        return 0;
}

static int
wl_iw_get_spy(struct net_device *dev,
              struct iw_request_info *info, struct iw_point *dwrq, char *extra)
{
        wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
        struct sockaddr *addr = (struct sockaddr *)extra;
        struct iw_quality *qual = (struct iw_quality *)&addr[iw->spy_num];
        int i;

        WL_TRACE("%s: SIOCGIWSPY\n", dev->name);

        if (!extra)
                return -EINVAL;

        dwrq->length = iw->spy_num;
        for (i = 0; i < iw->spy_num; i++) {
                memcpy(addr[i].sa_data, &iw->spy_addr[i], ETH_ALEN);
                addr[i].sa_family = AF_UNIX;
                memcpy(&qual[i], &iw->spy_qual[i], sizeof(struct iw_quality));
                iw->spy_qual[i].updated = 0;
        }

        return 0;
}

static int
wl_iw_ch_to_chanspec(int ch, wl_join_params_t *join_params,
                     int *join_params_size)
{
        chanspec_t chanspec = 0;

        if (ch != 0) {
                join_params->params.chanspec_num = 1;
                join_params->params.chanspec_list[0] = ch;

                if (join_params->params.chanspec_list[0])
                        chanspec |= WL_CHANSPEC_BAND_2G;
                else
                        chanspec |= WL_CHANSPEC_BAND_5G;

                chanspec |= WL_CHANSPEC_BW_20;
                chanspec |= WL_CHANSPEC_CTL_SB_NONE;

                *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
                    join_params->params.chanspec_num * sizeof(chanspec_t);

                join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
                join_params->params.chanspec_list[0] |= chanspec;
                join_params->params.chanspec_list[0] =
                    htodchanspec(join_params->params.chanspec_list[0]);

                join_params->params.chanspec_num =
                    htod32(join_params->params.chanspec_num);

                WL_TRACE("%s  join_params->params.chanspec_list[0]= %X\n",
                         __func__, join_params->params.chanspec_list[0]);
        }
        return 1;
}

static int
wl_iw_set_wap(struct net_device *dev,
              struct iw_request_info *info, struct sockaddr *awrq, char *extra)
{
        int error = -EINVAL;
        wl_join_params_t join_params;
        int join_params_size;

        WL_TRACE("%s: SIOCSIWAP\n", dev->name);

        if (awrq->sa_family != ARPHRD_ETHER) {
                WL_ERROR("Invalid Header...sa_family\n");
                return -EINVAL;
        }

        if (is_broadcast_ether_addr(awrq->sa_data) ||
            is_zero_ether_addr(awrq->sa_data)) {
                scb_val_t scbval;
                memset(&scbval, 0, sizeof(scb_val_t));
                (void)dev_wlc_ioctl(dev, WLC_DISASSOC, &scbval,
                                    sizeof(scb_val_t));
                return 0;
        }

        memset(&join_params, 0, sizeof(join_params));
        join_params_size = sizeof(join_params.ssid);

        memcpy(join_params.ssid.SSID, g_ssid.SSID, g_ssid.SSID_len);
        join_params.ssid.SSID_len = htod32(g_ssid.SSID_len);
        memcpy(&join_params.params.bssid, awrq->sa_data, ETH_ALEN);

        WL_TRACE("%s  target_channel=%d\n",
                 __func__, g_wl_iw_params.target_channel);
        wl_iw_ch_to_chanspec(g_wl_iw_params.target_channel, &join_params,
                             &join_params_size);

        error = dev_wlc_ioctl(dev, WLC_SET_SSID, &join_params,
                                join_params_size);
        if (error) {
                WL_ERROR("%s Invalid ioctl data=%d\n", __func__, error);
        }

        if (g_ssid.SSID_len) {
                WL_TRACE("%s: join SSID=%s BSSID=%pM ch=%d\n",
                         __func__, g_ssid.SSID, awrq->sa_data,
                         g_wl_iw_params.target_channel);
        }

        memset(&g_ssid, 0, sizeof(g_ssid));
        return 0;
}

static int
wl_iw_get_wap(struct net_device *dev,
              struct iw_request_info *info, struct sockaddr *awrq, char *extra)
{
        WL_TRACE("%s: SIOCGIWAP\n", dev->name);

        awrq->sa_family = ARPHRD_ETHER;
        memset(awrq->sa_data, 0, ETH_ALEN);

        (void)dev_wlc_ioctl(dev, WLC_GET_BSSID, awrq->sa_data, ETH_ALEN);

        return 0;
}

#if WIRELESS_EXT > 17
static int
wl_iw_mlme(struct net_device *dev,
           struct iw_request_info *info, struct sockaddr *awrq, char *extra)
{
        struct iw_mlme *mlme;
        scb_val_t scbval;
        int error = -EINVAL;

        WL_TRACE("%s: SIOCSIWMLME DISASSOC/DEAUTH\n", dev->name);

        mlme = (struct iw_mlme *)extra;
        if (mlme == NULL) {
                WL_ERROR("Invalid ioctl data\n");
                return error;
        }

        scbval.val = mlme->reason_code;
        bcopy(&mlme->addr.sa_data, &scbval.ea, ETH_ALEN);

        if (mlme->cmd == IW_MLME_DISASSOC) {
                scbval.val = htod32(scbval.val);
                error =
                    dev_wlc_ioctl(dev, WLC_DISASSOC, &scbval,
                                  sizeof(scb_val_t));
        } else if (mlme->cmd == IW_MLME_DEAUTH) {
                scbval.val = htod32(scbval.val);
                error =
                    dev_wlc_ioctl(dev, WLC_SCB_DEAUTHENTICATE_FOR_REASON,
                                  &scbval, sizeof(scb_val_t));
        } else {
                WL_ERROR("Invalid ioctl data\n");
                return error;
        }

        return error;
}
#endif                          /* WIRELESS_EXT > 17 */

#ifndef WL_IW_USE_ISCAN
static int
wl_iw_get_aplist(struct net_device *dev,
                 struct iw_request_info *info,
                 struct iw_point *dwrq, char *extra)
{
        wl_scan_results_t *list;
        struct sockaddr *addr = (struct sockaddr *)extra;
        struct iw_quality qual[IW_MAX_AP];
        wl_bss_info_t *bi = NULL;
        int error, i;
        uint buflen = dwrq->length;

        WL_TRACE("%s: SIOCGIWAPLIST\n", dev->name);

        if (!extra)
                return -EINVAL;

        list = kmalloc(buflen, GFP_KERNEL);
        if (!list)
                return -ENOMEM;
        memset(list, 0, buflen);
        list->buflen = htod32(buflen);
        error = dev_wlc_ioctl(dev, WLC_SCAN_RESULTS, list, buflen);
        if (error) {
                WL_ERROR("%d: Scan results error %d\n", __LINE__, error);
                kfree(list);
                return error;
        }
        list->buflen = dtoh32(list->buflen);
        list->version = dtoh32(list->version);
        list->count = dtoh32(list->count);
        if (list->version != WL_BSS_INFO_VERSION) {
                WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
                         __func__, list->version);
                kfree(list);
                return -EINVAL;
        }

        for (i = 0, dwrq->length = 0;
             i < list->count && dwrq->length < IW_MAX_AP; i++) {
                bi = bi ? (wl_bss_info_t *) ((unsigned long)bi +
                                             dtoh32(bi->length)) : list->
                    bss_info;
                ASSERT(((unsigned long)bi + dtoh32(bi->length)) <=
                       ((unsigned long)list + buflen));

                if (!(dtoh16(bi->capability) & DOT11_CAP_ESS))
                        continue;

                memcpy(addr[dwrq->length].sa_data, &bi->BSSID, ETH_ALEN);
                addr[dwrq->length].sa_family = ARPHRD_ETHER;
                qual[dwrq->length].qual = rssi_to_qual(dtoh16(bi->RSSI));
                qual[dwrq->length].level = 0x100 + dtoh16(bi->RSSI);
                qual[dwrq->length].noise = 0x100 + bi->phy_noise;

#if WIRELESS_EXT > 18
                qual[dwrq->length].updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
#else
                qual[dwrq->length].updated = 7;
#endif
                dwrq->length++;
        }

        kfree(list);

        if (dwrq->length) {
                memcpy(&addr[dwrq->length], qual,
                       sizeof(struct iw_quality) * dwrq->length);
                dwrq->flags = 1;
        }

        return 0;
}
#endif                          /* WL_IW_USE_ISCAN */

#ifdef WL_IW_USE_ISCAN
static int
wl_iw_iscan_get_aplist(struct net_device *dev,
                       struct iw_request_info *info,
                       struct iw_point *dwrq, char *extra)
{
        wl_scan_results_t *list;
        iscan_buf_t *buf;
        iscan_info_t *iscan = g_iscan;

        struct sockaddr *addr = (struct sockaddr *)extra;
        struct iw_quality qual[IW_MAX_AP];
        wl_bss_info_t *bi = NULL;
        int i;

        WL_TRACE("%s: SIOCGIWAPLIST\n", dev->name);

        if (!extra)
                return -EINVAL;

        if ((!iscan) || (!iscan->sysioc_tsk)) {
                WL_ERROR("%s error\n", __func__);
                return 0;
        }

        buf = iscan->list_hdr;
        while (buf) {
                list = &((wl_iscan_results_t *) buf->iscan_buf)->results;
                if (list->version != WL_BSS_INFO_VERSION) {
                        WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
                                 __func__, list->version);
                        return -EINVAL;
                }

                bi = NULL;
                for (i = 0, dwrq->length = 0;
                     i < list->count && dwrq->length < IW_MAX_AP; i++) {
                        bi = bi ? (wl_bss_info_t *) ((unsigned long)bi +
                                                     dtoh32(bi->length)) :
                            list->bss_info;
                        ASSERT(((unsigned long)bi + dtoh32(bi->length)) <=
                               ((unsigned long)list + WLC_IW_ISCAN_MAXLEN));

                        if (!(dtoh16(bi->capability) & DOT11_CAP_ESS))
                                continue;

                        memcpy(addr[dwrq->length].sa_data, &bi->BSSID,
                               ETH_ALEN);
                        addr[dwrq->length].sa_family = ARPHRD_ETHER;
                        qual[dwrq->length].qual =
                            rssi_to_qual(dtoh16(bi->RSSI));
                        qual[dwrq->length].level = 0x100 + dtoh16(bi->RSSI);
                        qual[dwrq->length].noise = 0x100 + bi->phy_noise;

#if WIRELESS_EXT > 18
                        qual[dwrq->length].updated =
                            IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
#else
                        qual[dwrq->length].updated = 7;
#endif

                        dwrq->length++;
                }
                buf = buf->next;
        }
        if (dwrq->length) {
                memcpy(&addr[dwrq->length], qual,
                       sizeof(struct iw_quality) * dwrq->length);
                dwrq->flags = 1;
        }

        return 0;
}

static int wl_iw_iscan_prep(wl_scan_params_t *params, wlc_ssid_t *ssid)
{
        int err = 0;

        memcpy(&params->bssid, &ether_bcast, ETH_ALEN);
        params->bss_type = DOT11_BSSTYPE_ANY;
        params->scan_type = 0;
        params->nprobes = -1;
        params->active_time = -1;
        params->passive_time = -1;
        params->home_time = -1;
        params->channel_num = 0;

        params->nprobes = htod32(params->nprobes);
        params->active_time = htod32(params->active_time);
        params->passive_time = htod32(params->passive_time);
        params->home_time = htod32(params->home_time);
        if (ssid && ssid->SSID_len)
                memcpy(&params->ssid, ssid, sizeof(wlc_ssid_t));

        return err;
}

static int wl_iw_iscan(iscan_info_t *iscan, wlc_ssid_t *ssid, u16 action)
{
        int err = 0;

        iscan->iscan_ex_params_p->version = htod32(ISCAN_REQ_VERSION);
        iscan->iscan_ex_params_p->action = htod16(action);
        iscan->iscan_ex_params_p->scan_duration = htod16(0);

        WL_SCAN("%s : nprobes=%d\n",
                __func__, iscan->iscan_ex_params_p->params.nprobes);
        WL_SCAN("active_time=%d\n",
                 iscan->iscan_ex_params_p->params.active_time);
        WL_SCAN("passive_time=%d\n",
                 iscan->iscan_ex_params_p->params.passive_time);
        WL_SCAN("home_time=%d\n", iscan->iscan_ex_params_p->params.home_time);
        WL_SCAN("scan_type=%d\n", iscan->iscan_ex_params_p->params.scan_type);
        WL_SCAN("bss_type=%d\n", iscan->iscan_ex_params_p->params.bss_type);

        (void)dev_iw_iovar_setbuf(iscan->dev, "iscan", iscan->iscan_ex_params_p,
                                  iscan->iscan_ex_param_size, iscan->ioctlbuf,
                                  sizeof(iscan->ioctlbuf));

        return err;
}

static void wl_iw_timerfunc(unsigned long data)
{
        iscan_info_t *iscan = (iscan_info_t *) data;
        if (iscan) {
                iscan->timer_on = 0;
                if (iscan->iscan_state != ISCAN_STATE_IDLE) {
                        WL_TRACE("timer trigger\n");
                        up(&iscan->sysioc_sem);
                }
        }
}

static void wl_iw_set_event_mask(struct net_device *dev)
{
        char eventmask[WL_EVENTING_MASK_LEN];
        char iovbuf[WL_EVENTING_MASK_LEN + 12];

        dev_iw_iovar_getbuf(dev, "event_msgs", "", 0, iovbuf, sizeof(iovbuf));
        bcopy(iovbuf, eventmask, WL_EVENTING_MASK_LEN);
        setbit(eventmask, WLC_E_SCAN_COMPLETE);
        dev_iw_iovar_setbuf(dev, "event_msgs", eventmask, WL_EVENTING_MASK_LEN,
                            iovbuf, sizeof(iovbuf));
}

static u32 wl_iw_iscan_get(iscan_info_t *iscan)
{
        iscan_buf_t *buf;
        iscan_buf_t *ptr;
        wl_iscan_results_t *list_buf;
        wl_iscan_results_t list;
        wl_scan_results_t *results;
        u32 status;
        int res = 0;

        MUTEX_LOCK_WL_SCAN_SET();
        if (iscan->list_cur) {
                buf = iscan->list_cur;
                iscan->list_cur = buf->next;
        } else {
                buf = kmalloc(sizeof(iscan_buf_t), GFP_KERNEL);
                if (!buf) {
                        WL_ERROR("%s can't alloc iscan_buf_t : going to abort current iscan\n",
                                 __func__);
                        MUTEX_UNLOCK_WL_SCAN_SET();
                        return WL_SCAN_RESULTS_NO_MEM;
                }
                buf->next = NULL;
                if (!iscan->list_hdr)
                        iscan->list_hdr = buf;
                else {
                        ptr = iscan->list_hdr;
                        while (ptr->next) {
                                ptr = ptr->next;
                        }
                        ptr->next = buf;
                }
        }
        memset(buf->iscan_buf, 0, WLC_IW_ISCAN_MAXLEN);
        list_buf = (wl_iscan_results_t *) buf->iscan_buf;
        results = &list_buf->results;
        results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
        results->version = 0;
        results->count = 0;

        memset(&list, 0, sizeof(list));
        list.results.buflen = htod32(WLC_IW_ISCAN_MAXLEN);
        res = dev_iw_iovar_getbuf(iscan->dev,
                                  "iscanresults",
                                  &list,
                                  WL_ISCAN_RESULTS_FIXED_SIZE,
                                  buf->iscan_buf, WLC_IW_ISCAN_MAXLEN);
        if (res == 0) {
                results->buflen = dtoh32(results->buflen);
                results->version = dtoh32(results->version);
                results->count = dtoh32(results->count);
                WL_TRACE("results->count = %d\n", results->count);
                WL_TRACE("results->buflen = %d\n", results->buflen);
                status = dtoh32(list_buf->status);
        } else {
                WL_ERROR("%s returns error %d\n", __func__, res);
                status = WL_SCAN_RESULTS_NO_MEM;
        }
        MUTEX_UNLOCK_WL_SCAN_SET();
        return status;
}

static void wl_iw_force_specific_scan(iscan_info_t *iscan)
{
        WL_TRACE("%s force Specific SCAN for %s\n",
                 __func__, g_specific_ssid.SSID);
        rtnl_lock();

        (void)dev_wlc_ioctl(iscan->dev, WLC_SCAN, &g_specific_ssid,
                            sizeof(g_specific_ssid));

        rtnl_unlock();
}

static void wl_iw_send_scan_complete(iscan_info_t *iscan)
{
#ifndef SANDGATE2G
        union iwreq_data wrqu;

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

        wireless_send_event(iscan->dev, SIOCGIWSCAN, &wrqu, NULL);
        WL_TRACE("Send Event ISCAN complete\n");
#endif
}

static int _iscan_sysioc_thread(void *data)
{
        u32 status;
        iscan_info_t *iscan = (iscan_info_t *) data;
        static bool iscan_pass_abort = false;

        allow_signal(SIGTERM);
        status = WL_SCAN_RESULTS_PARTIAL;
        while (down_interruptible(&iscan->sysioc_sem) == 0) {
                if (kthread_should_stop())
                        break;

                if (iscan->timer_on) {
                        del_timer_sync(&iscan->timer);
                        iscan->timer_on = 0;
                }
                rtnl_lock();
                status = wl_iw_iscan_get(iscan);
                rtnl_unlock();
                if (g_scan_specified_ssid && (iscan_pass_abort == true)) {
                        WL_TRACE("%s Get results from specific scan status = %d\n",
                                 __func__, status);
                        wl_iw_send_scan_complete(iscan);
                        iscan_pass_abort = false;
                        status = -1;
                }

                switch (status) {
                case WL_SCAN_RESULTS_PARTIAL:
                        WL_TRACE("iscanresults incomplete\n");
                        rtnl_lock();
                        wl_iw_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
                        rtnl_unlock();
                        mod_timer(&iscan->timer,
                                  jiffies + iscan->timer_ms * HZ / 1000);
                        iscan->timer_on = 1;
                        break;
                case WL_SCAN_RESULTS_SUCCESS:
                        WL_TRACE("iscanresults complete\n");
                        iscan->iscan_state = ISCAN_STATE_IDLE;
                        wl_iw_send_scan_complete(iscan);
                        break;
                case WL_SCAN_RESULTS_PENDING:
                        WL_TRACE("iscanresults pending\n");
                        mod_timer(&iscan->timer,
                                  jiffies + iscan->timer_ms * HZ / 1000);
                        iscan->timer_on = 1;
                        break;
                case WL_SCAN_RESULTS_ABORTED:
                        WL_TRACE("iscanresults aborted\n");
                        iscan->iscan_state = ISCAN_STATE_IDLE;
                        if (g_scan_specified_ssid == 0)
                                wl_iw_send_scan_complete(iscan);
                        else {
                                iscan_pass_abort = true;
                                wl_iw_force_specific_scan(iscan);
                        }
                        break;
                case WL_SCAN_RESULTS_NO_MEM:
                        WL_TRACE("iscanresults can't alloc memory: skip\n");
                        iscan->iscan_state = ISCAN_STATE_IDLE;
                        break;
                default:
                        WL_TRACE("iscanresults returned unknown status %d\n",
                                 status);
                        break;
                }
        }

        if (iscan->timer_on) {
                del_timer_sync(&iscan->timer);
                iscan->timer_on = 0;
        }
        return 0;
}
#endif                          /* WL_IW_USE_ISCAN */

static int
wl_iw_set_scan(struct net_device *dev,
               struct iw_request_info *info,
               union iwreq_data *wrqu, char *extra)
{
        int error;
        WL_TRACE("\n:%s dev:%s: SIOCSIWSCAN : SCAN\n", __func__, dev->name);

        g_set_essid_before_scan = false;
#if defined(CSCAN)
        WL_ERROR("%s: Scan from SIOCGIWSCAN not supported\n", __func__);
        return -EINVAL;
#endif

        if (g_onoff == G_WLAN_SET_OFF)
                return 0;

        memset(&g_specific_ssid, 0, sizeof(g_specific_ssid));
#ifndef WL_IW_USE_ISCAN
        g_scan_specified_ssid = 0;
#endif

#if WIRELESS_EXT > 17
        if (wrqu->data.length == sizeof(struct iw_scan_req)) {
                if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
                        struct iw_scan_req *req = (struct iw_scan_req *)extra;
                        if (g_scan_specified_ssid) {
                                WL_TRACE("%s Specific SCAN is not done ignore scan for = %s\n",
                                         __func__, req->essid);
                                return -EBUSY;
                        } else {
                                g_specific_ssid.SSID_len = min_t(size_t,
                                                sizeof(g_specific_ssid.SSID),
                                                req->essid_len);
                                memcpy(g_specific_ssid.SSID, req->essid,
                                       g_specific_ssid.SSID_len);
                                g_specific_ssid.SSID_len =
                                    htod32(g_specific_ssid.SSID_len);
                                g_scan_specified_ssid = 1;
                                WL_TRACE("### Specific scan ssid=%s len=%d\n",
                                         g_specific_ssid.SSID,
                                         g_specific_ssid.SSID_len);
                        }
                }
        }
#endif                          /* WIRELESS_EXT > 17 */
        error = dev_wlc_ioctl(dev, WLC_SCAN, &g_specific_ssid,
                                sizeof(g_specific_ssid));
        if (error) {
                WL_TRACE("#### Set SCAN for %s failed with %d\n",
                         g_specific_ssid.SSID, error);
                g_scan_specified_ssid = 0;
                return -EBUSY;
        }

        return 0;
}

#ifdef WL_IW_USE_ISCAN
int wl_iw_iscan_set_scan_broadcast_prep(struct net_device *dev, uint flag)
{
        wlc_ssid_t ssid;
        iscan_info_t *iscan = g_iscan;

        if (flag)
                rtnl_lock();

        wl_iw_set_event_mask(dev);

        WL_TRACE("+++: Set Broadcast ISCAN\n");
        memset(&ssid, 0, sizeof(ssid));

        iscan->list_cur = iscan->list_hdr;
        iscan->iscan_state = ISCAN_STATE_SCANING;

        memset(&iscan->iscan_ex_params_p->params, 0,
               iscan->iscan_ex_param_size);
        wl_iw_iscan_prep(&iscan->iscan_ex_params_p->params, &ssid);
        wl_iw_iscan(iscan, &ssid, WL_SCAN_ACTION_START);

        if (flag)
                rtnl_unlock();

        mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);

        iscan->timer_on = 1;

        return 0;
}

static int
wl_iw_iscan_set_scan(struct net_device *dev,
                     struct iw_request_info *info,
                     union iwreq_data *wrqu, char *extra)
{
        wlc_ssid_t ssid;
        iscan_info_t *iscan = g_iscan;

        WL_TRACE("%s: SIOCSIWSCAN : ISCAN\n", dev->name);

#if defined(CSCAN)
        WL_ERROR("%s: Scan from SIOCGIWSCAN not supported\n", __func__);
        return -EINVAL;
#endif

        if (g_onoff == G_WLAN_SET_OFF) {
                WL_TRACE("%s: driver is not up yet after START\n", __func__);
                return 0;
        }
#ifdef PNO_SUPPORT
        if (dhd_dev_get_pno_status(dev)) {
                WL_ERROR("%s: Scan called when PNO is active\n", __func__);
        }
#endif

        if ((!iscan) || (!iscan->sysioc_tsk))
                return wl_iw_set_scan(dev, info, wrqu, extra);

        if (g_scan_specified_ssid) {
                WL_TRACE("%s Specific SCAN already running ignoring BC scan\n",
                         __func__);
                return EBUSY;
        }

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

#if WIRELESS_EXT > 17
        if (wrqu->data.length == sizeof(struct iw_scan_req)) {
                if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
                        struct iw_scan_req *req = (struct iw_scan_req *)extra;
                        ssid.SSID_len = min_t(size_t, sizeof(ssid.SSID),
                                                req->essid_len);
                        memcpy(ssid.SSID, req->essid, ssid.SSID_len);
                        ssid.SSID_len = htod32(ssid.SSID_len);
                } else {
                        g_scan_specified_ssid = 0;

                        if (iscan->iscan_state == ISCAN_STATE_SCANING) {
                                WL_TRACE("%s ISCAN already in progress\n",
                                         __func__);
                                return 0;
                        }
                }
        }
#endif                          /* WIRELESS_EXT > 17 */
        wl_iw_iscan_set_scan_broadcast_prep(dev, 0);

        return 0;
}
#endif                          /* WL_IW_USE_ISCAN */

#if WIRELESS_EXT > 17
static bool ie_is_wpa_ie(u8 **wpaie, u8 **tlvs, int *tlvs_len)
{

        u8 *ie = *wpaie;

        if ((ie[1] >= 6) &&
            !memcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x01"), 4)) {
                return true;
        }

        ie += ie[1] + 2;
        *tlvs_len -= (int)(ie - *tlvs);
        *tlvs = ie;
        return false;
}

static bool ie_is_wps_ie(u8 **wpsie, u8 **tlvs, int *tlvs_len)
{

        u8 *ie = *wpsie;

        if ((ie[1] >= 4) &&
            !memcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x04"), 4)) {
                return true;
        }

        ie += ie[1] + 2;
        *tlvs_len -= (int)(ie - *tlvs);
        *tlvs = ie;
        return false;
}
#endif                          /* WIRELESS_EXT > 17 */

static int
wl_iw_handle_scanresults_ies(char **event_p, char *end,
                             struct iw_request_info *info, wl_bss_info_t *bi)
{
#if WIRELESS_EXT > 17
        struct iw_event iwe;
        char *event;

        event = *event_p;
        if (bi->ie_length) {
                bcm_tlv_t *ie;
                u8 *ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
                int ptr_len = bi->ie_length;

                ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_RSN_ID);
                if (ie) {
                        iwe.cmd = IWEVGENIE;
                        iwe.u.data.length = ie->len + 2;
                        event =
                            IWE_STREAM_ADD_POINT(info, event, end, &iwe,
                                                 (char *)ie);
                }
                ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);

                while ((ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_WPA_ID))) {
                        if (ie_is_wps_ie(((u8 **)&ie), &ptr, &ptr_len)) {
                                iwe.cmd = IWEVGENIE;
                                iwe.u.data.length = ie->len + 2;
                                event =
                                    IWE_STREAM_ADD_POINT(info, event, end, &iwe,
                                                         (char *)ie);
                                break;
                        }
                }

                ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
                ptr_len = bi->ie_length;
                while ((ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_WPA_ID))) {
                        if (ie_is_wpa_ie(((u8 **)&ie), &ptr, &ptr_len)) {
                                iwe.cmd = IWEVGENIE;
                                iwe.u.data.length = ie->len + 2;
                                event =
                                    IWE_STREAM_ADD_POINT(info, event, end, &iwe,
                                                         (char *)ie);
                                break;
                        }
                }

                *event_p = event;
        }
#endif          /* WIRELESS_EXT > 17 */
        return 0;
}

static uint
wl_iw_get_scan_prep(wl_scan_results_t *list,
                    struct iw_request_info *info, char *extra, short max_size)
{
        int i, j;
        struct iw_event iwe;
        wl_bss_info_t *bi = NULL;
        char *event = extra, *end = extra + max_size - WE_ADD_EVENT_FIX, *value;
        int ret = 0;

        ASSERT(list);

        for (i = 0; i < list->count && i < IW_MAX_AP; i++) {
                if (list->version != WL_BSS_INFO_VERSION) {
                        WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
                                 __func__, list->version);
                        return ret;
                }

                bi = bi ? (wl_bss_info_t *)((unsigned long)bi +
                                             dtoh32(bi->length)) : list->
                    bss_info;

                WL_TRACE("%s : %s\n", __func__, bi->SSID);

                iwe.cmd = SIOCGIWAP;
                iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
                memcpy(iwe.u.ap_addr.sa_data, &bi->BSSID, ETH_ALEN);
                event =
                    IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                         IW_EV_ADDR_LEN);
                iwe.u.data.length = dtoh32(bi->SSID_len);
                iwe.cmd = SIOCGIWESSID;
                iwe.u.data.flags = 1;
                event = IWE_STREAM_ADD_POINT(info, event, end, &iwe, bi->SSID);

                if (dtoh16(bi->capability) & (DOT11_CAP_ESS | DOT11_CAP_IBSS)) {
                        iwe.cmd = SIOCGIWMODE;
                        if (dtoh16(bi->capability) & DOT11_CAP_ESS)
                                iwe.u.mode = IW_MODE_INFRA;
                        else
                                iwe.u.mode = IW_MODE_ADHOC;
                        event =
                            IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                                 IW_EV_UINT_LEN);
                }

                iwe.cmd = SIOCGIWFREQ;
                iwe.u.freq.m = wf_channel2mhz(CHSPEC_CHANNEL(bi->chanspec),
                                              CHSPEC_CHANNEL(bi->chanspec) <=
                                              CH_MAX_2G_CHANNEL ?
                                              WF_CHAN_FACTOR_2_4_G :
                                              WF_CHAN_FACTOR_5_G);
                iwe.u.freq.e = 6;
                event =
                    IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                         IW_EV_FREQ_LEN);

                iwe.cmd = IWEVQUAL;
                iwe.u.qual.qual = rssi_to_qual(dtoh16(bi->RSSI));
                iwe.u.qual.level = 0x100 + dtoh16(bi->RSSI);
                iwe.u.qual.noise = 0x100 + bi->phy_noise;
                event =
                    IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                         IW_EV_QUAL_LEN);

                wl_iw_handle_scanresults_ies(&event, end, info, bi);

                iwe.cmd = SIOCGIWENCODE;
                if (dtoh16(bi->capability) & DOT11_CAP_PRIVACY)
                        iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
                else
                        iwe.u.data.flags = IW_ENCODE_DISABLED;
                iwe.u.data.length = 0;
                event =
                    IWE_STREAM_ADD_POINT(info, event, end, &iwe, (char *)event);

                if (bi->rateset.count) {
                        if (((event - extra) +
                                IW_EV_LCP_LEN) <= (unsigned long)end) {
                                value = event + IW_EV_LCP_LEN;
                                iwe.cmd = SIOCGIWRATE;
                                iwe.u.bitrate.fixed = iwe.u.bitrate.disabled =
                                    0;
                                for (j = 0;
                                     j < bi->rateset.count
                                     && j < IW_MAX_BITRATES; j++) {
                                        iwe.u.bitrate.value =
                                            (bi->rateset.rates[j] & 0x7f) *
                                            500000;
                                        value =
                                            IWE_STREAM_ADD_VALUE(info, event,
                                                 value, end, &iwe,
                                                 IW_EV_PARAM_LEN);
                                }
                                event = value;
                        }
                }
        }

        ret = event - extra;
        if (ret < 0) {
                WL_ERROR("==> Wrong size\n");
                ret = 0;
        }
        WL_TRACE("%s: size=%d bytes prepared\n",
                 __func__, (unsigned int)(event - extra));
        return (uint)ret;
}

static int
wl_iw_get_scan(struct net_device *dev,
               struct iw_request_info *info, struct iw_point *dwrq, char *extra)
{
        channel_info_t ci;
        wl_scan_results_t *list_merge;
        wl_scan_results_t *list = (wl_scan_results_t *) g_scan;
        int error;
        uint buflen_from_user = dwrq->length;
        uint len = G_SCAN_RESULTS;
        __u16 len_ret = 0;
#if defined(WL_IW_USE_ISCAN)
        iscan_info_t *iscan = g_iscan;
        iscan_buf_t *p_buf;
#endif

        WL_TRACE("%s: buflen_from_user %d:\n", dev->name, buflen_from_user);

        if (!extra) {
                WL_TRACE("%s: wl_iw_get_scan return -EINVAL\n", dev->name);
                return -EINVAL;
        }

        error = dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci));
        if (error)
                return error;
        ci.scan_channel = dtoh32(ci.scan_channel);
        if (ci.scan_channel)
                return -EAGAIN;

        if (g_scan_specified_ssid) {
                list = kmalloc(len, GFP_KERNEL);
                if (!list) {
                        WL_TRACE("%s: wl_iw_get_scan return -ENOMEM\n",
                                 dev->name);
                        g_scan_specified_ssid = 0;
                        return -ENOMEM;
                }
        }

        memset(list, 0, len);
        list->buflen = htod32(len);
        error = dev_wlc_ioctl(dev, WLC_SCAN_RESULTS, list, len);
        if (error) {
                WL_ERROR("%s: %s : Scan_results ERROR %d\n",
                         dev->name, __func__, error);
                dwrq->length = len;
                if (g_scan_specified_ssid) {
                        g_scan_specified_ssid = 0;
                        kfree(list);
                }
                return 0;
        }
        list->buflen = dtoh32(list->buflen);
        list->version = dtoh32(list->version);
        list->count = dtoh32(list->count);

        if (list->version != WL_BSS_INFO_VERSION) {
                WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
                         __func__, list->version);
                if (g_scan_specified_ssid) {
                        g_scan_specified_ssid = 0;
                        kfree(list);
                }
                return -EINVAL;
        }

        if (g_scan_specified_ssid) {
                WL_TRACE("%s: Specified scan APs in the list =%d\n",
                         __func__, list->count);
                len_ret =
                    (__u16) wl_iw_get_scan_prep(list, info, extra,
                                                buflen_from_user);
                kfree(list);

#if defined(WL_IW_USE_ISCAN)
                p_buf = iscan->list_hdr;
                while (p_buf != iscan->list_cur) {
                        list_merge =
                            &((wl_iscan_results_t *) p_buf->iscan_buf)->results;
                        WL_TRACE("%s: Bcast APs list=%d\n",
                                 __func__, list_merge->count);
                        if (list_merge->count > 0)
                                len_ret +=
                                    (__u16) wl_iw_get_scan_prep(list_merge,
                                        info, extra + len_ret,
                                        buflen_from_user - len_ret);
                        p_buf = p_buf->next;
                }
#else
                list_merge = (wl_scan_results_t *) g_scan;
                WL_TRACE("%s: Bcast APs list=%d\n",
                         __func__, list_merge->count);
                if (list_merge->count > 0)
                        len_ret +=
                            (__u16) wl_iw_get_scan_prep(list_merge, info,
                                                        extra + len_ret,
                                                        buflen_from_user -
                                                        len_ret);
#endif                          /* defined(WL_IW_USE_ISCAN) */
        } else {
                list = (wl_scan_results_t *) g_scan;
                len_ret =
                    (__u16) wl_iw_get_scan_prep(list, info, extra,
                                                buflen_from_user);
        }

#if defined(WL_IW_USE_ISCAN)
        g_scan_specified_ssid = 0;
#endif
        if ((len_ret + WE_ADD_EVENT_FIX) < buflen_from_user)
                len = len_ret;

        dwrq->length = len;
        dwrq->flags = 0;

        WL_TRACE("%s return to WE %d bytes APs=%d\n",
                 __func__, dwrq->length, list->count);
        return 0;
}

#if defined(WL_IW_USE_ISCAN)
static int
wl_iw_iscan_get_scan(struct net_device *dev,
                     struct iw_request_info *info,
                     struct iw_point *dwrq, char *extra)
{
        wl_scan_results_t *list;
        struct iw_event iwe;
        wl_bss_info_t *bi = NULL;
        int ii, j;
        int apcnt;
        char *event = extra, *end = extra + dwrq->length, *value;
        iscan_info_t *iscan = g_iscan;
        iscan_buf_t *p_buf;
        u32 counter = 0;
        u8 channel;

        WL_TRACE("%s %s buflen_from_user %d:\n",
                 dev->name, __func__, dwrq->length);

        if (!extra) {
                WL_TRACE("%s: INVALID SIOCGIWSCAN GET bad parameter\n",
                         dev->name);
                return -EINVAL;
        }

        if ((!iscan) || (!iscan->sysioc_tsk)) {
                WL_ERROR("%ssysioc_tsk\n", __func__);
                return wl_iw_get_scan(dev, info, dwrq, extra);
        }

        if (iscan->iscan_state == ISCAN_STATE_SCANING) {
                WL_TRACE("%s: SIOCGIWSCAN GET still scanning\n", dev->name);
                return -EAGAIN;
        }

        WL_TRACE("%s: SIOCGIWSCAN GET broadcast results\n", dev->name);
        apcnt = 0;
        p_buf = iscan->list_hdr;
        while (p_buf != iscan->list_cur) {
                list = &((wl_iscan_results_t *) p_buf->iscan_buf)->results;

                counter += list->count;

                if (list->version != WL_BSS_INFO_VERSION) {
                        WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
                                 __func__, list->version);
                        return -EINVAL;
                }

                bi = NULL;
                for (ii = 0; ii < list->count && apcnt < IW_MAX_AP;
                     apcnt++, ii++) {
                        bi = bi ? (wl_bss_info_t *)((unsigned long)bi +
                                                     dtoh32(bi->length)) :
                            list->bss_info;
                        ASSERT(((unsigned long)bi + dtoh32(bi->length)) <=
                               ((unsigned long)list + WLC_IW_ISCAN_MAXLEN));

                        if (event + ETH_ALEN + bi->SSID_len +
                            IW_EV_UINT_LEN + IW_EV_FREQ_LEN + IW_EV_QUAL_LEN >=
                            end)
                                return -E2BIG;
                        iwe.cmd = SIOCGIWAP;
                        iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
                        memcpy(iwe.u.ap_addr.sa_data, &bi->BSSID,
                               ETH_ALEN);
                        event =
                            IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                                 IW_EV_ADDR_LEN);

                        iwe.u.data.length = dtoh32(bi->SSID_len);
                        iwe.cmd = SIOCGIWESSID;
                        iwe.u.data.flags = 1;
                        event =
                            IWE_STREAM_ADD_POINT(info, event, end, &iwe,
                                                 bi->SSID);

                        if (dtoh16(bi->capability) &
                            (DOT11_CAP_ESS | DOT11_CAP_IBSS)) {
                                iwe.cmd = SIOCGIWMODE;
                                if (dtoh16(bi->capability) & DOT11_CAP_ESS)
                                        iwe.u.mode = IW_MODE_INFRA;
                                else
                                        iwe.u.mode = IW_MODE_ADHOC;
                                event =
                                    IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                                         IW_EV_UINT_LEN);
                        }

                        iwe.cmd = SIOCGIWFREQ;
                        channel =
                            (bi->ctl_ch ==
                             0) ? CHSPEC_CHANNEL(bi->chanspec) : bi->ctl_ch;
                        iwe.u.freq.m =
                            wf_channel2mhz(channel,
                                           channel <=
                                           CH_MAX_2G_CHANNEL ?
                                           WF_CHAN_FACTOR_2_4_G :
                                           WF_CHAN_FACTOR_5_G);
                        iwe.u.freq.e = 6;
                        event =
                            IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                                 IW_EV_FREQ_LEN);

                        iwe.cmd = IWEVQUAL;
                        iwe.u.qual.qual = rssi_to_qual(dtoh16(bi->RSSI));
                        iwe.u.qual.level = 0x100 + dtoh16(bi->RSSI);
                        iwe.u.qual.noise = 0x100 + bi->phy_noise;
                        event =
                            IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
                                                 IW_EV_QUAL_LEN);

                        wl_iw_handle_scanresults_ies(&event, end, info, bi);

                        iwe.cmd = SIOCGIWENCODE;
                        if (dtoh16(bi->capability) & DOT11_CAP_PRIVACY)
                                iwe.u.data.flags =
                                    IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
                        else
                                iwe.u.data.flags = IW_ENCODE_DISABLED;
                        iwe.u.data.length = 0;
                        event =
                            IWE_STREAM_ADD_POINT(info, event, end, &iwe,
                                                 (char *)event);

                        if (bi->rateset.count) {
                                if (event + IW_MAX_BITRATES * IW_EV_PARAM_LEN >=
                                    end)
                                        return -E2BIG;

                                value = event + IW_EV_LCP_LEN;
                                iwe.cmd = SIOCGIWRATE;
                                iwe.u.bitrate.fixed = iwe.u.bitrate.disabled =
                                    0;
                                for (j = 0;
                                     j < bi->rateset.count
                                     && j < IW_MAX_BITRATES; j++) {
                                        iwe.u.bitrate.value =
                                            (bi->rateset.rates[j] & 0x7f) *
                                            500000;
                                        value =
                                            IWE_STREAM_ADD_VALUE(info, event,
                                                 value, end,
                                                 &iwe,
                                                 IW_EV_PARAM_LEN);
                                }
                                event = value;
                        }
                }
                p_buf = p_buf->next;
        }

        dwrq->length = event - extra;
        dwrq->flags = 0;

        WL_TRACE("%s return to WE %d bytes APs=%d\n",
                 __func__, dwrq->length, counter);

        if (!dwrq->length)
                return -EAGAIN;

        return 0;
}
#endif                          /* defined(WL_IW_USE_ISCAN) */

static int
wl_iw_set_essid(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *dwrq, char *extra)
{
        int error;
        wl_join_params_t join_params;
        int join_params_size;

        WL_TRACE("%s: SIOCSIWESSID\n", dev->name);

        if (g_set_essid_before_scan)
                return -EAGAIN;

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

        CHECK_EXTRA_FOR_NULL(extra);

        if (dwrq->length && extra) {
#if WIRELESS_EXT > 20
                g_ssid.SSID_len = min_t(size_t, sizeof(g_ssid.SSID),
                                        dwrq->length);
#else
                g_ssid.SSID_len = min_t(size_t, sizeof(g_ssid.SSID),
                                        dwrq->length - 1);
#endif
                memcpy(g_ssid.SSID, extra, g_ssid.SSID_len);
        } else {
                g_ssid.SSID_len = 0;
        }
        g_ssid.SSID_len = htod32(g_ssid.SSID_len);

        memset(&join_params, 0, sizeof(join_params));
        join_params_size = sizeof(join_params.ssid);

        memcpy(&join_params.ssid.SSID, g_ssid.SSID, g_ssid.SSID_len);
        join_params.ssid.SSID_len = htod32(g_ssid.SSID_len);
        memcpy(&join_params.params.bssid, &ether_bcast, ETH_ALEN);

        wl_iw_ch_to_chanspec(g_wl_iw_params.target_channel, &join_params,
                             &join_params_size);

        error = dev_wlc_ioctl(dev, WLC_SET_SSID, &join_params,
                                join_params_size);
        if (error)
                WL_ERROR("Invalid ioctl data=%d\n", error);

        if (g_ssid.SSID_len) {
                WL_TRACE("%s: join SSID=%s ch=%d\n",
                         __func__, g_ssid.SSID, g_wl_iw_params.target_channel);
        }
        return 0;
}

static int
wl_iw_get_essid(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *dwrq, char *extra)
{
        wlc_ssid_t ssid;
        int error;

        WL_TRACE("%s: SIOCGIWESSID\n", dev->name);

        if (!extra)
                return -EINVAL;

        error = dev_wlc_ioctl(dev, WLC_GET_SSID, &ssid, sizeof(ssid));
        if (error) {
                WL_ERROR("Error getting the SSID\n");
                return error;
        }

        ssid.SSID_len = dtoh32(ssid.SSID_len);

        memcpy(extra, ssid.SSID, ssid.SSID_len);

        dwrq->length = ssid.SSID_len;

        dwrq->flags = 1;

        return 0;
}

static int
wl_iw_set_nick(struct net_device *dev,
               struct iw_request_info *info, struct iw_point *dwrq, char *extra)
{
        wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);

        WL_TRACE("%s: SIOCSIWNICKN\n", dev->name);

        if (!extra)
                return -EINVAL;

        if (dwrq->length > sizeof(iw->nickname))
                return -E2BIG;

        memcpy(iw->nickname, extra, dwrq->length);
        iw->nickname[dwrq->length - 1] = '\0';

        return 0;
}

static int
wl_iw_get_nick(struct net_device *dev,
               struct iw_request_info *info, struct iw_point *dwrq, char *extra)
{
        wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);

        WL_TRACE("%s: SIOCGIWNICKN\n", dev->name);

        if (!extra)
                return -EINVAL;

        strcpy(extra, iw->nickname);

        dwrq->length = strlen(extra) + 1;

        return 0;
}

static int
wl_iw_set_rate(struct net_device *dev,
               struct iw_request_info *info, struct iw_param *vwrq, char *extra)
{
        wl_rateset_t rateset;
        int error, rate, i, error_bg, error_a;

        WL_TRACE("%s: SIOCSIWRATE\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
                                sizeof(rateset));
        if (error)
                return error;

        rateset.count = dtoh32(rateset.count);

        if (vwrq->value < 0)
                rate = rateset.rates[rateset.count - 1] & 0x7f;
        else if (vwrq->value < rateset.count)
                rate = rateset.rates[vwrq->value] & 0x7f;
        else
                rate = vwrq->value / 500000;

        if (vwrq->fixed) {
                error_bg = dev_wlc_intvar_set(dev, "bg_rate", rate);
                error_a = dev_wlc_intvar_set(dev, "a_rate", rate);

                if (error_bg && error_a)
                        return error_bg | error_a;
        } else {
                error_bg = dev_wlc_intvar_set(dev, "bg_rate", 0);
                error_a = dev_wlc_intvar_set(dev, "a_rate", 0);

                if (error_bg && error_a)
                        return error_bg | error_a;

                for (i = 0; i < rateset.count; i++)
                        if ((rateset.rates[i] & 0x7f) > rate)
                                break;
                rateset.count = htod32(i);

                error = dev_wlc_ioctl(dev, WLC_SET_RATESET, &rateset,
                                        sizeof(rateset));
                if (error)
                        return error;
        }

        return 0;
}

static int
wl_iw_get_rate(struct net_device *dev,
               struct iw_request_info *info, struct iw_param *vwrq, char *extra)
{
        int error, rate;

        WL_TRACE("%s: SIOCGIWRATE\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
        if (error)
                return error;
        rate = dtoh32(rate);
        vwrq->value = rate * 500000;

        return 0;
}

static int
wl_iw_set_rts(struct net_device *dev,
              struct iw_request_info *info, struct iw_param *vwrq, char *extra)
{
        int error, rts;

        WL_TRACE("%s: SIOCSIWRTS\n", dev->name);

        if (vwrq->disabled)
                rts = DOT11_DEFAULT_RTS_LEN;
        else if (vwrq->value < 0 || vwrq->value > DOT11_DEFAULT_RTS_LEN)
                return -EINVAL;
        else
                rts = vwrq->value;

        error = dev_wlc_intvar_set(dev, "rtsthresh", rts);
        if (error)
                return error;

        return 0;
}

static int
wl_iw_get_rts(struct net_device *dev,
              struct iw_request_info *info, struct iw_param *vwrq, char *extra)
{
        int error, rts;

        WL_TRACE("%s: SIOCGIWRTS\n", dev->name);

        error = dev_wlc_intvar_get(dev, "rtsthresh", &rts);
        if (error)
                return error;

        vwrq->value = rts;
        vwrq->disabled = (rts >= DOT11_DEFAULT_RTS_LEN);
        vwrq->fixed = 1;

        return 0;
}

static int
wl_iw_set_frag(struct net_device *dev,
               struct iw_request_info *info, struct iw_param *vwrq, char *extra)
{
        int error, frag;

        WL_TRACE("%s: SIOCSIWFRAG\n", dev->name);

        if (vwrq->disabled)
                frag = DOT11_DEFAULT_FRAG_LEN;
        else if (vwrq->value < 0 || vwrq->value > DOT11_DEFAULT_FRAG_LEN)
                return -EINVAL;
        else
                frag = vwrq->value;

        error = dev_wlc_intvar_set(dev, "fragthresh", frag);
        if (error)
                return error;

        return 0;
}

static int
wl_iw_get_frag(struct net_device *dev,
               struct iw_request_info *info, struct iw_param *vwrq, char *extra)
{
        int error, fragthreshold;

        WL_TRACE("%s: SIOCGIWFRAG\n", dev->name);

        error = dev_wlc_intvar_get(dev, "fragthresh", &fragthreshold);
        if (error)
                return error;

        vwrq->value = fragthreshold;
        vwrq->disabled = (fragthreshold >= DOT11_DEFAULT_FRAG_LEN);
        vwrq->fixed = 1;

        return 0;
}

static int
wl_iw_set_txpow(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        int error, disable;
        u16 txpwrmw;
        WL_TRACE("%s: SIOCSIWTXPOW\n", dev->name);

        disable = vwrq->disabled ? WL_RADIO_SW_DISABLE : 0;
        disable += WL_RADIO_SW_DISABLE << 16;

        disable = htod32(disable);
        error = dev_wlc_ioctl(dev, WLC_SET_RADIO, &disable, sizeof(disable));
        if (error)
                return error;

        if (disable & WL_RADIO_SW_DISABLE)
                return 0;

        if (!(vwrq->flags & IW_TXPOW_MWATT))
                return -EINVAL;

        if (vwrq->value < 0)
                return 0;

        if (vwrq->value > 0xffff)
                txpwrmw = 0xffff;
        else
                txpwrmw = (u16) vwrq->value;

        error =
            dev_wlc_intvar_set(dev, "qtxpower", (int)(bcm_mw_to_qdbm(txpwrmw)));
        return error;
}

static int
wl_iw_get_txpow(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        int error, disable, txpwrdbm;
        u8 result;

        WL_TRACE("%s: SIOCGIWTXPOW\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_RADIO, &disable, sizeof(disable));
        if (error)
                return error;

        error = dev_wlc_intvar_get(dev, "qtxpower", &txpwrdbm);
        if (error)
                return error;

        disable = dtoh32(disable);
        result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
        vwrq->value = (s32) bcm_qdbm_to_mw(result);
        vwrq->fixed = 0;
        vwrq->disabled =
            (disable & (WL_RADIO_SW_DISABLE | WL_RADIO_HW_DISABLE)) ? 1 : 0;
        vwrq->flags = IW_TXPOW_MWATT;

        return 0;
}

#if WIRELESS_EXT > 10
static int
wl_iw_set_retry(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        int error, lrl, srl;

        WL_TRACE("%s: SIOCSIWRETRY\n", dev->name);

        if (vwrq->disabled || (vwrq->flags & IW_RETRY_LIFETIME))
                return -EINVAL;

        if (vwrq->flags & IW_RETRY_LIMIT) {

#if WIRELESS_EXT > 20
                if ((vwrq->flags & IW_RETRY_LONG)
                    || (vwrq->flags & IW_RETRY_MAX)
                    || !((vwrq->flags & IW_RETRY_SHORT)
                         || (vwrq->flags & IW_RETRY_MIN))) {
#else
                if ((vwrq->flags & IW_RETRY_MAX)
                    || !(vwrq->flags & IW_RETRY_MIN)) {
#endif
                        lrl = htod32(vwrq->value);
                        error = dev_wlc_ioctl(dev, WLC_SET_LRL, &lrl,
                                                sizeof(lrl));
                        if (error)
                                return error;
                }
#if WIRELESS_EXT > 20
                if ((vwrq->flags & IW_RETRY_SHORT)
                    || (vwrq->flags & IW_RETRY_MIN)
                    || !((vwrq->flags & IW_RETRY_LONG)
                         || (vwrq->flags & IW_RETRY_MAX))) {
#else
                if ((vwrq->flags & IW_RETRY_MIN)
                    || !(vwrq->flags & IW_RETRY_MAX)) {
#endif
                        srl = htod32(vwrq->value);
                        error = dev_wlc_ioctl(dev, WLC_SET_SRL, &srl,
                                                sizeof(srl));
                        if (error)
                                return error;
                }
        }
        return 0;
}

static int
wl_iw_get_retry(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        int error, lrl, srl;

        WL_TRACE("%s: SIOCGIWRETRY\n", dev->name);

        vwrq->disabled = 0;

        if ((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
                return -EINVAL;

        error = dev_wlc_ioctl(dev, WLC_GET_LRL, &lrl, sizeof(lrl));
        if (error)
                return error;

        error = dev_wlc_ioctl(dev, WLC_GET_SRL, &srl, sizeof(srl));
        if (error)
                return error;

        lrl = dtoh32(lrl);
        srl = dtoh32(srl);

        if (vwrq->flags & IW_RETRY_MAX) {
                vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
                vwrq->value = lrl;
        } else {
                vwrq->flags = IW_RETRY_LIMIT;
                vwrq->value = srl;
                if (srl != lrl)
                        vwrq->flags |= IW_RETRY_MIN;
        }

        return 0;
}
#endif                          /* WIRELESS_EXT > 10 */

static int
wl_iw_set_encode(struct net_device *dev,
                 struct iw_request_info *info,
                 struct iw_point *dwrq, char *extra)
{
        wl_wsec_key_t key;
        int error, val, wsec;

        WL_TRACE("%s: SIOCSIWENCODE\n", dev->name);

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

        if ((dwrq->flags & IW_ENCODE_INDEX) == 0) {
                for (key.index = 0; key.index < DOT11_MAX_DEFAULT_KEYS;
                     key.index++) {
                        val = htod32(key.index);
                        error = dev_wlc_ioctl(dev, WLC_GET_KEY_PRIMARY, &val,
                                                sizeof(val));
                        if (error)
                                return error;
                        val = dtoh32(val);
                        if (val)
                                break;
                }
                if (key.index == DOT11_MAX_DEFAULT_KEYS)
                        key.index = 0;
        } else {
                key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
                if (key.index >= DOT11_MAX_DEFAULT_KEYS)
                        return -EINVAL;
        }

        if (!extra || !dwrq->length || (dwrq->flags & IW_ENCODE_NOKEY)) {
                val = htod32(key.index);
                error = dev_wlc_ioctl(dev, WLC_SET_KEY_PRIMARY, &val,
                                        sizeof(val));
                if (error)
                        return error;
        } else {
                key.len = dwrq->length;

                if (dwrq->length > sizeof(key.data))
                        return -EINVAL;

                memcpy(key.data, extra, dwrq->length);

                key.flags = WL_PRIMARY_KEY;
                switch (key.len) {
                case WEP1_KEY_SIZE:
                        key.algo = CRYPTO_ALGO_WEP1;
                        break;
                case WEP128_KEY_SIZE:
                        key.algo = CRYPTO_ALGO_WEP128;
                        break;
                case TKIP_KEY_SIZE:
                        key.algo = CRYPTO_ALGO_TKIP;
                        break;
                case AES_KEY_SIZE:
                        key.algo = CRYPTO_ALGO_AES_CCM;
                        break;
                default:
                        return -EINVAL;
                }

                swap_key_from_BE(&key);
                error = dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
                if (error)
                        return error;
        }

        val = (dwrq->flags & IW_ENCODE_DISABLED) ? 0 : WEP_ENABLED;

        error = dev_wlc_intvar_get(dev, "wsec", &wsec);
        if (error)
                return error;

        wsec &= ~(WEP_ENABLED);
        wsec |= val;

        error = dev_wlc_intvar_set(dev, "wsec", wsec);
        if (error)
                return error;

        val = (dwrq->flags & IW_ENCODE_RESTRICTED) ? 1 : 0;
        val = htod32(val);
        error = dev_wlc_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
        if (error)
                return error;

        return 0;
}

static int
wl_iw_get_encode(struct net_device *dev,
                 struct iw_request_info *info,
                 struct iw_point *dwrq, char *extra)
{
        wl_wsec_key_t key;
        int error, val, wsec, auth;

        WL_TRACE("%s: SIOCGIWENCODE\n", dev->name);

        memset(&key, 0, sizeof(wl_wsec_key_t));

        if ((dwrq->flags & IW_ENCODE_INDEX) == 0) {
                for (key.index = 0; key.index < DOT11_MAX_DEFAULT_KEYS;
                     key.index++) {
                        val = key.index;
                        error = dev_wlc_ioctl(dev, WLC_GET_KEY_PRIMARY, &val,
                                                sizeof(val));
                        if (error)
                                return error;
                        val = dtoh32(val);
                        if (val)
                                break;
                }
        } else
                key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;

        if (key.index >= DOT11_MAX_DEFAULT_KEYS)
                key.index = 0;

        error = dev_wlc_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
        if (error)
                return error;

        error = dev_wlc_ioctl(dev, WLC_GET_AUTH, &auth, sizeof(auth));
        if (error)
                return error;

        swap_key_to_BE(&key);

        wsec = dtoh32(wsec);
        auth = dtoh32(auth);
        dwrq->length = min_t(u16, DOT11_MAX_KEY_SIZE, key.len);

        dwrq->flags = key.index + 1;
        if (!(wsec & (WEP_ENABLED | TKIP_ENABLED | AES_ENABLED)))
                dwrq->flags |= IW_ENCODE_DISABLED;

        if (auth)
                dwrq->flags |= IW_ENCODE_RESTRICTED;

        if (dwrq->length && extra)
                memcpy(extra, key.data, dwrq->length);

        return 0;
}

static int
wl_iw_set_power(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        int error, pm;

        WL_TRACE("%s: SIOCSIWPOWER\n", dev->name);

        pm = vwrq->disabled ? PM_OFF : PM_MAX;

        pm = htod32(pm);
        error = dev_wlc_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
        if (error)
                return error;

        return 0;
}

static int
wl_iw_get_power(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        int error, pm;

        WL_TRACE("%s: SIOCGIWPOWER\n", dev->name);

        error = dev_wlc_ioctl(dev, WLC_GET_PM, &pm, sizeof(pm));
        if (error)
                return error;

        pm = dtoh32(pm);
        vwrq->disabled = pm ? 0 : 1;
        vwrq->flags = IW_POWER_ALL_R;

        return 0;
}

#if WIRELESS_EXT > 17
static int
wl_iw_set_wpaie(struct net_device *dev,
                struct iw_request_info *info, struct iw_point *iwp, char *extra)
{

        WL_TRACE("%s: SIOCSIWGENIE\n", dev->name);

        CHECK_EXTRA_FOR_NULL(extra);

        dev_wlc_bufvar_set(dev, "wpaie", extra, iwp->length);

        return 0;
}

static int
wl_iw_get_wpaie(struct net_device *dev,
                struct iw_request_info *info, struct iw_point *iwp, char *extra)
{
        WL_TRACE("%s: SIOCGIWGENIE\n", dev->name);
        iwp->length = 64;
        dev_wlc_bufvar_get(dev, "wpaie", extra, iwp->length);
        return 0;
}

static int
wl_iw_set_encodeext(struct net_device *dev,
                    struct iw_request_info *info,
                    struct iw_point *dwrq, char *extra)
{
        wl_wsec_key_t key;
        int error;
        struct iw_encode_ext *iwe;

        WL_TRACE("%s: SIOCSIWENCODEEXT\n", dev->name);

        CHECK_EXTRA_FOR_NULL(extra);

        memset(&key, 0, sizeof(key));
        iwe = (struct iw_encode_ext *)extra;

        if (dwrq->flags & IW_ENCODE_DISABLED) {

        }

        key.index = 0;
        if (dwrq->flags & IW_ENCODE_INDEX)
                key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;

        key.len = iwe->key_len;

        if (!is_multicast_ether_addr(iwe->addr.sa_data))
                bcopy((void *)&iwe->addr.sa_data, (char *)&key.ea,
                      ETH_ALEN);

        if (key.len == 0) {
                if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
                        WL_WSEC("Changing the the primary Key to %d\n",
                                key.index);
                        key.index = htod32(key.index);
                        error = dev_wlc_ioctl(dev, WLC_SET_KEY_PRIMARY,
                                              &key.index, sizeof(key.index));
                        if (error)
                                return error;
                } else {
                        swap_key_from_BE(&key);
                        dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
                }
        } else {
                if (iwe->key_len > sizeof(key.data))
                        return -EINVAL;

                WL_WSEC("Setting the key index %d\n", key.index);
                if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
                        WL_WSEC("key is a Primary Key\n");
                        key.flags = WL_PRIMARY_KEY;
                }

                bcopy((void *)iwe->key, key.data, iwe->key_len);

                if (iwe->alg == IW_ENCODE_ALG_TKIP) {
                        u8 keybuf[8];
                        bcopy(&key.data[24], keybuf, sizeof(keybuf));
                        bcopy(&key.data[16], &key.data[24], sizeof(keybuf));
                        bcopy(keybuf, &key.data[16], sizeof(keybuf));
                }

                if (iwe->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
                        unsigned char *ivptr;
                        ivptr = (unsigned char *) iwe->rx_seq;
                        key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
                            (ivptr[3] << 8) | ivptr[2];
                        key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
                        key.iv_initialized = true;
                }

                switch (iwe->alg) {
                case IW_ENCODE_ALG_NONE:
                        key.algo = CRYPTO_ALGO_OFF;
                        break;
                case IW_ENCODE_ALG_WEP:
                        if (iwe->key_len == WEP1_KEY_SIZE)
                                key.algo = CRYPTO_ALGO_WEP1;
                        else
                                key.algo = CRYPTO_ALGO_WEP128;
                        break;
                case IW_ENCODE_ALG_TKIP:
                        key.algo = CRYPTO_ALGO_TKIP;
                        break;
                case IW_ENCODE_ALG_CCMP:
                        key.algo = CRYPTO_ALGO_AES_CCM;
                        break;
                default:
                        break;
                }
                swap_key_from_BE(&key);

                dhd_wait_pend8021x(dev);

                error = dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
                if (error)
                        return error;
        }
        return 0;
}

#if WIRELESS_EXT > 17
struct {
        pmkid_list_t pmkids;
        pmkid_t foo[MAXPMKID - 1];
} pmkid_list;

static int
wl_iw_set_pmksa(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *vwrq, char *extra)
{
        struct iw_pmksa *iwpmksa;
        uint i;
        int ret = 0;

        WL_WSEC("%s: SIOCSIWPMKSA\n", dev->name);

        CHECK_EXTRA_FOR_NULL(extra);

        iwpmksa = (struct iw_pmksa *)extra;

        if (iwpmksa->cmd == IW_PMKSA_FLUSH) {
                WL_WSEC("wl_iw_set_pmksa - IW_PMKSA_FLUSH\n");
                memset((char *)&pmkid_list, 0, sizeof(pmkid_list));
        }

        else if (iwpmksa->cmd == IW_PMKSA_REMOVE) {
                {
                        pmkid_list_t pmkid, *pmkidptr;
                        uint j;
                        pmkidptr = &pmkid;

                        bcopy(&iwpmksa->bssid.sa_data[0],
                              &pmkidptr->pmkid[0].BSSID, ETH_ALEN);
                        bcopy(&iwpmksa->pmkid[0], &pmkidptr->pmkid[0].PMKID,
                              WPA2_PMKID_LEN);

                        WL_WSEC("wl_iw_set_pmksa:IW_PMKSA_REMOVE:PMKID: %pM = ",
                                &pmkidptr->pmkid[0].BSSID);
                        for (j = 0; j < WPA2_PMKID_LEN; j++)
                                WL_WSEC("%02x ", pmkidptr->pmkid[0].PMKID[j]);
                        WL_WSEC("\n");
                }

                for (i = 0; i < pmkid_list.pmkids.npmkid; i++)
                        if (!memcmp
                            (&iwpmksa->bssid.sa_data[0],
                             &pmkid_list.pmkids.pmkid[i].BSSID, ETH_ALEN))
                                break;

                if ((pmkid_list.pmkids.npmkid > 0)
                    && (i < pmkid_list.pmkids.npmkid)) {
                        memset(&pmkid_list.pmkids.pmkid[i], 0, sizeof(pmkid_t));
                        for (; i < (pmkid_list.pmkids.npmkid - 1); i++) {
                                bcopy(&pmkid_list.pmkids.pmkid[i + 1].BSSID,
                                      &pmkid_list.pmkids.pmkid[i].BSSID,
                                      ETH_ALEN);
                                bcopy(&pmkid_list.pmkids.pmkid[i + 1].PMKID,
                                      &pmkid_list.pmkids.pmkid[i].PMKID,
                                      WPA2_PMKID_LEN);
                        }
                        pmkid_list.pmkids.npmkid--;
                } else
                        ret = -EINVAL;
        }

        else if (iwpmksa->cmd == IW_PMKSA_ADD) {
                for (i = 0; i < pmkid_list.pmkids.npmkid; i++)
                        if (!memcmp
                            (&iwpmksa->bssid.sa_data[0],
                             &pmkid_list.pmkids.pmkid[i].BSSID, ETH_ALEN))
                                break;
                if (i < MAXPMKID) {
                        bcopy(&iwpmksa->bssid.sa_data[0],
                              &pmkid_list.pmkids.pmkid[i].BSSID,
                              ETH_ALEN);
                        bcopy(&iwpmksa->pmkid[0],
                              &pmkid_list.pmkids.pmkid[i].PMKID,
                              WPA2_PMKID_LEN);
                        if (i == pmkid_list.pmkids.npmkid)
                                pmkid_list.pmkids.npmkid++;
                } else
                        ret = -EINVAL;
                {
                        uint j;
                        uint k;
                        k = pmkid_list.pmkids.npmkid;
                        WL_WSEC("wl_iw_set_pmksa,IW_PMKSA_ADD - PMKID: %pM = ",
                                &pmkid_list.pmkids.pmkid[k].BSSID);
                        for (j = 0; j < WPA2_PMKID_LEN; j++)
                                WL_WSEC("%02x ",
                                        pmkid_list.pmkids.pmkid[k].PMKID[j]);
                        WL_WSEC("\n");
                }
        }
        WL_WSEC("PRINTING pmkid LIST - No of elements %d\n",
                pmkid_list.pmkids.npmkid);
        for (i = 0; i < pmkid_list.pmkids.npmkid; i++) {
                uint j;
                WL_WSEC("PMKID[%d]: %pM = ",
                        i, &pmkid_list.pmkids.pmkid[i].BSSID);
                for (j = 0; j < WPA2_PMKID_LEN; j++)
                        WL_WSEC("%02x ", pmkid_list.pmkids.pmkid[i].PMKID[j]);
                WL_WSEC("\n");
        }
        WL_WSEC("\n");

        if (!ret)
                ret = dev_wlc_bufvar_set(dev, "pmkid_info", (char *)&pmkid_list,
                                         sizeof(pmkid_list));
        return ret;
}
#endif                          /* WIRELESS_EXT > 17 */

static int
wl_iw_get_encodeext(struct net_device *dev,
                    struct iw_request_info *info,
                    struct iw_param *vwrq, char *extra)
{
        WL_TRACE("%s: SIOCGIWENCODEEXT\n", dev->name);
        return 0;
}

static int
wl_iw_set_wpaauth(struct net_device *dev,
                  struct iw_request_info *info,
                  struct iw_param *vwrq, char *extra)
{
        int error = 0;
        int paramid;
        int paramval;
        int val = 0;
        wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);

        WL_TRACE("%s: SIOCSIWAUTH\n", dev->name);

        paramid = vwrq->flags & IW_AUTH_INDEX;
        paramval = vwrq->value;

        WL_TRACE("%s: SIOCSIWAUTH, paramid = 0x%0x, paramval = 0x%0x\n",
                 dev->name, paramid, paramval);

        switch (paramid) {
        case IW_AUTH_WPA_VERSION:
                if (paramval & IW_AUTH_WPA_VERSION_DISABLED)
                        val = WPA_AUTH_DISABLED;
                else if (paramval & (IW_AUTH_WPA_VERSION_WPA))
                        val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
                else if (paramval & IW_AUTH_WPA_VERSION_WPA2)
                        val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
                WL_INFORM("%s: %d: setting wpa_auth to 0x%0x\n",
                          __func__, __LINE__, val);
                error = dev_wlc_intvar_set(dev, "wpa_auth", val);
                if (error)
                        return error;
                break;
        case IW_AUTH_CIPHER_PAIRWISE:
        case IW_AUTH_CIPHER_GROUP:
                if (paramval & (IW_AUTH_CIPHER_WEP40 | IW_AUTH_CIPHER_WEP104))
                        val = WEP_ENABLED;
                if (paramval & IW_AUTH_CIPHER_TKIP)
                        val = TKIP_ENABLED;
                if (paramval & IW_AUTH_CIPHER_CCMP)
                        val = AES_ENABLED;

                if (paramid == IW_AUTH_CIPHER_PAIRWISE) {
                        iw->pwsec = val;
                        val |= iw->gwsec;
                } else {
                        iw->gwsec = val;
                        val |= iw->pwsec;
                }

                if (iw->privacy_invoked && !val) {
                        WL_WSEC("%s: %s: 'Privacy invoked' true but clearing wsec, assuming we're a WPS enrollee\n",
                                dev->name, __func__);
                        error = dev_wlc_intvar_set(dev, "is_WPS_enrollee",
                                                        true);
                        if (error) {
                                WL_WSEC("Failed to set is_WPS_enrollee\n");
                                return error;
                        }
                } else if (val) {
                        error = dev_wlc_intvar_set(dev, "is_WPS_enrollee",
                                                        false);
                        if (error) {
                                WL_WSEC("Failed to clear is_WPS_enrollee\n");
                                return error;
                        }
                }

                error = dev_wlc_intvar_set(dev, "wsec", val);
                if (error)
                        return error;

                break;

        case IW_AUTH_KEY_MGMT:
                error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
                if (error)
                        return error;

                if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
                        if (paramval & IW_AUTH_KEY_MGMT_PSK)
                                val = WPA_AUTH_PSK;
                        else
                                val = WPA_AUTH_UNSPECIFIED;
                } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
                        if (paramval & IW_AUTH_KEY_MGMT_PSK)
                                val = WPA2_AUTH_PSK;
                        else
                                val = WPA2_AUTH_UNSPECIFIED;
                }
                WL_INFORM("%s: %d: setting wpa_auth to %d\n",
                          __func__, __LINE__, val);
                error = dev_wlc_intvar_set(dev, "wpa_auth", val);
                if (error)
                        return error;

                break;
        case IW_AUTH_TKIP_COUNTERMEASURES:
                dev_wlc_bufvar_set(dev, "tkip_countermeasures",
                                   (char *)&paramval, 1);
                break;

        case IW_AUTH_80211_AUTH_ALG:
                WL_INFORM("Setting the D11auth %d\n", paramval);
                if (paramval == IW_AUTH_ALG_OPEN_SYSTEM)
                        val = 0;
                else if (paramval == IW_AUTH_ALG_SHARED_KEY)
                        val = 1;
                else if (paramval ==
                         (IW_AUTH_ALG_OPEN_SYSTEM | IW_AUTH_ALG_SHARED_KEY))
                        val = 2;
                else
                        error = 1;
                if (!error) {
                        error = dev_wlc_intvar_set(dev, "auth", val);
                        if (error)
                                return error;
                }
                break;

        case IW_AUTH_WPA_ENABLED:
                if (paramval == 0) {
                        iw->pwsec = 0;
                        iw->gwsec = 0;
                        error = dev_wlc_intvar_get(dev, "wsec", &val);
                        if (error)
                                return error;
                        if (val & (TKIP_ENABLED | AES_ENABLED)) {
                                val &= ~(TKIP_ENABLED | AES_ENABLED);
                                dev_wlc_intvar_set(dev, "wsec", val);
                        }
                        val = 0;
                        WL_INFORM("%s: %d: setting wpa_auth to %d\n",
                                  __func__, __LINE__, val);
                        dev_wlc_intvar_set(dev, "wpa_auth", 0);
                        return error;
                }
                break;

        case IW_AUTH_DROP_UNENCRYPTED:
                dev_wlc_bufvar_set(dev, "wsec_restrict", (char *)&paramval, 1);
                break;

        case IW_AUTH_RX_UNENCRYPTED_EAPOL:
                dev_wlc_bufvar_set(dev, "rx_unencrypted_eapol",
                                   (char *)&paramval, 1);
                break;

#if WIRELESS_EXT > 17
        case IW_AUTH_ROAMING_CONTROL:
                WL_INFORM("%s: IW_AUTH_ROAMING_CONTROL\n", __func__);
                break;
        case IW_AUTH_PRIVACY_INVOKED:
                {
                        int wsec;

                        if (paramval == 0) {
                                iw->privacy_invoked = false;
                                error = dev_wlc_intvar_set(dev,
                                                "is_WPS_enrollee", false);
                                if (error) {
                                        WL_WSEC("Failed to clear iovar is_WPS_enrollee\n");
                                        return error;
                                }
                        } else {
                                iw->privacy_invoked = true;
                                error = dev_wlc_intvar_get(dev, "wsec", &wsec);
                                if (error)
                                        return error;

                                if (!(IW_WSEC_ENABLED(wsec))) {
                                        error = dev_wlc_intvar_set(dev,
                                                        "is_WPS_enrollee",
                                                        true);
                                        if (error) {
                                                WL_WSEC("Failed to set iovar is_WPS_enrollee\n");
                                                return error;
                                        }
                                } else {
                                        error = dev_wlc_intvar_set(dev,
                                                        "is_WPS_enrollee",
                                                        false);
                                        if (error) {
                                                WL_WSEC("Failed to clear is_WPS_enrollee\n");
                                                return error;
                                        }
                                }
                        }
                        break;
                }
#endif                          /* WIRELESS_EXT > 17 */
        default:
                break;
        }
        return 0;
}

#define VAL_PSK(_val) (((_val) & WPA_AUTH_PSK) || ((_val) & WPA2_AUTH_PSK))

static int
wl_iw_get_wpaauth(struct net_device *dev,
                  struct iw_request_info *info,
                  struct iw_param *vwrq, char *extra)
{
        int error;
        int paramid;
        int paramval = 0;
        int val;
        wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);

        WL_TRACE("%s: SIOCGIWAUTH\n", dev->name);

        paramid = vwrq->flags & IW_AUTH_INDEX;

        switch (paramid) {
        case IW_AUTH_WPA_VERSION:
                error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
                if (error)
                        return error;
                if (val & (WPA_AUTH_NONE | WPA_AUTH_DISABLED))
                        paramval = IW_AUTH_WPA_VERSION_DISABLED;
                else if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED))
                        paramval = IW_AUTH_WPA_VERSION_WPA;
                else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED))
                        paramval = IW_AUTH_WPA_VERSION_WPA2;
                break;
        case IW_AUTH_CIPHER_PAIRWISE:
        case IW_AUTH_CIPHER_GROUP:
                if (paramid == IW_AUTH_CIPHER_PAIRWISE)
                        val = iw->pwsec;
                else
                        val = iw->gwsec;

                paramval = 0;
                if (val) {
                        if (val & WEP_ENABLED)
                                paramval |=
                                    (IW_AUTH_CIPHER_WEP40 |
                                     IW_AUTH_CIPHER_WEP104);
                        if (val & TKIP_ENABLED)
                                paramval |= (IW_AUTH_CIPHER_TKIP);
                        if (val & AES_ENABLED)
                                paramval |= (IW_AUTH_CIPHER_CCMP);
                } else
                        paramval = IW_AUTH_CIPHER_NONE;
                break;
        case IW_AUTH_KEY_MGMT:
                error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
                if (error)
                        return error;
                if (VAL_PSK(val))
                        paramval = IW_AUTH_KEY_MGMT_PSK;
                else
                        paramval = IW_AUTH_KEY_MGMT_802_1X;

                break;