path: root/drivers/staging/otus/ioctl.c

/*
 * 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 <asm/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

#if WIRELESS_EXT > 12
#include <net/iw_handler.h>
#endif

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

#if WIRELESS_EXT > 14
/*
 * 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);
}
#endif                                            /* WIRELESS_EXT > 14 */

/*------------------------------------------------------------------*/
/*
 * 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;
#if WIRELESS_EXT > 14
    char    buf[64*2 + 30];
#endif

    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;
#if WIRELESS_EXT > 18
    iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED
                        |IW_QUAL_NOISE_UPDATED;
#endif
    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;
#if WIRELESS_EXT > 14
#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;
        }
    }
#endif
/* 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;

#if WIRELESS_EXT > 9
    range->txpower_capa = IW_TXPOW_DBM;
// XXX what about min/max_pmp, min/max_pmt, etc.
#endif

#if WIRELESS_EXT > 10
    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;
#endif                                        /* WIRELESS_EXT > 10 */

    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;
    for (i = 1; i <= 14; i++) // B,G Bands
    {
        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);

    for (i = 0; i < num_band_a; i++) // A Bands
    {
        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("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("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("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 WIRELESS_EXT > 16
        if (current_ev == end_buf)
        {
            kfree(pBssList);
            data->length = current_ev - extra;
            return -E2BIG;
        }
#endif
    }

/* 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("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, 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:
            keyLen = 32;
            break;
#endif //ZM_ENABLE_CENC
        case ZM_NO_WEP:
            keyLen = 0;
            break;
        default :
            keyLen = 0;
            printk("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;
//				vap->iv_ic->ic_flags |= IEEE80211_F_WME; /* XXX needed by ic_reset */
//			}
//			else {
//				vap->iv_flags &= ~IEEE80211_F_WME;
//				vap->iv_ic->ic_flags &= ~IEEE80211_F_WME; /* XXX needed by ic_reset */
//			}
//			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_DEBUG "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_DEBUG "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_DEBUG "ZM_IOCTL_TEST:len=%d\n", zdreq->addr);
            //zfiWlanReadReg(dev, 0x10f400);
            //zfiWlanReadReg(dev, 0x10f404);
            printk("IOCTL TEST\n");
            #if 1
            //print packet
            for (i=0; i<zdreq->addr; i++)
            {
                if ((i&0x7) == 0)
                {
                    printk("\n");
                }
                printk("%02X ", (unsigned char)zdreq->data[i]);
            }
            printk("\n");
            #endif


            #if 0 //For Test?? 1 to 0 by CWYang(-)
            {
            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("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("Current Signal Strength : %02d\n", buffer[0]);
            }
            break;
        //CWYang(+)
        case ZM_IOCTL_SIGNAL_QUALITY :
            {
                u8_t buffer[2];
                zfiWlanQuerySignalInfo(dev, &buffer[0]);
                printk("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;

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

                if (zdparm->sta_addr[0] & 1)//del group key
                {
                    //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)
            {
                int ii;
                printk("Otus: Key Context:\n");
                for(ii = 0; ii < keyInfo.keyLength;)
                {
                    printk("0x%02x ", keyInfo.key[ii]);
                    if((++ii % 16) == 0)
                        printk("\n");
                }
                printk("\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(" -------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(" -------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);
            {
                int ii;
                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;
    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;


		case SIOCIWFIRSTPRIV + 0x2: /* set_auth */
		{
			//printk("CWY - SIOCIWFIRSTPRIV + 0x2 (set_auth)\n");
			if (! capable(CAP_NET_ADMIN))
			{
				err = -EPERM;
				break;
			}
			{
				int 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;

		case SIOCIWFIRSTPRIV + 0x3: /* get_auth */
		{
		    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;


        case ZDAPIOCTL:    //debug command
            if (copy_from_user(&zdreq, ifr->ifr_data, sizeof (zdreq)))
            {
                printk(KERN_ERR "usbdrv: copy_from_user error\n");
                return -EFAULT;
            }

            //printk(KERN_DEBUG "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);
                        }
                        if ((macp->supIe[21] == 0x50) || (macp->supIe[22] == 0xf2))//WPA or WPAPSK
                        {
                            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);
                            }
                        }
                        if ((macp->supIe[17] == 0xf) || (macp->supIe[18] == 0xac)) //WPA2 or WPA2PSK
                        {
                            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;
}