/*
 * Copyright (c) 2007-2008 Atheros Communications Inc.
 *
 * 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.
 */
/*                                                                      */
/*  Module Name : ioctl.c                                               */
/*                                                                      */
/*  Abstract                                                            */
/*      This module contains Linux wireless extension related functons. */
/*                                                                      */
/*  NOTES                                                               */
/*     Platform dependent.                                              */
/*                                                                      */
/************************************************************************/
#include <linux/module.h>
#include <linux/if_arp.h>
#include <linux/uaccess.h>

#include "usbdrv.h"

#define ZD_IOCTL_WPA                        (SIOCDEVPRIVATE + 1)
#define ZD_IOCTL_PARAM                      (SIOCDEVPRIVATE + 2)
#define ZD_IOCTL_GETWPAIE                   (SIOCDEVPRIVATE + 3)
#ifdef ZM_ENABLE_CENC
#define ZM_IOCTL_CENC               (SIOCDEVPRIVATE + 4)
#endif  /* ZM_ENABLE_CENC */
#define ZD_PARAM_ROAMING                    0x0001
#define ZD_PARAM_PRIVACY                    0x0002
#define ZD_PARAM_WPA                        0x0003
#define ZD_PARAM_COUNTERMEASURES        0x0004
#define ZD_PARAM_DROPUNENCRYPTED        0x0005
#define ZD_PARAM_AUTH_ALGS                  0x0006
#define ZD_PARAM_WPS_FILTER                 0x0007

#ifdef ZM_ENABLE_CENC
#define P80211_PACKET_CENCFLAG          0x0001
#endif  /* ZM_ENABLE_CENC */
#define P80211_PACKET_SETKEY            0x0003

#define ZD_CMD_SET_ENCRYPT_KEY          0x0001
#define ZD_CMD_SET_MLME                     0x0002
#define ZD_CMD_SCAN_REQ                     0x0003
#define ZD_CMD_SET_GENERIC_ELEMENT      0x0004
#define ZD_CMD_GET_TSC                      0x0005

#define ZD_CRYPT_ALG_NAME_LEN           16
#define ZD_MAX_KEY_SIZE                     32
#define ZD_MAX_GENERIC_SIZE                 64

#include <net/iw_handler.h>

extern u16_t zfLnxGetVapId(zdev_t *dev);

static const u32_t channel_frequency_11A[] =
{
        /* Even element for Channel Number, Odd for Frequency */
        36, 5180,
        40, 5200,
        44, 5220,
        48, 5240,
        52, 5260,
        56, 5280,
        60, 5300,
        64, 5320,
        100, 5500,
        104, 5520,
        108, 5540,
        112, 5560,
        116, 5580,
        120, 5600,
        124, 5620,
        128, 5640,
        132, 5660,
        136, 5680,
        140, 5700,
        /**/
        184, 4920,
        188, 4940,
        192, 4960,
        196, 4980,
        8, 5040,
        12, 5060,
        16, 5080,
        34, 5170,
        38, 5190,
        42, 5210,
        46, 5230,
        /**/
        149, 5745,
        153, 5765,
        157, 5785,
        161, 5805,
        165, 5825
        /**/
};

int usbdrv_freq2chan(u32_t freq)
{
        /* 2.4G Hz */
        if (freq > 2400 && freq < 3000) {
                return ((freq-2412)/5) + 1;
        } else {
                u16_t ii;
                u16_t num_chan = sizeof(channel_frequency_11A)/sizeof(u32_t);

                for (ii = 1; ii < num_chan; ii += 2) {
                        if (channel_frequency_11A[ii] == freq)
                                return channel_frequency_11A[ii-1];
                }
        }

        return 0;
}

int usbdrv_chan2freq(int chan)
{
        int freq;

        /* If channel number is out of range */
        if (chan > 165 || chan <= 0)
                return -1;

        /* 2.4G band */
        if (chan >= 1 && chan <= 13) {
                freq = (2412 + (chan - 1) * 5);
                        return freq;
        } else if (chan >= 36 && chan <= 165) {
                u16_t ii;
                u16_t num_chan = sizeof(channel_frequency_11A)/sizeof(u32_t);

                for (ii = 0; ii < num_chan; ii += 2) {
                        if (channel_frequency_11A[ii] == chan)
                                return channel_frequency_11A[ii+1];
                }

        /* Can't find desired frequency */
        if (ii == num_chan)
                return -1;
        }

        /* Can't find deisred frequency */
        return -1;
}

int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq)
{
        #ifdef ZM_HOSTAPD_SUPPORT
        /* struct usbdrv_private *macp = dev->ml_priv; */
        char essidbuf[IW_ESSID_MAX_SIZE+1];
        int i;

        if (!netif_running(dev))
                return -EINVAL;

        memset(essidbuf, 0, sizeof(essidbuf));

        printk(KERN_ERR "usbdrv_ioctl_setessid\n");

        /* printk("ssidlen=%d\n", erq->length); //for any, it is 1. */
        if (erq->flags) {
                if (erq->length > (IW_ESSID_MAX_SIZE+1))
                        return -E2BIG;

                if (copy_from_user(essidbuf, erq->pointer, erq->length))
                        return -EFAULT;
        }

        /* zd_DisasocAll(2); */
        /* wait_ms(100); */

        printk(KERN_ERR "essidbuf: ");

        for (i = 0; i < erq->length; i++)
                printk(KERN_ERR "%02x ", essidbuf[i]);

        printk(KERN_ERR "\n");

        essidbuf[erq->length] = '\0';
        /* memcpy(macp->wd.ws.ssid, essidbuf, erq->length); */
        /* macp->wd.ws.ssidLen = strlen(essidbuf)+2; */
        /* macp->wd.ws.ssid[1] = strlen(essidbuf); Update ssid length */

        zfiWlanSetSSID(dev, essidbuf, erq->length);
        #if 0
                printk(KERN_ERR "macp->wd.ws.ssid: ");

                for (i = 0; i < macp->wd.ws.ssidLen; i++)
                        printk(KERN_ERR "%02x ", macp->wd.ws.ssid[i]);

                printk(KERN_ERR "\n");
        #endif

        zfiWlanDisable(dev, 0);
        zfiWlanEnable(dev);

        #endif

        return 0;
}

int usbdrv_ioctl_getessid(struct net_device *dev, struct iw_point *erq)
{
        /* struct usbdrv_private *macp = dev->ml_priv; */
        u8_t essidbuf[IW_ESSID_MAX_SIZE+1];
        u8_t len;
        u8_t i;


        /* len = macp->wd.ws.ssidLen; */
        /* memcpy(essidbuf, macp->wd.ws.ssid, macp->wd.ws.ssidLen); */
        zfiWlanQuerySSID(dev, essidbuf, &len);

        essidbuf[len] = 0;

        printk(KERN_ERR "ESSID: ");

        for (i = 0; i < len; i++)
                printk(KERN_ERR "%c", essidbuf[i]);

        printk(KERN_ERR "\n");

        erq->flags = 1;
        erq->length = strlen(essidbuf) + 1;

        if (erq->pointer) {
                if (copy_to_user(erq->pointer, essidbuf, erq->length))
                        return -EFAULT;
        }

        return 0;
}

int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq)
{
        return 0;
}

/*
 * Encode a WPA or RSN information element as a custom
 * element using the hostap format.
 */
u32 encode_ie(void *buf, u32 bufsize, const u8 *ie, u32 ielen,
                const u8 *leader, u32 leader_len)
{
        u8 *p;
        u32 i;

        if (bufsize < leader_len)
                return 0;
        p = buf;
        memcpy(p, leader, leader_len);
        bufsize -= leader_len;
        p += leader_len;
        for (i = 0; i < ielen && bufsize > 2; i++)
                p += sprintf(p, "%02x", ie[i]);
        return (i == ielen ? p - (u8 *)buf:0);
}

/*
 * Translate scan data returned from the card to a card independent
 * format that the Wireless Tools will understand
 */
char *usbdrv_translate_scan(struct net_device *dev,
        struct iw_request_info *info, char *current_ev,
        char *end_buf, struct zsBssInfo *list)
{
        struct iw_event iwe;   /* Temporary buffer */
        u16_t capabilities;
        char *current_val;     /* For rates */
        char *last_ev;
        int i;
        char    buf[64*2 + 30];

        last_ev = current_ev;

        /* First entry *MUST* be the AP MAC address */
        iwe.cmd = SIOCGIWAP;
        iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
        memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
        current_ev = iwe_stream_add_event(info, current_ev,
                                        end_buf, &iwe, IW_EV_ADDR_LEN);

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        /* Other entries will be displayed in the order we give them */

        /* Add the ESSID */
        iwe.u.data.length = list->ssid[1];
        if (iwe.u.data.length > 32)
                iwe.u.data.length = 32;
        iwe.cmd = SIOCGIWESSID;
        iwe.u.data.flags = 1;
        current_ev = iwe_stream_add_point(info, current_ev,
                                        end_buf, &iwe, &list->ssid[2]);

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        /* Add mode */
        iwe.cmd = SIOCGIWMODE;
        capabilities = (list->capability[1] << 8) + list->capability[0];
        if (capabilities & (0x01 | 0x02)) {
                if (capabilities & 0x01)
                        iwe.u.mode = IW_MODE_MASTER;
                else
                        iwe.u.mode = IW_MODE_ADHOC;
                        current_ev = iwe_stream_add_event(info, current_ev,
                                                end_buf, &iwe, IW_EV_UINT_LEN);
        }

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        /* Add frequency */
        iwe.cmd = SIOCGIWFREQ;
        iwe.u.freq.m = list->channel;
        /* Channel frequency in KHz */
        if (iwe.u.freq.m > 14) {
                if ((184 <= iwe.u.freq.m) && (iwe.u.freq.m <= 196))
                        iwe.u.freq.m = 4000 + iwe.u.freq.m * 5;
                else
                        iwe.u.freq.m = 5000 + iwe.u.freq.m * 5;
        } else {
                if (iwe.u.freq.m == 14)
                        iwe.u.freq.m = 2484;
                else
                        iwe.u.freq.m = 2412 + (iwe.u.freq.m - 1) * 5;
        }
        iwe.u.freq.e = 6;
        current_ev = iwe_stream_add_event(info, current_ev,
                                        end_buf, &iwe, IW_EV_FREQ_LEN);

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        /* Add quality statistics */
        iwe.cmd = IWEVQUAL;
        iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED
                                | IW_QUAL_NOISE_UPDATED;
        iwe.u.qual.level = list->signalStrength;
        iwe.u.qual.noise = 0;
        iwe.u.qual.qual = list->signalQuality;
        current_ev = iwe_stream_add_event(info, current_ev,
                                        end_buf, &iwe, IW_EV_QUAL_LEN);

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        /* Add encryption capability */

        iwe.cmd = SIOCGIWENCODE;
        if (capabilities & 0x10)
                iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
        else
                iwe.u.data.flags = IW_ENCODE_DISABLED;

        iwe.u.data.length = 0;
        current_ev = iwe_stream_add_point(info, current_ev,
                                        end_buf, &iwe, list->ssid);

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        /* Rate : stuffing multiple values in a single event require a bit
        * more of magic
        */
        current_val = current_ev + IW_EV_LCP_LEN;

        iwe.cmd = SIOCGIWRATE;
        /* Those two flags are ignored... */
        iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;

        for (i = 0 ; i < list->supportedRates[1] ; i++) {
                /* Bit rate given in 500 kb/s units (+ 0x80) */
                iwe.u.bitrate.value = ((list->supportedRates[i+2] & 0x7f)
                                        * 500000);
                /* Add new value to event */
                current_val = iwe_stream_add_value(info, current_ev,
                                current_val, end_buf, &iwe, IW_EV_PARAM_LEN);

                /* Ran out of buffer */
                if (last_ev == current_val)
                        return end_buf;

                last_ev = current_val;
        }

        for (i = 0 ; i < list->extSupportedRates[1] ; i++) {
                /* Bit rate given in 500 kb/s units (+ 0x80) */
                iwe.u.bitrate.value = ((list->extSupportedRates[i+2] & 0x7f)
                                        * 500000);
                /* Add new value to event */
                current_val = iwe_stream_add_value(info, current_ev,
                                current_val, end_buf, &iwe, IW_EV_PARAM_LEN);

                /* Ran out of buffer */
                if (last_ev == current_val)
                        return end_buf;

                last_ev = current_ev;
        }

        /* Check if we added any event */
        if ((current_val - current_ev) > IW_EV_LCP_LEN)
                current_ev = current_val;
                #define IEEE80211_ELEMID_RSN 0x30
        memset(&iwe, 0, sizeof(iwe));
        iwe.cmd = IWEVCUSTOM;
        snprintf(buf, sizeof(buf), "bcn_int=%d", (list->beaconInterval[1] << 8)
                                                + list->beaconInterval[0]);
        iwe.u.data.length = strlen(buf);
        current_ev = iwe_stream_add_point(info, current_ev,
                                                end_buf, &iwe, buf);

        /* Ran out of buffer */
        if (last_ev == current_ev)
                return end_buf;

        last_ev = current_ev;

        if (list->wpaIe[1] != 0) {
                static const char rsn_leader[] = "rsn_ie=";
                static const char wpa_leader[] = "wpa_ie=";

                memset(&iwe, 0, sizeof(iwe));
                iwe.cmd = IWEVCUSTOM;
                if (list->wpaIe[0] == IEEE80211_ELEMID_RSN)
                        iwe.u.data.length = encode_ie(buf, sizeof(buf),
                                        list->wpaIe, list->wpaIe[1]+2,
                                        rsn_leader, sizeof(rsn_leader)-1);
                else
                        iwe.u.data.length = encode_ie(buf, sizeof(buf),
                                        list->wpaIe, list->wpaIe[1]+2,
                                        wpa_leader, sizeof(wpa_leader)-1);

                if (iwe.u.data.length != 0)
                        current_ev = iwe_stream_add_point(info, current_ev,
                                                        end_buf, &iwe, buf);

                /* Ran out of buffer */
                if (last_ev == current_ev)
                        return end_buf;

                last_ev = current_ev;
        }

        if (list->rsnIe[1] != 0) {
                static const char rsn_leader[] = "rsn_ie=";
                memset(&iwe, 0, sizeof(iwe));
                iwe.cmd = IWEVCUSTOM;

                if (list->rsnIe[0] == IEEE80211_ELEMID_RSN) {
                        iwe.u.data.length = encode_ie(buf, sizeof(buf),
                        list->rsnIe, list->rsnIe[1]+2,
                        rsn_leader, sizeof(rsn_leader)-1);
                        if (iwe.u.data.length != 0)
                                current_ev = iwe_stream_add_point(info,
                                        current_ev, end_buf,  &iwe, buf);

                        /* Ran out of buffer */
                        if (last_ev == current_ev)
                                return end_buf;

                        last_ev = current_ev;
                }
        }
        /* The other data in the scan result are not really
        * interesting, so for now drop it
        */
        return current_ev;
}

int usbdrvwext_giwname(struct net_device *dev,
                struct iw_request_info *info,
                union iwreq_data *wrq, char *extra)
{
        /* struct usbdrv_private *macp = dev->ml_priv; */

        strcpy(wrq->name, "IEEE 802.11-MIMO");

        return 0;
}

int usbdrvwext_siwfreq(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_freq *freq, char *extra)
{
        u32_t FreqKHz;
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if (freq->e > 1)
                return -EINVAL;

        if (freq->e == 1) {
                FreqKHz = (freq->m / 100000);

                if (FreqKHz > 4000000) {
                        if (FreqKHz > 5825000)
                                FreqKHz = 5825000;
                        else if (FreqKHz < 4920000)
                                FreqKHz = 4920000;
                        else if (FreqKHz < 5000000)
                                FreqKHz = (((FreqKHz - 4000000) / 5000) * 5000)
                                                + 4000000;
                        else
                                FreqKHz = (((FreqKHz - 5000000) / 5000) * 5000)
                                                + 5000000;
                } else {
                        if (FreqKHz > 2484000)
                                FreqKHz = 2484000;
                        else if (FreqKHz < 2412000)
                                FreqKHz = 2412000;
                        else
                                FreqKHz = (((FreqKHz - 2412000) / 5000) * 5000)
                                                + 2412000;
                }
        } else {
                FreqKHz = usbdrv_chan2freq(freq->m);

                if (FreqKHz != -1)
                        FreqKHz *= 1000;
                else
                        FreqKHz = 2412000;
        }

        /* printk("freq->m: %d, freq->e: %d\n", freq->m, freq->e); */
        /* printk("FreqKHz: %d\n", FreqKHz); */

        if (macp->DeviceOpened == 1) {
                zfiWlanSetFrequency(dev, FreqKHz, 0); /* Immediate */
                /* u8_t wpaieLen,wpaie[50]; */
                /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
                zfiWlanDisable(dev, 0);
                zfiWlanEnable(dev);
                /* if (wpaieLen > 2) */
                /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
        }

        return 0;
}

int usbdrvwext_giwfreq(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_freq *freq, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;

        if (macp->DeviceOpened != 1)
                return 0;

        freq->m = zfiWlanQueryFrequency(dev);
        freq->e = 3;

        return 0;
}

int usbdrvwext_siwmode(struct net_device *dev,
                struct iw_request_info *info,
                union iwreq_data *wrq, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u8_t WlanMode;

        if (!netif_running(dev))
                return -EINVAL;

        if (macp->DeviceOpened != 1)
                return 0;

        switch (wrq->mode) {
        case IW_MODE_MASTER:
                WlanMode = ZM_MODE_AP;
                break;
        case IW_MODE_INFRA:
                WlanMode = ZM_MODE_INFRASTRUCTURE;
                break;
        case IW_MODE_ADHOC:
                WlanMode = ZM_MODE_IBSS;
                break;
        default:
                WlanMode = ZM_MODE_IBSS;
                break;
        }

        zfiWlanSetWlanMode(dev, WlanMode);
        zfiWlanDisable(dev, 1);
        zfiWlanEnable(dev);

        return 0;
}

int usbdrvwext_giwmode(struct net_device *dev,
        struct iw_request_info *info,
        __u32 *mode, char *extra)
{
        unsigned long irqFlag;
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if (macp->DeviceOpened != 1)
                return 0;

        spin_lock_irqsave(&macp->cs_lock, irqFlag);

        switch (zfiWlanQueryWlanMode(dev)) {
        case ZM_MODE_AP:
                *mode = IW_MODE_MASTER;
                break;
        case ZM_MODE_INFRASTRUCTURE:
                *mode = IW_MODE_INFRA;
                break;
        case ZM_MODE_IBSS:
                *mode = IW_MODE_ADHOC;
                break;
        default:
                *mode = IW_MODE_ADHOC;
                break;
        }

        spin_unlock_irqrestore(&macp->cs_lock, irqFlag);

        return 0;
}

int usbdrvwext_siwsens(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *sens, char *extra)
{
        return 0;
}

int usbdrvwext_giwsens(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *sens, char *extra)
{
        sens->value = 0;
        sens->fixed = 1;

        return 0;
}

int usbdrvwext_giwrange(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *data, char *extra)
{
        struct iw_range *range = (struct iw_range *) extra;
        int i, val;
        /* int num_band_a; */
        u16_t channels[60];
        u16_t channel_num;

        if (!netif_running(dev))
                return -EINVAL;

        range->txpower_capa = IW_TXPOW_DBM;
        /* XXX what about min/max_pmp, min/max_pmt, etc. */

        range->we_version_compiled = WIRELESS_EXT;
        range->we_version_source = 13;

        range->retry_capa = IW_RETRY_LIMIT;
        range->retry_flags = IW_RETRY_LIMIT;
        range->min_retry = 0;
        range->max_retry = 255;

        channel_num = zfiWlanQueryAllowChannels(dev, channels);

        /* Gurantee reported channel numbers is less
        * or equal to IW_MAX_FREQUENCIES
        */
        if (channel_num > IW_MAX_FREQUENCIES)
                channel_num = IW_MAX_FREQUENCIES;

        val = 0;

        for (i = 0; i < channel_num; i++) {
                range->freq[val].i = usbdrv_freq2chan(channels[i]);
                range->freq[val].m = channels[i];
                range->freq[val].e = 6;
                val++;
        }

        range->num_channels = channel_num;
        range->num_frequency = channel_num;

        #if 0
        range->num_channels = 14; /* Only 2.4G */

        /* XXX need to filter against the regulatory domain &| active set */
        val = 0;
        /* B,G Bands */
        for (i = 1; i <= 14; i++) {
                range->freq[val].i = i;
                if (i == 14)
                        range->freq[val].m = 2484000;
                else
                        range->freq[val].m = (2412+(i-1)*5)*1000;
                range->freq[val].e = 3;
                val++;
        }

        num_band_a = (IW_MAX_FREQUENCIES - val);
        /* A Bands */
        for (i = 0; i < num_band_a; i++) {
                range->freq[val].i = channel_frequency_11A[2 * i];
                range->freq[val].m = channel_frequency_11A[2 * i + 1] * 1000;
                range->freq[val].e = 3;
                val++;
        }
        /* MIMO Rate Not Defined Now
        * For 802.11a, there are too more frequency.
        * We can't return them all.
        */
        range->num_frequency = val;
        #endif

        /* Max of /proc/net/wireless */
        range->max_qual.qual = 100;  /* ??  92; */
        range->max_qual.level = 154; /* ?? */
        range->max_qual.noise = 154; /* ?? */
        range->sensitivity = 3;      /* ?? */

        /* XXX these need to be nsd-specific! */
        range->min_rts = 0;
        range->max_rts = 2347;
        range->min_frag = 256;
        range->max_frag = 2346;
        range->max_encoding_tokens = 4 /* NUM_WEPKEYS ?? */;
        range->num_encoding_sizes = 2; /* ?? */

        range->encoding_size[0] = 5; /* ?? WEP Key Encoding Size */
        range->encoding_size[1] = 13; /* ?? */

        /* XXX what about num_bitrates/throughput? */
        range->num_bitrates = 0; /* ?? */

        /* estimated max throughput
        * XXX need to cap it if we're running at ~2Mbps..
        */

        range->throughput = 300000000;

        return 0;
}

int usbdrvwext_siwap(struct net_device *dev, struct iw_request_info *info,
                struct sockaddr *MacAddr, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
                /* AP Mode */
                zfiWlanSetMacAddress(dev, (u16_t *)&MacAddr->sa_data[0]);
        } else {
                /* STA Mode */
                zfiWlanSetBssid(dev, &MacAddr->sa_data[0]);
        }

        if (macp->DeviceOpened == 1) {
                /* u8_t wpaieLen,wpaie[80]; */
                /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
                zfiWlanDisable(dev, 0);
                zfiWlanEnable(dev);
                /* if (wpaieLen > 2) */
                /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
        }

        return 0;
}

int usbdrvwext_giwap(struct net_device *dev,
                struct iw_request_info *info,
                struct sockaddr *MacAddr, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;

        if (macp->DeviceOpened != 1)
                return 0;

        if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
                /* AP Mode */
                zfiWlanQueryMacAddress(dev, &MacAddr->sa_data[0]);
        } else {
                /* STA Mode */
                if (macp->adapterState == ZM_STATUS_MEDIA_CONNECT) {
                        zfiWlanQueryBssid(dev, &MacAddr->sa_data[0]);
                } else {
                        u8_t zero_addr[6] = { 0x00, 0x00, 0x00, 0x00,
                                                                0x00, 0x00 };
                        memcpy(&MacAddr->sa_data[0], zero_addr,
                                                        sizeof(zero_addr));
                }
        }

        return 0;
}

int usbdrvwext_iwaplist(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_point *data, char *extra)
{
        /* Don't know how to do yet--CWYang(+) */
        return 0;

}

int usbdrvwext_siwscan(struct net_device *dev, struct iw_request_info *info,
        struct iw_point *data, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;

        if (macp->DeviceOpened != 1)
                return 0;

        printk(KERN_WARNING "CWY - usbdrvwext_siwscan\n");

        zfiWlanScan(dev);

        return 0;
}

int usbdrvwext_giwscan(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *data, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        /* struct zsWlanDev* wd = (struct zsWlanDev*) zmw_wlan_dev(dev); */
        char *current_ev = extra;
        char *end_buf;
        int i;
        /* struct zsBssList BssList; */
        struct zsBssListV1 *pBssList = kmalloc(sizeof(struct zsBssListV1),
                                                                GFP_KERNEL);
        /* BssList = wd->sta.pBssList; */
        /* zmw_get_wlan_dev(dev); */

        if (macp->DeviceOpened != 1)
                return 0;

        if (data->length == 0)
                end_buf = extra + IW_SCAN_MAX_DATA;
        else
                end_buf = extra + data->length;

        printk(KERN_WARNING "giwscan - Report Scan Results\n");
        /* printk("giwscan - BssList Sreucture Len : %d\n", sizeof(BssList));
        * printk("giwscan - BssList Count : %d\n",
        * wd->sta.pBssList->bssCount);
        * printk("giwscan - UpdateBssList Count : %d\n",
        * wd->sta.pUpdateBssList->bssCount);
        */
        zfiWlanQueryBssListV1(dev, pBssList);
        /* zfiWlanQueryBssList(dev, &BssList); */

        /* Read and parse all entries */
        printk(KERN_WARNING "giwscan - pBssList->bssCount : %d\n",
                                                pBssList->bssCount);
        /* printk("giwscan - BssList.bssCount : %d\n", BssList.bssCount); */

        for (i = 0; i < pBssList->bssCount; i++) {
                /* Translate to WE format this entry
                * current_ev = usbdrv_translate_scan(dev, info, current_ev,
                * extra + IW_SCAN_MAX_DATA, &pBssList->bssInfo[i]);
                */
                current_ev = usbdrv_translate_scan(dev, info, current_ev,
                                        end_buf, &pBssList->bssInfo[i]);

                if (current_ev == end_buf) {
                        kfree(pBssList);
                        data->length = current_ev - extra;
                        return -E2BIG;
                }
        }

        /* Length of data */
        data->length = (current_ev - extra);
        data->flags = 0;   /* todo */

        kfree(pBssList);

        return 0;
}

int usbdrvwext_siwessid(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *essid, char *extra)
{
        char EssidBuf[IW_ESSID_MAX_SIZE + 1];
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if (essid->flags == 1) {
                if (essid->length > (IW_ESSID_MAX_SIZE + 1))
                        return -E2BIG;

                if (copy_from_user(&EssidBuf, essid->pointer, essid->length))
                        return -EFAULT;

                EssidBuf[essid->length] = '\0';
                /* printk("siwessid - Set Essid : %s\n",EssidBuf); */
                /* printk("siwessid - Essid Len : %d\n",essid->length); */
                /* printk("siwessid - Essid Flag : %x\n",essid->flags); */
                if (macp->DeviceOpened == 1) {
                        zfiWlanSetSSID(dev, EssidBuf, strlen(EssidBuf));
                        zfiWlanSetFrequency(dev, zfiWlanQueryFrequency(dev),
                                                FALSE);
                        zfiWlanSetEncryMode(dev, zfiWlanQueryEncryMode(dev));
                        /* u8_t wpaieLen,wpaie[50]; */
                        /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
                        zfiWlanDisable(dev, 0);
                        zfiWlanEnable(dev);
                        /* if (wpaieLen > 2) */
                        /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
                }
        }

        return 0;
}

int usbdrvwext_giwessid(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *essid, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u8_t EssidLen;
        char EssidBuf[IW_ESSID_MAX_SIZE + 1];
        int ssid_len;

        if (!netif_running(dev))
                return -EINVAL;

        if (macp->DeviceOpened != 1)
                return 0;

        zfiWlanQuerySSID(dev, &EssidBuf[0], &EssidLen);

        /* Convert type from unsigned char to char */
        ssid_len = (int)EssidLen;

        /* Make sure the essid length is not greater than IW_ESSID_MAX_SIZE */
        if (ssid_len > IW_ESSID_MAX_SIZE)
                ssid_len = IW_ESSID_MAX_SIZE;

        EssidBuf[ssid_len] = '\0';

        essid->flags = 1;
        essid->length = strlen(EssidBuf);

        memcpy(extra, EssidBuf, essid->length);
        /* wireless.c in Kernel would handle copy_to_user -- line 679 */
        /* if (essid->pointer) {
        * if (copy_to_user(essid->pointer, EssidBuf, essid->length)) {
        * printk("giwessid - copy_to_user Fail\n");
        * return -EFAULT;
        * }
        * }
        */

        return 0;
}

int usbdrvwext_siwnickn(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_point *data, char *nickname)
{
        /* Exist but junk--CWYang(+) */
        return 0;
}

int usbdrvwext_giwnickn(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_point *data, char *nickname)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u8_t EssidLen;
        char EssidBuf[IW_ESSID_MAX_SIZE + 1];

        if (macp->DeviceOpened != 1)
                return 0;

        zfiWlanQuerySSID(dev, &EssidBuf[0], &EssidLen);
        EssidBuf[EssidLen] = 0;

        data->flags = 1;
        data->length = strlen(EssidBuf);

        memcpy(nickname, EssidBuf, data->length);

        return 0;
}

int usbdrvwext_siwrate(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *frq, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        /* Array to Define Rate Number that Send to Driver */
        u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0,
                        48000, 24000, 12000, 6000, 54000, 36000, 18000, 9000};
        u16_t zcRateToMCS[] = {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd,
                                0x8, 0xc};
        u8_t i, RateIndex = 4;
        u16_t RateKbps;

        /* printk("frq->disabled : 0x%x\n",frq->disabled); */
        /* printk("frq->value : 0x%x\n",frq->value); */

        RateKbps = frq->value / 1000;
        /* printk("RateKbps : %d\n", RateKbps); */
        for (i = 0; i < 16; i++) {
                if (RateKbps == zcIndextoRateBG[i])
                        RateIndex = i;
        }

        if (zcIndextoRateBG[RateIndex] == 0)
                RateIndex = 0xff;
        /* printk("RateIndex : %x\n", RateIndex); */
        for (i = 0; i < 13; i++)
                if (RateIndex == zcRateToMCS[i])
                        break;
        /* printk("Index : %x\n", i); */
        if (RateKbps == 65000) {
                RateIndex = 20;
                printk(KERN_WARNING "RateIndex : %d\n", RateIndex);
        }

        if (macp->DeviceOpened == 1) {
                zfiWlanSetTxRate(dev, i);
                /* zfiWlanDisable(dev); */
                /* zfiWlanEnable(dev); */
        }

        return 0;
}

int usbdrvwext_giwrate(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *frq, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if (macp->DeviceOpened != 1)
                return 0;

        frq->fixed = 0;
        frq->disabled = 0;
        frq->value = zfiWlanQueryRxRate(dev) * 1000;

        return 0;
}

int usbdrvwext_siwrts(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *rts, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        int val = rts->value;

        if (macp->DeviceOpened != 1)
                return 0;

        if (rts->disabled)
                val = 2347;

        if ((val < 0) || (val > 2347))
                return -EINVAL;

        zfiWlanSetRtsThreshold(dev, val);

        return 0;
}

int usbdrvwext_giwrts(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *rts, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if (macp->DeviceOpened != 1)
                return 0;

        rts->value = zfiWlanQueryRtsThreshold(dev);
        rts->disabled = (rts->value >= 2347);
        rts->fixed = 1;

        return 0;
}

int usbdrvwext_siwfrag(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *frag, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u16_t fragThreshold;

        if (macp->DeviceOpened != 1)
                return 0;

        if (frag->disabled)
                fragThreshold = 0;
        else
                fragThreshold = frag->value;

        zfiWlanSetFragThreshold(dev, fragThreshold);

        return 0;
}

int usbdrvwext_giwfrag(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *frag, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u16 val;
        unsigned long irqFlag;

        if (!netif_running(dev))
                return -EINVAL;

        if (macp->DeviceOpened != 1)
                return 0;

        spin_lock_irqsave(&macp->cs_lock, irqFlag);

        val = zfiWlanQueryFragThreshold(dev);

        frag->value = val;

        frag->disabled = (val >= 2346);
        frag->fixed = 1;

        spin_unlock_irqrestore(&macp->cs_lock, irqFlag);

        return 0;
}

int usbdrvwext_siwtxpow(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
        /* Not support yet--CWYng(+) */
        return 0;
}

int usbdrvwext_giwtxpow(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
        /* Not support yet--CWYng(+) */
        return 0;
}

int usbdrvwext_siwretry(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
        /* Do nothing--CWYang(+) */
        return 0;
}

int usbdrvwext_giwretry(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
        /* Do nothing--CWYang(+) */
        return 0;
}

int usbdrvwext_siwencode(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *erq, char *key)
{
        struct zsKeyInfo keyInfo;
        int i;
        int WepState = ZM_ENCRYPTION_WEP_DISABLED;
        struct usbdrv_private *macp = dev->ml_priv;

        if (!netif_running(dev))
                return -EINVAL;

        if ((erq->flags & IW_ENCODE_DISABLED) == 0) {
                keyInfo.key = key;
                keyInfo.keyLength = erq->length;
                keyInfo.keyIndex = (erq->flags & IW_ENCODE_INDEX) - 1;
                if (keyInfo.keyIndex >= 4)
                        keyInfo.keyIndex = 0;
                keyInfo.flag = ZM_KEY_FLAG_DEFAULT_KEY;

                zfiWlanSetKey(dev, keyInfo);
                WepState = ZM_ENCRYPTION_WEP_ENABLED;
        } else {
                for (i = 1; i < 4; i++)
                        zfiWlanRemoveKey(dev, 0, i);
                WepState = ZM_ENCRYPTION_WEP_DISABLED;
                /* zfiWlanSetEncryMode(dev, ZM_NO_WEP); */
        }

        if (macp->DeviceOpened == 1) {
                zfiWlanSetWepStatus(dev, WepState);
                zfiWlanSetFrequency(dev, zfiWlanQueryFrequency(dev), FALSE);
                /* zfiWlanSetEncryMode(dev, zfiWlanQueryEncryMode(dev)); */
                /* u8_t wpaieLen,wpaie[50]; */
                /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
                zfiWlanDisable(dev, 0);
                zfiWlanEnable(dev);
                /* if (wpaieLen > 2) */
                /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
        }

        return 0;
}

int usbdrvwext_giwencode(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_point *erq, char *key)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u8_t EncryptionMode;
        u8_t keyLen = 0;

        if (macp->DeviceOpened != 1)
                return 0;

        EncryptionMode = zfiWlanQueryEncryMode(dev);

        if (EncryptionMode)
                erq->flags = IW_ENCODE_ENABLED;
        else
                erq->flags = IW_ENCODE_DISABLED;

        /* We can't return the key, so set the proper flag and return zero */
        erq->flags |= IW_ENCODE_NOKEY;
        memset(key, 0, 16);

        /* Copy the key to the user buffer */
        switch (EncryptionMode) {
        case ZM_WEP64:
                keyLen = 5;
                break;
        case ZM_WEP128:
                keyLen = 13;
                break;
        case ZM_WEP256:
                keyLen = 29;
                break;
        case ZM_AES:
                keyLen = 16;
                break;
        case ZM_TKIP:
                keyLen = 32;
                break;
        #ifdef ZM_ENABLE_CENC
        case ZM_CENC:
                /* ZM_ENABLE_CENC */
                keyLen = 32;
                break;
        #endif
        case ZM_NO_WEP:
                keyLen = 0;
                break;
        default:
                keyLen = 0;
                printk(KERN_ERR "Unknown EncryMode\n");
                break;
        }
        erq->length = keyLen;

        return 0;
}

int usbdrvwext_siwpower(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *frq, char *extra)
{
        struct usbdrv_private *macp = dev->ml_priv;
        u8_t PSMode;

        if (macp->DeviceOpened != 1)
                return 0;

        if (frq->disabled)
                PSMode = ZM_STA_PS_NONE;
        else
                PSMode = ZM_STA_PS_MAX;

        zfiWlanSetPowerSaveMode(dev, PSMode);

        return 0;
}

int usbdrvwext_giwpower(struct net_device *dev,
                struct iw_request_info *info,
                struct iw_param *frq, char *extra)
{
        unsigned long irqFlag;
        struct usbdrv_private *macp = dev->ml_priv;

        if (macp->DeviceOpened != 1)
                return 0;

        spin_lock_irqsave(&macp->cs_lock, irqFlag);

        if (zfiWlanQueryPowerSaveMode(dev) == ZM_STA_PS_NONE)
                frq->disabled = 1;
        else
                frq->disabled = 0;

        spin_unlock_irqrestore(&macp->cs_lock, irqFlag);

        return 0;
}

/*int usbdrvwext_setparam(struct net_device *dev, struct iw_request_info *info,
*                        void *w, char *extra)
*{
*       struct ieee80211vap *vap = dev->ml_priv;
*       struct ieee80211com *ic = vap->iv_ic;
*       struct ieee80211_rsnparms *rsn = &vap->iv_bss->ni_rsn;
*       int *i = (int *) extra;
*       int param = i[0];               // parameter id is 1st
*       int value = i[1];               // NB: most values are TYPE_INT
*       int retv = 0;
*       int j, caps;
*       const struct ieee80211_authenticator *auth;
*       const struct ieee80211_aclator *acl;
*
*       switch (param) {
*       case IEEE80211_PARAM_AUTHMODE:
*               switch (value) {
*               case IEEE80211_AUTH_WPA:        // WPA
*               case IEEE80211_AUTH_8021X:      // 802.1x
*               case IEEE80211_AUTH_OPEN:       // open
*               case IEEE80211_AUTH_SHARED:     // shared-key
*               case IEEE80211_AUTH_AUTO:       // auto
*                       auth = ieee80211_authenticator_get(value);
*                       if (auth == NULL)
*                               return -EINVAL;
*                       break;
*               default:
*                       return -EINVAL;
*               }
*               switch (value) {
*               case IEEE80211_AUTH_WPA:        // WPA w/ 802.1x
*                       vap->iv_flags |= IEEE80211_F_PRIVACY;
*                       value = IEEE80211_AUTH_8021X;
*                       break;
*               case IEEE80211_AUTH_OPEN:       // open
*               vap->iv_flags &= ~(IEEE80211_F_WPA | IEEE80211_F_PRIVACY);
*                       break;
*               case IEEE80211_AUTH_SHARED:     // shared-key
*               case IEEE80211_AUTH_AUTO:       // auto
*               case IEEE80211_AUTH_8021X:      // 802.1x
*                       vap->iv_flags &= ~IEEE80211_F_WPA;
*                       // both require a key so mark the PRIVACY capability
*                       vap->iv_flags |= IEEE80211_F_PRIVACY;
*                       break;
*               }
*               // NB: authenticator attach/detach happens on state change
*               vap->iv_bss->ni_authmode = value;
*               // XXX mixed/mode/usage?
*               vap->iv_auth = auth;
*               retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_PROTMODE:
*               if (value > IEEE80211_PROT_RTSCTS)
*                       return -EINVAL;
*               ic->ic_protmode = value;
*               // NB: if not operating in 11g this can wait
*               if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
*                   IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan))
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_MCASTCIPHER:
*               if ((vap->iv_caps & cipher2cap(value)) == 0 &&
*                   !ieee80211_crypto_available(value))
*                       return -EINVAL;
*               rsn->rsn_mcastcipher = value;
*               if (vap->iv_flags & IEEE80211_F_WPA)
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_MCASTKEYLEN:
*               if (!(0 < value && value < IEEE80211_KEYBUF_SIZE))
*                       return -EINVAL;
*               // XXX no way to verify driver capability
*               rsn->rsn_mcastkeylen = value;
*               if (vap->iv_flags & IEEE80211_F_WPA)
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_UCASTCIPHERS:
*
*                // Convert cipher set to equivalent capabilities.
*                // NB: this logic intentionally ignores unknown and
*                // unsupported ciphers so folks can specify 0xff or
*                // similar and get all available ciphers.
*
*               caps = 0;
*               for (j = 1; j < 32; j++)        // NB: skip WEP
*                       if ((value & (1<<j)) &&
*                           ((vap->iv_caps & cipher2cap(j)) ||
*                            ieee80211_crypto_available(j)))
*                               caps |= 1<<j;
*               if (caps == 0)                  // nothing available
*                       return -EINVAL;
*               // XXX verify ciphers ok for unicast use?
*               // XXX disallow if running as it'll have no effect
*               rsn->rsn_ucastcipherset = caps;
*               if (vap->iv_flags & IEEE80211_F_WPA)
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_UCASTCIPHER:
*               if ((rsn->rsn_ucastcipherset & cipher2cap(value)) == 0)
*                       return -EINVAL;
*               rsn->rsn_ucastcipher = value;
*               break;
*       case IEEE80211_PARAM_UCASTKEYLEN:
*               if (!(0 < value && value < IEEE80211_KEYBUF_SIZE))
*                       return -EINVAL;
*               // XXX no way to verify driver capability
*               rsn->rsn_ucastkeylen = value;
*               break;
*       case IEEE80211_PARAM_KEYMGTALGS:
*               // XXX check
*               rsn->rsn_keymgmtset = value;
*               if (vap->iv_flags & IEEE80211_F_WPA)
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_RSNCAPS:
*               // XXX check
*               rsn->rsn_caps = value;
*               if (vap->iv_flags & IEEE80211_F_WPA)
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_WPA:
*               if (value > 3)
*                       return -EINVAL;
*               // XXX verify ciphers available
*               vap->iv_flags &= ~IEEE80211_F_WPA;
*               switch (value) {
*               case 1:
*                       vap->iv_flags |= IEEE80211_F_WPA1;
*                       break;
*               case 2:
*                       vap->iv_flags |= IEEE80211_F_WPA2;
*                       break;
*               case 3:
*                       vap->iv_flags |= IEEE80211_F_WPA1 | IEEE80211_F_WPA2;
*                       break;
*               }
*               retv = ENETRESET;               // XXX?
*               break;
*       case IEEE80211_PARAM_ROAMING:
*               if (!(IEEE80211_ROAMING_DEVICE <= value &&
*                   value <= IEEE80211_ROAMING_MANUAL))
*                       return -EINVAL;
*               ic->ic_roaming = value;
*               break;
*       case IEEE80211_PARAM_PRIVACY:
*               if (value) {
*                       // XXX check for key state?
*                       vap->iv_flags |= IEEE80211_F_PRIVACY;
*               } else
*                       vap->iv_flags &= ~IEEE80211_F_PRIVACY;
*               break;
*       case IEEE80211_PARAM_DROPUNENCRYPTED:
*               if (value)
*                       vap->iv_flags |= IEEE80211_F_DROPUNENC;
*               else
*                       vap->iv_flags &= ~IEEE80211_F_DROPUNENC;
*               break;
*       case IEEE80211_PARAM_COUNTERMEASURES:
*               if (value) {
*                       if ((vap->iv_flags & IEEE80211_F_WPA) == 0)
*                               return -EINVAL;
*                       vap->iv_flags |= IEEE80211_F_COUNTERM;
*               } else
*                       vap->iv_flags &= ~IEEE80211_F_COUNTERM;
*               break;
*       case IEEE80211_PARAM_DRIVER_CAPS:
*               vap->iv_caps = value;           // NB: for testing
*               break;
*       case IEEE80211_PARAM_MACCMD:
*               acl = vap->iv_acl;
*               switch (value) {
*               case IEEE80211_MACCMD_POLICY_OPEN:
*               case IEEE80211_MACCMD_POLICY_ALLOW:
*               case IEEE80211_MACCMD_POLICY_DENY:
*                       if (acl == NULL) {
*                               acl = ieee80211_aclator_get("mac");
*                               if (acl == NULL || !acl->iac_attach(vap))
*                                       return -EINVAL;
*                               vap->iv_acl = acl;
*                       }
*                       acl->iac_setpolicy(vap, value);
*                       break;
*               case IEEE80211_MACCMD_FLUSH:
*                       if (acl != NULL)
*                               acl->iac_flush(vap);
*                       // NB: silently ignore when not in use
*                       break;
*               case IEEE80211_MACCMD_DETACH:
*                       if (acl != NULL) {
*                               vap->iv_acl = NULL;
*                               acl->iac_detach(vap);
*                       }
*                       break;
*               }
*               break;
*       case IEEE80211_PARAM_WMM:
*               if (ic->ic_caps & IEEE80211_C_WME){
*                       if (value) {
*                               vap->iv_flags |= IEEE80211_F_WME;
*                                *//* XXX needed by ic_reset *//*
*                               vap->iv_ic->ic_flags |= IEEE80211_F_WME;
*                       }
*                       else {
*                               *//* XXX needed by ic_reset *//*
*                               vap->iv_flags &= ~IEEE80211_F_WME;
*                               vap->iv_ic->ic_flags &= ~IEEE80211_F_WME;
*                       }
*                       retv = ENETRESET;       // Renegotiate for capabilities
*               }
*               break;
*       case IEEE80211_PARAM_HIDESSID:
*               if (value)
*                       vap->iv_flags |= IEEE80211_F_HIDESSID;
*               else
*                       vap->iv_flags &= ~IEEE80211_F_HIDESSID;
*               retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_APBRIDGE:
*               if (value == 0)
*                       vap->iv_flags |= IEEE80211_F_NOBRIDGE;
*               else
*                       vap->iv_flags &= ~IEEE80211_F_NOBRIDGE;
*               break;
*       case IEEE80211_PARAM_INACT:
*               vap->iv_inact_run = value / IEEE80211_INACT_WAIT;
*               break;
*       case IEEE80211_PARAM_INACT_AUTH:
*               vap->iv_inact_auth = value / IEEE80211_INACT_WAIT;
*               break;
*       case IEEE80211_PARAM_INACT_INIT:
*               vap->iv_inact_init = value / IEEE80211_INACT_WAIT;
*               break;
*       case IEEE80211_PARAM_ABOLT:
*               caps = 0;
*
*                // Map abolt settings to capability bits;
*                // this also strips unknown/unwanted bits.
*
*               if (value & IEEE80211_ABOLT_TURBO_PRIME)
*                       caps |= IEEE80211_ATHC_TURBOP;
*               if (value & IEEE80211_ABOLT_COMPRESSION)
*                       caps |= IEEE80211_ATHC_COMP;
*               if (value & IEEE80211_ABOLT_FAST_FRAME)
*                       caps |= IEEE80211_ATHC_FF;
*               if (value & IEEE80211_ABOLT_XR)
*                       caps |= IEEE80211_ATHC_XR;
*               if (value & IEEE80211_ABOLT_AR)
*                       caps |= IEEE80211_ATHC_AR;
*               if (value & IEEE80211_ABOLT_BURST)
*                       caps |= IEEE80211_ATHC_BURST;
*        if (value & IEEE80211_ABOLT_WME_ELE)
*            caps |= IEEE80211_ATHC_WME;
*               // verify requested capabilities are supported
*               if ((caps & ic->ic_ath_cap) != caps)
*                       return -EINVAL;
*               if (vap->iv_ath_cap != caps) {
*                       if ((vap->iv_ath_cap ^ caps) & IEEE80211_ATHC_TURBOP) {
*                               if (ieee80211_set_turbo(dev,
*                                               caps & IEEE80211_ATHC_TURBOP))
*                                       return -EINVAL;
*                               ieee80211_scan_flush(ic);
*                       }
*                       vap->iv_ath_cap = caps;
*                       ic->ic_athcapsetup(vap->iv_ic, vap->iv_ath_cap);
*                       retv = ENETRESET;
*               }
*               break;
*       case IEEE80211_PARAM_DTIM_PERIOD:
*               if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
*                   vap->iv_opmode != IEEE80211_M_IBSS)
*                       return -EINVAL;
*               if (IEEE80211_DTIM_MIN <= value &&
*                   value <= IEEE80211_DTIM_MAX) {
*                       vap->iv_dtim_period = value;
*                       retv = ENETRESET;               // requires restart
*               } else
*                       retv = EINVAL;
*               break;
*       case IEEE80211_PARAM_BEACON_INTERVAL:
*               if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
*                   vap->iv_opmode != IEEE80211_M_IBSS)
*                       return -EINVAL;
*               if (IEEE80211_BINTVAL_MIN <= value &&
*                   value <= IEEE80211_BINTVAL_MAX) {
*                       ic->ic_lintval = value;         // XXX multi-bss
*                       retv = ENETRESET;               // requires restart
*               } else
*                       retv = EINVAL;
*               break;
*       case IEEE80211_PARAM_DOTH:
*               if (value) {
*                       ic->ic_flags |= IEEE80211_F_DOTH;
*               }
*               else
*                       ic->ic_flags &= ~IEEE80211_F_DOTH;
*               retv = ENETRESET;       // XXX: need something this drastic?
*               break;
*       case IEEE80211_PARAM_PWRTARGET:
*               ic->ic_curchanmaxpwr = value;
*               break;
*       case IEEE80211_PARAM_GENREASSOC:
*               IEEE80211_SEND_MGMT(vap->iv_bss,
*                                       IEEE80211_FC0_SUBTYPE_REASSOC_REQ, 0);
*               break;
*       case IEEE80211_PARAM_COMPRESSION:
*               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_COMP, value);
*               break;
*    case IEEE80211_PARAM_WMM_AGGRMODE:
*        retv = ieee80211_setathcap(vap, IEEE80211_ATHC_WME, value);
*        break;
*       case IEEE80211_PARAM_FF:
*               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_FF, value);
*               break;
*       case IEEE80211_PARAM_TURBO:
*               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_TURBOP, value);
*               if (retv == ENETRESET) {
*                       if(ieee80211_set_turbo(dev,value))
*                                       return -EINVAL;
*                       ieee80211_scan_flush(ic);
*               }
*               break;
*       case IEEE80211_PARAM_XR:
*               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_XR, value);
*               break;
*       case IEEE80211_PARAM_BURST:
*               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_BURST, value);
*               break;
*       case IEEE80211_PARAM_AR:
*               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_AR, value);
*               break;
*       case IEEE80211_PARAM_PUREG:
*               if (value)
*                       vap->iv_flags |= IEEE80211_F_PUREG;
*               else
*                       vap->iv_flags &= ~IEEE80211_F_PUREG;
*               // NB: reset only if we're operating on an 11g channel
*               if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
*                   IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan))
*                       retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_WDS:
*               if (value)
*                       vap->iv_flags_ext |= IEEE80211_FEXT_WDS;
*               else
*                       vap->iv_flags_ext &= ~IEEE80211_FEXT_WDS;
*               break;
*       case IEEE80211_PARAM_BGSCAN:
*               if (value) {
*                       if ((vap->iv_caps & IEEE80211_C_BGSCAN) == 0)
*                               return -EINVAL;
*                       vap->iv_flags |= IEEE80211_F_BGSCAN;
*               } else {
*                       // XXX racey?
*                       vap->iv_flags &= ~IEEE80211_F_BGSCAN;
*                       ieee80211_cancel_scan(vap);     // anything current
*               }
*               break;
*       case IEEE80211_PARAM_BGSCAN_IDLE:
*               if (value >= IEEE80211_BGSCAN_IDLE_MIN)
*                       vap->iv_bgscanidle = value*HZ/1000;
*               else
*                       retv = EINVAL;
*               break;
*       case IEEE80211_PARAM_BGSCAN_INTERVAL:
*               if (value >= IEEE80211_BGSCAN_INTVAL_MIN)
*                       vap->iv_bgscanintvl = value*HZ;
*               else
*                       retv = EINVAL;
*               break;
*       case IEEE80211_PARAM_MCAST_RATE:
*               // units are in KILObits per second
*               if (value >= 256 && value <= 54000)
*                       vap->iv_mcast_rate = value;
*               else
*                       retv = EINVAL;
*               break;
*       case IEEE80211_PARAM_COVERAGE_CLASS:
*               if (value >= 0 && value <= IEEE80211_COVERAGE_CLASS_MAX) {
*                       ic->ic_coverageclass = value;
*                       if (IS_UP_AUTO(vap))
*                               ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
*                       retv = 0;
*               }
*               else
*                       retv = EINVAL;
*               break;
*       case IEEE80211_PARAM_COUNTRY_IE:
*               if (value)
*                       ic->ic_flags_ext |= IEEE80211_FEXT_COUNTRYIE;
*               else
*                       ic->ic_flags_ext &= ~IEEE80211_FEXT_COUNTRYIE;
*               retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_REGCLASS:
*               if (value)
*                       ic->ic_flags_ext |= IEEE80211_FEXT_REGCLASS;
*               else
*                       ic->ic_flags_ext &= ~IEEE80211_FEXT_REGCLASS;
*               retv = ENETRESET;
*               break;
*       case IEEE80211_PARAM_SCANVALID:
*               vap->iv_scanvalid = value*HZ;
*               break;
*       case IEEE80211_PARAM_ROAM_RSSI_11A:
*               vap->iv_roam.rssi11a = value;
*               break;
*       case IEEE80211_PARAM_ROAM_RSSI_11B:
*               vap->iv_roam.rssi11bOnly = value;
*               break;
*       case IEEE80211_PARAM_ROAM_RSSI_11G:
*               vap->iv_roam.rssi11b = value;
*               break;
*       case IEEE80211_PARAM_ROAM_RATE_11A:
*               vap->iv_roam.rate11a = value;
*               break;
*       case IEEE80211_PARAM_ROAM_RATE_11B:
*               vap->iv_roam.rate11bOnly = value;
*               break;
*       case IEEE80211_PARAM_ROAM_RATE_11G:
*               vap->iv_roam.rate11b = value;
*               break;
*       case IEEE80211_PARAM_UAPSDINFO:
*               if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
*                       if (ic->ic_caps & IEEE80211_C_UAPSD) {
*                               if (value)
*                                       IEEE80211_VAP_UAPSD_ENABLE(vap);
*                               else
*                                       IEEE80211_VAP_UAPSD_DISABLE(vap);
*                               retv = ENETRESET;
*                       }
*               }
*               else if (vap->iv_opmode == IEEE80211_M_STA) {
*                       vap->iv_uapsdinfo = value;
*                       IEEE80211_VAP_UAPSD_ENABLE(vap);
*                       retv = ENETRESET;
*               }
*               break;
*       case IEEE80211_PARAM_SLEEP:
*               // XXX: Forced sleep for testing. Does not actually place the
*               //      HW in sleep mode yet. this only makes sense for STAs.
*
*               if (value) {
*                       // goto sleep
*                       IEEE80211_VAP_GOTOSLEEP(vap);
*               }
*               else {
*                       // wakeup
*                       IEEE80211_VAP_WAKEUP(vap);
*               }
*               ieee80211_send_nulldata(ieee80211_ref_node(vap->iv_bss));
*               break;
*       case IEEE80211_PARAM_QOSNULL:
*               // Force a QoS Null for testing.
*               ieee80211_send_qosnulldata(vap->iv_bss, value);
*               break;
*       case IEEE80211_PARAM_PSPOLL:
*               // Force a PS-POLL for testing.
*               ieee80211_send_pspoll(vap->iv_bss);
*               break;
*       case IEEE80211_PARAM_EOSPDROP:
*               if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
*                       if (value) IEEE80211_VAP_EOSPDROP_ENABLE(vap);
*                       else IEEE80211_VAP_EOSPDROP_DISABLE(vap);
*               }
*               break;
*       case IEEE80211_PARAM_MARKDFS:
*               if (value)
*                       ic->ic_flags_ext |= IEEE80211_FEXT_MARKDFS;
*               else
*                       ic->ic_flags_ext &= ~IEEE80211_FEXT_MARKDFS;
*               break;
*       case IEEE80211_PARAM_CHANBW:
*               switch (value) {
*                       case 0:
*                               ic->ic_chanbwflag = 0;
*                               break;
*                       case 1:
*                               ic->ic_chanbwflag = IEEE80211_CHAN_HALF;
*                               break;
*                       case 2:
*                               ic->ic_chanbwflag = IEEE80211_CHAN_QUARTER;
*                               break;
*                       default:
*                               retv = EINVAL;
*                               break;
*               }
*               break;
*       case IEEE80211_PARAM_SHORTPREAMBLE:
*               if (value) {
*                       ic->ic_caps |= IEEE80211_C_SHPREAMBLE;
*               } else {
*                       ic->ic_caps &= ~IEEE80211_C_SHPREAMBLE;
*               }
*               retv = ENETRESET;
*               break;
*       default:
*               retv = EOPNOTSUPP;
*               break;
*       }
*       // XXX should any of these cause a rescan?
*       if (retv == ENETRESET)
*               retv = IS_UP_AUTO(vap) ? ieee80211_open(vap->iv_dev) : 0;
*       return -retv;
*}
*/

int usbdrvwext_setmode(struct net_device *dev, struct iw_request_info *info,
                        void *w, char *extra)
{
        return 0;
}

int usbdrvwext_getmode(struct net_device *dev, struct iw_request_info *info,
                        void *w, char *extra)
{
        /* struct usbdrv_private *macp = dev->ml_priv; */
        struct iw_point *wri = (struct iw_point *)extra;
        char mode[8];

        strcpy(mode, "11g");
        return copy_to_user(wri->pointer, mode, 6) ? -EFAULT : 0;
}

int zfLnxPrivateIoctl(struct net_device *dev, struct zdap_ioctl* zdreq)
{
        /* void* regp = macp->regp; */
        u16_t cmd;
        /* u32_t temp; */
        u32_t *p;
        u32_t i;

        cmd = zdreq->cmd;
        switch (cmd) {
        case ZM_IOCTL_REG_READ:
                zfiDbgReadReg(dev, zdreq->addr);
                break;
        case ZM_IOCTL_REG_WRITE:
                zfiDbgWriteReg(dev, zdreq->addr, zdreq->value);
                break;
        case ZM_IOCTL_MEM_READ:
                p = (u32_t *) bus_to_virt(zdreq->addr);
                printk(KERN_WARNING
                                "usbdrv: read memory addr: 0x%08x value:"
                                " 0x%08x\n", zdreq->addr, *p);
                break;
        case ZM_IOCTL_MEM_WRITE:
                p = (u32_t *) bus_to_virt(zdreq->addr);
                *p = zdreq->value;
                printk(KERN_WARNING
                        "usbdrv : write value : 0x%08x to memory addr :"
                        " 0x%08x\n", zdreq->value, zdreq->addr);
                break;
        case ZM_IOCTL_TALLY:
                zfiWlanShowTally(dev);
                if (zdreq->addr)
                        zfiWlanResetTally(dev);
                break;
        case ZM_IOCTL_TEST:
                printk(KERN_WARNING
                                "ZM_IOCTL_TEST:len=%d\n", zdreq->addr);
                /* zfiWlanReadReg(dev, 0x10f400); */
                /* zfiWlanReadReg(dev, 0x10f404); */
                printk(KERN_WARNING "IOCTL TEST\n");
                #if 1
                /* print packet */
                for (i = 0; i < zdreq->addr; i++) {
                        if ((i&0x7) == 0)
                                printk(KERN_WARNING "\n");
                        printk(KERN_WARNING "%02X ",
                                        (unsigned char)zdreq->data[i]);
                }
                printk(KERN_WARNING "\n");
                #endif

                /* For Test?? 1 to 0 by CWYang(-) */
                #if 0
                        struct sk_buff *s;

                        /* Allocate a skb */
                        s = alloc_skb(2000, GFP_ATOMIC);

                        /* Copy data to skb */
                        for (i = 0; i < zdreq->addr; i++)
                                s->data[i] = zdreq->data[i];
                        s->len = zdreq->addr;

                        /* Call zfIdlRecv() */
                        zfiRecv80211(dev, s, NULL);
                #endif
                break;
        /************************* ZDCONFIG ***************************/
        case ZM_IOCTL_FRAG:
                zfiWlanSetFragThreshold(dev, zdreq->addr);
                break;
        case ZM_IOCTL_RTS:
                zfiWlanSetRtsThreshold(dev, zdreq->addr);
                break;
        case ZM_IOCTL_SCAN:
                zfiWlanScan(dev);
                break;
        case ZM_IOCTL_KEY: {
                u8_t key[29];
                struct zsKeyInfo keyInfo;
                u32_t i;

                for (i = 0; i < 29; i++)
                        key[i] = 0;

                for (i = 0; i < zdreq->addr; i++)
                        key[i] = zdreq->data[i];

                printk(KERN_WARNING
                        "key len=%d, key=%02x%02x%02x%02x%02x...\n",
                        zdreq->addr, key[0], key[1], key[2], key[3], key[4]);

                keyInfo.keyLength = zdreq->addr;
                keyInfo.keyIndex = 0;
                keyInfo.flag = 0;
                keyInfo.key = key;
                zfiWlanSetKey(dev, keyInfo);
        }
                break;
        case ZM_IOCTL_RATE:
                zfiWlanSetTxRate(dev, zdreq->addr);
                break;
        case ZM_IOCTL_ENCRYPTION_MODE:
                zfiWlanSetEncryMode(dev, zdreq->addr);

                zfiWlanDisable(dev, 0);
                zfiWlanEnable(dev);
                break;
                /* CWYang(+) */
        case ZM_IOCTL_SIGNAL_STRENGTH: {
                u8_t buffer[2];
                zfiWlanQuerySignalInfo(dev, &buffer[0]);
                printk(KERN_WARNING
                        "Current Signal Strength : %02d\n", buffer[0]);
        }
                break;
                /* CWYang(+) */
        case ZM_IOCTL_SIGNAL_QUALITY: {
                u8_t buffer[2];

                zfiWlanQuerySignalInfo(dev, &buffer[0]);
                printk(KERN_WARNING
                        "Current Signal Quality : %02d\n", buffer[1]);
        }
                break;
        case ZM_IOCTL_SET_PIBSS_MODE:
                if (zdreq->addr == 1)
                        zfiWlanSetWlanMode(dev, ZM_MODE_PSEUDO);
                else
                        zfiWlanSetWlanMode(dev, ZM_MODE_INFRASTRUCTURE);

                zfiWlanDisable(dev, 0);
                zfiWlanEnable(dev);
                break;
        /********************* ZDCONFIG ***********************/
        default:
                printk(KERN_ERR "usbdrv: error command = %x\n", cmd);
                break;
        }

        return 0;
}

int usbdrv_wpa_ioctl(struct net_device *dev, struct athr_wlan_param *zdparm)
{
        int ret = 0;
        u8_t bc_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
        u8_t mac_addr[80];
        struct zsKeyInfo keyInfo;
        struct usbdrv_private *macp = dev->ml_priv;
        u16_t vapId = 0;
        int ii;

        /* zmw_get_wlan_dev(dev); */

        switch (zdparm->cmd) {
        case ZD_CMD_SET_ENCRYPT_KEY:
                /* Set up key information */
                keyInfo.keyLength = zdparm->u.crypt.key_len;
                keyInfo.keyIndex = zdparm->u.crypt.idx;
                if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
                        /* AP Mode */
                        keyInfo.flag = ZM_KEY_FLAG_AUTHENTICATOR;
                } else
                        keyInfo.flag = 0;
                keyInfo.key = zdparm->u.crypt.key;
                keyInfo.initIv = zdparm->u.crypt.seq;
                keyInfo.macAddr = (u16_t *)zdparm->sta_addr;

                /* Identify the MAC address information */
                if (memcmp(zdparm->sta_addr, bc_addr, sizeof(bc_addr)) == 0)
                        keyInfo.flag |= ZM_KEY_FLAG_GK;
                else
                        keyInfo.flag |= ZM_KEY_FLAG_PK;

                if (!strcmp(zdparm->u.crypt.alg, "NONE")) {
                        /* u8_t zero_mac[]={0,0,0,0,0,0}; */

                        /* Set key length to zero */
                        keyInfo.keyLength = 0;

                        /* del group key */
                        if (zdparm->sta_addr[0] & 1) {
                                /* if (macp->cardSetting.WPAIeLen==0)
                                * { 802.1x dynamic WEP
                                *    mDynKeyMode = 0;
                                *    mKeyFormat[0] = 0;
                                *    mPrivacyInvoked[0]=FALSE;
                                *    mCap[0] &= ~CAP_PRIVACY;
                                *    macp->cardSetting.EncryOnOff[0]=0;
                                * }
                                * mWpaBcKeyLen = mGkInstalled = 0;
                                */
                        } else {
                                /* if (memcmp(zero_mac,zdparm->sta_addr, 6)==0)
                                * {
                                *     mDynKeyMode=0;
                                *    mKeyFormat[0]=0;
                                *    pSetting->DynKeyMode=0;
                                *    pSetting->EncryMode[0]=0;
                                *    mDynKeyMode=0;
                                * }
                                */
                        }

                        printk(KERN_ERR "Set Encryption Type NONE\n");
                        return ret;
                } else if (!strcmp(zdparm->u.crypt.alg, "TKIP")) {
                        zfiWlanSetEncryMode(dev, ZM_TKIP);
                        /* //Linux Supplicant will inverse Tx/Rx key
                        * //So we inverse it back, CWYang(+)
                        * zfMemoryCopy(&temp[0], &keyInfo.key[16], 8);
                        * zfMemoryCopy(&keyInfo.key[16], keyInfo.key[24], 8);
                        * zfMemoryCopy(&keyInfo.key[24], &temp[0], 8);
                        * u8_t temp;
                        * int k;
                        * for (k = 0; k < 8; k++)
                        * {
                        *     temp = keyInfo.key[16 + k];
                        *     keyInfo.key[16 + k] = keyInfo.key[24 + k];
                        *     keyInfo.key[24 + k] = temp;
                        * }
                        * CamEncryType = ZM_TKIP;
                        * if (idx == 0)
                        * {   // Pairwise key
                        *     mKeyFormat[0] = CamEncryType;
                        *     mDynKeyMode = pSetting->DynKeyMode = DYN_KEY_TKIP;
                        * }
                        */
                } else if (!strcmp(zdparm->u.crypt.alg, "CCMP")) {
                        zfiWlanSetEncryMode(dev, ZM_AES);
                        /* CamEncryType = ZM_AES;
                        * if (idx == 0)
                        * {  // Pairwise key
                        *    mKeyFormat[0] = CamEncryType;
                        *    mDynKeyMode = pSetting->DynKeyMode = DYN_KEY_AES;
                        * }
                        */
                } else if (!strcmp(zdparm->u.crypt.alg, "WEP")) {
                        if (keyInfo.keyLength == 5) {
                                /* WEP 64 */
                                zfiWlanSetEncryMode(dev, ZM_WEP64);
                                /* CamEncryType = ZM_WEP64; */
                                /* tmpDynKeyMode=DYN_KEY_WEP64; */
                        } else if (keyInfo.keyLength == 13) {
                                /* keylen=13, WEP 128 */
                                zfiWlanSetEncryMode(dev, ZM_WEP128);
                                /* CamEncryType = ZM_WEP128; */
                                /* tmpDynKeyMode=DYN_KEY_WEP128; */
                        } else {
                                zfiWlanSetEncryMode(dev, ZM_WEP256);
                        }

        /* For Dynamic WEP key (Non-WPA Radius), the key ID range: 0-3
        * In WPA/RSN mode, the key ID range: 1-3, usually, a broadcast key.
        * For WEP key setting: we set mDynKeyMode and mKeyFormat in following
        * case:
        *   1. For 802.1x dynamically generated WEP key method.
        *   2. For WPA/RSN mode, but key id == 0.
        *       (But this is an impossible case)
        * So, only check case 1.
        * if (macp->cardSetting.WPAIeLen==0)
        * {
        *    mKeyFormat[0] = CamEncryType;
        *    mDynKeyMode = pSetting->DynKeyMode = tmpDynKeyMode;
        *    mPrivacyInvoked[0]=TRUE;
        *    mCap[0] |= CAP_PRIVACY;
        *    macp->cardSetting.EncryOnOff[0]=1;
        * }
        */
                }

                /* DUMP key context */
                /* #ifdef WPA_DEBUG */
                if (keyInfo.keyLength > 0) {
                        printk(KERN_WARNING
                                                "Otus: Key Context:\n");
                        for (ii = 0; ii < keyInfo.keyLength; ) {
                                printk(KERN_WARNING
                                                "0x%02x ", keyInfo.key[ii]);
                                if ((++ii % 16) == 0)
                                        printk(KERN_WARNING "\n");
                        }
                        printk(KERN_WARNING "\n");
                }
                /* #endif */

                /* Set encrypt mode */
                /* zfiWlanSetEncryMode(dev, CamEncryType); */
                vapId = zfLnxGetVapId(dev);
                if (vapId == 0xffff)
                        keyInfo.vapId = 0;
                else
                        keyInfo.vapId = vapId + 1;
                keyInfo.vapAddr[0] = keyInfo.macAddr[0];
                keyInfo.vapAddr[1] = keyInfo.macAddr[1];
                keyInfo.vapAddr[2] = keyInfo.macAddr[2];

                zfiWlanSetKey(dev, keyInfo);

                /* zfiWlanDisable(dev); */
                /* zfiWlanEnable(dev); */
                break;
        case ZD_CMD_SET_MLME:
                printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SET_MLME\n");

                /* Translate STA's address */
                sprintf(mac_addr, "%02x:%02x:%02x:%02x:%02x:%02x",
                        zdparm->sta_addr[0], zdparm->sta_addr[1],
                        zdparm->sta_addr[2], zdparm->sta_addr[3],
                        zdparm->sta_addr[4], zdparm->sta_addr[5]);

                switch (zdparm->u.mlme.cmd) {
                case MLME_STA_DEAUTH:
                        printk(KERN_WARNING
                                " -------Call zfiWlanDeauth, reason:%d\n",
                                zdparm->u.mlme.reason_code);
                        if (zfiWlanDeauth(dev, (u16_t *) zdparm->sta_addr,
                                zdparm->u.mlme.reason_code) != 0)
                                printk(KERN_ERR "Can't deauthencate STA: %s\n",
                                        mac_addr);
                        else
                                printk(KERN_ERR "Deauthenticate STA: %s"
                                        "with reason code: %d\n",
                                        mac_addr, zdparm->u.mlme.reason_code);
                        break;
                case MLME_STA_DISASSOC:
                        printk(KERN_WARNING
                                " -------Call zfiWlanDeauth, reason:%d\n",
                                zdparm->u.mlme.reason_code);
                        if (zfiWlanDeauth(dev, (u16_t *) zdparm->sta_addr,
                                zdparm->u.mlme.reason_code) != 0)
                                printk(KERN_ERR "Can't disassociate STA: %s\n",
                                        mac_addr);
                        else
                                printk(KERN_ERR "Disassociate STA: %s"
                                        "with reason code: %d\n",
                                        mac_addr, zdparm->u.mlme.reason_code);
                        break;
                default:
                        printk(KERN_ERR "MLME command: 0x%04x not support\n",
                                zdparm->u.mlme.cmd);
                        break;
                }

                break;
        case ZD_CMD_SCAN_REQ:
                printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SCAN_REQ\n");
                break;
        case ZD_CMD_SET_GENERIC_ELEMENT:
                printk(KERN_ERR "usbdrv_wpa_ioctl:"
                                        " ZD_CMD_SET_GENERIC_ELEMENT\n");

                /* Copy the WPA IE
                * zm_msg1_mm(ZM_LV_0, "CWY - wpaie Length : ",
                * zdparm->u.generic_elem.len);
                */
                printk(KERN_ERR "wpaie Length : % d\n",
                                                zdparm->u.generic_elem.len);
                if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
                        /* AP Mode */
                        zfiWlanSetWpaIe(dev, zdparm->u.generic_elem.data,
                                        zdparm->u.generic_elem.len);
                } else {
                        macp->supLen = zdparm->u.generic_elem.len;
                        memcpy(macp->supIe, zdparm->u.generic_elem.data,
                                zdparm->u.generic_elem.len);
                }
                zfiWlanSetWpaSupport(dev, 1);
                /* zfiWlanSetWpaIe(dev, zdparm->u.generic_elem.data,
                * zdparm->u.generic_elem.len);
                */
                u8_t len = zdparm->u.generic_elem.len;
                u8_t *wpaie = (u8_t *)zdparm->u.generic_elem.data;

                printk(KERN_ERR "wd->ap.wpaLen : % d\n", len);

                /* DUMP WPA IE */
                for(ii = 0; ii < len;) {
                        printk(KERN_ERR "0x%02x ", wpaie[ii]);

                        if((++ii % 16) == 0)
                                printk(KERN_ERR "\n");
                }
                printk(KERN_ERR "\n");

                /* #ifdef ZM_HOSTAPD_SUPPORT
                * if (wd->wlanMode == ZM_MODE_AP)
                * {// Update Beacon FIFO in the next TBTT.
                *     memcpy(&mWPAIe, pSetting->WPAIe, pSetting->WPAIeLen);
                *     printk(KERN_ERR "Copy WPA IE into mWPAIe\n");
                * }
                * #endif
                */
                break;

        /* #ifdef ZM_HOSTAPD_SUPPORT */
        case ZD_CMD_GET_TSC:
                printk(KERN_ERR "usbdrv_wpa_ioctl : ZD_CMD_GET_TSC\n");
                break;
        /* #endif */

        default:
                printk(KERN_ERR "usbdrv_wpa_ioctl default : 0x%04x\n",
                        zdparm->cmd);
                ret = -EINVAL;
                break;
        }

        return ret;
}

#ifdef ZM_ENABLE_CENC
int usbdrv_cenc_ioctl(struct net_device *dev, struct zydas_cenc_param *zdparm)
{
        /* struct usbdrv_private *macp = dev->ml_priv; */
        struct zsKeyInfo keyInfo;
        u16_t apId;
        u8_t bc_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
        int ret = 0;
        int ii;

        /* Get the AP Id */
        apId = zfLnxGetVapId(dev);

        if (apId == 0xffff) {
                apId = 0;
        } else {
                apId = apId + 1;
        }

        switch (zdparm->cmd) {
        case ZM_CMD_CENC_SETCENC:
                printk(KERN_ERR "ZM_CMD_CENC_SETCENC\n");
                printk(KERN_ERR "length : % d\n", zdparm->len);
                printk(KERN_ERR "policy : % d\n", zdparm->u.info.cenc_policy);
                break;
        case ZM_CMD_CENC_SETKEY:
                /* ret = wai_ioctl_setkey(vap, ioctl_msg); */
                printk(KERN_ERR "ZM_CMD_CENC_SETKEY\n");

                printk(KERN_ERR "MAC address = ");
                for (ii = 0; ii < 6; ii++) {
                        printk(KERN_ERR "0x%02x ",
                                zdparm->u.crypt.sta_addr[ii]);
                }
                printk(KERN_ERR "\n");

                printk(KERN_ERR "Key Index : % d\n", zdparm->u.crypt.keyid);
                printk(KERN_ERR "Encryption key = ");
                for (ii = 0; ii < 16; ii++) {
                        printk(KERN_ERR "0x%02x ", zdparm->u.crypt.key[ii]);
                }
                printk(KERN_ERR "\n");

                printk(KERN_ERR "MIC key = ");
                for(ii = 16; ii < ZM_CENC_KEY_SIZE; ii++) {
                        printk(KERN_ERR "0x%02x ", zdparm->u.crypt.key[ii]);
                }
                printk(KERN_ERR "\n");

                /* Set up key information */
                keyInfo.keyLength = ZM_CENC_KEY_SIZE;
                keyInfo.keyIndex = zdparm->u.crypt.keyid;
                keyInfo.flag = ZM_KEY_FLAG_AUTHENTICATOR | ZM_KEY_FLAG_CENC;
                keyInfo.key = zdparm->u.crypt.key;
                keyInfo.macAddr = (u16_t *)zdparm->u.crypt.sta_addr;

                /* Identify the MAC address information */
                if (memcmp(zdparm->u.crypt.sta_addr, bc_addr,
                                sizeof(bc_addr)) == 0) {
                        keyInfo.flag |= ZM_KEY_FLAG_GK;
                        keyInfo.vapId = apId;
                        memcpy(keyInfo.vapAddr, dev->dev_addr, ETH_ALEN);
                } else {
                        keyInfo.flag |= ZM_KEY_FLAG_PK;
                }

                zfiWlanSetKey(dev, keyInfo);

                break;
        case ZM_CMD_CENC_REKEY:
                /* ret = wai_ioctl_rekey(vap, ioctl_msg); */
                printk(KERN_ERR "ZM_CMD_CENC_REKEY\n");
                break;
        default:
                ret = -EOPNOTSUPP;
                break;
        }

        /* if (retv == ENETRESET) */
        /* retv = IS_UP_AUTO(vap) ? ieee80211_open(vap->iv_dev) : 0; */

        return ret;
}
#endif /* ZM_ENABLE_CENC */

int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
        /* struct usbdrv_private *macp; */
        /* void *regp; */
        struct zdap_ioctl zdreq;
        struct iwreq *wrq = (struct iwreq *)ifr;
        struct athr_wlan_param zdparm;
        struct usbdrv_private *macp = dev->ml_priv;

        int err = 0, val = 0;
        int changed = 0;

        /* regp = macp->regp; */

        if (!netif_running(dev))
                return -EINVAL;

        switch (cmd) {
        case SIOCGIWNAME:
                strcpy(wrq->u.name, "IEEE 802.11-DS");
                break;
        case SIOCGIWAP:
                err = usbdrvwext_giwap(dev, NULL, &wrq->u.ap_addr, NULL);
                break;
        case SIOCSIWAP:
                err = usbdrvwext_siwap(dev, NULL, &wrq->u.ap_addr, NULL);
                break;
        case SIOCGIWMODE:
                err = usbdrvwext_giwmode(dev, NULL, &wrq->u.mode, NULL);
                break;
        case SIOCSIWESSID:
                printk(KERN_ERR "CWY - usbdrvwext_siwessid\n");
                /* err = usbdrv_ioctl_setessid(dev, &wrq->u.essid); */
                err = usbdrvwext_siwessid(dev, NULL, &wrq->u.essid, NULL);

                if (!err)
                        changed = 1;
                break;
        case SIOCGIWESSID:
                err = usbdrvwext_giwessid(dev, NULL, &wrq->u.essid, NULL);
                break;
        case SIOCSIWRTS:
                err = usbdrv_ioctl_setrts(dev, &wrq->u.rts);
                if (! err)
                        changed = 1;
                break;
        /* set_auth */
        case SIOCIWFIRSTPRIV + 0x2: {
                /* printk("CWY - SIOCIWFIRSTPRIV + 0x2(set_auth)\n"); */
                if (!capable(CAP_NET_ADMIN)) {
                        err = -EPERM;
                        break;
                }
                val = *((int *) wrq->u.name);
                if ((val < 0) || (val > 2)) {
                        err = -EINVAL;
                        break;
                } else {
                        zfiWlanSetAuthenticationMode(dev, val);

                        if (macp->DeviceOpened == 1) {
                                zfiWlanDisable(dev, 0);
                                zfiWlanEnable(dev);
                        }

                        err = 0;
                        changed = 1;
                }
        }
                break;
        /* get_auth */
        case SIOCIWFIRSTPRIV + 0x3: {
                int AuthMode = ZM_AUTH_MODE_OPEN;

                /* printk("CWY - SIOCIWFIRSTPRIV + 0x3(get_auth)\n"); */

                if (wrq->u.data.pointer) {
                        wrq->u.data.flags = 1;

                        AuthMode = zfiWlanQueryAuthenticationMode(dev, 0);
                        if (AuthMode == ZM_AUTH_MODE_OPEN) {
                                wrq->u.data.length = 12;

                                if (copy_to_user(wrq->u.data.pointer,
                                        "open system", 12)) {
                                                return -EFAULT;
                                }
                        } else if (AuthMode == ZM_AUTH_MODE_SHARED_KEY) {
                                wrq->u.data.length = 11;

                                if (copy_to_user(wrq->u.data.pointer,
                                        "shared key", 11)) {
                                                        return -EFAULT;
                                }
                        } else if (AuthMode == ZM_AUTH_MODE_AUTO) {
                                wrq->u.data.length = 10;

                                if (copy_to_user(wrq->u.data.pointer,
                                        "auto mode", 10)) {
                                                        return -EFAULT;
                                }
                        } else {
                                return -EFAULT;
                        }
                }
        }
                break;
        /* debug command */
        case ZDAPIOCTL:
                if (copy_from_user(&zdreq, ifr->ifr_data, sizeof(zdreq))) {
                        printk(KERN_ERR "usbdrv : copy_from_user error\n");
                        return -EFAULT;
                }

                /* printk(KERN_WARNING
                * "usbdrv : cmd = % 2x, reg = 0x%04lx,
                *value = 0x%08lx\n",
                * zdreq.cmd, zdreq.addr, zdreq.value);
                */
                zfLnxPrivateIoctl(dev, &zdreq);

                err = 0;
                break;
        case ZD_IOCTL_WPA:
                if (copy_from_user(&zdparm, ifr->ifr_data,
                        sizeof(struct athr_wlan_param))) {
                        printk(KERN_ERR "usbdrv : copy_from_user error\n");
                        return -EFAULT;
                }

                usbdrv_wpa_ioctl(dev, &zdparm);
                err = 0;
                break;
        case ZD_IOCTL_PARAM: {
                int *p;
                int op;
                int arg;

                /* Point to the name field and retrieve the
                * op and arg elements.
                */
                p = (int *)wrq->u.name;
                op = *p++;
                arg = *p;

                if (op == ZD_PARAM_ROAMING) {
                        printk(KERN_ERR
                        "*************ZD_PARAM_ROAMING : % d\n", arg);
                        /* macp->cardSetting.ap_scan=(U8)arg; */
                }
                if (op == ZD_PARAM_PRIVACY) {
                        printk(KERN_ERR "ZD_IOCTL_PRIVACY : ");

                        /* Turn on the privacy invoke flag */
                        if (arg) {
                                /* mCap[0] |= CAP_PRIVACY; */
                                /* macp->cardSetting.EncryOnOff[0] = 1; */
                                printk(KERN_ERR "enable\n");

                        } else {
                                /* mCap[0] &= ~CAP_PRIVACY; */
                                /* macp->cardSetting.EncryOnOff[0] = 0; */
                                printk(KERN_ERR "disable\n");
                        }
                        /* changed=1; */
                }
                if (op == ZD_PARAM_WPA) {

                printk(KERN_ERR "ZD_PARAM_WPA : ");

                if (arg) {
                        printk(KERN_ERR "enable\n");

                        if (zfiWlanQueryWlanMode(dev) != ZM_MODE_AP) {
                                printk(KERN_ERR "Station Mode\n");
                                /* zfiWlanQueryWpaIe(dev, (u8_t *)
                                        &wpaIe, &wpalen); */
                                /* printk("wpaIe : % 2x, % 2x, % 2x\n",
                                        wpaIe[21], wpaIe[22], wpaIe[23]); */
                                /* printk("rsnIe : % 2x, % 2x, % 2x\n",
                                        wpaIe[17], wpaIe[18], wpaIe[19]); */
                                if ((macp->supIe[21] == 0x50) &&
                                        (macp->supIe[22] == 0xf2) &&
                                        (macp->supIe[23] == 0x2)) {
                                        printk(KERN_ERR
                                "wd->sta.authMode = ZM_AUTH_MODE_WPAPSK\n");
                                /* wd->sta.authMode = ZM_AUTH_MODE_WPAPSK; */
                                /* wd->ws.authMode = ZM_AUTH_MODE_WPAPSK; */
                                zfiWlanSetAuthenticationMode(dev,
                                                        ZM_AUTH_MODE_WPAPSK);
                                } else if ((macp->supIe[21] == 0x50) &&
                                        (macp->supIe[22] == 0xf2) &&
                                        (macp->supIe[23] == 0x1)) {
                                        printk(KERN_ERR
                                "wd->sta.authMode = ZM_AUTH_MODE_WPA\n");
                                /* wd->sta.authMode = ZM_AUTH_MODE_WPA; */
                                /* wd->ws.authMode = ZM_AUTH_MODE_WPA; */
                                zfiWlanSetAuthenticationMode(dev,
                                                        ZM_AUTH_MODE_WPA);
                                        } else if ((macp->supIe[17] == 0xf) &&
                                                (macp->supIe[18] == 0xac) &&
                                                (macp->supIe[19] == 0x2))
                                        {
                                                printk(KERN_ERR
                                "wd->sta.authMode = ZM_AUTH_MODE_WPA2PSK\n");
                                /* wd->sta.authMode = ZM_AUTH_MODE_WPA2PSK; */
                                /* wd->ws.authMode = ZM_AUTH_MODE_WPA2PSK; */
                                zfiWlanSetAuthenticationMode(dev,
                                ZM_AUTH_MODE_WPA2PSK);
                        } else if ((macp->supIe[17] == 0xf) &&
                                (macp->supIe[18] == 0xac) &&
                                (macp->supIe[19] == 0x1))
                                {
                                        printk(KERN_ERR
                                "wd->sta.authMode = ZM_AUTH_MODE_WPA2\n");
                                /* wd->sta.authMode = ZM_AUTH_MODE_WPA2; */
                                /* wd->ws.authMode = ZM_AUTH_MODE_WPA2; */
                                zfiWlanSetAuthenticationMode(dev,
                                                        ZM_AUTH_MODE_WPA2);
                        }
                        /* WPA or WPAPSK */
                        if ((macp->supIe[21] == 0x50) ||
                                (macp->supIe[22] == 0xf2)) {
                                if (macp->supIe[11] == 0x2) {
                                        printk(KERN_ERR
                                "wd->sta.wepStatus = ZM_ENCRYPTION_TKIP\n");
                                /* wd->sta.wepStatus = ZM_ENCRYPTION_TKIP; */
                                /* wd->ws.wepStatus = ZM_ENCRYPTION_TKIP; */
                                zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_TKIP);
                        } else {
                                printk(KERN_ERR
                                "wd->sta.wepStatus = ZM_ENCRYPTION_AES\n");
                                /* wd->sta.wepStatus = ZM_ENCRYPTION_AES; */
                                /* wd->ws.wepStatus = ZM_ENCRYPTION_AES; */
                                zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_AES);
                                }
                        }
                        //WPA2 or WPA2PSK
                        if ((macp->supIe[17] == 0xf) ||
                                (macp->supIe[18] == 0xac)) {
                                if (macp->supIe[13] == 0x2) {
                                        printk(KERN_ERR
                                "wd->sta.wepStatus = ZM_ENCRYPTION_TKIP\n");
                                /* wd->sta.wepStatus = ZM_ENCRYPTION_TKIP; */
                                /* wd->ws.wepStatus = ZM_ENCRYPTION_TKIP; */
                                zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_TKIP);
                                } else {
                                        printk(KERN_ERR
                                "wd->sta.wepStatus = ZM_ENCRYPTION_AES\n");
                                /* wd->sta.wepStatus = ZM_ENCRYPTION_AES; */
                                /* wd->ws.wepStatus = ZM_ENCRYPTION_AES; */
                                zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_AES);
                                        }
                                }
                        }
                        zfiWlanSetWpaSupport(dev, 1);
                } else {
                        /* Reset the WPA related variables */
                        printk(KERN_ERR "disable\n");

                        zfiWlanSetWpaSupport(dev, 0);
                        zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_OPEN);
                        zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_WEP_DISABLED);

                        /* Now we only set the length in the WPA IE
                        * field to zero.
                        *macp->cardSetting.WPAIe[1] = 0;
                        */
                        }
                }

                if (op == ZD_PARAM_COUNTERMEASURES) {
                        printk(KERN_ERR
                                "****************ZD_PARAM_COUNTERMEASURES : ");

                        if(arg) {
                                /*    mCounterMeasureState=1; */
                                printk(KERN_ERR "enable\n");
                        } else {
                                /*    mCounterMeasureState=0; */
                                printk(KERN_ERR "disable\n");
                        }
                }
                if (op == ZD_PARAM_DROPUNENCRYPTED) {
                        printk(KERN_ERR "ZD_PARAM_DROPUNENCRYPTED : ");

                        if(arg) {
                                printk(KERN_ERR "enable\n");
                        } else {
                                printk(KERN_ERR "disable\n");
                        }
                }
                if (op == ZD_PARAM_AUTH_ALGS) {
                        printk(KERN_ERR "ZD_PARAM_AUTH_ALGS : ");

                        if (arg == 0) {
                                printk(KERN_ERR "OPEN_SYSTEM\n");
                        } else {
                                printk(KERN_ERR "SHARED_KEY\n");
                        }
                }
                if (op == ZD_PARAM_WPS_FILTER) {
                        printk(KERN_ERR "ZD_PARAM_WPS_FILTER : ");

                        if (arg) {
                                /*    mCounterMeasureState=1; */
                                macp->forwardMgmt = 1;
                                printk(KERN_ERR "enable\n");
                        } else {
                                /*    mCounterMeasureState=0; */
                                macp->forwardMgmt = 0;
                                printk(KERN_ERR "disable\n");
                        }
                }
        }
                err = 0;
                break;
        case ZD_IOCTL_GETWPAIE: {
                struct ieee80211req_wpaie req_wpaie;
                u16_t apId, i, j;

                /* Get the AP Id */
                apId = zfLnxGetVapId(dev);

                if (apId == 0xffff) {
                        apId = 0;
                } else {
                        apId = apId + 1;
                }

                if (copy_from_user(&req_wpaie, ifr->ifr_data,
                                        sizeof(struct ieee80211req_wpaie))) {
                        printk(KERN_ERR "usbdrv : copy_from_user error\n");
                        return -EFAULT;
                }

                for (i = 0; i < ZM_OAL_MAX_STA_SUPPORT; i++) {
                        for (j = 0; j < IEEE80211_ADDR_LEN; j++) {
                                if (macp->stawpaie[i].wpa_macaddr[j] !=
                                                req_wpaie.wpa_macaddr[j])
                                break;
                        }
                        if (j == 6)
                        break;
                }

                if (i < ZM_OAL_MAX_STA_SUPPORT) {
                /* printk("ZD_IOCTL_GETWPAIE - sta index = % d\n", i); */
                memcpy(req_wpaie.wpa_ie, macp->stawpaie[i].wpa_ie,
                                                        IEEE80211_MAX_IE_SIZE);
                }

                if (copy_to_user(wrq->u.data.pointer, &req_wpaie,
                                sizeof(struct ieee80211req_wpaie))) {
                        return -EFAULT;
                }
        }

                err = 0;
                break;
        #ifdef ZM_ENABLE_CENC
        case ZM_IOCTL_CENC:
                if (copy_from_user(&macp->zd_wpa_req, ifr->ifr_data,
                        sizeof(struct athr_wlan_param))) {
                        printk(KERN_ERR "usbdrv : copy_from_user error\n");
                        return -EFAULT;
                }

                usbdrv_cenc_ioctl(dev,
                                (struct zydas_cenc_param *)&macp->zd_wpa_req);
                err = 0;
                break;
        #endif /* ZM_ENABLE_CENC */
        default:
                err = -EOPNOTSUPP;
                break;
        }

        return err;
}