diff options
Diffstat (limited to 'drivers/staging/otus/ioctl.c')
| -rw-r--r-- | drivers/staging/otus/ioctl.c | 2913 |
1 files changed, 2913 insertions, 0 deletions
diff --git a/drivers/staging/otus/ioctl.c b/drivers/staging/otus/ioctl.c new file mode 100644 index 000000000000..7a5c1e876b01 --- /dev/null +++ b/drivers/staging/otus/ioctl.c @@ -0,0 +1,2913 @@ +/* + * 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; +} |