ioctl_linux.c revision 7057dcb3afa29499c40ae404a616122fdd196d1b
1/****************************************************************************** 2 * 3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, write to the Free Software Foundation, Inc., 16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 17 * 18 * 19 ******************************************************************************/ 20#define _IOCTL_LINUX_C_ 21 22#include <osdep_service.h> 23#include <drv_types.h> 24#include <wlan_bssdef.h> 25#include <rtw_debug.h> 26#include <wifi.h> 27#include <rtw_mlme.h> 28#include <rtw_mlme_ext.h> 29#include <rtw_ioctl.h> 30#include <rtw_ioctl_set.h> 31#include <rtw_mp_ioctl.h> 32#include <usb_ops.h> 33#include <rtw_version.h> 34#include <rtl8188e_hal.h> 35 36#include <rtw_mp.h> 37#include <rtw_iol.h> 38 39#define RTL_IOCTL_WPA_SUPPLICANT (SIOCIWFIRSTPRIV + 30) 40 41#define SCAN_ITEM_SIZE 768 42#define MAX_CUSTOM_LEN 64 43#define RATE_COUNT 4 44 45/* combo scan */ 46#define WEXT_CSCAN_AMOUNT 9 47#define WEXT_CSCAN_BUF_LEN 360 48#define WEXT_CSCAN_HEADER "CSCAN S\x01\x00\x00S\x00" 49#define WEXT_CSCAN_HEADER_SIZE 12 50#define WEXT_CSCAN_SSID_SECTION 'S' 51#define WEXT_CSCAN_CHANNEL_SECTION 'C' 52#define WEXT_CSCAN_NPROBE_SECTION 'N' 53#define WEXT_CSCAN_ACTV_DWELL_SECTION 'A' 54#define WEXT_CSCAN_PASV_DWELL_SECTION 'P' 55#define WEXT_CSCAN_HOME_DWELL_SECTION 'H' 56#define WEXT_CSCAN_TYPE_SECTION 'T' 57 58static struct mp_ioctl_handler mp_ioctl_hdl[] = { 59/*0*/ GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_start_test_hdl, OID_RT_PRO_START_TEST) 60 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_stop_test_hdl, OID_RT_PRO_STOP_TEST) 61 62 GEN_HANDLER(sizeof(struct rwreg_param), rtl8188eu_oid_rt_pro_read_register_hdl, OID_RT_PRO_READ_REGISTER) 63 GEN_HANDLER(sizeof(struct rwreg_param), rtl8188eu_oid_rt_pro_write_register_hdl, OID_RT_PRO_WRITE_REGISTER) 64 GEN_HANDLER(sizeof(struct bb_reg_param), rtl8188eu_oid_rt_pro_read_bb_reg_hdl, OID_RT_PRO_READ_BB_REG) 65/*5*/ GEN_HANDLER(sizeof(struct bb_reg_param), rtl8188eu_oid_rt_pro_write_bb_reg_hdl, OID_RT_PRO_WRITE_BB_REG) 66 GEN_HANDLER(sizeof(struct rf_reg_param), rtl8188eu_oid_rt_pro_read_rf_reg_hdl, OID_RT_PRO_RF_READ_REGISTRY) 67 GEN_HANDLER(sizeof(struct rf_reg_param), rtl8188eu_oid_rt_pro_write_rf_reg_hdl, OID_RT_PRO_RF_WRITE_REGISTRY) 68 69 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl, OID_RT_PRO_SET_CHANNEL_DIRECT_CALL) 70 GEN_HANDLER(sizeof(struct txpower_param), rtl8188eu_oid_rt_pro_set_tx_power_control_hdl, OID_RT_PRO_SET_TX_POWER_CONTROL) 71/*10*/ GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_data_rate_hdl, OID_RT_PRO_SET_DATA_RATE) 72 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_set_bandwidth_hdl, OID_RT_SET_BANDWIDTH) 73 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_antenna_bb_hdl, OID_RT_PRO_SET_ANTENNA_BB) 74 75 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_continuous_tx_hdl, OID_RT_PRO_SET_CONTINUOUS_TX) 76 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_single_carrier_tx_hdl, OID_RT_PRO_SET_SINGLE_CARRIER_TX) 77/*15*/ GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_carrier_suppression_tx_hdl, OID_RT_PRO_SET_CARRIER_SUPPRESSION_TX) 78 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_pro_set_single_tone_tx_hdl, OID_RT_PRO_SET_SINGLE_TONE_TX) 79 80 EXT_MP_IOCTL_HANDLER(0, xmit_packet, 0) 81 82 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_set_rx_packet_type_hdl, OID_RT_SET_RX_PACKET_TYPE) 83 GEN_HANDLER(0, rtl8188eu_oid_rt_reset_phy_rx_packet_count_hdl, OID_RT_RESET_PHY_RX_PACKET_COUNT) 84/*20*/ GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_get_phy_rx_packet_received_hdl, OID_RT_GET_PHY_RX_PACKET_RECEIVED) 85 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_get_phy_rx_packet_crc32_error_hdl, OID_RT_GET_PHY_RX_PACKET_CRC32_ERROR) 86 87 GEN_HANDLER(sizeof(struct eeprom_rw_param), NULL, 0) 88 GEN_HANDLER(sizeof(struct eeprom_rw_param), NULL, 0) 89 GEN_HANDLER(sizeof(struct efuse_access_struct), rtl8188eu_oid_rt_pro_efuse_hdl, OID_RT_PRO_EFUSE) 90/*25*/ GEN_HANDLER(0, rtl8188eu_oid_rt_pro_efuse_map_hdl, OID_RT_PRO_EFUSE_MAP) 91 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_get_efuse_max_size_hdl, OID_RT_GET_EFUSE_MAX_SIZE) 92 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_get_efuse_current_size_hdl, OID_RT_GET_EFUSE_CURRENT_SIZE) 93 94 GEN_HANDLER(sizeof(u32), rtl8188eu_oid_rt_get_thermal_meter_hdl, OID_RT_PRO_GET_THERMAL_METER) 95 GEN_HANDLER(sizeof(u8), rtl8188eu_oid_rt_pro_set_power_tracking_hdl, OID_RT_PRO_SET_POWER_TRACKING) 96/*30*/ GEN_HANDLER(sizeof(u8), rtl8188eu_oid_rt_set_power_down_hdl, OID_RT_SET_POWER_DOWN) 97/*31*/ GEN_HANDLER(0, rtl8188eu_oid_rt_pro_trigger_gpio_hdl, 0) 98}; 99 100static u32 rtw_rates[] = {1000000, 2000000, 5500000, 11000000, 101 6000000, 9000000, 12000000, 18000000, 24000000, 36000000, 102 48000000, 54000000}; 103 104static const char * const iw_operation_mode[] = { 105 "Auto", "Ad-Hoc", "Managed", "Master", "Repeater", 106 "Secondary", "Monitor" 107}; 108 109static int hex2num_i(char c) 110{ 111 if (c >= '0' && c <= '9') 112 return c - '0'; 113 if (c >= 'a' && c <= 'f') 114 return c - 'a' + 10; 115 if (c >= 'A' && c <= 'F') 116 return c - 'A' + 10; 117 return -1; 118} 119 120/** 121 * hwaddr_aton - Convert ASCII string to MAC address 122 * @txt: MAC address as a string (e.g., "00:11:22:33:44:55") 123 * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes) 124 * Returns: 0 on success, -1 on failure (e.g., string not a MAC address) 125 */ 126static int hwaddr_aton_i(const char *txt, u8 *addr) 127{ 128 int i; 129 130 for (i = 0; i < 6; i++) { 131 int a, b; 132 133 a = hex2num_i(*txt++); 134 if (a < 0) 135 return -1; 136 b = hex2num_i(*txt++); 137 if (b < 0) 138 return -1; 139 *addr++ = (a << 4) | b; 140 if (i < 5 && *txt++ != ':') 141 return -1; 142 } 143 144 return 0; 145} 146 147void indicate_wx_scan_complete_event(struct adapter *padapter) 148{ 149 union iwreq_data wrqu; 150 151 _rtw_memset(&wrqu, 0, sizeof(union iwreq_data)); 152 wireless_send_event(padapter->pnetdev, SIOCGIWSCAN, &wrqu, NULL); 153} 154 155void rtw_indicate_wx_assoc_event(struct adapter *padapter) 156{ 157 union iwreq_data wrqu; 158 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 159 160 _rtw_memset(&wrqu, 0, sizeof(union iwreq_data)); 161 162 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 163 164 memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, ETH_ALEN); 165 166 DBG_88E_LEVEL(_drv_always_, "assoc success\n"); 167 wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL); 168} 169 170void rtw_indicate_wx_disassoc_event(struct adapter *padapter) 171{ 172 union iwreq_data wrqu; 173 174 _rtw_memset(&wrqu, 0, sizeof(union iwreq_data)); 175 176 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 177 _rtw_memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN); 178 179 DBG_88E_LEVEL(_drv_always_, "indicate disassoc\n"); 180 wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL); 181} 182 183static char *translate_scan(struct adapter *padapter, 184 struct iw_request_info *info, 185 struct wlan_network *pnetwork, 186 char *start, char *stop) 187{ 188 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 189 struct iw_event iwe; 190 u16 cap; 191 __le16 le_tmp; 192 u32 ht_ielen = 0; 193 char custom[MAX_CUSTOM_LEN]; 194 char *p; 195 u16 max_rate = 0, rate, ht_cap = false; 196 u32 i = 0; 197 u8 bw_40MHz = 0, short_GI = 0; 198 u16 mcs_rate = 0; 199 u8 ss, sq; 200#ifdef CONFIG_88EU_P2P 201 struct wifidirect_info *pwdinfo = &padapter->wdinfo; 202 203 if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) { 204 u32 blnGotP2PIE = false; 205 206 /* User is doing the P2P device discovery */ 207 /* The prefix of SSID should be "DIRECT-" and the IE should contains the P2P IE. */ 208 /* If not, the driver should ignore this AP and go to the next AP. */ 209 210 /* Verifying the SSID */ 211 if (!memcmp(pnetwork->network.Ssid.Ssid, pwdinfo->p2p_wildcard_ssid, P2P_WILDCARD_SSID_LEN)) { 212 u32 p2pielen = 0; 213 214 if (pnetwork->network.Reserved[0] == 2) {/* Probe Request */ 215 /* Verifying the P2P IE */ 216 if (rtw_get_p2p_ie(pnetwork->network.IEs, pnetwork->network.IELength, NULL, &p2pielen)) 217 blnGotP2PIE = true; 218 } else {/* Beacon or Probe Respones */ 219 /* Verifying the P2P IE */ 220 if (rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &p2pielen)) 221 blnGotP2PIE = true; 222 } 223 } 224 225 if (!blnGotP2PIE) 226 return start; 227 } 228#endif /* CONFIG_88EU_P2P */ 229 230 /* AP MAC address */ 231 iwe.cmd = SIOCGIWAP; 232 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 233 234 memcpy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress, ETH_ALEN); 235 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN); 236 237 /* Add the ESSID */ 238 iwe.cmd = SIOCGIWESSID; 239 iwe.u.data.flags = 1; 240 iwe.u.data.length = min_t(u16, pnetwork->network.Ssid.SsidLength, 32); 241 start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid); 242 243 /* parsing HT_CAP_IE */ 244 p = rtw_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.IELength-12); 245 246 if (p && ht_ielen > 0) { 247 struct rtw_ieee80211_ht_cap *pht_capie; 248 ht_cap = true; 249 pht_capie = (struct rtw_ieee80211_ht_cap *)(p+2); 250 memcpy(&mcs_rate, pht_capie->supp_mcs_set, 2); 251 bw_40MHz = (pht_capie->cap_info&IEEE80211_HT_CAP_SUP_WIDTH) ? 1 : 0; 252 short_GI = (pht_capie->cap_info&(IEEE80211_HT_CAP_SGI_20|IEEE80211_HT_CAP_SGI_40)) ? 1 : 0; 253 } 254 255 /* Add the protocol name */ 256 iwe.cmd = SIOCGIWNAME; 257 if ((rtw_is_cckratesonly_included((u8 *)&pnetwork->network.SupportedRates))) { 258 if (ht_cap) 259 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn"); 260 else 261 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b"); 262 } else if ((rtw_is_cckrates_included((u8 *)&pnetwork->network.SupportedRates))) { 263 if (ht_cap) 264 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn"); 265 else 266 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg"); 267 } else { 268 if (pnetwork->network.Configuration.DSConfig > 14) { 269 if (ht_cap) 270 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11an"); 271 else 272 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11a"); 273 } else { 274 if (ht_cap) 275 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn"); 276 else 277 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g"); 278 } 279 } 280 281 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN); 282 283 /* Add mode */ 284 iwe.cmd = SIOCGIWMODE; 285 memcpy(&le_tmp, rtw_get_capability_from_ie(pnetwork->network.IEs), 2); 286 287 cap = le16_to_cpu(le_tmp); 288 289 if (cap & (WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_BSS)) { 290 if (cap & WLAN_CAPABILITY_BSS) 291 iwe.u.mode = IW_MODE_MASTER; 292 else 293 iwe.u.mode = IW_MODE_ADHOC; 294 295 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_UINT_LEN); 296 } 297 298 if (pnetwork->network.Configuration.DSConfig < 1) 299 pnetwork->network.Configuration.DSConfig = 1; 300 301 /* Add frequency/channel */ 302 iwe.cmd = SIOCGIWFREQ; 303 iwe.u.freq.m = rtw_ch2freq(pnetwork->network.Configuration.DSConfig) * 100000; 304 iwe.u.freq.e = 1; 305 iwe.u.freq.i = pnetwork->network.Configuration.DSConfig; 306 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_FREQ_LEN); 307 308 /* Add encryption capability */ 309 iwe.cmd = SIOCGIWENCODE; 310 if (cap & WLAN_CAPABILITY_PRIVACY) 311 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; 312 else 313 iwe.u.data.flags = IW_ENCODE_DISABLED; 314 iwe.u.data.length = 0; 315 start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid); 316 317 /*Add basic and extended rates */ 318 max_rate = 0; 319 p = custom; 320 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): "); 321 while (pnetwork->network.SupportedRates[i] != 0) { 322 rate = pnetwork->network.SupportedRates[i]&0x7F; 323 if (rate > max_rate) 324 max_rate = rate; 325 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), 326 "%d%s ", rate >> 1, (rate & 1) ? ".5" : ""); 327 i++; 328 } 329 330 if (ht_cap) { 331 if (mcs_rate&0x8000)/* MCS15 */ 332 max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) : ((short_GI) ? 144 : 130); 333 else if (mcs_rate&0x0080)/* MCS7 */ 334 ; 335 else/* default MCS7 */ 336 max_rate = (bw_40MHz) ? ((short_GI) ? 150 : 135) : ((short_GI) ? 72 : 65); 337 338 max_rate = max_rate*2;/* Mbps/2; */ 339 } 340 341 iwe.cmd = SIOCGIWRATE; 342 iwe.u.bitrate.fixed = 0; 343 iwe.u.bitrate.disabled = 0; 344 iwe.u.bitrate.value = max_rate * 500000; 345 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_PARAM_LEN); 346 347 /* parsing WPA/WPA2 IE */ 348 { 349 u8 buf[MAX_WPA_IE_LEN]; 350 u8 wpa_ie[255], rsn_ie[255]; 351 u16 wpa_len = 0, rsn_len = 0; 352 u8 *p; 353 354 rtw_get_sec_ie(pnetwork->network.IEs, pnetwork->network.IELength, rsn_ie, &rsn_len, wpa_ie, &wpa_len); 355 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: ssid =%s\n", pnetwork->network.Ssid.Ssid)); 356 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: wpa_len =%d rsn_len =%d\n", wpa_len, rsn_len)); 357 358 if (wpa_len > 0) { 359 p = buf; 360 _rtw_memset(buf, 0, MAX_WPA_IE_LEN); 361 p += sprintf(p, "wpa_ie ="); 362 for (i = 0; i < wpa_len; i++) 363 p += sprintf(p, "%02x", wpa_ie[i]); 364 365 _rtw_memset(&iwe, 0, sizeof(iwe)); 366 iwe.cmd = IWEVCUSTOM; 367 iwe.u.data.length = strlen(buf); 368 start = iwe_stream_add_point(info, start, stop, &iwe, buf); 369 370 _rtw_memset(&iwe, 0, sizeof(iwe)); 371 iwe.cmd = IWEVGENIE; 372 iwe.u.data.length = wpa_len; 373 start = iwe_stream_add_point(info, start, stop, &iwe, wpa_ie); 374 } 375 if (rsn_len > 0) { 376 p = buf; 377 _rtw_memset(buf, 0, MAX_WPA_IE_LEN); 378 p += sprintf(p, "rsn_ie ="); 379 for (i = 0; i < rsn_len; i++) 380 p += sprintf(p, "%02x", rsn_ie[i]); 381 _rtw_memset(&iwe, 0, sizeof(iwe)); 382 iwe.cmd = IWEVCUSTOM; 383 iwe.u.data.length = strlen(buf); 384 start = iwe_stream_add_point(info, start, stop, &iwe, buf); 385 386 _rtw_memset(&iwe, 0, sizeof(iwe)); 387 iwe.cmd = IWEVGENIE; 388 iwe.u.data.length = rsn_len; 389 start = iwe_stream_add_point(info, start, stop, &iwe, rsn_ie); 390 } 391 } 392 393 {/* parsing WPS IE */ 394 uint cnt = 0, total_ielen; 395 u8 *wpsie_ptr = NULL; 396 uint wps_ielen = 0; 397 398 u8 *ie_ptr = pnetwork->network.IEs + _FIXED_IE_LENGTH_; 399 total_ielen = pnetwork->network.IELength - _FIXED_IE_LENGTH_; 400 401 while (cnt < total_ielen) { 402 if (rtw_is_wps_ie(&ie_ptr[cnt], &wps_ielen) && (wps_ielen > 2)) { 403 wpsie_ptr = &ie_ptr[cnt]; 404 iwe.cmd = IWEVGENIE; 405 iwe.u.data.length = (u16)wps_ielen; 406 start = iwe_stream_add_point(info, start, stop, &iwe, wpsie_ptr); 407 } 408 cnt += ie_ptr[cnt+1]+2; /* goto next */ 409 } 410 } 411 412 /* Add quality statistics */ 413 iwe.cmd = IWEVQUAL; 414 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID; 415 416 if (check_fwstate(pmlmepriv, _FW_LINKED) == true && 417 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network)) { 418 ss = padapter->recvpriv.signal_strength; 419 sq = padapter->recvpriv.signal_qual; 420 } else { 421 ss = pnetwork->network.PhyInfo.SignalStrength; 422 sq = pnetwork->network.PhyInfo.SignalQuality; 423 } 424 425 iwe.u.qual.level = (u8)ss; 426 iwe.u.qual.qual = (u8)sq; /* signal quality */ 427 iwe.u.qual.noise = 0; /* noise level */ 428 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN); 429 return start; 430} 431 432static int wpa_set_auth_algs(struct net_device *dev, u32 value) 433{ 434 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 435 int ret = 0; 436 437 if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) { 438 DBG_88E("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY and AUTH_ALG_OPEN_SYSTEM [value:0x%x]\n", value); 439 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 440 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch; 441 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto; 442 } else if (value & AUTH_ALG_SHARED_KEY) { 443 DBG_88E("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY [value:0x%x]\n", value); 444 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 445 446 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared; 447 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared; 448 } else if (value & AUTH_ALG_OPEN_SYSTEM) { 449 DBG_88E("wpa_set_auth_algs, AUTH_ALG_OPEN_SYSTEM\n"); 450 if (padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK) { 451 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen; 452 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; 453 } 454 } else if (value & AUTH_ALG_LEAP) { 455 DBG_88E("wpa_set_auth_algs, AUTH_ALG_LEAP\n"); 456 } else { 457 DBG_88E("wpa_set_auth_algs, error!\n"); 458 ret = -EINVAL; 459 } 460 return ret; 461} 462 463static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 464{ 465 int ret = 0; 466 u32 wep_key_idx, wep_key_len, wep_total_len; 467 struct ndis_802_11_wep *pwep = NULL; 468 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 469 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 470 struct security_priv *psecuritypriv = &padapter->securitypriv; 471#ifdef CONFIG_88EU_P2P 472 struct wifidirect_info *pwdinfo = &padapter->wdinfo; 473#endif /* CONFIG_88EU_P2P */ 474 475_func_enter_; 476 477 param->u.crypt.err = 0; 478 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 479 480 if (param_len < (u32) ((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) { 481 ret = -EINVAL; 482 goto exit; 483 } 484 485 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 486 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 487 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 488 if (param->u.crypt.idx >= WEP_KEYS) { 489 ret = -EINVAL; 490 goto exit; 491 } 492 } else { 493 ret = -EINVAL; 494 goto exit; 495 } 496 497 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 498 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n")); 499 DBG_88E("wpa_set_encryption, crypt.alg = WEP\n"); 500 501 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 502 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 503 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_; 504 505 wep_key_idx = param->u.crypt.idx; 506 wep_key_len = param->u.crypt.key_len; 507 508 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(1)wep_key_idx =%d\n", wep_key_idx)); 509 DBG_88E("(1)wep_key_idx =%d\n", wep_key_idx); 510 511 if (wep_key_idx > WEP_KEYS) 512 return -EINVAL; 513 514 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(2)wep_key_idx =%d\n", wep_key_idx)); 515 516 if (wep_key_len > 0) { 517 wep_key_len = wep_key_len <= 5 ? 5 : 13; 518 wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial); 519 pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len); 520 if (pwep == NULL) { 521 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, (" wpa_set_encryption: pwep allocate fail !!!\n")); 522 goto exit; 523 } 524 _rtw_memset(pwep, 0, wep_total_len); 525 pwep->KeyLength = wep_key_len; 526 pwep->Length = wep_total_len; 527 if (wep_key_len == 13) { 528 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 529 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_; 530 } 531 } else { 532 ret = -EINVAL; 533 goto exit; 534 } 535 pwep->KeyIndex = wep_key_idx; 536 pwep->KeyIndex |= 0x80000000; 537 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength); 538 if (param->u.crypt.set_tx) { 539 DBG_88E("wep, set_tx = 1\n"); 540 if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL) 541 ret = -EOPNOTSUPP; 542 } else { 543 DBG_88E("wep, set_tx = 0\n"); 544 if (wep_key_idx >= WEP_KEYS) { 545 ret = -EOPNOTSUPP; 546 goto exit; 547 } 548 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength); 549 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength; 550 rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0); 551 } 552 goto exit; 553 } 554 555 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /* 802_1x */ 556 struct sta_info *psta, *pbcmc_sta; 557 struct sta_priv *pstapriv = &padapter->stapriv; 558 559 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE)) { /* sta mode */ 560 psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv)); 561 if (psta == NULL) { 562 ; 563 } else { 564 if (strcmp(param->u.crypt.alg, "none") != 0) 565 psta->ieee8021x_blocked = false; 566 567 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) || 568 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) 569 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 570 571 if (param->u.crypt.set_tx == 1) { /* pairwise key */ 572 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 573 574 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ 575 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 576 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 577 padapter->securitypriv.busetkipkey = false; 578 } 579 580 DBG_88E(" ~~~~set sta key:unicastkey\n"); 581 582 rtw_setstakey_cmd(padapter, (unsigned char *)psta, true); 583 } else { /* group key */ 584 memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 585 memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 586 memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 587 padapter->securitypriv.binstallGrpkey = true; 588 DBG_88E(" ~~~~set sta key:groupkey\n"); 589 590 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx; 591 592 rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1); 593#ifdef CONFIG_88EU_P2P 594 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_PROVISIONING_ING)) 595 rtw_p2p_set_state(pwdinfo, P2P_STATE_PROVISIONING_DONE); 596#endif /* CONFIG_88EU_P2P */ 597 } 598 } 599 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 600 if (pbcmc_sta == NULL) { 601 ; 602 } else { 603 /* Jeff: don't disable ieee8021x_blocked while clearing key */ 604 if (strcmp(param->u.crypt.alg, "none") != 0) 605 pbcmc_sta->ieee8021x_blocked = false; 606 607 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) || 608 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) 609 pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 610 } 611 } 612 } 613 614exit: 615 616 kfree(pwep); 617 618_func_exit_; 619 620 return ret; 621} 622 623static int rtw_set_wpa_ie(struct adapter *padapter, char *pie, unsigned short ielen) 624{ 625 u8 *buf = NULL; 626 int group_cipher = 0, pairwise_cipher = 0; 627 int ret = 0; 628#ifdef CONFIG_88EU_P2P 629 struct wifidirect_info *pwdinfo = &padapter->wdinfo; 630#endif /* CONFIG_88EU_P2P */ 631 632 if ((ielen > MAX_WPA_IE_LEN) || (pie == NULL)) { 633 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 634 if (pie == NULL) 635 return ret; 636 else 637 return -EINVAL; 638 } 639 640 if (ielen) { 641 buf = rtw_zmalloc(ielen); 642 if (buf == NULL) { 643 ret = -ENOMEM; 644 goto exit; 645 } 646 647 memcpy(buf, pie, ielen); 648 649 /* dump */ 650 { 651 int i; 652 DBG_88E("\n wpa_ie(length:%d):\n", ielen); 653 for (i = 0; i < ielen; i += 8) 654 DBG_88E("0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x\n", buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4], buf[i+5], buf[i+6], buf[i+7]); 655 } 656 657 if (ielen < RSN_HEADER_LEN) { 658 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("Ie len too short %d\n", ielen)); 659 ret = -1; 660 goto exit; 661 } 662 663 if (rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) { 664 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 665 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; 666 memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen); 667 } 668 669 if (rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) { 670 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 671 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; 672 memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen); 673 } 674 675 switch (group_cipher) { 676 case WPA_CIPHER_NONE: 677 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 678 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 679 break; 680 case WPA_CIPHER_WEP40: 681 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_; 682 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 683 break; 684 case WPA_CIPHER_TKIP: 685 padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_; 686 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 687 break; 688 case WPA_CIPHER_CCMP: 689 padapter->securitypriv.dot118021XGrpPrivacy = _AES_; 690 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 691 break; 692 case WPA_CIPHER_WEP104: 693 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_; 694 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 695 break; 696 } 697 698 switch (pairwise_cipher) { 699 case WPA_CIPHER_NONE: 700 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 701 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 702 break; 703 case WPA_CIPHER_WEP40: 704 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 705 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 706 break; 707 case WPA_CIPHER_TKIP: 708 padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_; 709 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 710 break; 711 case WPA_CIPHER_CCMP: 712 padapter->securitypriv.dot11PrivacyAlgrthm = _AES_; 713 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 714 break; 715 case WPA_CIPHER_WEP104: 716 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 717 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 718 break; 719 } 720 721 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 722 {/* set wps_ie */ 723 u16 cnt = 0; 724 u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 725 726 while (cnt < ielen) { 727 eid = buf[cnt]; 728 if ((eid == _VENDOR_SPECIFIC_IE_) && (!memcmp(&buf[cnt+2], wps_oui, 4))) { 729 DBG_88E("SET WPS_IE\n"); 730 731 padapter->securitypriv.wps_ie_len = ((buf[cnt+1]+2) < (MAX_WPA_IE_LEN<<2)) ? (buf[cnt+1]+2) : (MAX_WPA_IE_LEN<<2); 732 733 memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len); 734 735 set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS); 736#ifdef CONFIG_88EU_P2P 737 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_OK)) 738 rtw_p2p_set_state(pwdinfo, P2P_STATE_PROVISIONING_ING); 739#endif /* CONFIG_88EU_P2P */ 740 cnt += buf[cnt+1]+2; 741 break; 742 } else { 743 cnt += buf[cnt+1]+2; /* goto next */ 744 } 745 } 746 } 747 } 748 749 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 750 ("rtw_set_wpa_ie: pairwise_cipher = 0x%08x padapter->securitypriv.ndisencryptstatus =%d padapter->securitypriv.ndisauthtype =%d\n", 751 pairwise_cipher, padapter->securitypriv.ndisencryptstatus, padapter->securitypriv.ndisauthtype)); 752exit: 753 kfree(buf); 754 return ret; 755} 756 757typedef unsigned char NDIS_802_11_RATES_EX[NDIS_802_11_LENGTH_RATES_EX]; 758 759static int rtw_wx_get_name(struct net_device *dev, 760 struct iw_request_info *info, 761 union iwreq_data *wrqu, char *extra) 762{ 763 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 764 u32 ht_ielen = 0; 765 char *p; 766 u8 ht_cap = false; 767 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 768 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 769 NDIS_802_11_RATES_EX *prates = NULL; 770 771 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("cmd_code =%x\n", info->cmd)); 772 773 _func_enter_; 774 775 if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == true) { 776 /* parsing HT_CAP_IE */ 777 p = rtw_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->IELength-12); 778 if (p && ht_ielen > 0) 779 ht_cap = true; 780 781 prates = &pcur_bss->SupportedRates; 782 783 if (rtw_is_cckratesonly_included((u8 *)prates) == true) { 784 if (ht_cap) 785 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bn"); 786 else 787 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b"); 788 } else if ((rtw_is_cckrates_included((u8 *)prates)) == true) { 789 if (ht_cap) 790 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bgn"); 791 else 792 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bg"); 793 } else { 794 if (pcur_bss->Configuration.DSConfig > 14) { 795 if (ht_cap) 796 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11an"); 797 else 798 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11a"); 799 } else { 800 if (ht_cap) 801 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11gn"); 802 else 803 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g"); 804 } 805 } 806 } else { 807 snprintf(wrqu->name, IFNAMSIZ, "unassociated"); 808 } 809 810 _func_exit_; 811 812 return 0; 813} 814 815static int rtw_wx_set_freq(struct net_device *dev, 816 struct iw_request_info *info, 817 union iwreq_data *wrqu, char *extra) 818{ 819 _func_enter_; 820 821 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_wx_set_freq\n")); 822 823 _func_exit_; 824 825 return 0; 826} 827 828static int rtw_wx_get_freq(struct net_device *dev, 829 struct iw_request_info *info, 830 union iwreq_data *wrqu, char *extra) 831{ 832 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 833 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 834 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 835 836 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 837 /* wrqu->freq.m = ieee80211_wlan_frequencies[pcur_bss->Configuration.DSConfig-1] * 100000; */ 838 wrqu->freq.m = rtw_ch2freq(pcur_bss->Configuration.DSConfig) * 100000; 839 wrqu->freq.e = 1; 840 wrqu->freq.i = pcur_bss->Configuration.DSConfig; 841 } else { 842 wrqu->freq.m = rtw_ch2freq(padapter->mlmeextpriv.cur_channel) * 100000; 843 wrqu->freq.e = 1; 844 wrqu->freq.i = padapter->mlmeextpriv.cur_channel; 845 } 846 847 return 0; 848} 849 850static int rtw_wx_set_mode(struct net_device *dev, struct iw_request_info *a, 851 union iwreq_data *wrqu, char *b) 852{ 853 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 854 enum ndis_802_11_network_infra networkType; 855 int ret = 0; 856 857 _func_enter_; 858 859 if (_FAIL == rtw_pwr_wakeup(padapter)) { 860 ret = -EPERM; 861 goto exit; 862 } 863 864 if (!padapter->hw_init_completed) { 865 ret = -EPERM; 866 goto exit; 867 } 868 869 switch (wrqu->mode) { 870 case IW_MODE_AUTO: 871 networkType = Ndis802_11AutoUnknown; 872 DBG_88E("set_mode = IW_MODE_AUTO\n"); 873 break; 874 case IW_MODE_ADHOC: 875 networkType = Ndis802_11IBSS; 876 DBG_88E("set_mode = IW_MODE_ADHOC\n"); 877 break; 878 case IW_MODE_MASTER: 879 networkType = Ndis802_11APMode; 880 DBG_88E("set_mode = IW_MODE_MASTER\n"); 881 break; 882 case IW_MODE_INFRA: 883 networkType = Ndis802_11Infrastructure; 884 DBG_88E("set_mode = IW_MODE_INFRA\n"); 885 break; 886 default: 887 ret = -EINVAL; 888 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("\n Mode: %s is not supported\n", iw_operation_mode[wrqu->mode])); 889 goto exit; 890 } 891 if (rtw_set_802_11_infrastructure_mode(padapter, networkType) == false) { 892 ret = -EPERM; 893 goto exit; 894 } 895 rtw_setopmode_cmd(padapter, networkType); 896exit: 897 _func_exit_; 898 return ret; 899} 900 901static int rtw_wx_get_mode(struct net_device *dev, struct iw_request_info *a, 902 union iwreq_data *wrqu, char *b) 903{ 904 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 905 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 906 907 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_get_mode\n")); 908 909 _func_enter_; 910 911 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) 912 wrqu->mode = IW_MODE_INFRA; 913 else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) || 914 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))) 915 wrqu->mode = IW_MODE_ADHOC; 916 else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) 917 wrqu->mode = IW_MODE_MASTER; 918 else 919 wrqu->mode = IW_MODE_AUTO; 920 921 _func_exit_; 922 923 return 0; 924} 925 926static int rtw_wx_set_pmkid(struct net_device *dev, 927 struct iw_request_info *a, 928 union iwreq_data *wrqu, char *extra) 929{ 930 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 931 u8 j, blInserted = false; 932 int ret = false; 933 struct security_priv *psecuritypriv = &padapter->securitypriv; 934 struct iw_pmksa *pPMK = (struct iw_pmksa *)extra; 935 u8 strZeroMacAddress[ETH_ALEN] = {0x00}; 936 u8 strIssueBssid[ETH_ALEN] = {0x00}; 937 938 memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN); 939 if (pPMK->cmd == IW_PMKSA_ADD) { 940 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_ADD!\n"); 941 if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN)) 942 return ret; 943 else 944 ret = true; 945 blInserted = false; 946 947 /* overwrite PMKID */ 948 for (j = 0; j < NUM_PMKID_CACHE; j++) { 949 if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) { 950 /* BSSID is matched, the same AP => rewrite with new PMKID. */ 951 DBG_88E("[rtw_wx_set_pmkid] BSSID exists in the PMKList.\n"); 952 memcpy(psecuritypriv->PMKIDList[j].PMKID, pPMK->pmkid, IW_PMKID_LEN); 953 psecuritypriv->PMKIDList[j].bUsed = true; 954 psecuritypriv->PMKIDIndex = j+1; 955 blInserted = true; 956 break; 957 } 958 } 959 960 if (!blInserted) { 961 /* Find a new entry */ 962 DBG_88E("[rtw_wx_set_pmkid] Use the new entry index = %d for this PMKID.\n", 963 psecuritypriv->PMKIDIndex); 964 965 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, strIssueBssid, ETH_ALEN); 966 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, pPMK->pmkid, IW_PMKID_LEN); 967 968 psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed = true; 969 psecuritypriv->PMKIDIndex++; 970 if (psecuritypriv->PMKIDIndex == 16) 971 psecuritypriv->PMKIDIndex = 0; 972 } 973 } else if (pPMK->cmd == IW_PMKSA_REMOVE) { 974 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_REMOVE!\n"); 975 ret = true; 976 for (j = 0; j < NUM_PMKID_CACHE; j++) { 977 if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) { 978 /* BSSID is matched, the same AP => Remove this PMKID information and reset it. */ 979 _rtw_memset(psecuritypriv->PMKIDList[j].Bssid, 0x00, ETH_ALEN); 980 psecuritypriv->PMKIDList[j].bUsed = false; 981 break; 982 } 983 } 984 } else if (pPMK->cmd == IW_PMKSA_FLUSH) { 985 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_FLUSH!\n"); 986 _rtw_memset(&psecuritypriv->PMKIDList[0], 0x00, sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE); 987 psecuritypriv->PMKIDIndex = 0; 988 ret = true; 989 } 990 return ret; 991} 992 993static int rtw_wx_get_sens(struct net_device *dev, 994 struct iw_request_info *info, 995 union iwreq_data *wrqu, char *extra) 996{ 997 wrqu->sens.value = 0; 998 wrqu->sens.fixed = 0; /* no auto select */ 999 wrqu->sens.disabled = 1; 1000 return 0; 1001} 1002 1003static int rtw_wx_get_range(struct net_device *dev, 1004 struct iw_request_info *info, 1005 union iwreq_data *wrqu, char *extra) 1006{ 1007 struct iw_range *range = (struct iw_range *)extra; 1008 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1009 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1010 1011 u16 val; 1012 int i; 1013 1014 _func_enter_; 1015 1016 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_range. cmd_code =%x\n", info->cmd)); 1017 1018 wrqu->data.length = sizeof(*range); 1019 _rtw_memset(range, 0, sizeof(*range)); 1020 1021 /* Let's try to keep this struct in the same order as in 1022 * linux/include/wireless.h 1023 */ 1024 1025 /* TODO: See what values we can set, and remove the ones we can't 1026 * set, or fill them with some default data. 1027 */ 1028 1029 /* ~5 Mb/s real (802.11b) */ 1030 range->throughput = 5 * 1000 * 1000; 1031 1032 /* signal level threshold range */ 1033 1034 /* percent values between 0 and 100. */ 1035 range->max_qual.qual = 100; 1036 range->max_qual.level = 100; 1037 range->max_qual.noise = 100; 1038 range->max_qual.updated = 7; /* Updated all three */ 1039 1040 range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */ 1041 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */ 1042 range->avg_qual.level = 178; /* -78 dBm */ 1043 range->avg_qual.noise = 0; 1044 range->avg_qual.updated = 7; /* Updated all three */ 1045 1046 range->num_bitrates = RATE_COUNT; 1047 1048 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) 1049 range->bitrate[i] = rtw_rates[i]; 1050 1051 range->min_frag = MIN_FRAG_THRESHOLD; 1052 range->max_frag = MAX_FRAG_THRESHOLD; 1053 1054 range->pm_capa = 0; 1055 1056 range->we_version_compiled = WIRELESS_EXT; 1057 range->we_version_source = 16; 1058 1059 for (i = 0, val = 0; i < MAX_CHANNEL_NUM; i++) { 1060 /* Include only legal frequencies for some countries */ 1061 if (pmlmeext->channel_set[i].ChannelNum != 0) { 1062 range->freq[val].i = pmlmeext->channel_set[i].ChannelNum; 1063 range->freq[val].m = rtw_ch2freq(pmlmeext->channel_set[i].ChannelNum) * 100000; 1064 range->freq[val].e = 1; 1065 val++; 1066 } 1067 1068 if (val == IW_MAX_FREQUENCIES) 1069 break; 1070 } 1071 1072 range->num_channels = val; 1073 range->num_frequency = val; 1074 1075/* The following code will proivde the security capability to network manager. */ 1076/* If the driver doesn't provide this capability to network manager, */ 1077/* the WPA/WPA2 routers can't be chosen in the network manager. */ 1078 1079/* 1080#define IW_SCAN_CAPA_NONE 0x00 1081#define IW_SCAN_CAPA_ESSID 0x01 1082#define IW_SCAN_CAPA_BSSID 0x02 1083#define IW_SCAN_CAPA_CHANNEL 0x04 1084#define IW_SCAN_CAPA_MODE 0x08 1085#define IW_SCAN_CAPA_RATE 0x10 1086#define IW_SCAN_CAPA_TYPE 0x20 1087#define IW_SCAN_CAPA_TIME 0x40 1088*/ 1089 1090 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 1091 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 1092 1093 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE | 1094 IW_SCAN_CAPA_BSSID | IW_SCAN_CAPA_CHANNEL | 1095 IW_SCAN_CAPA_MODE | IW_SCAN_CAPA_RATE; 1096 _func_exit_; 1097 1098 return 0; 1099} 1100 1101/* set bssid flow */ 1102/* s1. rtw_set_802_11_infrastructure_mode() */ 1103/* s2. rtw_set_802_11_authentication_mode() */ 1104/* s3. set_802_11_encryption_mode() */ 1105/* s4. rtw_set_802_11_bssid() */ 1106static int rtw_wx_set_wap(struct net_device *dev, 1107 struct iw_request_info *info, 1108 union iwreq_data *awrq, 1109 char *extra) 1110{ 1111 unsigned long irqL; 1112 uint ret = 0; 1113 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1114 struct sockaddr *temp = (struct sockaddr *)awrq; 1115 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1116 struct list_head *phead; 1117 u8 *dst_bssid, *src_bssid; 1118 struct __queue *queue = &(pmlmepriv->scanned_queue); 1119 struct wlan_network *pnetwork = NULL; 1120 enum ndis_802_11_auth_mode authmode; 1121 1122 _func_enter_; 1123 1124 if (_FAIL == rtw_pwr_wakeup(padapter)) { 1125 ret = -1; 1126 goto exit; 1127 } 1128 1129 if (!padapter->bup) { 1130 ret = -1; 1131 goto exit; 1132 } 1133 1134 if (temp->sa_family != ARPHRD_ETHER) { 1135 ret = -EINVAL; 1136 goto exit; 1137 } 1138 1139 authmode = padapter->securitypriv.ndisauthtype; 1140 spin_lock_bh(&queue->lock); 1141 phead = get_list_head(queue); 1142 pmlmepriv->pscanned = get_next(phead); 1143 1144 while (1) { 1145 if ((rtw_end_of_queue_search(phead, pmlmepriv->pscanned)) == true) 1146 break; 1147 1148 pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list); 1149 1150 pmlmepriv->pscanned = get_next(pmlmepriv->pscanned); 1151 1152 dst_bssid = pnetwork->network.MacAddress; 1153 1154 src_bssid = temp->sa_data; 1155 1156 if ((!memcmp(dst_bssid, src_bssid, ETH_ALEN))) { 1157 if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) { 1158 ret = -1; 1159 _exit_critical_bh(&queue->lock, &irqL); 1160 goto exit; 1161 } 1162 1163 break; 1164 } 1165 } 1166 _exit_critical_bh(&queue->lock, &irqL); 1167 1168 rtw_set_802_11_authentication_mode(padapter, authmode); 1169 /* set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */ 1170 if (rtw_set_802_11_bssid(padapter, temp->sa_data) == false) { 1171 ret = -1; 1172 goto exit; 1173 } 1174 1175exit: 1176 1177 _func_exit_; 1178 1179 return ret; 1180} 1181 1182static int rtw_wx_get_wap(struct net_device *dev, 1183 struct iw_request_info *info, 1184 union iwreq_data *wrqu, char *extra) 1185{ 1186 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1187 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1188 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 1189 1190 wrqu->ap_addr.sa_family = ARPHRD_ETHER; 1191 1192 _rtw_memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN); 1193 1194 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_wap\n")); 1195 1196 _func_enter_; 1197 1198 if (((check_fwstate(pmlmepriv, _FW_LINKED)) == true) || 1199 ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true) || 1200 ((check_fwstate(pmlmepriv, WIFI_AP_STATE)) == true)) 1201 memcpy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress, ETH_ALEN); 1202 else 1203 _rtw_memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN); 1204 1205 _func_exit_; 1206 1207 return 0; 1208} 1209 1210static int rtw_wx_set_mlme(struct net_device *dev, 1211 struct iw_request_info *info, 1212 union iwreq_data *wrqu, char *extra) 1213{ 1214 int ret = 0; 1215 u16 reason; 1216 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1217 struct iw_mlme *mlme = (struct iw_mlme *)extra; 1218 1219 if (mlme == NULL) 1220 return -1; 1221 1222 DBG_88E("%s\n", __func__); 1223 1224 reason = mlme->reason_code; 1225 1226 DBG_88E("%s, cmd =%d, reason =%d\n", __func__, mlme->cmd, reason); 1227 1228 switch (mlme->cmd) { 1229 case IW_MLME_DEAUTH: 1230 if (!rtw_set_802_11_disassociate(padapter)) 1231 ret = -1; 1232 break; 1233 case IW_MLME_DISASSOC: 1234 if (!rtw_set_802_11_disassociate(padapter)) 1235 ret = -1; 1236 break; 1237 default: 1238 return -EOPNOTSUPP; 1239 } 1240 return ret; 1241} 1242 1243static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a, 1244 union iwreq_data *wrqu, char *extra) 1245{ 1246 u8 _status = false; 1247 int ret = 0; 1248 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1249 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1250 struct ndis_802_11_ssid ssid[RTW_SSID_SCAN_AMOUNT]; 1251 unsigned long irqL; 1252#ifdef CONFIG_88EU_P2P 1253 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 1254#endif /* CONFIG_88EU_P2P */ 1255 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_set_scan\n")); 1256 1257_func_enter_; 1258 if (padapter->registrypriv.mp_mode == 1) { 1259 if (check_fwstate(pmlmepriv, WIFI_MP_STATE)) { 1260 ret = -1; 1261 goto exit; 1262 } 1263 } 1264 if (_FAIL == rtw_pwr_wakeup(padapter)) { 1265 ret = -1; 1266 goto exit; 1267 } 1268 1269 if (padapter->bDriverStopped) { 1270 DBG_88E("bDriverStopped =%d\n", padapter->bDriverStopped); 1271 ret = -1; 1272 goto exit; 1273 } 1274 1275 if (!padapter->bup) { 1276 ret = -1; 1277 goto exit; 1278 } 1279 1280 if (!padapter->hw_init_completed) { 1281 ret = -1; 1282 goto exit; 1283 } 1284 1285 /* When Busy Traffic, driver do not site survey. So driver return success. */ 1286 /* wpa_supplicant will not issue SIOCSIWSCAN cmd again after scan timeout. */ 1287 /* modify by thomas 2011-02-22. */ 1288 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) { 1289 indicate_wx_scan_complete_event(padapter); 1290 goto exit; 1291 } 1292 1293 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) { 1294 indicate_wx_scan_complete_event(padapter); 1295 goto exit; 1296 } 1297 1298/* For the DMP WiFi Display project, the driver won't to scan because */ 1299/* the pmlmepriv->scan_interval is always equal to 3. */ 1300/* So, the wpa_supplicant won't find out the WPS SoftAP. */ 1301 1302#ifdef CONFIG_88EU_P2P 1303 if (pwdinfo->p2p_state != P2P_STATE_NONE) { 1304 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo)); 1305 rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH); 1306 rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_FULL); 1307 rtw_free_network_queue(padapter, true); 1308 } 1309#endif /* CONFIG_88EU_P2P */ 1310 1311 _rtw_memset(ssid, 0, sizeof(struct ndis_802_11_ssid)*RTW_SSID_SCAN_AMOUNT); 1312 1313 if (wrqu->data.length == sizeof(struct iw_scan_req)) { 1314 struct iw_scan_req *req = (struct iw_scan_req *)extra; 1315 1316 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) { 1317 int len = min((int)req->essid_len, IW_ESSID_MAX_SIZE); 1318 1319 memcpy(ssid[0].Ssid, req->essid, len); 1320 ssid[0].SsidLength = len; 1321 1322 DBG_88E("IW_SCAN_THIS_ESSID, ssid =%s, len =%d\n", req->essid, req->essid_len); 1323 1324 spin_lock_bh(&pmlmepriv->lock); 1325 1326 _status = rtw_sitesurvey_cmd(padapter, ssid, 1, NULL, 0); 1327 1328 _exit_critical_bh(&pmlmepriv->lock, &irqL); 1329 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) { 1330 DBG_88E("rtw_wx_set_scan, req->scan_type == IW_SCAN_TYPE_PASSIVE\n"); 1331 } 1332 } else { 1333 if (wrqu->data.length >= WEXT_CSCAN_HEADER_SIZE && 1334 !memcmp(extra, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) { 1335 int len = wrqu->data.length - WEXT_CSCAN_HEADER_SIZE; 1336 char *pos = extra+WEXT_CSCAN_HEADER_SIZE; 1337 char section; 1338 char sec_len; 1339 int ssid_index = 0; 1340 1341 while (len >= 1) { 1342 section = *(pos++); 1343 len -= 1; 1344 1345 switch (section) { 1346 case WEXT_CSCAN_SSID_SECTION: 1347 if (len < 1) { 1348 len = 0; 1349 break; 1350 } 1351 sec_len = *(pos++); len -= 1; 1352 if (sec_len > 0 && sec_len <= len) { 1353 ssid[ssid_index].SsidLength = sec_len; 1354 memcpy(ssid[ssid_index].Ssid, pos, ssid[ssid_index].SsidLength); 1355 ssid_index++; 1356 } 1357 pos += sec_len; 1358 len -= sec_len; 1359 break; 1360 case WEXT_CSCAN_TYPE_SECTION: 1361 case WEXT_CSCAN_CHANNEL_SECTION: 1362 pos += 1; 1363 len -= 1; 1364 break; 1365 case WEXT_CSCAN_PASV_DWELL_SECTION: 1366 case WEXT_CSCAN_HOME_DWELL_SECTION: 1367 case WEXT_CSCAN_ACTV_DWELL_SECTION: 1368 pos += 2; 1369 len -= 2; 1370 break; 1371 default: 1372 len = 0; /* stop parsing */ 1373 } 1374 } 1375 1376 /* it has still some scan parameter to parse, we only do this now... */ 1377 _status = rtw_set_802_11_bssid_list_scan(padapter, ssid, RTW_SSID_SCAN_AMOUNT); 1378 } else { 1379 _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0); 1380 } 1381 } 1382 1383 if (!_status) 1384 ret = -1; 1385 1386exit: 1387 1388_func_exit_; 1389 return ret; 1390} 1391 1392static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a, 1393 union iwreq_data *wrqu, char *extra) 1394{ 1395 unsigned long irqL; 1396 struct list_head *plist, *phead; 1397 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1398 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1399 struct __queue *queue = &(pmlmepriv->scanned_queue); 1400 struct wlan_network *pnetwork = NULL; 1401 char *ev = extra; 1402 char *stop = ev + wrqu->data.length; 1403 u32 ret = 0; 1404 u32 cnt = 0; 1405 u32 wait_for_surveydone; 1406 int wait_status; 1407#ifdef CONFIG_88EU_P2P 1408 struct wifidirect_info *pwdinfo = &padapter->wdinfo; 1409#endif /* CONFIG_88EU_P2P */ 1410 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan\n")); 1411 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, (" Start of Query SIOCGIWSCAN .\n")); 1412 1413 _func_enter_; 1414 1415 if (padapter->pwrctrlpriv.brfoffbyhw && padapter->bDriverStopped) { 1416 ret = -EINVAL; 1417 goto exit; 1418 } 1419 1420#ifdef CONFIG_88EU_P2P 1421 if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) { 1422 /* P2P is enabled */ 1423 wait_for_surveydone = 200; 1424 } else { 1425 /* P2P is disabled */ 1426 wait_for_surveydone = 100; 1427 } 1428#else 1429 { 1430 wait_for_surveydone = 100; 1431 } 1432#endif /* CONFIG_88EU_P2P */ 1433 1434 wait_status = _FW_UNDER_SURVEY | _FW_UNDER_LINKING; 1435 1436 while (check_fwstate(pmlmepriv, wait_status)) { 1437 rtw_msleep_os(30); 1438 cnt++; 1439 if (cnt > wait_for_surveydone) 1440 break; 1441 } 1442 1443 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1444 1445 phead = get_list_head(queue); 1446 plist = get_next(phead); 1447 1448 while (1) { 1449 if (rtw_end_of_queue_search(phead, plist)) 1450 break; 1451 1452 if ((stop - ev) < SCAN_ITEM_SIZE) { 1453 ret = -E2BIG; 1454 break; 1455 } 1456 1457 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 1458 1459 /* report network only if the current channel set contains the channel to which this network belongs */ 1460 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0) 1461 ev = translate_scan(padapter, a, pnetwork, ev, stop); 1462 1463 plist = get_next(plist); 1464 } 1465 1466 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 1467 1468 wrqu->data.length = ev-extra; 1469 wrqu->data.flags = 0; 1470 1471exit: 1472 _func_exit_; 1473 return ret; 1474} 1475 1476/* set ssid flow */ 1477/* s1. rtw_set_802_11_infrastructure_mode() */ 1478/* s2. set_802_11_authenticaion_mode() */ 1479/* s3. set_802_11_encryption_mode() */ 1480/* s4. rtw_set_802_11_ssid() */ 1481static int rtw_wx_set_essid(struct net_device *dev, 1482 struct iw_request_info *a, 1483 union iwreq_data *wrqu, char *extra) 1484{ 1485 unsigned long irqL; 1486 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1487 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1488 struct __queue *queue = &pmlmepriv->scanned_queue; 1489 struct list_head *phead; 1490 struct wlan_network *pnetwork = NULL; 1491 enum ndis_802_11_auth_mode authmode; 1492 struct ndis_802_11_ssid ndis_ssid; 1493 u8 *dst_ssid, *src_ssid; 1494 1495 uint ret = 0, len; 1496 1497 _func_enter_; 1498 1499 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 1500 ("+rtw_wx_set_essid: fw_state = 0x%08x\n", get_fwstate(pmlmepriv))); 1501 if (_FAIL == rtw_pwr_wakeup(padapter)) { 1502 ret = -1; 1503 goto exit; 1504 } 1505 1506 if (!padapter->bup) { 1507 ret = -1; 1508 goto exit; 1509 } 1510 1511 if (wrqu->essid.length > IW_ESSID_MAX_SIZE) { 1512 ret = -E2BIG; 1513 goto exit; 1514 } 1515 1516 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1517 ret = -1; 1518 goto exit; 1519 } 1520 1521 authmode = padapter->securitypriv.ndisauthtype; 1522 DBG_88E("=>%s\n", __func__); 1523 if (wrqu->essid.flags && wrqu->essid.length) { 1524 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? wrqu->essid.length : IW_ESSID_MAX_SIZE; 1525 1526 if (wrqu->essid.length != 33) 1527 DBG_88E("ssid =%s, len =%d\n", extra, wrqu->essid.length); 1528 1529 _rtw_memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid)); 1530 ndis_ssid.SsidLength = len; 1531 memcpy(ndis_ssid.Ssid, extra, len); 1532 src_ssid = ndis_ssid.Ssid; 1533 1534 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("rtw_wx_set_essid: ssid =[%s]\n", src_ssid)); 1535 spin_lock_bh(&queue->lock); 1536 phead = get_list_head(queue); 1537 pmlmepriv->pscanned = get_next(phead); 1538 1539 while (1) { 1540 if (rtw_end_of_queue_search(phead, pmlmepriv->pscanned) == true) { 1541 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_warning_, 1542 ("rtw_wx_set_essid: scan_q is empty, set ssid to check if scanning again!\n")); 1543 1544 break; 1545 } 1546 1547 pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list); 1548 1549 pmlmepriv->pscanned = get_next(pmlmepriv->pscanned); 1550 1551 dst_ssid = pnetwork->network.Ssid.Ssid; 1552 1553 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 1554 ("rtw_wx_set_essid: dst_ssid =%s\n", 1555 pnetwork->network.Ssid.Ssid)); 1556 1557 if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength)) && 1558 (pnetwork->network.Ssid.SsidLength == ndis_ssid.SsidLength)) { 1559 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 1560 ("rtw_wx_set_essid: find match, set infra mode\n")); 1561 1562 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) { 1563 if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode) 1564 continue; 1565 } 1566 1567 if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) { 1568 ret = -1; 1569 _exit_critical_bh(&queue->lock, &irqL); 1570 goto exit; 1571 } 1572 1573 break; 1574 } 1575 } 1576 _exit_critical_bh(&queue->lock, &irqL); 1577 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 1578 ("set ssid: set_802_11_auth. mode =%d\n", authmode)); 1579 rtw_set_802_11_authentication_mode(padapter, authmode); 1580 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false) { 1581 ret = -1; 1582 goto exit; 1583 } 1584 } 1585 1586exit: 1587 1588 DBG_88E("<=%s, ret %d\n", __func__, ret); 1589 1590 _func_exit_; 1591 1592 return ret; 1593} 1594 1595static int rtw_wx_get_essid(struct net_device *dev, 1596 struct iw_request_info *a, 1597 union iwreq_data *wrqu, char *extra) 1598{ 1599 u32 len, ret = 0; 1600 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1601 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1602 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 1603 1604 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_essid\n")); 1605 1606 _func_enter_; 1607 1608 if ((check_fwstate(pmlmepriv, _FW_LINKED)) || 1609 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) { 1610 len = pcur_bss->Ssid.SsidLength; 1611 1612 wrqu->essid.length = len; 1613 1614 memcpy(extra, pcur_bss->Ssid.Ssid, len); 1615 1616 wrqu->essid.flags = 1; 1617 } else { 1618 ret = -1; 1619 goto exit; 1620 } 1621 1622exit: 1623 1624 _func_exit_; 1625 1626 return ret; 1627} 1628 1629static int rtw_wx_set_rate(struct net_device *dev, 1630 struct iw_request_info *a, 1631 union iwreq_data *wrqu, char *extra) 1632{ 1633 int i, ret = 0; 1634 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1635 u8 datarates[NumRates]; 1636 u32 target_rate = wrqu->bitrate.value; 1637 u32 fixed = wrqu->bitrate.fixed; 1638 u32 ratevalue = 0; 1639 u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff}; 1640 1641_func_enter_; 1642 1643 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_set_rate\n")); 1644 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("target_rate = %d, fixed = %d\n", target_rate, fixed)); 1645 1646 if (target_rate == -1) { 1647 ratevalue = 11; 1648 goto set_rate; 1649 } 1650 target_rate = target_rate/100000; 1651 1652 switch (target_rate) { 1653 case 10: 1654 ratevalue = 0; 1655 break; 1656 case 20: 1657 ratevalue = 1; 1658 break; 1659 case 55: 1660 ratevalue = 2; 1661 break; 1662 case 60: 1663 ratevalue = 3; 1664 break; 1665 case 90: 1666 ratevalue = 4; 1667 break; 1668 case 110: 1669 ratevalue = 5; 1670 break; 1671 case 120: 1672 ratevalue = 6; 1673 break; 1674 case 180: 1675 ratevalue = 7; 1676 break; 1677 case 240: 1678 ratevalue = 8; 1679 break; 1680 case 360: 1681 ratevalue = 9; 1682 break; 1683 case 480: 1684 ratevalue = 10; 1685 break; 1686 case 540: 1687 ratevalue = 11; 1688 break; 1689 default: 1690 ratevalue = 11; 1691 break; 1692 } 1693 1694set_rate: 1695 1696 for (i = 0; i < NumRates; i++) { 1697 if (ratevalue == mpdatarate[i]) { 1698 datarates[i] = mpdatarate[i]; 1699 if (fixed == 0) 1700 break; 1701 } else { 1702 datarates[i] = 0xff; 1703 } 1704 1705 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("datarate_inx =%d\n", datarates[i])); 1706 } 1707 1708 if (rtw_setdatarate_cmd(padapter, datarates) != _SUCCESS) { 1709 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("rtw_wx_set_rate Fail!!!\n")); 1710 ret = -1; 1711 } 1712 1713_func_exit_; 1714 1715 return ret; 1716} 1717 1718static int rtw_wx_get_rate(struct net_device *dev, 1719 struct iw_request_info *info, 1720 union iwreq_data *wrqu, char *extra) 1721{ 1722 u16 max_rate = 0; 1723 1724 max_rate = rtw_get_cur_max_rate((struct adapter *)rtw_netdev_priv(dev)); 1725 1726 if (max_rate == 0) 1727 return -EPERM; 1728 1729 wrqu->bitrate.fixed = 0; /* no auto select */ 1730 wrqu->bitrate.value = max_rate * 100000; 1731 1732 return 0; 1733} 1734 1735static int rtw_wx_set_rts(struct net_device *dev, 1736 struct iw_request_info *info, 1737 union iwreq_data *wrqu, char *extra) 1738{ 1739 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1740 1741 _func_enter_; 1742 1743 if (wrqu->rts.disabled) { 1744 padapter->registrypriv.rts_thresh = 2347; 1745 } else { 1746 if (wrqu->rts.value < 0 || 1747 wrqu->rts.value > 2347) 1748 return -EINVAL; 1749 1750 padapter->registrypriv.rts_thresh = wrqu->rts.value; 1751 } 1752 1753 DBG_88E("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh); 1754 1755 _func_exit_; 1756 1757 return 0; 1758} 1759 1760static int rtw_wx_get_rts(struct net_device *dev, 1761 struct iw_request_info *info, 1762 union iwreq_data *wrqu, char *extra) 1763{ 1764 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1765 1766 _func_enter_; 1767 1768 DBG_88E("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh); 1769 1770 wrqu->rts.value = padapter->registrypriv.rts_thresh; 1771 wrqu->rts.fixed = 0; /* no auto select */ 1772 /* wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD); */ 1773 1774 _func_exit_; 1775 1776 return 0; 1777} 1778 1779static int rtw_wx_set_frag(struct net_device *dev, 1780 struct iw_request_info *info, 1781 union iwreq_data *wrqu, char *extra) 1782{ 1783 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1784 1785 _func_enter_; 1786 1787 if (wrqu->frag.disabled) { 1788 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD; 1789 } else { 1790 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 1791 wrqu->frag.value > MAX_FRAG_THRESHOLD) 1792 return -EINVAL; 1793 1794 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1; 1795 } 1796 1797 DBG_88E("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len); 1798 1799 _func_exit_; 1800 1801 return 0; 1802} 1803 1804static int rtw_wx_get_frag(struct net_device *dev, 1805 struct iw_request_info *info, 1806 union iwreq_data *wrqu, char *extra) 1807{ 1808 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1809 1810 _func_enter_; 1811 1812 DBG_88E("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len); 1813 1814 wrqu->frag.value = padapter->xmitpriv.frag_len; 1815 wrqu->frag.fixed = 0; /* no auto select */ 1816 1817 _func_exit_; 1818 1819 return 0; 1820} 1821 1822static int rtw_wx_get_retry(struct net_device *dev, 1823 struct iw_request_info *info, 1824 union iwreq_data *wrqu, char *extra) 1825{ 1826 wrqu->retry.value = 7; 1827 wrqu->retry.fixed = 0; /* no auto select */ 1828 wrqu->retry.disabled = 1; 1829 1830 return 0; 1831} 1832 1833static int rtw_wx_set_enc(struct net_device *dev, 1834 struct iw_request_info *info, 1835 union iwreq_data *wrqu, char *keybuf) 1836{ 1837 u32 key, ret = 0; 1838 u32 keyindex_provided; 1839 struct ndis_802_11_wep wep; 1840 enum ndis_802_11_auth_mode authmode; 1841 1842 struct iw_point *erq = &(wrqu->encoding); 1843 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1844 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; 1845 DBG_88E("+rtw_wx_set_enc, flags = 0x%x\n", erq->flags); 1846 1847 _rtw_memset(&wep, 0, sizeof(struct ndis_802_11_wep)); 1848 1849 key = erq->flags & IW_ENCODE_INDEX; 1850 1851 _func_enter_; 1852 1853 if (erq->flags & IW_ENCODE_DISABLED) { 1854 DBG_88E("EncryptionDisabled\n"); 1855 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 1856 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 1857 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 1858 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 1859 authmode = Ndis802_11AuthModeOpen; 1860 padapter->securitypriv.ndisauthtype = authmode; 1861 1862 goto exit; 1863 } 1864 1865 if (key) { 1866 if (key > WEP_KEYS) 1867 return -EINVAL; 1868 key--; 1869 keyindex_provided = 1; 1870 } else { 1871 keyindex_provided = 0; 1872 key = padapter->securitypriv.dot11PrivacyKeyIndex; 1873 DBG_88E("rtw_wx_set_enc, key =%d\n", key); 1874 } 1875 1876 /* set authentication mode */ 1877 if (erq->flags & IW_ENCODE_OPEN) { 1878 DBG_88E("rtw_wx_set_enc():IW_ENCODE_OPEN\n"); 1879 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */ 1880 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; 1881 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 1882 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 1883 authmode = Ndis802_11AuthModeOpen; 1884 padapter->securitypriv.ndisauthtype = authmode; 1885 } else if (erq->flags & IW_ENCODE_RESTRICTED) { 1886 DBG_88E("rtw_wx_set_enc():IW_ENCODE_RESTRICTED\n"); 1887 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 1888 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared; 1889 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 1890 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_; 1891 authmode = Ndis802_11AuthModeShared; 1892 padapter->securitypriv.ndisauthtype = authmode; 1893 } else { 1894 DBG_88E("rtw_wx_set_enc():erq->flags = 0x%x\n", erq->flags); 1895 1896 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */ 1897 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 1898 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 1899 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 1900 authmode = Ndis802_11AuthModeOpen; 1901 padapter->securitypriv.ndisauthtype = authmode; 1902 } 1903 1904 wep.KeyIndex = key; 1905 if (erq->length > 0) { 1906 wep.KeyLength = erq->length <= 5 ? 5 : 13; 1907 1908 wep.Length = wep.KeyLength + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial); 1909 } else { 1910 wep.KeyLength = 0; 1911 1912 if (keyindex_provided == 1) { 1913 /* set key_id only, no given KeyMaterial(erq->length == 0). */ 1914 padapter->securitypriv.dot11PrivacyKeyIndex = key; 1915 1916 DBG_88E("(keyindex_provided == 1), keyid =%d, key_len =%d\n", key, padapter->securitypriv.dot11DefKeylen[key]); 1917 1918 switch (padapter->securitypriv.dot11DefKeylen[key]) { 1919 case 5: 1920 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 1921 break; 1922 case 13: 1923 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 1924 break; 1925 default: 1926 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 1927 break; 1928 } 1929 1930 goto exit; 1931 } 1932 } 1933 1934 wep.KeyIndex |= 0x80000000; 1935 1936 memcpy(wep.KeyMaterial, keybuf, wep.KeyLength); 1937 1938 if (rtw_set_802_11_add_wep(padapter, &wep) == false) { 1939 if (rf_on == pwrpriv->rf_pwrstate) 1940 ret = -EOPNOTSUPP; 1941 goto exit; 1942 } 1943 1944exit: 1945 1946 _func_exit_; 1947 1948 return ret; 1949} 1950 1951static int rtw_wx_get_enc(struct net_device *dev, 1952 struct iw_request_info *info, 1953 union iwreq_data *wrqu, char *keybuf) 1954{ 1955 uint key, ret = 0; 1956 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 1957 struct iw_point *erq = &(wrqu->encoding); 1958 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1959 1960 _func_enter_; 1961 1962 if (check_fwstate(pmlmepriv, _FW_LINKED) != true) { 1963 if (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) { 1964 erq->length = 0; 1965 erq->flags |= IW_ENCODE_DISABLED; 1966 return 0; 1967 } 1968 } 1969 1970 key = erq->flags & IW_ENCODE_INDEX; 1971 1972 if (key) { 1973 if (key > WEP_KEYS) 1974 return -EINVAL; 1975 key--; 1976 } else { 1977 key = padapter->securitypriv.dot11PrivacyKeyIndex; 1978 } 1979 1980 erq->flags = key + 1; 1981 1982 switch (padapter->securitypriv.ndisencryptstatus) { 1983 case Ndis802_11EncryptionNotSupported: 1984 case Ndis802_11EncryptionDisabled: 1985 erq->length = 0; 1986 erq->flags |= IW_ENCODE_DISABLED; 1987 break; 1988 case Ndis802_11Encryption1Enabled: 1989 erq->length = padapter->securitypriv.dot11DefKeylen[key]; 1990 if (erq->length) { 1991 memcpy(keybuf, padapter->securitypriv.dot11DefKey[key].skey, padapter->securitypriv.dot11DefKeylen[key]); 1992 1993 erq->flags |= IW_ENCODE_ENABLED; 1994 1995 if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen) 1996 erq->flags |= IW_ENCODE_OPEN; 1997 else if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeShared) 1998 erq->flags |= IW_ENCODE_RESTRICTED; 1999 } else { 2000 erq->length = 0; 2001 erq->flags |= IW_ENCODE_DISABLED; 2002 } 2003 break; 2004 case Ndis802_11Encryption2Enabled: 2005 case Ndis802_11Encryption3Enabled: 2006 erq->length = 16; 2007 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | IW_ENCODE_NOKEY); 2008 break; 2009 default: 2010 erq->length = 0; 2011 erq->flags |= IW_ENCODE_DISABLED; 2012 break; 2013 } 2014 _func_exit_; 2015 2016 return ret; 2017} 2018 2019static int rtw_wx_get_power(struct net_device *dev, 2020 struct iw_request_info *info, 2021 union iwreq_data *wrqu, char *extra) 2022{ 2023 wrqu->power.value = 0; 2024 wrqu->power.fixed = 0; /* no auto select */ 2025 wrqu->power.disabled = 1; 2026 2027 return 0; 2028} 2029 2030static int rtw_wx_set_gen_ie(struct net_device *dev, 2031 struct iw_request_info *info, 2032 union iwreq_data *wrqu, char *extra) 2033{ 2034 int ret; 2035 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2036 2037 ret = rtw_set_wpa_ie(padapter, extra, wrqu->data.length); 2038 return ret; 2039} 2040 2041static int rtw_wx_set_auth(struct net_device *dev, 2042 struct iw_request_info *info, 2043 union iwreq_data *wrqu, char *extra) 2044{ 2045 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2046 struct iw_param *param = (struct iw_param *)&(wrqu->param); 2047 int ret = 0; 2048 2049 switch (param->flags & IW_AUTH_INDEX) { 2050 case IW_AUTH_WPA_VERSION: 2051 break; 2052 case IW_AUTH_CIPHER_PAIRWISE: 2053 2054 break; 2055 case IW_AUTH_CIPHER_GROUP: 2056 2057 break; 2058 case IW_AUTH_KEY_MGMT: 2059 /* 2060 * ??? does not use these parameters 2061 */ 2062 break; 2063 case IW_AUTH_TKIP_COUNTERMEASURES: 2064 if (param->value) { 2065 /* wpa_supplicant is enabling the tkip countermeasure. */ 2066 padapter->securitypriv.btkip_countermeasure = true; 2067 } else { 2068 /* wpa_supplicant is disabling the tkip countermeasure. */ 2069 padapter->securitypriv.btkip_countermeasure = false; 2070 } 2071 break; 2072 case IW_AUTH_DROP_UNENCRYPTED: 2073 /* HACK: 2074 * 2075 * wpa_supplicant calls set_wpa_enabled when the driver 2076 * is loaded and unloaded, regardless of if WPA is being 2077 * used. No other calls are made which can be used to 2078 * determine if encryption will be used or not prior to 2079 * association being expected. If encryption is not being 2080 * used, drop_unencrypted is set to false, else true -- we 2081 * can use this to determine if the CAP_PRIVACY_ON bit should 2082 * be set. 2083 */ 2084 2085 if (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption1Enabled) 2086 break;/* it means init value, or using wep, ndisencryptstatus = Ndis802_11Encryption1Enabled, */ 2087 /* then it needn't reset it; */ 2088 2089 if (param->value) { 2090 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 2091 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 2092 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 2093 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 2094 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen; 2095 } 2096 2097 break; 2098 case IW_AUTH_80211_AUTH_ALG: 2099 /* 2100 * It's the starting point of a link layer connection using wpa_supplicant 2101 */ 2102 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 2103 LeaveAllPowerSaveMode(padapter); 2104 rtw_disassoc_cmd(padapter, 500, false); 2105 DBG_88E("%s...call rtw_indicate_disconnect\n ", __func__); 2106 rtw_indicate_disconnect(padapter); 2107 rtw_free_assoc_resources(padapter, 1); 2108 } 2109 ret = wpa_set_auth_algs(dev, (u32)param->value); 2110 break; 2111 case IW_AUTH_WPA_ENABLED: 2112 break; 2113 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 2114 break; 2115 case IW_AUTH_PRIVACY_INVOKED: 2116 break; 2117 default: 2118 return -EOPNOTSUPP; 2119 } 2120 2121 return ret; 2122} 2123 2124static int rtw_wx_set_enc_ext(struct net_device *dev, 2125 struct iw_request_info *info, 2126 union iwreq_data *wrqu, char *extra) 2127{ 2128 char *alg_name; 2129 u32 param_len; 2130 struct ieee_param *param = NULL; 2131 struct iw_point *pencoding = &wrqu->encoding; 2132 struct iw_encode_ext *pext = (struct iw_encode_ext *)extra; 2133 int ret = 0; 2134 2135 param_len = sizeof(struct ieee_param) + pext->key_len; 2136 param = (struct ieee_param *)rtw_malloc(param_len); 2137 if (param == NULL) 2138 return -1; 2139 2140 _rtw_memset(param, 0, param_len); 2141 2142 param->cmd = IEEE_CMD_SET_ENCRYPTION; 2143 _rtw_memset(param->sta_addr, 0xff, ETH_ALEN); 2144 2145 switch (pext->alg) { 2146 case IW_ENCODE_ALG_NONE: 2147 /* todo: remove key */ 2148 /* remove = 1; */ 2149 alg_name = "none"; 2150 break; 2151 case IW_ENCODE_ALG_WEP: 2152 alg_name = "WEP"; 2153 break; 2154 case IW_ENCODE_ALG_TKIP: 2155 alg_name = "TKIP"; 2156 break; 2157 case IW_ENCODE_ALG_CCMP: 2158 alg_name = "CCMP"; 2159 break; 2160 default: 2161 return -1; 2162 } 2163 2164 strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN); 2165 2166 if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) 2167 param->u.crypt.set_tx = 1; 2168 2169 /* cliW: WEP does not have group key 2170 * just not checking GROUP key setting 2171 */ 2172 if ((pext->alg != IW_ENCODE_ALG_WEP) && 2173 (pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)) 2174 param->u.crypt.set_tx = 0; 2175 2176 param->u.crypt.idx = (pencoding->flags&0x00FF) - 1; 2177 2178 if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) 2179 memcpy(param->u.crypt.seq, pext->rx_seq, 8); 2180 2181 if (pext->key_len) { 2182 param->u.crypt.key_len = pext->key_len; 2183 memcpy(param->u.crypt.key, pext + 1, pext->key_len); 2184 } 2185 2186 ret = wpa_set_encryption(dev, param, param_len); 2187 2188 kfree(param); 2189 return ret; 2190} 2191 2192static int rtw_wx_get_nick(struct net_device *dev, 2193 struct iw_request_info *info, 2194 union iwreq_data *wrqu, char *extra) 2195{ 2196 if (extra) { 2197 wrqu->data.length = 14; 2198 wrqu->data.flags = 1; 2199 memcpy(extra, "<WIFI@REALTEK>", 14); 2200 } 2201 2202 /* dump debug info here */ 2203 return 0; 2204} 2205 2206static int rtw_wx_read32(struct net_device *dev, 2207 struct iw_request_info *info, 2208 union iwreq_data *wrqu, char *extra) 2209{ 2210 struct adapter *padapter; 2211 struct iw_point *p; 2212 u16 len; 2213 u32 addr; 2214 u32 data32; 2215 u32 bytes; 2216 u8 *ptmp; 2217 2218 padapter = (struct adapter *)rtw_netdev_priv(dev); 2219 p = &wrqu->data; 2220 len = p->length; 2221 ptmp = (u8 *)rtw_malloc(len); 2222 if (NULL == ptmp) 2223 return -ENOMEM; 2224 2225 if (copy_from_user(ptmp, p->pointer, len)) { 2226 kfree(ptmp); 2227 return -EFAULT; 2228 } 2229 2230 bytes = 0; 2231 addr = 0; 2232 sscanf(ptmp, "%d,%x", &bytes, &addr); 2233 2234 switch (bytes) { 2235 case 1: 2236 data32 = rtw_read8(padapter, addr); 2237 sprintf(extra, "0x%02X", data32); 2238 break; 2239 case 2: 2240 data32 = rtw_read16(padapter, addr); 2241 sprintf(extra, "0x%04X", data32); 2242 break; 2243 case 4: 2244 data32 = rtw_read32(padapter, addr); 2245 sprintf(extra, "0x%08X", data32); 2246 break; 2247 default: 2248 DBG_88E(KERN_INFO "%s: usage> read [bytes],[address(hex)]\n", __func__); 2249 return -EINVAL; 2250 } 2251 DBG_88E(KERN_INFO "%s: addr = 0x%08X data =%s\n", __func__, addr, extra); 2252 2253 kfree(ptmp); 2254 return 0; 2255} 2256 2257static int rtw_wx_write32(struct net_device *dev, 2258 struct iw_request_info *info, 2259 union iwreq_data *wrqu, char *extra) 2260{ 2261 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2262 2263 u32 addr; 2264 u32 data32; 2265 u32 bytes; 2266 2267 bytes = 0; 2268 addr = 0; 2269 data32 = 0; 2270 sscanf(extra, "%d,%x,%x", &bytes, &addr, &data32); 2271 2272 switch (bytes) { 2273 case 1: 2274 rtw_write8(padapter, addr, (u8)data32); 2275 DBG_88E(KERN_INFO "%s: addr = 0x%08X data = 0x%02X\n", __func__, addr, (u8)data32); 2276 break; 2277 case 2: 2278 rtw_write16(padapter, addr, (u16)data32); 2279 DBG_88E(KERN_INFO "%s: addr = 0x%08X data = 0x%04X\n", __func__, addr, (u16)data32); 2280 break; 2281 case 4: 2282 rtw_write32(padapter, addr, data32); 2283 DBG_88E(KERN_INFO "%s: addr = 0x%08X data = 0x%08X\n", __func__, addr, data32); 2284 break; 2285 default: 2286 DBG_88E(KERN_INFO "%s: usage> write [bytes],[address(hex)],[data(hex)]\n", __func__); 2287 return -EINVAL; 2288 } 2289 2290 return 0; 2291} 2292 2293static int rtw_wx_read_rf(struct net_device *dev, 2294 struct iw_request_info *info, 2295 union iwreq_data *wrqu, char *extra) 2296{ 2297 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2298 u32 path, addr, data32; 2299 2300 path = *(u32 *)extra; 2301 addr = *((u32 *)extra + 1); 2302 data32 = rtw_hal_read_rfreg(padapter, path, addr, 0xFFFFF); 2303 /* 2304 * IMPORTANT!! 2305 * Only when wireless private ioctl is at odd order, 2306 * "extra" would be copied to user space. 2307 */ 2308 sprintf(extra, "0x%05x", data32); 2309 2310 return 0; 2311} 2312 2313static int rtw_wx_write_rf(struct net_device *dev, 2314 struct iw_request_info *info, 2315 union iwreq_data *wrqu, char *extra) 2316{ 2317 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2318 u32 path, addr, data32; 2319 2320 path = *(u32 *)extra; 2321 addr = *((u32 *)extra + 1); 2322 data32 = *((u32 *)extra + 2); 2323 rtw_hal_write_rfreg(padapter, path, addr, 0xFFFFF, data32); 2324 2325 return 0; 2326} 2327 2328static int rtw_wx_priv_null(struct net_device *dev, struct iw_request_info *a, 2329 union iwreq_data *wrqu, char *b) 2330{ 2331 return -1; 2332} 2333 2334static int dummy(struct net_device *dev, struct iw_request_info *a, 2335 union iwreq_data *wrqu, char *b) 2336{ 2337 return -1; 2338} 2339 2340static int rtw_wx_set_channel_plan(struct net_device *dev, 2341 struct iw_request_info *info, 2342 union iwreq_data *wrqu, char *extra) 2343{ 2344 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2345 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2346 u8 channel_plan_req = (u8) (*((int *)wrqu)); 2347 2348 if (_SUCCESS == rtw_set_chplan_cmd(padapter, channel_plan_req, 1)) 2349 DBG_88E("%s set channel_plan = 0x%02X\n", __func__, pmlmepriv->ChannelPlan); 2350 else 2351 return -EPERM; 2352 2353 return 0; 2354} 2355 2356static int rtw_wx_set_mtk_wps_probe_ie(struct net_device *dev, 2357 struct iw_request_info *a, 2358 union iwreq_data *wrqu, char *b) 2359{ 2360 return 0; 2361} 2362 2363static int rtw_wx_get_sensitivity(struct net_device *dev, 2364 struct iw_request_info *info, 2365 union iwreq_data *wrqu, char *buf) 2366{ 2367 return 0; 2368} 2369 2370static int rtw_wx_set_mtk_wps_ie(struct net_device *dev, 2371 struct iw_request_info *info, 2372 union iwreq_data *wrqu, char *extra) 2373{ 2374 return 0; 2375} 2376 2377/* 2378 * For all data larger than 16 octets, we need to use a 2379 * pointer to memory allocated in user space. 2380 */ 2381static int rtw_drvext_hdl(struct net_device *dev, struct iw_request_info *info, 2382 union iwreq_data *wrqu, char *extra) 2383{ 2384 return 0; 2385} 2386 2387static void rtw_dbg_mode_hdl(struct adapter *padapter, u32 id, u8 *pdata, u32 len) 2388{ 2389 struct mp_rw_reg *RegRWStruct; 2390 struct rf_reg_param *prfreg; 2391 u8 path; 2392 u8 offset; 2393 u32 value; 2394 2395 DBG_88E("%s\n", __func__); 2396 2397 switch (id) { 2398 case GEN_MP_IOCTL_SUBCODE(MP_START): 2399 DBG_88E("871x_driver is only for normal mode, can't enter mp mode\n"); 2400 break; 2401 case GEN_MP_IOCTL_SUBCODE(READ_REG): 2402 RegRWStruct = (struct mp_rw_reg *)pdata; 2403 switch (RegRWStruct->width) { 2404 case 1: 2405 RegRWStruct->value = rtw_read8(padapter, RegRWStruct->offset); 2406 break; 2407 case 2: 2408 RegRWStruct->value = rtw_read16(padapter, RegRWStruct->offset); 2409 break; 2410 case 4: 2411 RegRWStruct->value = rtw_read32(padapter, RegRWStruct->offset); 2412 break; 2413 default: 2414 break; 2415 } 2416 2417 break; 2418 case GEN_MP_IOCTL_SUBCODE(WRITE_REG): 2419 RegRWStruct = (struct mp_rw_reg *)pdata; 2420 switch (RegRWStruct->width) { 2421 case 1: 2422 rtw_write8(padapter, RegRWStruct->offset, (u8)RegRWStruct->value); 2423 break; 2424 case 2: 2425 rtw_write16(padapter, RegRWStruct->offset, (u16)RegRWStruct->value); 2426 break; 2427 case 4: 2428 rtw_write32(padapter, RegRWStruct->offset, (u32)RegRWStruct->value); 2429 break; 2430 default: 2431 break; 2432 } 2433 2434 break; 2435 case GEN_MP_IOCTL_SUBCODE(READ_RF_REG): 2436 2437 prfreg = (struct rf_reg_param *)pdata; 2438 2439 path = (u8)prfreg->path; 2440 offset = (u8)prfreg->offset; 2441 2442 value = rtw_hal_read_rfreg(padapter, path, offset, 0xffffffff); 2443 2444 prfreg->value = value; 2445 2446 break; 2447 case GEN_MP_IOCTL_SUBCODE(WRITE_RF_REG): 2448 2449 prfreg = (struct rf_reg_param *)pdata; 2450 2451 path = (u8)prfreg->path; 2452 offset = (u8)prfreg->offset; 2453 value = prfreg->value; 2454 2455 rtw_hal_write_rfreg(padapter, path, offset, 0xffffffff, value); 2456 2457 break; 2458 case GEN_MP_IOCTL_SUBCODE(TRIGGER_GPIO): 2459 DBG_88E("==> trigger gpio 0\n"); 2460 rtw_hal_set_hwreg(padapter, HW_VAR_TRIGGER_GPIO_0, NULL); 2461 break; 2462 case GEN_MP_IOCTL_SUBCODE(GET_WIFI_STATUS): 2463 *pdata = rtw_hal_sreset_get_wifi_status(padapter); 2464 break; 2465 default: 2466 break; 2467 } 2468} 2469 2470static int rtw_mp_ioctl_hdl(struct net_device *dev, struct iw_request_info *info, 2471 union iwreq_data *wrqu, char *extra) 2472{ 2473 int ret = 0; 2474 u32 BytesRead, BytesWritten, BytesNeeded; 2475 struct oid_par_priv oid_par; 2476 struct mp_ioctl_handler *phandler; 2477 struct mp_ioctl_param *poidparam; 2478 uint status = 0; 2479 u16 len; 2480 u8 *pparmbuf = NULL, bset; 2481 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2482 struct iw_point *p = &wrqu->data; 2483 2484 if ((!p->length) || (!p->pointer)) { 2485 ret = -EINVAL; 2486 goto _rtw_mp_ioctl_hdl_exit; 2487 } 2488 pparmbuf = NULL; 2489 bset = (u8)(p->flags & 0xFFFF); 2490 len = p->length; 2491 pparmbuf = (u8 *)rtw_malloc(len); 2492 if (pparmbuf == NULL) { 2493 ret = -ENOMEM; 2494 goto _rtw_mp_ioctl_hdl_exit; 2495 } 2496 2497 if (copy_from_user(pparmbuf, p->pointer, len)) { 2498 ret = -EFAULT; 2499 goto _rtw_mp_ioctl_hdl_exit; 2500 } 2501 2502 poidparam = (struct mp_ioctl_param *)pparmbuf; 2503 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 2504 ("rtw_mp_ioctl_hdl: subcode [%d], len[%d], buffer_len[%d]\r\n", 2505 poidparam->subcode, poidparam->len, len)); 2506 2507 if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) { 2508 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("no matching drvext subcodes\r\n")); 2509 ret = -EINVAL; 2510 goto _rtw_mp_ioctl_hdl_exit; 2511 } 2512 2513 if (padapter->registrypriv.mp_mode == 1) { 2514 phandler = mp_ioctl_hdl + poidparam->subcode; 2515 2516 if ((phandler->paramsize != 0) && (poidparam->len < phandler->paramsize)) { 2517 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, 2518 ("no matching drvext param size %d vs %d\r\n", 2519 poidparam->len, phandler->paramsize)); 2520 ret = -EINVAL; 2521 goto _rtw_mp_ioctl_hdl_exit; 2522 } 2523 2524 if (phandler->handler) { 2525 oid_par.adapter_context = padapter; 2526 oid_par.oid = phandler->oid; 2527 oid_par.information_buf = poidparam->data; 2528 oid_par.information_buf_len = poidparam->len; 2529 oid_par.dbg = 0; 2530 2531 BytesWritten = 0; 2532 BytesNeeded = 0; 2533 2534 if (bset) { 2535 oid_par.bytes_rw = &BytesRead; 2536 oid_par.bytes_needed = &BytesNeeded; 2537 oid_par.type_of_oid = SET_OID; 2538 } else { 2539 oid_par.bytes_rw = &BytesWritten; 2540 oid_par.bytes_needed = &BytesNeeded; 2541 oid_par.type_of_oid = QUERY_OID; 2542 } 2543 2544 status = phandler->handler(&oid_par); 2545 } else { 2546 DBG_88E("rtw_mp_ioctl_hdl(): err!, subcode =%d, oid =%d, handler =%p\n", 2547 poidparam->subcode, phandler->oid, phandler->handler); 2548 ret = -EFAULT; 2549 goto _rtw_mp_ioctl_hdl_exit; 2550 } 2551 } else { 2552 rtw_dbg_mode_hdl(padapter, poidparam->subcode, poidparam->data, poidparam->len); 2553 } 2554 2555 if (bset == 0x00) {/* query info */ 2556 if (copy_to_user(p->pointer, pparmbuf, len)) 2557 ret = -EFAULT; 2558 } 2559 2560 if (status) { 2561 ret = -EFAULT; 2562 goto _rtw_mp_ioctl_hdl_exit; 2563 } 2564 2565_rtw_mp_ioctl_hdl_exit: 2566 2567 kfree(pparmbuf); 2568 return ret; 2569} 2570 2571static int rtw_get_ap_info(struct net_device *dev, 2572 struct iw_request_info *info, 2573 union iwreq_data *wrqu, char *extra) 2574{ 2575 int ret = 0; 2576 u32 cnt = 0, wpa_ielen; 2577 unsigned long irqL; 2578 struct list_head *plist, *phead; 2579 unsigned char *pbuf; 2580 u8 bssid[ETH_ALEN]; 2581 char data[32]; 2582 struct wlan_network *pnetwork = NULL; 2583 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2584 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 2585 struct __queue *queue = &(pmlmepriv->scanned_queue); 2586 struct iw_point *pdata = &wrqu->data; 2587 2588 DBG_88E("+rtw_get_aplist_info\n"); 2589 2590 if ((padapter->bDriverStopped) || (pdata == NULL)) { 2591 ret = -EINVAL; 2592 goto exit; 2593 } 2594 2595 while ((check_fwstate(pmlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)))) { 2596 rtw_msleep_os(30); 2597 cnt++; 2598 if (cnt > 100) 2599 break; 2600 } 2601 pdata->flags = 0; 2602 if (pdata->length >= 32) { 2603 if (copy_from_user(data, pdata->pointer, 32)) { 2604 ret = -EINVAL; 2605 goto exit; 2606 } 2607 } else { 2608 ret = -EINVAL; 2609 goto exit; 2610 } 2611 2612 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 2613 2614 phead = get_list_head(queue); 2615 plist = get_next(phead); 2616 2617 while (1) { 2618 if (rtw_end_of_queue_search(phead, plist) == true) 2619 break; 2620 2621 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 2622 2623 if (hwaddr_aton_i(data, bssid)) { 2624 DBG_88E("Invalid BSSID '%s'.\n", (u8 *)data); 2625 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 2626 return -EINVAL; 2627 } 2628 2629 if (!memcmp(bssid, pnetwork->network.MacAddress, ETH_ALEN)) { 2630 /* BSSID match, then check if supporting wpa/wpa2 */ 2631 DBG_88E("BSSID:%pM\n", (bssid)); 2632 2633 pbuf = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12); 2634 if (pbuf && (wpa_ielen > 0)) { 2635 pdata->flags = 1; 2636 break; 2637 } 2638 2639 pbuf = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12); 2640 if (pbuf && (wpa_ielen > 0)) { 2641 pdata->flags = 2; 2642 break; 2643 } 2644 } 2645 2646 plist = get_next(plist); 2647 } 2648 2649 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 2650 2651 if (pdata->length >= 34) { 2652 if (copy_to_user(pdata->pointer+32, (u8 *)&pdata->flags, 1)) { 2653 ret = -EINVAL; 2654 goto exit; 2655 } 2656 } 2657 2658exit: 2659 2660 return ret; 2661} 2662 2663static int rtw_set_pid(struct net_device *dev, 2664 struct iw_request_info *info, 2665 union iwreq_data *wrqu, char *extra) 2666{ 2667 int ret = 0; 2668 struct adapter *padapter = rtw_netdev_priv(dev); 2669 int *pdata = (int *)wrqu; 2670 int selector; 2671 2672 if ((padapter->bDriverStopped) || (pdata == NULL)) { 2673 ret = -EINVAL; 2674 goto exit; 2675 } 2676 2677 selector = *pdata; 2678 if (selector < 3 && selector >= 0) { 2679 padapter->pid[selector] = *(pdata+1); 2680 ui_pid[selector] = *(pdata+1); 2681 DBG_88E("%s set pid[%d] =%d\n", __func__, selector, padapter->pid[selector]); 2682 } else { 2683 DBG_88E("%s selector %d error\n", __func__, selector); 2684 } 2685exit: 2686 return ret; 2687} 2688 2689static int rtw_wps_start(struct net_device *dev, 2690 struct iw_request_info *info, 2691 union iwreq_data *wrqu, char *extra) 2692{ 2693 int ret = 0; 2694 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2695 struct iw_point *pdata = &wrqu->data; 2696 u32 u32wps_start = 0; 2697 2698 ret = copy_from_user((void *)&u32wps_start, pdata->pointer, 4); 2699 if (ret) { 2700 ret = -EINVAL; 2701 goto exit; 2702 } 2703 2704 if ((padapter->bDriverStopped) || (pdata == NULL)) { 2705 ret = -EINVAL; 2706 goto exit; 2707 } 2708 2709 if (u32wps_start == 0) 2710 u32wps_start = *extra; 2711 2712 DBG_88E("[%s] wps_start = %d\n", __func__, u32wps_start); 2713 2714 if (u32wps_start == 1) /* WPS Start */ 2715 rtw_led_control(padapter, LED_CTL_START_WPS); 2716 else if (u32wps_start == 2) /* WPS Stop because of wps success */ 2717 rtw_led_control(padapter, LED_CTL_STOP_WPS); 2718 else if (u32wps_start == 3) /* WPS Stop because of wps fail */ 2719 rtw_led_control(padapter, LED_CTL_STOP_WPS_FAIL); 2720 2721exit: 2722 return ret; 2723} 2724 2725#ifdef CONFIG_88EU_P2P 2726static int rtw_wext_p2p_enable(struct net_device *dev, 2727 struct iw_request_info *info, 2728 union iwreq_data *wrqu, char *extra) 2729{ 2730 int ret = 0; 2731 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2732 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2733 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2734 enum P2P_ROLE init_role = P2P_ROLE_DISABLE; 2735 2736 if (*extra == '0') 2737 init_role = P2P_ROLE_DISABLE; 2738 else if (*extra == '1') 2739 init_role = P2P_ROLE_DEVICE; 2740 else if (*extra == '2') 2741 init_role = P2P_ROLE_CLIENT; 2742 else if (*extra == '3') 2743 init_role = P2P_ROLE_GO; 2744 2745 if (_FAIL == rtw_p2p_enable(padapter, init_role)) { 2746 ret = -EFAULT; 2747 goto exit; 2748 } 2749 2750 /* set channel/bandwidth */ 2751 if (init_role != P2P_ROLE_DISABLE) { 2752 u8 channel, ch_offset; 2753 u16 bwmode; 2754 2755 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_LISTEN)) { 2756 /* Stay at the listen state and wait for discovery. */ 2757 channel = pwdinfo->listen_channel; 2758 pwdinfo->operating_channel = pwdinfo->listen_channel; 2759 ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 2760 bwmode = HT_CHANNEL_WIDTH_20; 2761 } else { 2762 pwdinfo->operating_channel = pmlmeext->cur_channel; 2763 2764 channel = pwdinfo->operating_channel; 2765 ch_offset = pmlmeext->cur_ch_offset; 2766 bwmode = pmlmeext->cur_bwmode; 2767 } 2768 2769 set_channel_bwmode(padapter, channel, ch_offset, bwmode); 2770 } 2771 2772exit: 2773 return ret; 2774} 2775 2776static int rtw_p2p_set_go_nego_ssid(struct net_device *dev, 2777 struct iw_request_info *info, 2778 union iwreq_data *wrqu, char *extra) 2779{ 2780 int ret = 0; 2781 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2782 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2783 2784 DBG_88E("[%s] ssid = %s, len = %zu\n", __func__, extra, strlen(extra)); 2785 memcpy(pwdinfo->nego_ssid, extra, strlen(extra)); 2786 pwdinfo->nego_ssidlen = strlen(extra); 2787 2788 return ret; 2789} 2790 2791static int rtw_p2p_set_intent(struct net_device *dev, 2792 struct iw_request_info *info, 2793 union iwreq_data *wrqu, char *extra) 2794{ 2795 int ret = 0; 2796 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2797 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2798 u8 intent = pwdinfo->intent; 2799 2800 switch (wrqu->data.length) { 2801 case 1: 2802 intent = extra[0] - '0'; 2803 break; 2804 case 2: 2805 intent = str_2char2num(extra[0], extra[1]); 2806 break; 2807 } 2808 if (intent <= 15) 2809 pwdinfo->intent = intent; 2810 else 2811 ret = -1; 2812 DBG_88E("[%s] intent = %d\n", __func__, intent); 2813 return ret; 2814} 2815 2816static int rtw_p2p_set_listen_ch(struct net_device *dev, 2817 struct iw_request_info *info, 2818 union iwreq_data *wrqu, char *extra) 2819{ 2820 int ret = 0; 2821 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2822 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2823 u8 listen_ch = pwdinfo->listen_channel; /* Listen channel number */ 2824 2825 switch (wrqu->data.length) { 2826 case 1: 2827 listen_ch = extra[0] - '0'; 2828 break; 2829 case 2: 2830 listen_ch = str_2char2num(extra[0], extra[1]); 2831 break; 2832 } 2833 2834 if ((listen_ch == 1) || (listen_ch == 6) || (listen_ch == 11)) { 2835 pwdinfo->listen_channel = listen_ch; 2836 set_channel_bwmode(padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20); 2837 } else { 2838 ret = -1; 2839 } 2840 2841 DBG_88E("[%s] listen_ch = %d\n", __func__, pwdinfo->listen_channel); 2842 2843 return ret; 2844} 2845 2846static int rtw_p2p_set_op_ch(struct net_device *dev, 2847 struct iw_request_info *info, 2848 union iwreq_data *wrqu, char *extra) 2849{ 2850/* Commented by Albert 20110524 */ 2851/* This function is used to set the operating channel if the driver will become the group owner */ 2852 2853 int ret = 0; 2854 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2855 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2856 u8 op_ch = pwdinfo->operating_channel; /* Operating channel number */ 2857 2858 switch (wrqu->data.length) { 2859 case 1: 2860 op_ch = extra[0] - '0'; 2861 break; 2862 case 2: 2863 op_ch = str_2char2num(extra[0], extra[1]); 2864 break; 2865 } 2866 2867 if (op_ch > 0) 2868 pwdinfo->operating_channel = op_ch; 2869 else 2870 ret = -1; 2871 2872 DBG_88E("[%s] op_ch = %d\n", __func__, pwdinfo->operating_channel); 2873 2874 return ret; 2875} 2876 2877static int rtw_p2p_profilefound(struct net_device *dev, 2878 struct iw_request_info *info, 2879 union iwreq_data *wrqu, char *extra) 2880{ 2881 int ret = 0; 2882 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2883 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2884 2885 /* Comment by Albert 2010/10/13 */ 2886 /* Input data format: */ 2887 /* Ex: 0 */ 2888 /* Ex: 1XX:XX:XX:XX:XX:XXYYSSID */ 2889 /* 0 => Reflush the profile record list. */ 2890 /* 1 => Add the profile list */ 2891 /* XX:XX:XX:XX:XX:XX => peer's MAC Address (ex: 00:E0:4C:00:00:01) */ 2892 /* YY => SSID Length */ 2893 /* SSID => SSID for persistence group */ 2894 2895 DBG_88E("[%s] In value = %s, len = %d\n", __func__, extra, wrqu->data.length - 1); 2896 2897 /* The upper application should pass the SSID to driver by using this rtw_p2p_profilefound function. */ 2898 if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) { 2899 if (extra[0] == '0') { 2900 /* Remove all the profile information of wifidirect_info structure. */ 2901 _rtw_memset(&pwdinfo->profileinfo[0], 0x00, sizeof(struct profile_info) * P2P_MAX_PERSISTENT_GROUP_NUM); 2902 pwdinfo->profileindex = 0; 2903 } else { 2904 if (pwdinfo->profileindex >= P2P_MAX_PERSISTENT_GROUP_NUM) { 2905 ret = -1; 2906 } else { 2907 int jj, kk; 2908 2909 /* Add this profile information into pwdinfo->profileinfo */ 2910 /* Ex: 1XX:XX:XX:XX:XX:XXYYSSID */ 2911 for (jj = 0, kk = 1; jj < ETH_ALEN; jj++, kk += 3) 2912 pwdinfo->profileinfo[pwdinfo->profileindex].peermac[jj] = key_2char2num(extra[kk], extra[kk + 1]); 2913 2914 pwdinfo->profileinfo[pwdinfo->profileindex].ssidlen = (extra[18] - '0') * 10 + (extra[19] - '0'); 2915 memcpy(pwdinfo->profileinfo[pwdinfo->profileindex].ssid, &extra[20], pwdinfo->profileinfo[pwdinfo->profileindex].ssidlen); 2916 pwdinfo->profileindex++; 2917 } 2918 } 2919 } 2920 2921 return ret; 2922} 2923 2924static int rtw_p2p_setDN(struct net_device *dev, 2925 struct iw_request_info *info, 2926 union iwreq_data *wrqu, char *extra) 2927{ 2928 int ret = 0; 2929 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2930 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2931 2932 DBG_88E("[%s] %s %d\n", __func__, extra, wrqu->data.length - 1); 2933 _rtw_memset(pwdinfo->device_name, 0x00, WPS_MAX_DEVICE_NAME_LEN); 2934 memcpy(pwdinfo->device_name, extra, wrqu->data.length - 1); 2935 pwdinfo->device_name_len = wrqu->data.length - 1; 2936 2937 return ret; 2938} 2939 2940static int rtw_p2p_get_status(struct net_device *dev, 2941 struct iw_request_info *info, 2942 union iwreq_data *wrqu, char *extra) 2943{ 2944 int ret = 0; 2945 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2946 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2947 2948 if (padapter->bShowGetP2PState) 2949 DBG_88E("[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __func__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo), 2950 pwdinfo->p2p_peer_interface_addr[0], pwdinfo->p2p_peer_interface_addr[1], pwdinfo->p2p_peer_interface_addr[2], 2951 pwdinfo->p2p_peer_interface_addr[3], pwdinfo->p2p_peer_interface_addr[4], pwdinfo->p2p_peer_interface_addr[5]); 2952 2953 /* Commented by Albert 2010/10/12 */ 2954 /* Because of the output size limitation, I had removed the "Role" information. */ 2955 /* About the "Role" information, we will use the new private IOCTL to get the "Role" information. */ 2956 sprintf(extra, "\n\nStatus =%.2d\n", rtw_p2p_state(pwdinfo)); 2957 wrqu->data.length = strlen(extra); 2958 2959 return ret; 2960} 2961 2962/* Commented by Albert 20110520 */ 2963/* This function will return the config method description */ 2964/* This config method description will show us which config method the remote P2P device is intended to use */ 2965/* by sending the provisioning discovery request frame. */ 2966 2967static int rtw_p2p_get_req_cm(struct net_device *dev, 2968 struct iw_request_info *info, 2969 union iwreq_data *wrqu, char *extra) 2970{ 2971 int ret = 0; 2972 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2973 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2974 2975 sprintf(extra, "\n\nCM =%s\n", pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req); 2976 wrqu->data.length = strlen(extra); 2977 return ret; 2978} 2979 2980static int rtw_p2p_get_role(struct net_device *dev, 2981 struct iw_request_info *info, 2982 union iwreq_data *wrqu, char *extra) 2983{ 2984 int ret = 0; 2985 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 2986 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 2987 2988 DBG_88E("[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __func__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo), 2989 pwdinfo->p2p_peer_interface_addr[0], pwdinfo->p2p_peer_interface_addr[1], pwdinfo->p2p_peer_interface_addr[2], 2990 pwdinfo->p2p_peer_interface_addr[3], pwdinfo->p2p_peer_interface_addr[4], pwdinfo->p2p_peer_interface_addr[5]); 2991 2992 sprintf(extra, "\n\nRole =%.2d\n", rtw_p2p_role(pwdinfo)); 2993 wrqu->data.length = strlen(extra); 2994 return ret; 2995} 2996 2997static int rtw_p2p_get_peer_ifaddr(struct net_device *dev, 2998 struct iw_request_info *info, 2999 union iwreq_data *wrqu, char *extra) 3000{ 3001 int ret = 0; 3002 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3003 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3004 3005 DBG_88E("[%s] Role = %d, Status = %d, peer addr = %pM\n", __func__, 3006 rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo), 3007 pwdinfo->p2p_peer_interface_addr); 3008 sprintf(extra, "\nMAC %pM", 3009 pwdinfo->p2p_peer_interface_addr); 3010 wrqu->data.length = strlen(extra); 3011 return ret; 3012} 3013 3014static int rtw_p2p_get_peer_devaddr(struct net_device *dev, 3015 struct iw_request_info *info, 3016 union iwreq_data *wrqu, char *extra) 3017 3018{ 3019 int ret = 0; 3020 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3021 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3022 3023 DBG_88E("[%s] Role = %d, Status = %d, peer addr = %pM\n", __func__, 3024 rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo), 3025 pwdinfo->rx_prov_disc_info.peerDevAddr); 3026 sprintf(extra, "\n%pM", 3027 pwdinfo->rx_prov_disc_info.peerDevAddr); 3028 wrqu->data.length = strlen(extra); 3029 return ret; 3030} 3031 3032static int rtw_p2p_get_peer_devaddr_by_invitation(struct net_device *dev, 3033 struct iw_request_info *info, 3034 union iwreq_data *wrqu, char *extra) 3035 3036{ 3037 int ret = 0; 3038 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3039 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3040 3041 DBG_88E("[%s] Role = %d, Status = %d, peer addr = %pM\n", 3042 __func__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo), 3043 pwdinfo->p2p_peer_device_addr); 3044 sprintf(extra, "\nMAC %pM", 3045 pwdinfo->p2p_peer_device_addr); 3046 wrqu->data.length = strlen(extra); 3047 return ret; 3048} 3049 3050static int rtw_p2p_get_groupid(struct net_device *dev, 3051 struct iw_request_info *info, 3052 union iwreq_data *wrqu, char *extra) 3053 3054{ 3055 int ret = 0; 3056 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3057 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3058 3059 sprintf(extra, "\n%.2X:%.2X:%.2X:%.2X:%.2X:%.2X %s", 3060 pwdinfo->groupid_info.go_device_addr[0], pwdinfo->groupid_info.go_device_addr[1], 3061 pwdinfo->groupid_info.go_device_addr[2], pwdinfo->groupid_info.go_device_addr[3], 3062 pwdinfo->groupid_info.go_device_addr[4], pwdinfo->groupid_info.go_device_addr[5], 3063 pwdinfo->groupid_info.ssid); 3064 wrqu->data.length = strlen(extra); 3065 return ret; 3066} 3067 3068static int rtw_p2p_get_op_ch(struct net_device *dev, 3069 struct iw_request_info *info, 3070 union iwreq_data *wrqu, char *extra) 3071 3072{ 3073 int ret = 0; 3074 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3075 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3076 3077 DBG_88E("[%s] Op_ch = %02x\n", __func__, pwdinfo->operating_channel); 3078 3079 sprintf(extra, "\n\nOp_ch =%.2d\n", pwdinfo->operating_channel); 3080 wrqu->data.length = strlen(extra); 3081 return ret; 3082} 3083 3084static int rtw_p2p_get_wps_configmethod(struct net_device *dev, 3085 struct iw_request_info *info, 3086 union iwreq_data *wrqu, char *extra) 3087{ 3088 int ret = 0; 3089 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3090 u8 peerMAC[ETH_ALEN] = {0x00}; 3091 int jj, kk; 3092 u8 peerMACStr[17] = {0x00}; 3093 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3094 unsigned long irqL; 3095 struct list_head *plist, *phead; 3096 struct __queue *queue = &(pmlmepriv->scanned_queue); 3097 struct wlan_network *pnetwork = NULL; 3098 u8 blnMatch = 0; 3099 u16 attr_content = 0; 3100 uint attr_contentlen = 0; 3101 /* 6 is the string "wpsCM =", 17 is the MAC addr, we have to clear it at wrqu->data.pointer */ 3102 u8 attr_content_str[6 + 17] = {0x00}; 3103 3104 /* Commented by Albert 20110727 */ 3105 /* The input data is the MAC address which the application wants to know its WPS config method. */ 3106 /* After knowing its WPS config method, the application can decide the config method for provisioning discovery. */ 3107 /* Format: iwpriv wlanx p2p_get_wpsCM 00:E0:4C:00:00:05 */ 3108 3109 DBG_88E("[%s] data = %s\n", __func__, (char *)extra); 3110 if (copy_from_user(peerMACStr, wrqu->data.pointer + 6, 17)) 3111 return -EFAULT; 3112 3113 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3114 peerMAC[jj] = key_2char2num(peerMACStr[kk], peerMACStr[kk + 1]); 3115 3116 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3117 3118 phead = get_list_head(queue); 3119 plist = get_next(phead); 3120 3121 while (1) { 3122 if (rtw_end_of_queue_search(phead, plist) == true) 3123 break; 3124 3125 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3126 if (!memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN)) { 3127 u8 *wpsie; 3128 uint wpsie_len = 0; 3129 __be16 be_tmp; 3130 3131 /* The mac address is matched. */ 3132 wpsie = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &wpsie_len); 3133 if (wpsie) { 3134 rtw_get_wps_attr_content(wpsie, wpsie_len, WPS_ATTR_CONF_METHOD, (u8 *) &be_tmp, &attr_contentlen); 3135 if (attr_contentlen) { 3136 attr_content = be16_to_cpu(be_tmp); 3137 sprintf(attr_content_str, "\n\nM =%.4d", attr_content); 3138 blnMatch = 1; 3139 } 3140 } 3141 break; 3142 } 3143 plist = get_next(plist); 3144 } 3145 3146 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3147 3148 if (!blnMatch) 3149 sprintf(attr_content_str, "\n\nM = 0000"); 3150 3151 if (copy_to_user(wrqu->data.pointer, attr_content_str, 6 + 17)) 3152 return -EFAULT; 3153 return ret; 3154} 3155 3156static int rtw_p2p_get_go_device_address(struct net_device *dev, 3157 struct iw_request_info *info, 3158 union iwreq_data *wrqu, char *extra) 3159{ 3160 int ret = 0; 3161 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3162 u8 peerMAC[ETH_ALEN] = {0x00}; 3163 int jj, kk; 3164 u8 peerMACStr[17] = {0x00}; 3165 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3166 unsigned long irqL; 3167 struct list_head *plist, *phead; 3168 struct __queue *queue = &(pmlmepriv->scanned_queue); 3169 struct wlan_network *pnetwork = NULL; 3170 u8 blnMatch = 0; 3171 u8 *p2pie; 3172 uint p2pielen = 0, attr_contentlen = 0; 3173 u8 attr_content[100] = {0x00}; 3174 3175 u8 go_devadd_str[17 + 10] = {0x00}; 3176 /* +10 is for the str "go_devadd =", we have to clear it at wrqu->data.pointer */ 3177 3178 /* Commented by Albert 20121209 */ 3179 /* The input data is the GO's interface address which the application wants to know its device address. */ 3180 /* Format: iwpriv wlanx p2p_get2 go_devadd = 00:E0:4C:00:00:05 */ 3181 3182 DBG_88E("[%s] data = %s\n", __func__, (char *)extra); 3183 if (copy_from_user(peerMACStr, wrqu->data.pointer + 10, 17)) 3184 return -EFAULT; 3185 3186 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3187 peerMAC[jj] = key_2char2num(peerMACStr[kk], peerMACStr[kk + 1]); 3188 3189 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3190 3191 phead = get_list_head(queue); 3192 plist = get_next(phead); 3193 3194 while (1) { 3195 if (rtw_end_of_queue_search(phead, plist) == true) 3196 break; 3197 3198 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3199 if (!memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN)) { 3200 /* Commented by Albert 2011/05/18 */ 3201 /* Match the device address located in the P2P IE */ 3202 /* This is for the case that the P2P device address is not the same as the P2P interface address. */ 3203 3204 p2pie = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &p2pielen); 3205 if (p2pie) { 3206 while (p2pie) { 3207 /* The P2P Device ID attribute is included in the Beacon frame. */ 3208 /* The P2P Device Info attribute is included in the probe response frame. */ 3209 3210 _rtw_memset(attr_content, 0x00, 100); 3211 if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen)) { 3212 /* Handle the P2P Device ID attribute of Beacon first */ 3213 blnMatch = 1; 3214 break; 3215 } else if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen)) { 3216 /* Handle the P2P Device Info attribute of probe response */ 3217 blnMatch = 1; 3218 break; 3219 } 3220 3221 /* Get the next P2P IE */ 3222 p2pie = rtw_get_p2p_ie(p2pie+p2pielen, pnetwork->network.IELength - 12 - (p2pie - &pnetwork->network.IEs[12] + p2pielen), NULL, &p2pielen); 3223 } 3224 } 3225 } 3226 3227 plist = get_next(plist); 3228 } 3229 3230 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3231 3232 if (!blnMatch) 3233 sprintf(go_devadd_str, "\n\ndev_add = NULL"); 3234 else 3235 sprintf(go_devadd_str, "\n\ndev_add =%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", 3236 attr_content[0], attr_content[1], attr_content[2], attr_content[3], attr_content[4], attr_content[5]); 3237 3238 if (copy_to_user(wrqu->data.pointer, go_devadd_str, 10 + 17)) 3239 return -EFAULT; 3240 return ret; 3241} 3242 3243static int rtw_p2p_get_device_type(struct net_device *dev, 3244 struct iw_request_info *info, 3245 union iwreq_data *wrqu, char *extra) 3246{ 3247 int ret = 0; 3248 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3249 u8 peerMAC[ETH_ALEN] = {0x00}; 3250 int jj, kk; 3251 u8 peerMACStr[17] = {0x00}; 3252 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3253 unsigned long irqL; 3254 struct list_head *plist, *phead; 3255 struct __queue *queue = &(pmlmepriv->scanned_queue); 3256 struct wlan_network *pnetwork = NULL; 3257 u8 blnMatch = 0; 3258 u8 dev_type[8] = {0x00}; 3259 uint dev_type_len = 0; 3260 u8 dev_type_str[17 + 9] = {0x00}; /* +9 is for the str "dev_type =", we have to clear it at wrqu->data.pointer */ 3261 3262 /* Commented by Albert 20121209 */ 3263 /* The input data is the MAC address which the application wants to know its device type. */ 3264 /* Such user interface could know the device type. */ 3265 /* Format: iwpriv wlanx p2p_get2 dev_type = 00:E0:4C:00:00:05 */ 3266 3267 DBG_88E("[%s] data = %s\n", __func__, (char *)extra); 3268 if (copy_from_user(peerMACStr, wrqu->data.pointer + 9, 17)) 3269 return -EFAULT; 3270 3271 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3272 peerMAC[jj] = key_2char2num(peerMACStr[kk], peerMACStr[kk + 1]); 3273 3274 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3275 3276 phead = get_list_head(queue); 3277 plist = get_next(phead); 3278 3279 while (1) { 3280 if (rtw_end_of_queue_search(phead, plist) == true) 3281 break; 3282 3283 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3284 if (!memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN)) { 3285 u8 *wpsie; 3286 uint wpsie_len = 0; 3287 3288 /* The mac address is matched. */ 3289 3290 wpsie = rtw_get_wps_ie(&pnetwork->network.IEs[12], 3291 pnetwork->network.IELength - 12, 3292 NULL, &wpsie_len); 3293 if (wpsie) { 3294 rtw_get_wps_attr_content(wpsie, wpsie_len, WPS_ATTR_PRIMARY_DEV_TYPE, dev_type, &dev_type_len); 3295 if (dev_type_len) { 3296 u16 type = 0; 3297 __be16 be_tmp; 3298 3299 memcpy(&be_tmp, dev_type, 2); 3300 type = be16_to_cpu(be_tmp); 3301 sprintf(dev_type_str, "\n\nN =%.2d", type); 3302 blnMatch = 1; 3303 } 3304 } 3305 break; 3306 } 3307 3308 plist = get_next(plist); 3309 } 3310 3311 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3312 3313 if (!blnMatch) 3314 sprintf(dev_type_str, "\n\nN = 00"); 3315 3316 if (copy_to_user(wrqu->data.pointer, dev_type_str, 9 + 17)) { 3317 return -EFAULT; 3318 } 3319 3320 return ret; 3321} 3322 3323static int rtw_p2p_get_device_name(struct net_device *dev, 3324 struct iw_request_info *info, 3325 union iwreq_data *wrqu, char *extra) 3326{ 3327 int ret = 0; 3328 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3329 u8 peerMAC[ETH_ALEN] = {0x00}; 3330 int jj, kk; 3331 u8 peerMACStr[17] = {0x00}; 3332 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3333 unsigned long irqL; 3334 struct list_head *plist, *phead; 3335 struct __queue *queue = &(pmlmepriv->scanned_queue); 3336 struct wlan_network *pnetwork = NULL; 3337 u8 blnMatch = 0; 3338 u8 dev_name[WPS_MAX_DEVICE_NAME_LEN] = {0x00}; 3339 uint dev_len = 0; 3340 u8 dev_name_str[WPS_MAX_DEVICE_NAME_LEN + 5] = {0x00}; /* +5 is for the str "devN =", we have to clear it at wrqu->data.pointer */ 3341 3342 /* Commented by Albert 20121225 */ 3343 /* The input data is the MAC address which the application wants to know its device name. */ 3344 /* Such user interface could show peer device's device name instead of ssid. */ 3345 /* Format: iwpriv wlanx p2p_get2 devN = 00:E0:4C:00:00:05 */ 3346 3347 DBG_88E("[%s] data = %s\n", __func__, (char *)extra); 3348 if (copy_from_user(peerMACStr, wrqu->data.pointer + 5, 17)) 3349 return -EFAULT; 3350 3351 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3352 peerMAC[jj] = key_2char2num(peerMACStr[kk], peerMACStr[kk + 1]); 3353 3354 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3355 3356 phead = get_list_head(queue); 3357 plist = get_next(phead); 3358 3359 while (1) { 3360 if (rtw_end_of_queue_search(phead, plist) == true) 3361 break; 3362 3363 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3364 if (!memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN)) { 3365 u8 *wpsie; 3366 uint wpsie_len = 0; 3367 3368 /* The mac address is matched. */ 3369 wpsie = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &wpsie_len); 3370 if (wpsie) { 3371 rtw_get_wps_attr_content(wpsie, wpsie_len, WPS_ATTR_DEVICE_NAME, dev_name, &dev_len); 3372 if (dev_len) { 3373 sprintf(dev_name_str, "\n\nN =%s", dev_name); 3374 blnMatch = 1; 3375 } 3376 } 3377 break; 3378 } 3379 3380 plist = get_next(plist); 3381 } 3382 3383 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3384 3385 if (!blnMatch) 3386 sprintf(dev_name_str, "\n\nN = 0000"); 3387 3388 if (copy_to_user(wrqu->data.pointer, dev_name_str, 5 + ((dev_len > 17) ? dev_len : 17))) 3389 return -EFAULT; 3390 return ret; 3391} 3392 3393static int rtw_p2p_get_invitation_procedure(struct net_device *dev, 3394 struct iw_request_info *info, 3395 union iwreq_data *wrqu, char *extra) 3396{ 3397 int ret = 0; 3398 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3399 u8 peerMAC[ETH_ALEN] = {0x00}; 3400 int jj, kk; 3401 u8 peerMACStr[17] = {0x00}; 3402 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3403 unsigned long irqL; 3404 struct list_head *plist, *phead; 3405 struct __queue *queue = &(pmlmepriv->scanned_queue); 3406 struct wlan_network *pnetwork = NULL; 3407 u8 blnMatch = 0; 3408 u8 *p2pie; 3409 uint p2pielen = 0, attr_contentlen = 0; 3410 u8 attr_content[2] = {0x00}; 3411 3412 u8 inv_proc_str[17 + 8] = {0x00}; 3413 /* +8 is for the str "InvProc =", we have to clear it at wrqu->data.pointer */ 3414 3415 /* Commented by Ouden 20121226 */ 3416 /* The application wants to know P2P initiation procedure is supported or not. */ 3417 /* Format: iwpriv wlanx p2p_get2 InvProc = 00:E0:4C:00:00:05 */ 3418 3419 DBG_88E("[%s] data = %s\n", __func__, (char *)extra); 3420 if (copy_from_user(peerMACStr, wrqu->data.pointer + 8, 17)) 3421 return -EFAULT; 3422 3423 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3424 peerMAC[jj] = key_2char2num(peerMACStr[kk], peerMACStr[kk + 1]); 3425 3426 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3427 3428 phead = get_list_head(queue); 3429 plist = get_next(phead); 3430 3431 while (1) { 3432 if (rtw_end_of_queue_search(phead, plist) == true) 3433 break; 3434 3435 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3436 if (!memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN)) { 3437 /* Commented by Albert 20121226 */ 3438 /* Match the device address located in the P2P IE */ 3439 /* This is for the case that the P2P device address is not the same as the P2P interface address. */ 3440 3441 p2pie = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &p2pielen); 3442 if (p2pie) { 3443 while (p2pie) { 3444 if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_CAPABILITY, attr_content, &attr_contentlen)) { 3445 /* Handle the P2P capability attribute */ 3446 blnMatch = 1; 3447 break; 3448 } 3449 3450 /* Get the next P2P IE */ 3451 p2pie = rtw_get_p2p_ie(p2pie+p2pielen, pnetwork->network.IELength - 12 - (p2pie - &pnetwork->network.IEs[12] + p2pielen), NULL, &p2pielen); 3452 } 3453 } 3454 } 3455 plist = get_next(plist); 3456 } 3457 3458 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3459 3460 if (!blnMatch) { 3461 sprintf(inv_proc_str, "\nIP =-1"); 3462 } else { 3463 if (attr_content[0] & 0x20) 3464 sprintf(inv_proc_str, "\nIP = 1"); 3465 else 3466 sprintf(inv_proc_str, "\nIP = 0"); 3467 } 3468 if (copy_to_user(wrqu->data.pointer, inv_proc_str, 8 + 17)) 3469 return -EFAULT; 3470 return ret; 3471} 3472 3473static int rtw_p2p_connect(struct net_device *dev, 3474 struct iw_request_info *info, 3475 union iwreq_data *wrqu, char *extra) 3476{ 3477 int ret = 0; 3478 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3479 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3480 u8 peerMAC[ETH_ALEN] = {0x00}; 3481 int jj, kk; 3482 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3483 unsigned long irqL; 3484 struct list_head *plist, *phead; 3485 struct __queue *queue = &(pmlmepriv->scanned_queue); 3486 struct wlan_network *pnetwork = NULL; 3487 uint uintPeerChannel = 0; 3488 3489 /* Commented by Albert 20110304 */ 3490 /* The input data contains two informations. */ 3491 /* 1. First information is the MAC address which wants to formate with */ 3492 /* 2. Second information is the WPS PINCode or "pbc" string for push button method */ 3493 /* Format: 00:E0:4C:00:00:05 */ 3494 /* Format: 00:E0:4C:00:00:05 */ 3495 3496 DBG_88E("[%s] data = %s\n", __func__, extra); 3497 3498 if (pwdinfo->p2p_state == P2P_STATE_NONE) { 3499 DBG_88E("[%s] WiFi Direct is disable!\n", __func__); 3500 return ret; 3501 } 3502 3503 if (pwdinfo->ui_got_wps_info == P2P_NO_WPSINFO) 3504 return -1; 3505 3506 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3507 peerMAC[jj] = key_2char2num(extra[kk], extra[kk + 1]); 3508 3509 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3510 3511 phead = get_list_head(queue); 3512 plist = get_next(phead); 3513 3514 while (1) { 3515 if (rtw_end_of_queue_search(phead, plist) == true) 3516 break; 3517 3518 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3519 if (!memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN)) { 3520 uintPeerChannel = pnetwork->network.Configuration.DSConfig; 3521 break; 3522 } 3523 3524 plist = get_next(plist); 3525 } 3526 3527 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3528 3529 if (uintPeerChannel) { 3530 _rtw_memset(&pwdinfo->nego_req_info, 0x00, sizeof(struct tx_nego_req_info)); 3531 _rtw_memset(&pwdinfo->groupid_info, 0x00, sizeof(struct group_id_info)); 3532 3533 pwdinfo->nego_req_info.peer_channel_num[0] = uintPeerChannel; 3534 memcpy(pwdinfo->nego_req_info.peerDevAddr, pnetwork->network.MacAddress, ETH_ALEN); 3535 pwdinfo->nego_req_info.benable = true; 3536 3537 _cancel_timer_ex(&pwdinfo->restore_p2p_state_timer); 3538 if (rtw_p2p_state(pwdinfo) != P2P_STATE_GONEGO_OK) { 3539 /* Restore to the listen state if the current p2p state is not nego OK */ 3540 rtw_p2p_set_state(pwdinfo, P2P_STATE_LISTEN); 3541 } 3542 3543 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo)); 3544 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_ING); 3545 3546 DBG_88E("[%s] Start PreTx Procedure!\n", __func__); 3547 _set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT); 3548 _set_timer(&pwdinfo->restore_p2p_state_timer, P2P_GO_NEGO_TIMEOUT); 3549 } else { 3550 DBG_88E("[%s] Not Found in Scanning Queue~\n", __func__); 3551 ret = -1; 3552 } 3553 return ret; 3554} 3555 3556static int rtw_p2p_invite_req(struct net_device *dev, 3557 struct iw_request_info *info, 3558 union iwreq_data *wrqu, char *extra) 3559{ 3560 int ret = 0; 3561 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3562 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3563 int jj, kk; 3564 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3565 struct list_head *plist, *phead; 3566 struct __queue *queue = &(pmlmepriv->scanned_queue); 3567 struct wlan_network *pnetwork = NULL; 3568 uint uintPeerChannel = 0; 3569 u8 attr_content[50] = {0x00}; 3570 u8 *p2pie; 3571 uint p2pielen = 0, attr_contentlen = 0; 3572 unsigned long irqL; 3573 struct tx_invite_req_info *pinvite_req_info = &pwdinfo->invitereq_info; 3574 3575 /* The input data contains two informations. */ 3576 /* 1. First information is the P2P device address which you want to send to. */ 3577 /* 2. Second information is the group id which combines with GO's mac address, space and GO's ssid. */ 3578 /* Command line sample: iwpriv wlan0 p2p_set invite ="00:11:22:33:44:55 00:E0:4C:00:00:05 DIRECT-xy" */ 3579 /* Format: 00:11:22:33:44:55 00:E0:4C:00:00:05 DIRECT-xy */ 3580 3581 DBG_88E("[%s] data = %s\n", __func__, extra); 3582 3583 if (wrqu->data.length <= 37) { 3584 DBG_88E("[%s] Wrong format!\n", __func__); 3585 return ret; 3586 } 3587 3588 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) { 3589 DBG_88E("[%s] WiFi Direct is disable!\n", __func__); 3590 return ret; 3591 } else { 3592 /* Reset the content of struct tx_invite_req_info */ 3593 pinvite_req_info->benable = false; 3594 _rtw_memset(pinvite_req_info->go_bssid, 0x00, ETH_ALEN); 3595 _rtw_memset(pinvite_req_info->go_ssid, 0x00, WLAN_SSID_MAXLEN); 3596 pinvite_req_info->ssidlen = 0x00; 3597 pinvite_req_info->operating_ch = pwdinfo->operating_channel; 3598 _rtw_memset(pinvite_req_info->peer_macaddr, 0x00, ETH_ALEN); 3599 pinvite_req_info->token = 3; 3600 } 3601 3602 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3603 pinvite_req_info->peer_macaddr[jj] = key_2char2num(extra[kk], extra[kk + 1]); 3604 3605 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3606 3607 phead = get_list_head(queue); 3608 plist = get_next(phead); 3609 3610 while (1) { 3611 if (rtw_end_of_queue_search(phead, plist) == true) 3612 break; 3613 3614 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3615 3616 /* Commented by Albert 2011/05/18 */ 3617 /* Match the device address located in the P2P IE */ 3618 /* This is for the case that the P2P device address is not the same as the P2P interface address. */ 3619 3620 p2pie = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &p2pielen); 3621 if (p2pie) { 3622 /* The P2P Device ID attribute is included in the Beacon frame. */ 3623 /* The P2P Device Info attribute is included in the probe response frame. */ 3624 3625 if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen)) { 3626 /* Handle the P2P Device ID attribute of Beacon first */ 3627 if (!memcmp(attr_content, pinvite_req_info->peer_macaddr, ETH_ALEN)) { 3628 uintPeerChannel = pnetwork->network.Configuration.DSConfig; 3629 break; 3630 } 3631 } else if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen)) { 3632 /* Handle the P2P Device Info attribute of probe response */ 3633 if (!memcmp(attr_content, pinvite_req_info->peer_macaddr, ETH_ALEN)) { 3634 uintPeerChannel = pnetwork->network.Configuration.DSConfig; 3635 break; 3636 } 3637 } 3638 } 3639 plist = get_next(plist); 3640 } 3641 3642 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3643 3644 if (uintPeerChannel) { 3645 /* Store the GO's bssid */ 3646 for (jj = 0, kk = 18; jj < ETH_ALEN; jj++, kk += 3) 3647 pinvite_req_info->go_bssid[jj] = key_2char2num(extra[kk], extra[kk + 1]); 3648 3649 /* Store the GO's ssid */ 3650 pinvite_req_info->ssidlen = wrqu->data.length - 36; 3651 memcpy(pinvite_req_info->go_ssid, &extra[36], (u32) pinvite_req_info->ssidlen); 3652 pinvite_req_info->benable = true; 3653 pinvite_req_info->peer_ch = uintPeerChannel; 3654 3655 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo)); 3656 rtw_p2p_set_state(pwdinfo, P2P_STATE_TX_INVITE_REQ); 3657 3658 set_channel_bwmode(padapter, uintPeerChannel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20); 3659 3660 _set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT); 3661 3662 _set_timer(&pwdinfo->restore_p2p_state_timer, P2P_INVITE_TIMEOUT); 3663 } else { 3664 DBG_88E("[%s] NOT Found in the Scanning Queue!\n", __func__); 3665 } 3666 return ret; 3667} 3668 3669static int rtw_p2p_set_persistent(struct net_device *dev, 3670 struct iw_request_info *info, 3671 union iwreq_data *wrqu, char *extra) 3672{ 3673 int ret = 0; 3674 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3675 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3676 3677 /* The input data is 0 or 1 */ 3678 /* 0: disable persistent group functionality */ 3679 /* 1: enable persistent group founctionality */ 3680 3681 DBG_88E("[%s] data = %s\n", __func__, extra); 3682 3683 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) { 3684 DBG_88E("[%s] WiFi Direct is disable!\n", __func__); 3685 return ret; 3686 } else { 3687 if (extra[0] == '0') /* Disable the persistent group function. */ 3688 pwdinfo->persistent_supported = false; 3689 else if (extra[0] == '1') /* Enable the persistent group function. */ 3690 pwdinfo->persistent_supported = true; 3691 else 3692 pwdinfo->persistent_supported = false; 3693 } 3694 pr_info("[%s] persistent_supported = %d\n", __func__, pwdinfo->persistent_supported); 3695 return ret; 3696} 3697 3698static int rtw_p2p_prov_disc(struct net_device *dev, 3699 struct iw_request_info *info, 3700 union iwreq_data *wrqu, char *extra) 3701{ 3702 int ret = 0; 3703 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3704 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3705 u8 peerMAC[ETH_ALEN] = {0x00}; 3706 int jj, kk; 3707 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 3708 struct list_head *plist, *phead; 3709 struct __queue *queue = &(pmlmepriv->scanned_queue); 3710 struct wlan_network *pnetwork = NULL; 3711 uint uintPeerChannel = 0; 3712 u8 attr_content[100] = {0x00}; 3713 u8 *p2pie; 3714 uint p2pielen = 0, attr_contentlen = 0; 3715 unsigned long irqL; 3716 3717 /* The input data contains two informations. */ 3718 /* 1. First information is the MAC address which wants to issue the provisioning discovery request frame. */ 3719 /* 2. Second information is the WPS configuration method which wants to discovery */ 3720 /* Format: 00:E0:4C:00:00:05_display */ 3721 /* Format: 00:E0:4C:00:00:05_keypad */ 3722 /* Format: 00:E0:4C:00:00:05_pbc */ 3723 /* Format: 00:E0:4C:00:00:05_label */ 3724 3725 DBG_88E("[%s] data = %s\n", __func__, extra); 3726 3727 if (pwdinfo->p2p_state == P2P_STATE_NONE) { 3728 DBG_88E("[%s] WiFi Direct is disable!\n", __func__); 3729 return ret; 3730 } else { 3731 /* Reset the content of struct tx_provdisc_req_info excluded the wps_config_method_request. */ 3732 _rtw_memset(pwdinfo->tx_prov_disc_info.peerDevAddr, 0x00, ETH_ALEN); 3733 _rtw_memset(pwdinfo->tx_prov_disc_info.peerIFAddr, 0x00, ETH_ALEN); 3734 _rtw_memset(&pwdinfo->tx_prov_disc_info.ssid, 0x00, sizeof(struct ndis_802_11_ssid)); 3735 pwdinfo->tx_prov_disc_info.peer_channel_num[0] = 0; 3736 pwdinfo->tx_prov_disc_info.peer_channel_num[1] = 0; 3737 pwdinfo->tx_prov_disc_info.benable = false; 3738 } 3739 3740 for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3) 3741 peerMAC[jj] = key_2char2num(extra[kk], extra[kk + 1]); 3742 3743 if (!memcmp(&extra[18], "display", 7)) { 3744 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_DISPLYA; 3745 } else if (!memcmp(&extra[18], "keypad", 7)) { 3746 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_KEYPAD; 3747 } else if (!memcmp(&extra[18], "pbc", 3)) { 3748 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_PUSH_BUTTON; 3749 } else if (!memcmp(&extra[18], "label", 5)) { 3750 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_LABEL; 3751 } else { 3752 DBG_88E("[%s] Unknown WPS config methodn", __func__); 3753 return ret; 3754 } 3755 3756 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 3757 3758 phead = get_list_head(queue); 3759 plist = get_next(phead); 3760 3761 while (1) { 3762 if (rtw_end_of_queue_search(phead, plist) == true) 3763 break; 3764 3765 if (uintPeerChannel != 0) 3766 break; 3767 3768 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); 3769 3770 /* Commented by Albert 2011/05/18 */ 3771 /* Match the device address located in the P2P IE */ 3772 /* This is for the case that the P2P device address is not the same as the P2P interface address. */ 3773 3774 p2pie = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &p2pielen); 3775 if (p2pie) { 3776 while (p2pie) { 3777 /* The P2P Device ID attribute is included in the Beacon frame. */ 3778 /* The P2P Device Info attribute is included in the probe response frame. */ 3779 3780 if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen)) { 3781 /* Handle the P2P Device ID attribute of Beacon first */ 3782 if (!memcmp(attr_content, peerMAC, ETH_ALEN)) { 3783 uintPeerChannel = pnetwork->network.Configuration.DSConfig; 3784 break; 3785 } 3786 } else if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen)) { 3787 /* Handle the P2P Device Info attribute of probe response */ 3788 if (!memcmp(attr_content, peerMAC, ETH_ALEN)) { 3789 uintPeerChannel = pnetwork->network.Configuration.DSConfig; 3790 break; 3791 } 3792 } 3793 3794 /* Get the next P2P IE */ 3795 p2pie = rtw_get_p2p_ie(p2pie+p2pielen, pnetwork->network.IELength - 12 - (p2pie - &pnetwork->network.IEs[12] + p2pielen), NULL, &p2pielen); 3796 } 3797 } 3798 3799 plist = get_next(plist); 3800 } 3801 3802 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 3803 3804 if (uintPeerChannel) { 3805 DBG_88E("[%s] peer channel: %d!\n", __func__, uintPeerChannel); 3806 memcpy(pwdinfo->tx_prov_disc_info.peerIFAddr, pnetwork->network.MacAddress, ETH_ALEN); 3807 memcpy(pwdinfo->tx_prov_disc_info.peerDevAddr, peerMAC, ETH_ALEN); 3808 pwdinfo->tx_prov_disc_info.peer_channel_num[0] = (u16) uintPeerChannel; 3809 pwdinfo->tx_prov_disc_info.benable = true; 3810 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo)); 3811 rtw_p2p_set_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ); 3812 3813 if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT)) { 3814 memcpy(&pwdinfo->tx_prov_disc_info.ssid, &pnetwork->network.Ssid, sizeof(struct ndis_802_11_ssid)); 3815 } else if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) || rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) { 3816 memcpy(pwdinfo->tx_prov_disc_info.ssid.Ssid, pwdinfo->p2p_wildcard_ssid, P2P_WILDCARD_SSID_LEN); 3817 pwdinfo->tx_prov_disc_info.ssid.SsidLength = P2P_WILDCARD_SSID_LEN; 3818 } 3819 3820 set_channel_bwmode(padapter, uintPeerChannel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20); 3821 3822 _set_timer(&pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT); 3823 3824 _set_timer(&pwdinfo->restore_p2p_state_timer, P2P_PROVISION_TIMEOUT); 3825 } else { 3826 DBG_88E("[%s] NOT Found in the Scanning Queue!\n", __func__); 3827 } 3828 return ret; 3829} 3830 3831/* This function is used to inform the driver the user had specified the pin code value or pbc */ 3832/* to application. */ 3833 3834static int rtw_p2p_got_wpsinfo(struct net_device *dev, 3835 struct iw_request_info *info, 3836 union iwreq_data *wrqu, char *extra) 3837{ 3838 int ret = 0; 3839 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3840 struct wifidirect_info *pwdinfo = &(padapter->wdinfo); 3841 3842 DBG_88E("[%s] data = %s\n", __func__, extra); 3843 /* Added by Albert 20110328 */ 3844 /* if the input data is P2P_NO_WPSINFO -> reset the wpsinfo */ 3845 /* if the input data is P2P_GOT_WPSINFO_PEER_DISPLAY_PIN -> the utility just input the PIN code got from the peer P2P device. */ 3846 /* if the input data is P2P_GOT_WPSINFO_SELF_DISPLAY_PIN -> the utility just got the PIN code from itself. */ 3847 /* if the input data is P2P_GOT_WPSINFO_PBC -> the utility just determine to use the PBC */ 3848 3849 if (*extra == '0') 3850 pwdinfo->ui_got_wps_info = P2P_NO_WPSINFO; 3851 else if (*extra == '1') 3852 pwdinfo->ui_got_wps_info = P2P_GOT_WPSINFO_PEER_DISPLAY_PIN; 3853 else if (*extra == '2') 3854 pwdinfo->ui_got_wps_info = P2P_GOT_WPSINFO_SELF_DISPLAY_PIN; 3855 else if (*extra == '3') 3856 pwdinfo->ui_got_wps_info = P2P_GOT_WPSINFO_PBC; 3857 else 3858 pwdinfo->ui_got_wps_info = P2P_NO_WPSINFO; 3859 return ret; 3860} 3861 3862#endif /* CONFIG_88EU_P2P */ 3863 3864static int rtw_p2p_set(struct net_device *dev, 3865 struct iw_request_info *info, 3866 union iwreq_data *wrqu, char *extra) 3867{ 3868 int ret = 0; 3869 3870#ifdef CONFIG_88EU_P2P 3871 DBG_88E("[%s] extra = %s\n", __func__, extra); 3872 if (!memcmp(extra, "enable =", 7)) { 3873 rtw_wext_p2p_enable(dev, info, wrqu, &extra[7]); 3874 } else if (!memcmp(extra, "setDN =", 6)) { 3875 wrqu->data.length -= 6; 3876 rtw_p2p_setDN(dev, info, wrqu, &extra[6]); 3877 } else if (!memcmp(extra, "profilefound =", 13)) { 3878 wrqu->data.length -= 13; 3879 rtw_p2p_profilefound(dev, info, wrqu, &extra[13]); 3880 } else if (!memcmp(extra, "prov_disc =", 10)) { 3881 wrqu->data.length -= 10; 3882 rtw_p2p_prov_disc(dev, info, wrqu, &extra[10]); 3883 } else if (!memcmp(extra, "nego =", 5)) { 3884 wrqu->data.length -= 5; 3885 rtw_p2p_connect(dev, info, wrqu, &extra[5]); 3886 } else if (!memcmp(extra, "intent =", 7)) { 3887 /* Commented by Albert 2011/03/23 */ 3888 /* The wrqu->data.length will include the null character */ 3889 /* So, we will decrease 7 + 1 */ 3890 wrqu->data.length -= 8; 3891 rtw_p2p_set_intent(dev, info, wrqu, &extra[7]); 3892 } else if (!memcmp(extra, "ssid =", 5)) { 3893 wrqu->data.length -= 5; 3894 rtw_p2p_set_go_nego_ssid(dev, info, wrqu, &extra[5]); 3895 } else if (!memcmp(extra, "got_wpsinfo =", 12)) { 3896 wrqu->data.length -= 12; 3897 rtw_p2p_got_wpsinfo(dev, info, wrqu, &extra[12]); 3898 } else if (!memcmp(extra, "listen_ch =", 10)) { 3899 /* Commented by Albert 2011/05/24 */ 3900 /* The wrqu->data.length will include the null character */ 3901 /* So, we will decrease (10 + 1) */ 3902 wrqu->data.length -= 11; 3903 rtw_p2p_set_listen_ch(dev, info, wrqu, &extra[10]); 3904 } else if (!memcmp(extra, "op_ch =", 6)) { 3905 /* Commented by Albert 2011/05/24 */ 3906 /* The wrqu->data.length will include the null character */ 3907 /* So, we will decrease (6 + 1) */ 3908 wrqu->data.length -= 7; 3909 rtw_p2p_set_op_ch(dev, info, wrqu, &extra[6]); 3910 } else if (!memcmp(extra, "invite =", 7)) { 3911 wrqu->data.length -= 8; 3912 rtw_p2p_invite_req(dev, info, wrqu, &extra[7]); 3913 } else if (!memcmp(extra, "persistent =", 11)) { 3914 wrqu->data.length -= 11; 3915 rtw_p2p_set_persistent(dev, info, wrqu, &extra[11]); 3916 } 3917#endif /* CONFIG_88EU_P2P */ 3918 3919 return ret; 3920} 3921 3922static int rtw_p2p_get(struct net_device *dev, 3923 struct iw_request_info *info, 3924 union iwreq_data *wrqu, char *extra) 3925{ 3926 int ret = 0; 3927 3928#ifdef CONFIG_88EU_P2P 3929 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3930 3931 if (padapter->bShowGetP2PState) 3932 DBG_88E("[%s] extra = %s\n", __func__, (char *)wrqu->data.pointer); 3933 if (!memcmp(wrqu->data.pointer, "status", 6)) { 3934 rtw_p2p_get_status(dev, info, wrqu, extra); 3935 } else if (!memcmp(wrqu->data.pointer, "role", 4)) { 3936 rtw_p2p_get_role(dev, info, wrqu, extra); 3937 } else if (!memcmp(wrqu->data.pointer, "peer_ifa", 8)) { 3938 rtw_p2p_get_peer_ifaddr(dev, info, wrqu, extra); 3939 } else if (!memcmp(wrqu->data.pointer, "req_cm", 6)) { 3940 rtw_p2p_get_req_cm(dev, info, wrqu, extra); 3941 } else if (!memcmp(wrqu->data.pointer, "peer_deva", 9)) { 3942 /* Get the P2P device address when receiving the provision discovery request frame. */ 3943 rtw_p2p_get_peer_devaddr(dev, info, wrqu, extra); 3944 } else if (!memcmp(wrqu->data.pointer, "group_id", 8)) { 3945 rtw_p2p_get_groupid(dev, info, wrqu, extra); 3946 } else if (!memcmp(wrqu->data.pointer, "peer_deva_inv", 9)) { 3947 /* Get the P2P device address when receiving the P2P Invitation request frame. */ 3948 rtw_p2p_get_peer_devaddr_by_invitation(dev, info, wrqu, extra); 3949 } else if (!memcmp(wrqu->data.pointer, "op_ch", 5)) { 3950 rtw_p2p_get_op_ch(dev, info, wrqu, extra); 3951 } 3952#endif /* CONFIG_88EU_P2P */ 3953 return ret; 3954} 3955 3956static int rtw_p2p_get2(struct net_device *dev, 3957 struct iw_request_info *info, 3958 union iwreq_data *wrqu, char *extra) 3959{ 3960 int ret = 0; 3961 3962#ifdef CONFIG_88EU_P2P 3963 DBG_88E("[%s] extra = %s\n", __func__, (char *)wrqu->data.pointer); 3964 if (!memcmp(extra, "wpsCM =", 6)) { 3965 wrqu->data.length -= 6; 3966 rtw_p2p_get_wps_configmethod(dev, info, wrqu, &extra[6]); 3967 } else if (!memcmp(extra, "devN =", 5)) { 3968 wrqu->data.length -= 5; 3969 rtw_p2p_get_device_name(dev, info, wrqu, &extra[5]); 3970 } else if (!memcmp(extra, "dev_type =", 9)) { 3971 wrqu->data.length -= 9; 3972 rtw_p2p_get_device_type(dev, info, wrqu, &extra[9]); 3973 } else if (!memcmp(extra, "go_devadd =", 10)) { 3974 wrqu->data.length -= 10; 3975 rtw_p2p_get_go_device_address(dev, info, wrqu, &extra[10]); 3976 } else if (!memcmp(extra, "InvProc =", 8)) { 3977 wrqu->data.length -= 8; 3978 rtw_p2p_get_invitation_procedure(dev, info, wrqu, &extra[8]); 3979 } 3980 3981#endif /* CONFIG_88EU_P2P */ 3982 3983 return ret; 3984} 3985 3986static int rtw_cta_test_start(struct net_device *dev, 3987 struct iw_request_info *info, 3988 union iwreq_data *wrqu, char *extra) 3989{ 3990 int ret = 0; 3991 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 3992 DBG_88E("%s %s\n", __func__, extra); 3993 if (!strcmp(extra, "1")) 3994 padapter->in_cta_test = 1; 3995 else 3996 padapter->in_cta_test = 0; 3997 3998 if (padapter->in_cta_test) { 3999 u32 v = rtw_read32(padapter, REG_RCR); 4000 v &= ~(RCR_CBSSID_DATA | RCR_CBSSID_BCN);/* RCR_ADF */ 4001 rtw_write32(padapter, REG_RCR, v); 4002 DBG_88E("enable RCR_ADF\n"); 4003 } else { 4004 u32 v = rtw_read32(padapter, REG_RCR); 4005 v |= RCR_CBSSID_DATA | RCR_CBSSID_BCN;/* RCR_ADF */ 4006 rtw_write32(padapter, REG_RCR, v); 4007 DBG_88E("disable RCR_ADF\n"); 4008 } 4009 return ret; 4010} 4011 4012static int rtw_rereg_nd_name(struct net_device *dev, 4013 struct iw_request_info *info, 4014 union iwreq_data *wrqu, char *extra) 4015{ 4016 int ret = 0; 4017 struct adapter *padapter = rtw_netdev_priv(dev); 4018 struct rereg_nd_name_data *rereg_priv = &padapter->rereg_nd_name_priv; 4019 char new_ifname[IFNAMSIZ]; 4020 4021 if (rereg_priv->old_ifname[0] == 0) { 4022 char *reg_ifname; 4023 reg_ifname = padapter->registrypriv.if2name; 4024 4025 strncpy(rereg_priv->old_ifname, reg_ifname, IFNAMSIZ); 4026 rereg_priv->old_ifname[IFNAMSIZ-1] = 0; 4027 } 4028 4029 if (wrqu->data.length > IFNAMSIZ) 4030 return -EFAULT; 4031 4032 if (copy_from_user(new_ifname, wrqu->data.pointer, IFNAMSIZ)) 4033 return -EFAULT; 4034 4035 if (0 == strcmp(rereg_priv->old_ifname, new_ifname)) 4036 return ret; 4037 4038 DBG_88E("%s new_ifname:%s\n", __func__, new_ifname); 4039 ret = rtw_change_ifname(padapter, new_ifname); 4040 if (0 != ret) 4041 goto exit; 4042 4043 if (!memcmp(rereg_priv->old_ifname, "disable%d", 9)) { 4044 padapter->ledpriv.bRegUseLed = rereg_priv->old_bRegUseLed; 4045 rtw_hal_sw_led_init(padapter); 4046 rtw_ips_mode_req(&padapter->pwrctrlpriv, rereg_priv->old_ips_mode); 4047 } 4048 4049 strncpy(rereg_priv->old_ifname, new_ifname, IFNAMSIZ); 4050 rereg_priv->old_ifname[IFNAMSIZ-1] = 0; 4051 4052 if (!memcmp(new_ifname, "disable%d", 9)) { 4053 DBG_88E("%s disable\n", __func__); 4054 /* free network queue for Android's timming issue */ 4055 rtw_free_network_queue(padapter, true); 4056 4057 /* close led */ 4058 rtw_led_control(padapter, LED_CTL_POWER_OFF); 4059 rereg_priv->old_bRegUseLed = padapter->ledpriv.bRegUseLed; 4060 padapter->ledpriv.bRegUseLed = false; 4061 rtw_hal_sw_led_deinit(padapter); 4062 4063 /* the interface is being "disabled", we can do deeper IPS */ 4064 rereg_priv->old_ips_mode = rtw_get_ips_mode_req(&padapter->pwrctrlpriv); 4065 rtw_ips_mode_req(&padapter->pwrctrlpriv, IPS_NORMAL); 4066 } 4067exit: 4068 return ret; 4069} 4070 4071static void mac_reg_dump(struct adapter *padapter) 4072{ 4073 int i, j = 1; 4074 pr_info("\n ======= MAC REG =======\n"); 4075 for (i = 0x0; i < 0x300; i += 4) { 4076 if (j%4 == 1) 4077 pr_info("0x%02x", i); 4078 pr_info(" 0x%08x ", rtw_read32(padapter, i)); 4079 if ((j++)%4 == 0) 4080 pr_info("\n"); 4081 } 4082 for (i = 0x400; i < 0x800; i += 4) { 4083 if (j%4 == 1) 4084 pr_info("0x%02x", i); 4085 pr_info(" 0x%08x ", rtw_read32(padapter, i)); 4086 if ((j++)%4 == 0) 4087 pr_info("\n"); 4088 } 4089} 4090 4091static void bb_reg_dump(struct adapter *padapter) 4092{ 4093 int i, j = 1; 4094 pr_info("\n ======= BB REG =======\n"); 4095 for (i = 0x800; i < 0x1000; i += 4) { 4096 if (j%4 == 1) 4097 pr_info("0x%02x", i); 4098 4099 pr_info(" 0x%08x ", rtw_read32(padapter, i)); 4100 if ((j++)%4 == 0) 4101 pr_info("\n"); 4102 } 4103} 4104 4105static void rf_reg_dump(struct adapter *padapter) 4106{ 4107 int i, j = 1, path; 4108 u32 value; 4109 u8 rf_type, path_nums = 0; 4110 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type)); 4111 4112 pr_info("\n ======= RF REG =======\n"); 4113 if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) 4114 path_nums = 1; 4115 else 4116 path_nums = 2; 4117 4118 for (path = 0; path < path_nums; path++) { 4119 pr_info("\nRF_Path(%x)\n", path); 4120 for (i = 0; i < 0x100; i++) { 4121 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); 4122 if (j%4 == 1) 4123 pr_info("0x%02x ", i); 4124 pr_info(" 0x%08x ", value); 4125 if ((j++)%4 == 0) 4126 pr_info("\n"); 4127 } 4128 } 4129} 4130 4131static int rtw_dbg_port(struct net_device *dev, 4132 struct iw_request_info *info, 4133 union iwreq_data *wrqu, char *extra) 4134{ 4135 unsigned long irqL; 4136 int ret = 0; 4137 u8 major_cmd, minor_cmd; 4138 u16 arg; 4139 s32 extra_arg; 4140 u32 *pdata, val32; 4141 struct sta_info *psta; 4142 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 4143 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 4144 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 4145 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 4146 struct security_priv *psecuritypriv = &padapter->securitypriv; 4147 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 4148 struct sta_priv *pstapriv = &padapter->stapriv; 4149 4150 pdata = (u32 *)&wrqu->data; 4151 4152 val32 = *pdata; 4153 arg = (u16)(val32 & 0x0000ffff); 4154 major_cmd = (u8)(val32 >> 24); 4155 minor_cmd = (u8)((val32 >> 16) & 0x00ff); 4156 4157 extra_arg = *(pdata+1); 4158 4159 switch (major_cmd) { 4160 case 0x70:/* read_reg */ 4161 switch (minor_cmd) { 4162 case 1: 4163 DBG_88E("rtw_read8(0x%x) = 0x%02x\n", arg, rtw_read8(padapter, arg)); 4164 break; 4165 case 2: 4166 DBG_88E("rtw_read16(0x%x) = 0x%04x\n", arg, rtw_read16(padapter, arg)); 4167 break; 4168 case 4: 4169 DBG_88E("rtw_read32(0x%x) = 0x%08x\n", arg, rtw_read32(padapter, arg)); 4170 break; 4171 } 4172 break; 4173 case 0x71:/* write_reg */ 4174 switch (minor_cmd) { 4175 case 1: 4176 rtw_write8(padapter, arg, extra_arg); 4177 DBG_88E("rtw_write8(0x%x) = 0x%02x\n", arg, rtw_read8(padapter, arg)); 4178 break; 4179 case 2: 4180 rtw_write16(padapter, arg, extra_arg); 4181 DBG_88E("rtw_write16(0x%x) = 0x%04x\n", arg, rtw_read16(padapter, arg)); 4182 break; 4183 case 4: 4184 rtw_write32(padapter, arg, extra_arg); 4185 DBG_88E("rtw_write32(0x%x) = 0x%08x\n", arg, rtw_read32(padapter, arg)); 4186 break; 4187 } 4188 break; 4189 case 0x72:/* read_bb */ 4190 DBG_88E("read_bbreg(0x%x) = 0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff)); 4191 break; 4192 case 0x73:/* write_bb */ 4193 rtw_hal_write_bbreg(padapter, arg, 0xffffffff, extra_arg); 4194 DBG_88E("write_bbreg(0x%x) = 0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff)); 4195 break; 4196 case 0x74:/* read_rf */ 4197 DBG_88E("read RF_reg path(0x%02x), offset(0x%x), value(0x%08x)\n", minor_cmd, arg, rtw_hal_read_rfreg(padapter, minor_cmd, arg, 0xffffffff)); 4198 break; 4199 case 0x75:/* write_rf */ 4200 rtw_hal_write_rfreg(padapter, minor_cmd, arg, 0xffffffff, extra_arg); 4201 DBG_88E("write RF_reg path(0x%02x), offset(0x%x), value(0x%08x)\n", minor_cmd, arg, rtw_hal_read_rfreg(padapter, minor_cmd, arg, 0xffffffff)); 4202 break; 4203 4204 case 0x76: 4205 switch (minor_cmd) { 4206 case 0x00: /* normal mode, */ 4207 padapter->recvpriv.is_signal_dbg = 0; 4208 break; 4209 case 0x01: /* dbg mode */ 4210 padapter->recvpriv.is_signal_dbg = 1; 4211 extra_arg = extra_arg > 100 ? 100 : extra_arg; 4212 extra_arg = extra_arg < 0 ? 0 : extra_arg; 4213 padapter->recvpriv.signal_strength_dbg = extra_arg; 4214 break; 4215 } 4216 break; 4217 case 0x78: /* IOL test */ 4218 switch (minor_cmd) { 4219 case 0x04: /* LLT table initialization test */ 4220 { 4221 u8 page_boundary = 0xf9; 4222 struct xmit_frame *xmit_frame; 4223 4224 xmit_frame = rtw_IOL_accquire_xmit_frame(padapter); 4225 if (xmit_frame == NULL) { 4226 ret = -ENOMEM; 4227 break; 4228 } 4229 4230 rtw_IOL_append_LLT_cmd(xmit_frame, page_boundary); 4231 4232 if (_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 500, 0)) 4233 ret = -EPERM; 4234 } 4235 break; 4236 case 0x05: /* blink LED test */ 4237 { 4238 u16 reg = 0x4c; 4239 u32 blink_num = 50; 4240 u32 blink_delay_ms = 200; 4241 int i; 4242 struct xmit_frame *xmit_frame; 4243 4244 xmit_frame = rtw_IOL_accquire_xmit_frame(padapter); 4245 if (xmit_frame == NULL) { 4246 ret = -ENOMEM; 4247 break; 4248 } 4249 4250 for (i = 0; i < blink_num; i++) { 4251 rtw_IOL_append_WB_cmd(xmit_frame, reg, 0x00, 0xff); 4252 rtw_IOL_append_DELAY_MS_cmd(xmit_frame, blink_delay_ms); 4253 rtw_IOL_append_WB_cmd(xmit_frame, reg, 0x08, 0xff); 4254 rtw_IOL_append_DELAY_MS_cmd(xmit_frame, blink_delay_ms); 4255 } 4256 if (_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, (blink_delay_ms*blink_num*2)+200, 0)) 4257 ret = -EPERM; 4258 } 4259 break; 4260 4261 case 0x06: /* continuous write byte test */ 4262 { 4263 u16 reg = arg; 4264 u16 start_value = 0; 4265 u32 write_num = extra_arg; 4266 int i; 4267 u8 final; 4268 struct xmit_frame *xmit_frame; 4269 4270 xmit_frame = rtw_IOL_accquire_xmit_frame(padapter); 4271 if (xmit_frame == NULL) { 4272 ret = -ENOMEM; 4273 break; 4274 } 4275 4276 for (i = 0; i < write_num; i++) 4277 rtw_IOL_append_WB_cmd(xmit_frame, reg, i+start_value, 0xFF); 4278 if (_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 5000, 0)) 4279 ret = -EPERM; 4280 4281 final = rtw_read8(padapter, reg); 4282 if (start_value+write_num-1 == final) 4283 DBG_88E("continuous IOL_CMD_WB_REG to 0x%x %u times Success, start:%u, final:%u\n", reg, write_num, start_value, final); 4284 else 4285 DBG_88E("continuous IOL_CMD_WB_REG to 0x%x %u times Fail, start:%u, final:%u\n", reg, write_num, start_value, final); 4286 } 4287 break; 4288 4289 case 0x07: /* continuous write word test */ 4290 { 4291 u16 reg = arg; 4292 u16 start_value = 200; 4293 u32 write_num = extra_arg; 4294 4295 int i; 4296 u16 final; 4297 struct xmit_frame *xmit_frame; 4298 4299 xmit_frame = rtw_IOL_accquire_xmit_frame(padapter); 4300 if (xmit_frame == NULL) { 4301 ret = -ENOMEM; 4302 break; 4303 } 4304 4305 for (i = 0; i < write_num; i++) 4306 rtw_IOL_append_WW_cmd(xmit_frame, reg, i+start_value, 0xFFFF); 4307 if (_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 5000, 0)) 4308 ret = -EPERM; 4309 4310 final = rtw_read16(padapter, reg); 4311 if (start_value+write_num-1 == final) 4312 DBG_88E("continuous IOL_CMD_WW_REG to 0x%x %u times Success, start:%u, final:%u\n", reg, write_num, start_value, final); 4313 else 4314 DBG_88E("continuous IOL_CMD_WW_REG to 0x%x %u times Fail, start:%u, final:%u\n", reg, write_num, start_value, final); 4315 } 4316 break; 4317 case 0x08: /* continuous write dword test */ 4318 { 4319 u16 reg = arg; 4320 u32 start_value = 0x110000c7; 4321 u32 write_num = extra_arg; 4322 4323 int i; 4324 u32 final; 4325 struct xmit_frame *xmit_frame; 4326 4327 xmit_frame = rtw_IOL_accquire_xmit_frame(padapter); 4328 if (xmit_frame == NULL) { 4329 ret = -ENOMEM; 4330 break; 4331 } 4332 4333 for (i = 0; i < write_num; i++) 4334 rtw_IOL_append_WD_cmd(xmit_frame, reg, i+start_value, 0xFFFFFFFF); 4335 if (_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 5000, 0)) 4336 ret = -EPERM; 4337 4338 final = rtw_read32(padapter, reg); 4339 if (start_value+write_num-1 == final) 4340 DBG_88E("continuous IOL_CMD_WD_REG to 0x%x %u times Success, start:%u, final:%u\n", 4341 reg, write_num, start_value, final); 4342 else 4343 DBG_88E("continuous IOL_CMD_WD_REG to 0x%x %u times Fail, start:%u, final:%u\n", 4344 reg, write_num, start_value, final); 4345 } 4346 break; 4347 } 4348 break; 4349 case 0x79: 4350 { 4351 /* 4352 * dbg 0x79000000 [value], set RESP_TXAGC to + value, value:0~15 4353 * dbg 0x79010000 [value], set RESP_TXAGC to - value, value:0~15 4354 */ 4355 u8 value = extra_arg & 0x0f; 4356 u8 sign = minor_cmd; 4357 u16 write_value = 0; 4358 4359 DBG_88E("%s set RESP_TXAGC to %s %u\n", __func__, sign ? "minus" : "plus", value); 4360 4361 if (sign) 4362 value = value | 0x10; 4363 4364 write_value = value | (value << 5); 4365 rtw_write16(padapter, 0x6d9, write_value); 4366 } 4367 break; 4368 case 0x7a: 4369 receive_disconnect(padapter, pmlmeinfo->network.MacAddress 4370 , WLAN_REASON_EXPIRATION_CHK); 4371 break; 4372 case 0x7F: 4373 switch (minor_cmd) { 4374 case 0x0: 4375 DBG_88E("fwstate = 0x%x\n", get_fwstate(pmlmepriv)); 4376 break; 4377 case 0x01: 4378 DBG_88E("auth_alg = 0x%x, enc_alg = 0x%x, auth_type = 0x%x, enc_type = 0x%x\n", 4379 psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm, 4380 psecuritypriv->ndisauthtype, psecuritypriv->ndisencryptstatus); 4381 break; 4382 case 0x02: 4383 DBG_88E("pmlmeinfo->state = 0x%x\n", pmlmeinfo->state); 4384 break; 4385 case 0x03: 4386 DBG_88E("qos_option =%d\n", pmlmepriv->qospriv.qos_option); 4387 DBG_88E("ht_option =%d\n", pmlmepriv->htpriv.ht_option); 4388 break; 4389 case 0x04: 4390 DBG_88E("cur_ch =%d\n", pmlmeext->cur_channel); 4391 DBG_88E("cur_bw =%d\n", pmlmeext->cur_bwmode); 4392 DBG_88E("cur_ch_off =%d\n", pmlmeext->cur_ch_offset); 4393 break; 4394 case 0x05: 4395 psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress); 4396 if (psta) { 4397 int i; 4398 struct recv_reorder_ctrl *preorder_ctrl; 4399 4400 DBG_88E("SSID =%s\n", cur_network->network.Ssid.Ssid); 4401 DBG_88E("sta's macaddr: %pM\n", psta->hwaddr); 4402 DBG_88E("cur_channel =%d, cur_bwmode =%d, cur_ch_offset =%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset); 4403 DBG_88E("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self); 4404 DBG_88E("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid); 4405 DBG_88E("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate); 4406 DBG_88E("bwmode =%d, ch_offset =%d, sgi =%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi); 4407 DBG_88E("ampdu_enable = %d\n", psta->htpriv.ampdu_enable); 4408 DBG_88E("agg_enable_bitmap =%x, candidate_tid_bitmap =%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap); 4409 for (i = 0; i < 16; i++) { 4410 preorder_ctrl = &psta->recvreorder_ctrl[i]; 4411 if (preorder_ctrl->enable) 4412 DBG_88E("tid =%d, indicate_seq =%d\n", i, preorder_ctrl->indicate_seq); 4413 } 4414 } else { 4415 DBG_88E("can't get sta's macaddr, cur_network's macaddr:%pM\n", (cur_network->network.MacAddress)); 4416 } 4417 break; 4418 case 0x06: 4419 { 4420 u32 ODMFlag; 4421 rtw_hal_get_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag)); 4422 DBG_88E("(B)DMFlag = 0x%x, arg = 0x%x\n", ODMFlag, arg); 4423 ODMFlag = (u32)(0x0f&arg); 4424 DBG_88E("(A)DMFlag = 0x%x\n", ODMFlag); 4425 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag)); 4426 } 4427 break; 4428 case 0x07: 4429 DBG_88E("bSurpriseRemoved =%d, bDriverStopped =%d\n", 4430 padapter->bSurpriseRemoved, padapter->bDriverStopped); 4431 break; 4432 case 0x08: 4433 { 4434 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 4435 struct recv_priv *precvpriv = &padapter->recvpriv; 4436 4437 DBG_88E("free_xmitbuf_cnt =%d, free_xmitframe_cnt =%d, free_xmit_extbuf_cnt =%d\n", 4438 pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmit_extbuf_cnt); 4439 DBG_88E("rx_urb_pending_cn =%d\n", precvpriv->rx_pending_cnt); 4440 } 4441 break; 4442 case 0x09: 4443 { 4444 int i, j; 4445 struct list_head *plist, *phead; 4446 struct recv_reorder_ctrl *preorder_ctrl; 4447 4448#ifdef CONFIG_88EU_AP_MODE 4449 DBG_88E("sta_dz_bitmap = 0x%x, tim_bitmap = 0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap); 4450#endif 4451 spin_lock_bh(&pstapriv->sta_hash_lock); 4452 4453 for (i = 0; i < NUM_STA; i++) { 4454 phead = &(pstapriv->sta_hash[i]); 4455 plist = get_next(phead); 4456 4457 while ((rtw_end_of_queue_search(phead, plist)) == false) { 4458 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list); 4459 4460 plist = get_next(plist); 4461 4462 if (extra_arg == psta->aid) { 4463 DBG_88E("sta's macaddr:%pM\n", (psta->hwaddr)); 4464 DBG_88E("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self); 4465 DBG_88E("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid); 4466 DBG_88E("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate); 4467 DBG_88E("bwmode =%d, ch_offset =%d, sgi =%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi); 4468 DBG_88E("ampdu_enable = %d\n", psta->htpriv.ampdu_enable); 4469 DBG_88E("agg_enable_bitmap =%x, candidate_tid_bitmap =%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap); 4470 4471#ifdef CONFIG_88EU_AP_MODE 4472 DBG_88E("capability = 0x%x\n", psta->capability); 4473 DBG_88E("flags = 0x%x\n", psta->flags); 4474 DBG_88E("wpa_psk = 0x%x\n", psta->wpa_psk); 4475 DBG_88E("wpa2_group_cipher = 0x%x\n", psta->wpa2_group_cipher); 4476 DBG_88E("wpa2_pairwise_cipher = 0x%x\n", psta->wpa2_pairwise_cipher); 4477 DBG_88E("qos_info = 0x%x\n", psta->qos_info); 4478#endif 4479 DBG_88E("dot118021XPrivacy = 0x%x\n", psta->dot118021XPrivacy); 4480 4481 for (j = 0; j < 16; j++) { 4482 preorder_ctrl = &psta->recvreorder_ctrl[j]; 4483 if (preorder_ctrl->enable) 4484 DBG_88E("tid =%d, indicate_seq =%d\n", j, preorder_ctrl->indicate_seq); 4485 } 4486 } 4487 } 4488 } 4489 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL); 4490 } 4491 break; 4492 case 0x0c:/* dump rx/tx packet */ 4493 if (arg == 0) { 4494 DBG_88E("dump rx packet (%d)\n", extra_arg); 4495 rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_RXPKT, &(extra_arg)); 4496 } else if (arg == 1) { 4497 DBG_88E("dump tx packet (%d)\n", extra_arg); 4498 rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_TXPKT, &(extra_arg)); 4499 } 4500 break; 4501 case 0x0f: 4502 if (extra_arg == 0) { 4503 DBG_88E("###### silent reset test.......#####\n"); 4504 rtw_hal_sreset_reset(padapter); 4505 } 4506 break; 4507 case 0x15: 4508 { 4509 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; 4510 DBG_88E("==>silent resete cnts:%d\n", pwrpriv->ips_enter_cnts); 4511 } 4512 break; 4513 case 0x10:/* driver version display */ 4514 DBG_88E("rtw driver version =%s\n", DRIVERVERSION); 4515 break; 4516 case 0x11: 4517 DBG_88E("turn %s Rx RSSI display function\n", (extra_arg == 1) ? "on" : "off"); 4518 padapter->bRxRSSIDisplay = extra_arg; 4519 rtw_hal_set_def_var(padapter, HW_DEF_FA_CNT_DUMP, &extra_arg); 4520 break; 4521 case 0x12: /* set rx_stbc */ 4522 { 4523 struct registry_priv *pregpriv = &padapter->registrypriv; 4524 /* 0: disable, bit(0):enable 2.4g, bit(1):enable 5g, 0x3: enable both 2.4g and 5g */ 4525 /* default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ */ 4526 if (pregpriv && 4527 (extra_arg == 0 || 4528 extra_arg == 1 || 4529 extra_arg == 2 || 4530 extra_arg == 3)) { 4531 pregpriv->rx_stbc = extra_arg; 4532 DBG_88E("set rx_stbc =%d\n", pregpriv->rx_stbc); 4533 } else { 4534 DBG_88E("get rx_stbc =%d\n", pregpriv->rx_stbc); 4535 } 4536 } 4537 break; 4538 case 0x13: /* set ampdu_enable */ 4539 { 4540 struct registry_priv *pregpriv = &padapter->registrypriv; 4541 /* 0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */ 4542 if (pregpriv && extra_arg >= 0 && extra_arg < 3) { 4543 pregpriv->ampdu_enable = extra_arg; 4544 DBG_88E("set ampdu_enable =%d\n", pregpriv->ampdu_enable); 4545 } else { 4546 DBG_88E("get ampdu_enable =%d\n", pregpriv->ampdu_enable); 4547 } 4548 } 4549 break; 4550 case 0x14: /* get wifi_spec */ 4551 { 4552 struct registry_priv *pregpriv = &padapter->registrypriv; 4553 DBG_88E("get wifi_spec =%d\n", pregpriv->wifi_spec); 4554 } 4555 break; 4556 case 0x16: 4557 if (arg == 0xff) { 4558 pr_info("ODM_COMP_DIG\t\tBIT0\n"); 4559 pr_info("ODM_COMP_RA_MASK\t\tBIT1\n"); 4560 pr_info("ODM_COMP_DYNAMIC_TXPWR\tBIT2\n"); 4561 pr_info("ODM_COMP_FA_CNT\t\tBIT3\n"); 4562 pr_info("ODM_COMP_RSSI_MONITOR\tBIT4\n"); 4563 pr_info("ODM_COMP_CCK_PD\t\tBIT5\n"); 4564 pr_info("ODM_COMP_ANT_DIV\t\tBIT6\n"); 4565 pr_info("ODM_COMP_PWR_SAVE\t\tBIT7\n"); 4566 pr_info("ODM_COMP_PWR_TRAIN\tBIT8\n"); 4567 pr_info("ODM_COMP_RATE_ADAPTIVE\tBIT9\n"); 4568 pr_info("ODM_COMP_PATH_DIV\t\tBIT10\n"); 4569 pr_info("ODM_COMP_PSD \tBIT11\n"); 4570 pr_info("ODM_COMP_DYNAMIC_PRICCA\tBIT12\n"); 4571 pr_info("ODM_COMP_RXHP\t\tBIT13\n"); 4572 pr_info("ODM_COMP_EDCA_TURBO\tBIT16\n"); 4573 pr_info("ODM_COMP_EARLY_MODE\tBIT17\n"); 4574 pr_info("ODM_COMP_TX_PWR_TRACK\tBIT24\n"); 4575 pr_info("ODM_COMP_RX_GAIN_TRACK\tBIT25\n"); 4576 pr_info("ODM_COMP_CALIBRATION\tBIT26\n"); 4577 rtw_hal_get_def_var(padapter, HW_DEF_ODM_DBG_FLAG, &extra_arg); 4578 } else { 4579 rtw_hal_set_def_var(padapter, HW_DEF_ODM_DBG_FLAG, &extra_arg); 4580 } 4581 break; 4582 case 0x23: 4583 DBG_88E("turn %s the bNotifyChannelChange Variable\n", (extra_arg == 1) ? "on" : "off"); 4584 padapter->bNotifyChannelChange = extra_arg; 4585 break; 4586 case 0x24: 4587#ifdef CONFIG_88EU_P2P 4588 DBG_88E("turn %s the bShowGetP2PState Variable\n", (extra_arg == 1) ? "on" : "off"); 4589 padapter->bShowGetP2PState = extra_arg; 4590#endif /* CONFIG_88EU_P2P */ 4591 break; 4592 case 0xaa: 4593 if (extra_arg > 0x13) 4594 extra_arg = 0xFF; 4595 DBG_88E("chang data rate to :0x%02x\n", extra_arg); 4596 padapter->fix_rate = extra_arg; 4597 break; 4598 case 0xdd:/* registers dump, 0 for mac reg, 1 for bb reg, 2 for rf reg */ 4599 if (extra_arg == 0) 4600 mac_reg_dump(padapter); 4601 else if (extra_arg == 1) 4602 bb_reg_dump(padapter); 4603 else if (extra_arg == 2) 4604 rf_reg_dump(padapter); 4605 break; 4606 case 0xee:/* turn on/off dynamic funcs */ 4607 { 4608 u32 odm_flag; 4609 4610 if (0xf == extra_arg) { 4611 rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC, &odm_flag); 4612 DBG_88E(" === DMFlag(0x%08x) ===\n", odm_flag); 4613 DBG_88E("extra_arg = 0 - disable all dynamic func\n"); 4614 DBG_88E("extra_arg = 1 - disable DIG- BIT(0)\n"); 4615 DBG_88E("extra_arg = 2 - disable High power - BIT(1)\n"); 4616 DBG_88E("extra_arg = 3 - disable tx power tracking - BIT(2)\n"); 4617 DBG_88E("extra_arg = 4 - disable BT coexistence - BIT(3)\n"); 4618 DBG_88E("extra_arg = 5 - disable antenna diversity - BIT(4)\n"); 4619 DBG_88E("extra_arg = 6 - enable all dynamic func\n"); 4620 } else { 4621 /* extra_arg = 0 - disable all dynamic func 4622 extra_arg = 1 - disable DIG 4623 extra_arg = 2 - disable tx power tracking 4624 extra_arg = 3 - turn on all dynamic func 4625 */ 4626 rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DM_FUNC, &(extra_arg)); 4627 rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC, &odm_flag); 4628 DBG_88E(" === DMFlag(0x%08x) ===\n", odm_flag); 4629 } 4630 } 4631 break; 4632 4633 case 0xfd: 4634 rtw_write8(padapter, 0xc50, arg); 4635 DBG_88E("wr(0xc50) = 0x%x\n", rtw_read8(padapter, 0xc50)); 4636 rtw_write8(padapter, 0xc58, arg); 4637 DBG_88E("wr(0xc58) = 0x%x\n", rtw_read8(padapter, 0xc58)); 4638 break; 4639 case 0xfe: 4640 DBG_88E("rd(0xc50) = 0x%x\n", rtw_read8(padapter, 0xc50)); 4641 DBG_88E("rd(0xc58) = 0x%x\n", rtw_read8(padapter, 0xc58)); 4642 break; 4643 case 0xff: 4644 DBG_88E("dbg(0x210) = 0x%x\n", rtw_read32(padapter, 0x210)); 4645 DBG_88E("dbg(0x608) = 0x%x\n", rtw_read32(padapter, 0x608)); 4646 DBG_88E("dbg(0x280) = 0x%x\n", rtw_read32(padapter, 0x280)); 4647 DBG_88E("dbg(0x284) = 0x%x\n", rtw_read32(padapter, 0x284)); 4648 DBG_88E("dbg(0x288) = 0x%x\n", rtw_read32(padapter, 0x288)); 4649 4650 DBG_88E("dbg(0x664) = 0x%x\n", rtw_read32(padapter, 0x664)); 4651 4652 DBG_88E("\n"); 4653 4654 DBG_88E("dbg(0x430) = 0x%x\n", rtw_read32(padapter, 0x430)); 4655 DBG_88E("dbg(0x438) = 0x%x\n", rtw_read32(padapter, 0x438)); 4656 4657 DBG_88E("dbg(0x440) = 0x%x\n", rtw_read32(padapter, 0x440)); 4658 4659 DBG_88E("dbg(0x458) = 0x%x\n", rtw_read32(padapter, 0x458)); 4660 4661 DBG_88E("dbg(0x484) = 0x%x\n", rtw_read32(padapter, 0x484)); 4662 DBG_88E("dbg(0x488) = 0x%x\n", rtw_read32(padapter, 0x488)); 4663 4664 DBG_88E("dbg(0x444) = 0x%x\n", rtw_read32(padapter, 0x444)); 4665 DBG_88E("dbg(0x448) = 0x%x\n", rtw_read32(padapter, 0x448)); 4666 DBG_88E("dbg(0x44c) = 0x%x\n", rtw_read32(padapter, 0x44c)); 4667 DBG_88E("dbg(0x450) = 0x%x\n", rtw_read32(padapter, 0x450)); 4668 break; 4669 } 4670 break; 4671 default: 4672 DBG_88E("error dbg cmd!\n"); 4673 break; 4674 } 4675 return ret; 4676} 4677 4678static int wpa_set_param(struct net_device *dev, u8 name, u32 value) 4679{ 4680 uint ret = 0; 4681 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 4682 4683 switch (name) { 4684 case IEEE_PARAM_WPA_ENABLED: 4685 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */ 4686 switch ((value)&0xff) { 4687 case 1: /* WPA */ 4688 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */ 4689 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 4690 break; 4691 case 2: /* WPA2 */ 4692 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */ 4693 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 4694 break; 4695 } 4696 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, 4697 ("wpa_set_param:padapter->securitypriv.ndisauthtype =%d\n", padapter->securitypriv.ndisauthtype)); 4698 break; 4699 case IEEE_PARAM_TKIP_COUNTERMEASURES: 4700 break; 4701 case IEEE_PARAM_DROP_UNENCRYPTED: { 4702 /* HACK: 4703 * 4704 * wpa_supplicant calls set_wpa_enabled when the driver 4705 * is loaded and unloaded, regardless of if WPA is being 4706 * used. No other calls are made which can be used to 4707 * determine if encryption will be used or not prior to 4708 * association being expected. If encryption is not being 4709 * used, drop_unencrypted is set to false, else true -- we 4710 * can use this to determine if the CAP_PRIVACY_ON bit should 4711 * be set. 4712 */ 4713 4714 break; 4715 } 4716 case IEEE_PARAM_PRIVACY_INVOKED: 4717 break; 4718 4719 case IEEE_PARAM_AUTH_ALGS: 4720 ret = wpa_set_auth_algs(dev, value); 4721 break; 4722 case IEEE_PARAM_IEEE_802_1X: 4723 break; 4724 case IEEE_PARAM_WPAX_SELECT: 4725 break; 4726 default: 4727 ret = -EOPNOTSUPP; 4728 break; 4729 } 4730 return ret; 4731} 4732 4733static int wpa_mlme(struct net_device *dev, u32 command, u32 reason) 4734{ 4735 int ret = 0; 4736 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 4737 4738 switch (command) { 4739 case IEEE_MLME_STA_DEAUTH: 4740 if (!rtw_set_802_11_disassociate(padapter)) 4741 ret = -1; 4742 break; 4743 case IEEE_MLME_STA_DISASSOC: 4744 if (!rtw_set_802_11_disassociate(padapter)) 4745 ret = -1; 4746 break; 4747 default: 4748 ret = -EOPNOTSUPP; 4749 break; 4750 } 4751 4752 return ret; 4753} 4754 4755static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p) 4756{ 4757 struct ieee_param *param; 4758 uint ret = 0; 4759 4760 if (p->length < sizeof(struct ieee_param) || !p->pointer) { 4761 ret = -EINVAL; 4762 goto out; 4763 } 4764 4765 param = (struct ieee_param *)rtw_malloc(p->length); 4766 if (param == NULL) { 4767 ret = -ENOMEM; 4768 goto out; 4769 } 4770 4771 if (copy_from_user(param, p->pointer, p->length)) { 4772 kfree(param); 4773 ret = -EFAULT; 4774 goto out; 4775 } 4776 4777 switch (param->cmd) { 4778 case IEEE_CMD_SET_WPA_PARAM: 4779 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value); 4780 break; 4781 4782 case IEEE_CMD_SET_WPA_IE: 4783 ret = rtw_set_wpa_ie((struct adapter *)rtw_netdev_priv(dev), 4784 (char *)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len); 4785 break; 4786 4787 case IEEE_CMD_SET_ENCRYPTION: 4788 ret = wpa_set_encryption(dev, param, p->length); 4789 break; 4790 4791 case IEEE_CMD_MLME: 4792 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code); 4793 break; 4794 4795 default: 4796 DBG_88E("Unknown WPA supplicant request: %d\n", param->cmd); 4797 ret = -EOPNOTSUPP; 4798 break; 4799 } 4800 4801 if (ret == 0 && copy_to_user(p->pointer, param, p->length)) 4802 ret = -EFAULT; 4803 4804 kfree(param); 4805 4806out: 4807 4808 return ret; 4809} 4810 4811#ifdef CONFIG_88EU_AP_MODE 4812static u8 set_pairwise_key(struct adapter *padapter, struct sta_info *psta) 4813{ 4814 struct cmd_obj *ph2c; 4815 struct set_stakey_parm *psetstakey_para; 4816 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 4817 u8 res = _SUCCESS; 4818 4819 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj)); 4820 if (ph2c == NULL) { 4821 res = _FAIL; 4822 goto exit; 4823 } 4824 4825 psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm)); 4826 if (psetstakey_para == NULL) { 4827 kfree(ph2c); 4828 res = _FAIL; 4829 goto exit; 4830 } 4831 4832 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); 4833 4834 psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy; 4835 4836 memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN); 4837 4838 memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16); 4839 4840 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 4841 4842exit: 4843 4844 return res; 4845} 4846 4847static int set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid) 4848{ 4849 u8 keylen; 4850 struct cmd_obj *pcmd; 4851 struct setkey_parm *psetkeyparm; 4852 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv); 4853 int res = _SUCCESS; 4854 4855 DBG_88E("%s\n", __func__); 4856 4857 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj)); 4858 if (pcmd == NULL) { 4859 res = _FAIL; 4860 goto exit; 4861 } 4862 psetkeyparm = (struct setkey_parm *)rtw_zmalloc(sizeof(struct setkey_parm)); 4863 if (psetkeyparm == NULL) { 4864 kfree(pcmd); 4865 res = _FAIL; 4866 goto exit; 4867 } 4868 4869 _rtw_memset(psetkeyparm, 0, sizeof(struct setkey_parm)); 4870 4871 psetkeyparm->keyid = (u8)keyid; 4872 4873 psetkeyparm->algorithm = alg; 4874 4875 psetkeyparm->set_tx = 1; 4876 4877 switch (alg) { 4878 case _WEP40_: 4879 keylen = 5; 4880 break; 4881 case _WEP104_: 4882 keylen = 13; 4883 break; 4884 case _TKIP_: 4885 case _TKIP_WTMIC_: 4886 case _AES_: 4887 default: 4888 keylen = 16; 4889 } 4890 4891 memcpy(&(psetkeyparm->key[0]), key, keylen); 4892 4893 pcmd->cmdcode = _SetKey_CMD_; 4894 pcmd->parmbuf = (u8 *)psetkeyparm; 4895 pcmd->cmdsz = (sizeof(struct setkey_parm)); 4896 pcmd->rsp = NULL; 4897 pcmd->rspsz = 0; 4898 4899 _rtw_init_listhead(&pcmd->list); 4900 4901 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 4902 4903exit: 4904 4905 return res; 4906} 4907 4908static int set_wep_key(struct adapter *padapter, u8 *key, u8 keylen, int keyid) 4909{ 4910 u8 alg; 4911 4912 switch (keylen) { 4913 case 5: 4914 alg = _WEP40_; 4915 break; 4916 case 13: 4917 alg = _WEP104_; 4918 break; 4919 default: 4920 alg = _NO_PRIVACY_; 4921 } 4922 4923 return set_group_key(padapter, key, alg, keyid); 4924} 4925 4926static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 4927{ 4928 int ret = 0; 4929 u32 wep_key_idx, wep_key_len, wep_total_len; 4930 struct ndis_802_11_wep *pwep = NULL; 4931 struct sta_info *psta = NULL, *pbcmc_sta = NULL; 4932 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 4933 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 4934 struct security_priv *psecuritypriv = &(padapter->securitypriv); 4935 struct sta_priv *pstapriv = &padapter->stapriv; 4936 4937 DBG_88E("%s\n", __func__); 4938 param->u.crypt.err = 0; 4939 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 4940 if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) { 4941 ret = -EINVAL; 4942 goto exit; 4943 } 4944 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 4945 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 4946 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 4947 if (param->u.crypt.idx >= WEP_KEYS) { 4948 ret = -EINVAL; 4949 goto exit; 4950 } 4951 } else { 4952 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 4953 if (!psta) { 4954 DBG_88E("rtw_set_encryption(), sta has already been removed or never been added\n"); 4955 goto exit; 4956 } 4957 } 4958 4959 if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) { 4960 /* todo:clear default encryption keys */ 4961 4962 DBG_88E("clear default encryption keys, keyid =%d\n", param->u.crypt.idx); 4963 goto exit; 4964 } 4965 if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) { 4966 DBG_88E("r871x_set_encryption, crypt.alg = WEP\n"); 4967 wep_key_idx = param->u.crypt.idx; 4968 wep_key_len = param->u.crypt.key_len; 4969 DBG_88E("r871x_set_encryption, wep_key_idx=%d, len=%d\n", wep_key_idx, wep_key_len); 4970 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) { 4971 ret = -EINVAL; 4972 goto exit; 4973 } 4974 4975 if (wep_key_len > 0) { 4976 wep_key_len = wep_key_len <= 5 ? 5 : 13; 4977 wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial); 4978 pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len); 4979 if (pwep == NULL) { 4980 DBG_88E(" r871x_set_encryption: pwep allocate fail !!!\n"); 4981 goto exit; 4982 } 4983 4984 _rtw_memset(pwep, 0, wep_total_len); 4985 4986 pwep->KeyLength = wep_key_len; 4987 pwep->Length = wep_total_len; 4988 } 4989 4990 pwep->KeyIndex = wep_key_idx; 4991 4992 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength); 4993 4994 if (param->u.crypt.set_tx) { 4995 DBG_88E("wep, set_tx = 1\n"); 4996 4997 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 4998 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_; 4999 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 5000 5001 if (pwep->KeyLength == 13) { 5002 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_; 5003 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 5004 } 5005 5006 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx; 5007 5008 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength); 5009 5010 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength; 5011 5012 set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx); 5013 } else { 5014 DBG_88E("wep, set_tx = 0\n"); 5015 5016 /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */ 5017 /* psecuritypriv->dot11PrivacyKeyIndex = keyid", but can rtw_set_key to cam */ 5018 5019 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength); 5020 5021 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength; 5022 5023 set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx); 5024 } 5025 5026 goto exit; 5027 } 5028 5029 if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /* group key */ 5030 if (param->u.crypt.set_tx == 1) { 5031 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 5032 DBG_88E("%s, set group_key, WEP\n", __func__); 5033 5034 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5035 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5036 5037 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 5038 if (param->u.crypt.key_len == 13) 5039 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 5040 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 5041 DBG_88E("%s, set group_key, TKIP\n", __func__); 5042 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 5043 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5044 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5045 /* set mic key */ 5046 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 5047 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 5048 5049 psecuritypriv->busetkipkey = true; 5050 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 5051 DBG_88E("%s, set group_key, CCMP\n", __func__); 5052 psecuritypriv->dot118021XGrpPrivacy = _AES_; 5053 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5054 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5055 } else { 5056 DBG_88E("%s, set group_key, none\n", __func__); 5057 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 5058 } 5059 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 5060 psecuritypriv->binstallGrpkey = true; 5061 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 5062 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 5063 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 5064 if (pbcmc_sta) { 5065 pbcmc_sta->ieee8021x_blocked = false; 5066 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 5067 } 5068 } 5069 goto exit; 5070 } 5071 5072 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */ 5073 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 5074 if (param->u.crypt.set_tx == 1) { 5075 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5076 5077 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 5078 DBG_88E("%s, set pairwise key, WEP\n", __func__); 5079 5080 psta->dot118021XPrivacy = _WEP40_; 5081 if (param->u.crypt.key_len == 13) 5082 psta->dot118021XPrivacy = _WEP104_; 5083 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 5084 DBG_88E("%s, set pairwise key, TKIP\n", __func__); 5085 5086 psta->dot118021XPrivacy = _TKIP_; 5087 5088 /* set mic key */ 5089 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 5090 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 5091 5092 psecuritypriv->busetkipkey = true; 5093 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 5094 DBG_88E("%s, set pairwise key, CCMP\n", __func__); 5095 5096 psta->dot118021XPrivacy = _AES_; 5097 } else { 5098 DBG_88E("%s, set pairwise key, none\n", __func__); 5099 5100 psta->dot118021XPrivacy = _NO_PRIVACY_; 5101 } 5102 5103 set_pairwise_key(padapter, psta); 5104 5105 psta->ieee8021x_blocked = false; 5106 } else { /* group key??? */ 5107 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 5108 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5109 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5110 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 5111 if (param->u.crypt.key_len == 13) 5112 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 5113 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 5114 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 5115 5116 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5117 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5118 5119 /* set mic key */ 5120 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 5121 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 5122 5123 psecuritypriv->busetkipkey = true; 5124 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 5125 psecuritypriv->dot118021XGrpPrivacy = _AES_; 5126 5127 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5128 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5129 } else { 5130 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 5131 } 5132 5133 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 5134 5135 psecuritypriv->binstallGrpkey = true; 5136 5137 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 5138 5139 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 5140 5141 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 5142 if (pbcmc_sta) { 5143 pbcmc_sta->ieee8021x_blocked = false; 5144 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 5145 } 5146 } 5147 } 5148 } 5149 5150exit: 5151 5152 kfree(pwep); 5153 5154 return ret; 5155} 5156 5157static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len) 5158{ 5159 int ret = 0; 5160 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5161 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5162 struct sta_priv *pstapriv = &padapter->stapriv; 5163 unsigned char *pbuf = param->u.bcn_ie.buf; 5164 5165 DBG_88E("%s, len =%d\n", __func__, len); 5166 5167 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5168 return -EINVAL; 5169 5170 memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2); 5171 5172 if ((pstapriv->max_num_sta > NUM_STA) || (pstapriv->max_num_sta <= 0)) 5173 pstapriv->max_num_sta = NUM_STA; 5174 5175 if (rtw_check_beacon_data(padapter, pbuf, (len-12-2)) == _SUCCESS)/* 12 = param header, 2:no packed */ 5176 ret = 0; 5177 else 5178 ret = -EINVAL; 5179 5180 return ret; 5181} 5182 5183static int rtw_hostapd_sta_flush(struct net_device *dev) 5184{ 5185 int ret = 0; 5186 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5187 5188 DBG_88E("%s\n", __func__); 5189 5190 flush_all_cam_entry(padapter); /* clear CAM */ 5191 5192 ret = rtw_sta_flush(padapter); 5193 5194 return ret; 5195} 5196 5197static int rtw_add_sta(struct net_device *dev, struct ieee_param *param) 5198{ 5199 int ret = 0; 5200 struct sta_info *psta = NULL; 5201 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5202 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5203 struct sta_priv *pstapriv = &padapter->stapriv; 5204 5205 DBG_88E("rtw_add_sta(aid =%d) =%pM\n", param->u.add_sta.aid, (param->sta_addr)); 5206 5207 if (!check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE))) 5208 return -EINVAL; 5209 5210 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5211 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5212 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5213 return -EINVAL; 5214 5215 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 5216 if (psta) { 5217 int flags = param->u.add_sta.flags; 5218 5219 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */ 5220 5221 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16); 5222 5223 /* check wmm cap. */ 5224 if (WLAN_STA_WME&flags) 5225 psta->qos_option = 1; 5226 else 5227 psta->qos_option = 0; 5228 5229 if (pmlmepriv->qospriv.qos_option == 0) 5230 psta->qos_option = 0; 5231 5232 /* chec 802.11n ht cap. */ 5233 if (WLAN_STA_HT&flags) { 5234 psta->htpriv.ht_option = true; 5235 psta->qos_option = 1; 5236 memcpy((void *)&psta->htpriv.ht_cap, (void *)¶m->u.add_sta.ht_cap, sizeof(struct rtw_ieee80211_ht_cap)); 5237 } else { 5238 psta->htpriv.ht_option = false; 5239 } 5240 5241 if (pmlmepriv->htpriv.ht_option == false) 5242 psta->htpriv.ht_option = false; 5243 5244 update_sta_info_apmode(padapter, psta); 5245 } else { 5246 ret = -ENOMEM; 5247 } 5248 5249 return ret; 5250} 5251 5252static int rtw_del_sta(struct net_device *dev, struct ieee_param *param) 5253{ 5254 unsigned long irqL; 5255 int ret = 0; 5256 struct sta_info *psta = NULL; 5257 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5258 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5259 struct sta_priv *pstapriv = &padapter->stapriv; 5260 int updated = 0; 5261 5262 DBG_88E("rtw_del_sta =%pM\n", (param->sta_addr)); 5263 5264 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 5265 return -EINVAL; 5266 5267 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5268 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5269 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5270 return -EINVAL; 5271 5272 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 5273 if (psta) { 5274 spin_lock_bh(&pstapriv->asoc_list_lock); 5275 if (!rtw_is_list_empty(&psta->asoc_list)) { 5276 rtw_list_delete(&psta->asoc_list); 5277 pstapriv->asoc_list_cnt--; 5278 updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING); 5279 } 5280 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL); 5281 associated_clients_update(padapter, updated); 5282 psta = NULL; 5283 } else { 5284 DBG_88E("rtw_del_sta(), sta has already been removed or never been added\n"); 5285 } 5286 5287 return ret; 5288} 5289 5290static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len) 5291{ 5292 int ret = 0; 5293 struct sta_info *psta = NULL; 5294 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5295 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5296 struct sta_priv *pstapriv = &padapter->stapriv; 5297 struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param; 5298 struct sta_data *psta_data = (struct sta_data *)param_ex->data; 5299 5300 DBG_88E("rtw_ioctl_get_sta_info, sta_addr: %pM\n", (param_ex->sta_addr)); 5301 5302 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 5303 return -EINVAL; 5304 5305 if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff && 5306 param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff && 5307 param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff) 5308 return -EINVAL; 5309 5310 psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr); 5311 if (psta) { 5312 psta_data->aid = (u16)psta->aid; 5313 psta_data->capability = psta->capability; 5314 psta_data->flags = psta->flags; 5315 5316/* 5317 nonerp_set : BIT(0) 5318 no_short_slot_time_set : BIT(1) 5319 no_short_preamble_set : BIT(2) 5320 no_ht_gf_set : BIT(3) 5321 no_ht_set : BIT(4) 5322 ht_20mhz_set : BIT(5) 5323*/ 5324 5325 psta_data->sta_set = ((psta->nonerp_set) | 5326 (psta->no_short_slot_time_set << 1) | 5327 (psta->no_short_preamble_set << 2) | 5328 (psta->no_ht_gf_set << 3) | 5329 (psta->no_ht_set << 4) | 5330 (psta->ht_20mhz_set << 5)); 5331 psta_data->tx_supp_rates_len = psta->bssratelen; 5332 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen); 5333 memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct rtw_ieee80211_ht_cap)); 5334 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts; 5335 psta_data->rx_bytes = psta->sta_stats.rx_bytes; 5336 psta_data->rx_drops = psta->sta_stats.rx_drops; 5337 psta_data->tx_pkts = psta->sta_stats.tx_pkts; 5338 psta_data->tx_bytes = psta->sta_stats.tx_bytes; 5339 psta_data->tx_drops = psta->sta_stats.tx_drops; 5340 } else { 5341 ret = -1; 5342 } 5343 5344 return ret; 5345} 5346 5347static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param) 5348{ 5349 int ret = 0; 5350 struct sta_info *psta = NULL; 5351 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5352 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5353 struct sta_priv *pstapriv = &padapter->stapriv; 5354 5355 DBG_88E("rtw_get_sta_wpaie, sta_addr: %pM\n", (param->sta_addr)); 5356 5357 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 5358 return -EINVAL; 5359 5360 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5361 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5362 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5363 return -EINVAL; 5364 5365 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 5366 if (psta) { 5367 if ((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_GENERIC)) { 5368 int wpa_ie_len; 5369 int copy_len; 5370 5371 wpa_ie_len = psta->wpa_ie[1]; 5372 copy_len = ((wpa_ie_len+2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)) : (wpa_ie_len+2); 5373 param->u.wpa_ie.len = copy_len; 5374 memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len); 5375 } else { 5376 DBG_88E("sta's wpa_ie is NONE\n"); 5377 } 5378 } else { 5379 ret = -1; 5380 } 5381 5382 return ret; 5383} 5384 5385static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len) 5386{ 5387 int ret = 0; 5388 unsigned char wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 5389 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5390 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5391 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 5392 int ie_len; 5393 5394 DBG_88E("%s, len =%d\n", __func__, len); 5395 5396 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5397 return -EINVAL; 5398 5399 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 5400 5401 if (pmlmepriv->wps_beacon_ie) { 5402 kfree(pmlmepriv->wps_beacon_ie); 5403 pmlmepriv->wps_beacon_ie = NULL; 5404 } 5405 5406 if (ie_len > 0) { 5407 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len); 5408 pmlmepriv->wps_beacon_ie_len = ie_len; 5409 if (pmlmepriv->wps_beacon_ie == NULL) { 5410 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5411 return -EINVAL; 5412 } 5413 5414 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len); 5415 5416 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, true); 5417 5418 pmlmeext->bstart_bss = true; 5419 } 5420 5421 return ret; 5422} 5423 5424static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len) 5425{ 5426 int ret = 0; 5427 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5428 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5429 int ie_len; 5430 5431 DBG_88E("%s, len =%d\n", __func__, len); 5432 5433 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5434 return -EINVAL; 5435 5436 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 5437 5438 if (pmlmepriv->wps_probe_resp_ie) { 5439 kfree(pmlmepriv->wps_probe_resp_ie); 5440 pmlmepriv->wps_probe_resp_ie = NULL; 5441 } 5442 5443 if (ie_len > 0) { 5444 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len); 5445 pmlmepriv->wps_probe_resp_ie_len = ie_len; 5446 if (pmlmepriv->wps_probe_resp_ie == NULL) { 5447 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5448 return -EINVAL; 5449 } 5450 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len); 5451 } 5452 5453 return ret; 5454} 5455 5456static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len) 5457{ 5458 int ret = 0; 5459 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5460 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5461 int ie_len; 5462 5463 DBG_88E("%s, len =%d\n", __func__, len); 5464 5465 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5466 return -EINVAL; 5467 5468 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 5469 5470 if (pmlmepriv->wps_assoc_resp_ie) { 5471 kfree(pmlmepriv->wps_assoc_resp_ie); 5472 pmlmepriv->wps_assoc_resp_ie = NULL; 5473 } 5474 5475 if (ie_len > 0) { 5476 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len); 5477 pmlmepriv->wps_assoc_resp_ie_len = ie_len; 5478 if (pmlmepriv->wps_assoc_resp_ie == NULL) { 5479 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5480 return -EINVAL; 5481 } 5482 5483 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len); 5484 } 5485 5486 return ret; 5487} 5488 5489static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len) 5490{ 5491 int ret = 0; 5492 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5493 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5494 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 5495 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 5496 5497 u8 value; 5498 5499 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5500 return -EINVAL; 5501 5502 if (param->u.wpa_param.name != 0) /* dummy test... */ 5503 DBG_88E("%s name(%u) != 0\n", __func__, param->u.wpa_param.name); 5504 value = param->u.wpa_param.value; 5505 5506 /* use the same definition of hostapd's ignore_broadcast_ssid */ 5507 if (value != 1 && value != 2) 5508 value = 0; 5509 DBG_88E("%s value(%u)\n", __func__, value); 5510 pmlmeinfo->hidden_ssid_mode = value; 5511 return ret; 5512} 5513 5514static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len) 5515{ 5516 int ret = 0; 5517 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5518 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5519 5520 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5521 return -EINVAL; 5522 5523 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5524 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5525 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5526 return -EINVAL; 5527 ret = rtw_acl_remove_sta(padapter, param->sta_addr); 5528 return ret; 5529} 5530 5531static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len) 5532{ 5533 int ret = 0; 5534 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5535 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5536 5537 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5538 return -EINVAL; 5539 5540 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5541 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5542 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5543 return -EINVAL; 5544 ret = rtw_acl_add_sta(padapter, param->sta_addr); 5545 return ret; 5546} 5547 5548static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len) 5549{ 5550 int ret = 0; 5551 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5552 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5553 5554 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5555 return -EINVAL; 5556 5557 rtw_set_macaddr_acl(padapter, param->u.mlme.command); 5558 5559 return ret; 5560} 5561 5562static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p) 5563{ 5564 struct ieee_param *param; 5565 int ret = 0; 5566 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5567 5568 /* 5569 * this function is expect to call in master mode, which allows no power saving 5570 * so, we just check hw_init_completed 5571 */ 5572 5573 if (!padapter->hw_init_completed) { 5574 ret = -EPERM; 5575 goto out; 5576 } 5577 5578 if (!p->pointer) { 5579 ret = -EINVAL; 5580 goto out; 5581 } 5582 5583 param = (struct ieee_param *)rtw_malloc(p->length); 5584 if (param == NULL) { 5585 ret = -ENOMEM; 5586 goto out; 5587 } 5588 5589 if (copy_from_user(param, p->pointer, p->length)) { 5590 kfree(param); 5591 ret = -EFAULT; 5592 goto out; 5593 } 5594 5595 switch (param->cmd) { 5596 case RTL871X_HOSTAPD_FLUSH: 5597 ret = rtw_hostapd_sta_flush(dev); 5598 break; 5599 case RTL871X_HOSTAPD_ADD_STA: 5600 ret = rtw_add_sta(dev, param); 5601 break; 5602 case RTL871X_HOSTAPD_REMOVE_STA: 5603 ret = rtw_del_sta(dev, param); 5604 break; 5605 case RTL871X_HOSTAPD_SET_BEACON: 5606 ret = rtw_set_beacon(dev, param, p->length); 5607 break; 5608 case RTL871X_SET_ENCRYPTION: 5609 ret = rtw_set_encryption(dev, param, p->length); 5610 break; 5611 case RTL871X_HOSTAPD_GET_WPAIE_STA: 5612 ret = rtw_get_sta_wpaie(dev, param); 5613 break; 5614 case RTL871X_HOSTAPD_SET_WPS_BEACON: 5615 ret = rtw_set_wps_beacon(dev, param, p->length); 5616 break; 5617 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP: 5618 ret = rtw_set_wps_probe_resp(dev, param, p->length); 5619 break; 5620 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP: 5621 ret = rtw_set_wps_assoc_resp(dev, param, p->length); 5622 break; 5623 case RTL871X_HOSTAPD_SET_HIDDEN_SSID: 5624 ret = rtw_set_hidden_ssid(dev, param, p->length); 5625 break; 5626 case RTL871X_HOSTAPD_GET_INFO_STA: 5627 ret = rtw_ioctl_get_sta_data(dev, param, p->length); 5628 break; 5629 case RTL871X_HOSTAPD_SET_MACADDR_ACL: 5630 ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length); 5631 break; 5632 case RTL871X_HOSTAPD_ACL_ADD_STA: 5633 ret = rtw_ioctl_acl_add_sta(dev, param, p->length); 5634 break; 5635 case RTL871X_HOSTAPD_ACL_REMOVE_STA: 5636 ret = rtw_ioctl_acl_remove_sta(dev, param, p->length); 5637 break; 5638 default: 5639 DBG_88E("Unknown hostapd request: %d\n", param->cmd); 5640 ret = -EOPNOTSUPP; 5641 break; 5642 } 5643 5644 if (ret == 0 && copy_to_user(p->pointer, param, p->length)) 5645 ret = -EFAULT; 5646 kfree(param); 5647out: 5648 return ret; 5649} 5650#endif 5651 5652#include <rtw_android.h> 5653static int rtw_wx_set_priv(struct net_device *dev, 5654 struct iw_request_info *info, 5655 union iwreq_data *awrq, 5656 char *extra) 5657{ 5658 int ret = 0; 5659 int len = 0; 5660 char *ext; 5661 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5662 struct iw_point *dwrq = (struct iw_point *)awrq; 5663 5664 if (dwrq->length == 0) 5665 return -EFAULT; 5666 5667 len = dwrq->length; 5668 ext = rtw_vmalloc(len); 5669 if (!ext) 5670 return -ENOMEM; 5671 5672 if (copy_from_user(ext, dwrq->pointer, len)) { 5673 rtw_vmfree(ext, len); 5674 return -EFAULT; 5675 } 5676 5677 /* added for wps2.0 @20110524 */ 5678 if (dwrq->flags == 0x8766 && len > 8) { 5679 u32 cp_sz; 5680 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5681 u8 *probereq_wpsie = ext; 5682 int probereq_wpsie_len = len; 5683 u8 wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 5684 5685 if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) && 5686 (!memcmp(&probereq_wpsie[2], wps_oui, 4))) { 5687 cp_sz = probereq_wpsie_len > MAX_WPS_IE_LEN ? MAX_WPS_IE_LEN : probereq_wpsie_len; 5688 5689 pmlmepriv->wps_probe_req_ie_len = 0; 5690 kfree(pmlmepriv->wps_probe_req_ie); 5691 pmlmepriv->wps_probe_req_ie = NULL; 5692 5693 pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz); 5694 if (pmlmepriv->wps_probe_req_ie == NULL) { 5695 pr_info("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5696 ret = -EINVAL; 5697 goto FREE_EXT; 5698 } 5699 memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz); 5700 pmlmepriv->wps_probe_req_ie_len = cp_sz; 5701 } 5702 goto FREE_EXT; 5703 } 5704 5705 if (len >= WEXT_CSCAN_HEADER_SIZE && 5706 !memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) { 5707 ret = rtw_wx_set_scan(dev, info, awrq, ext); 5708 goto FREE_EXT; 5709 } 5710 5711FREE_EXT: 5712 5713 rtw_vmfree(ext, len); 5714 5715 return ret; 5716} 5717 5718static int rtw_pm_set(struct net_device *dev, 5719 struct iw_request_info *info, 5720 union iwreq_data *wrqu, char *extra) 5721{ 5722 int ret = 0; 5723 unsigned mode = 0; 5724 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5725 5726 DBG_88E("[%s] extra = %s\n", __func__, extra); 5727 5728 if (!memcmp(extra, "lps =", 4)) { 5729 sscanf(extra+4, "%u", &mode); 5730 ret = rtw_pm_set_lps(padapter, mode); 5731 } else if (!memcmp(extra, "ips =", 4)) { 5732 sscanf(extra+4, "%u", &mode); 5733 ret = rtw_pm_set_ips(padapter, mode); 5734 } else { 5735 ret = -EINVAL; 5736 } 5737 5738 return ret; 5739} 5740 5741static int rtw_mp_efuse_get(struct net_device *dev, 5742 struct iw_request_info *info, 5743 union iwreq_data *wdata, char *extra) 5744{ 5745 struct adapter *padapter = rtw_netdev_priv(dev); 5746 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter); 5747 struct hal_data_8188e *haldata = GET_HAL_DATA(padapter); 5748 struct efuse_hal *pEfuseHal; 5749 struct iw_point *wrqu; 5750 5751 u8 *PROMContent = pEEPROM->efuse_eeprom_data; 5752 u8 ips_mode = 0, lps_mode = 0; 5753 struct pwrctrl_priv *pwrctrlpriv; 5754 u8 *data = NULL; 5755 u8 *rawdata = NULL; 5756 char *pch, *ptmp, *token, *tmp[3] = {NULL, NULL, NULL}; 5757 u16 i = 0, j = 0, mapLen = 0, addr = 0, cnts = 0; 5758 u16 max_available_size = 0, raw_cursize = 0, raw_maxsize = 0; 5759 int err; 5760 u8 org_fw_iol = padapter->registrypriv.fw_iol;/* 0:Disable, 1:enable, 2:by usb speed */ 5761 5762 wrqu = (struct iw_point *)wdata; 5763 pwrctrlpriv = &padapter->pwrctrlpriv; 5764 pEfuseHal = &haldata->EfuseHal; 5765 5766 err = 0; 5767 data = _rtw_zmalloc(EFUSE_BT_MAX_MAP_LEN); 5768 if (data == NULL) { 5769 err = -ENOMEM; 5770 goto exit; 5771 } 5772 rawdata = _rtw_zmalloc(EFUSE_BT_MAX_MAP_LEN); 5773 if (rawdata == NULL) { 5774 err = -ENOMEM; 5775 goto exit; 5776 } 5777 5778 if (copy_from_user(extra, wrqu->pointer, wrqu->length)) { 5779 err = -EFAULT; 5780 goto exit; 5781 } 5782 lps_mode = pwrctrlpriv->power_mgnt;/* keep org value */ 5783 rtw_pm_set_lps(padapter, PS_MODE_ACTIVE); 5784 5785 ips_mode = pwrctrlpriv->ips_mode;/* keep org value */ 5786 rtw_pm_set_ips(padapter, IPS_NONE); 5787 5788 pch = extra; 5789 DBG_88E("%s: in =%s\n", __func__, extra); 5790 5791 i = 0; 5792 /* mac 16 "00e04c871200" rmap, 00, 2 */ 5793 while ((token = strsep(&pch, ",")) != NULL) { 5794 if (i > 2) 5795 break; 5796 tmp[i] = token; 5797 i++; 5798 } 5799 padapter->registrypriv.fw_iol = 0;/* 0:Disable, 1:enable, 2:by usb speed */ 5800 5801 if (strcmp(tmp[0], "status") == 0) { 5802 sprintf(extra, "Load File efuse =%s, Load File MAC =%s", (pEEPROM->bloadfile_fail_flag ? "FAIL" : "OK"), (pEEPROM->bloadmac_fail_flag ? "FAIL" : "OK")); 5803 5804 goto exit; 5805 } else if (strcmp(tmp[0], "filemap") == 0) { 5806 mapLen = EFUSE_MAP_SIZE; 5807 5808 sprintf(extra, "\n"); 5809 for (i = 0; i < EFUSE_MAP_SIZE; i += 16) { 5810 sprintf(extra, "%s0x%02x\t", extra, i); 5811 for (j = 0; j < 8; j++) 5812 sprintf(extra, "%s%02X ", extra, PROMContent[i+j]); 5813 sprintf(extra, "%s\t", extra); 5814 for (; j < 16; j++) 5815 sprintf(extra, "%s%02X ", extra, PROMContent[i+j]); 5816 sprintf(extra, "%s\n", extra); 5817 } 5818 } else if (strcmp(tmp[0], "realmap") == 0) { 5819 mapLen = EFUSE_MAP_SIZE; 5820 if (rtw_efuse_map_read(padapter, 0, mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL) { 5821 DBG_88E("%s: read realmap Fail!!\n", __func__); 5822 err = -EFAULT; 5823 goto exit; 5824 } 5825 5826 sprintf(extra, "\n"); 5827 for (i = 0; i < EFUSE_MAP_SIZE; i += 16) { 5828 sprintf(extra, "%s0x%02x\t", extra, i); 5829 for (j = 0; j < 8; j++) 5830 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseInitMap[i+j]); 5831 sprintf(extra, "%s\t", extra); 5832 for (; j < 16; j++) 5833 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseInitMap[i+j]); 5834 sprintf(extra, "%s\n", extra); 5835 } 5836 } else if (strcmp(tmp[0], "rmap") == 0) { 5837 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 5838 DBG_88E("%s: rmap Fail!! Parameters error!\n", __func__); 5839 err = -EINVAL; 5840 goto exit; 5841 } 5842 5843 /* rmap addr cnts */ 5844 addr = simple_strtoul(tmp[1], &ptmp, 16); 5845 DBG_88E("%s: addr =%x\n", __func__, addr); 5846 5847 cnts = simple_strtoul(tmp[2], &ptmp, 10); 5848 if (cnts == 0) { 5849 DBG_88E("%s: rmap Fail!! cnts error!\n", __func__); 5850 err = -EINVAL; 5851 goto exit; 5852 } 5853 DBG_88E("%s: cnts =%d\n", __func__, cnts); 5854 5855 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5856 if ((addr + cnts) > max_available_size) { 5857 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5858 err = -EINVAL; 5859 goto exit; 5860 } 5861 5862 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 5863 DBG_88E("%s: rtw_efuse_map_read error!\n", __func__); 5864 err = -EFAULT; 5865 goto exit; 5866 } 5867 5868 *extra = 0; 5869 for (i = 0; i < cnts; i++) 5870 sprintf(extra, "%s0x%02X ", extra, data[i]); 5871 } else if (strcmp(tmp[0], "realraw") == 0) { 5872 addr = 0; 5873 mapLen = EFUSE_MAX_SIZE; 5874 if (rtw_efuse_access(padapter, false, addr, mapLen, rawdata) == _FAIL) { 5875 DBG_88E("%s: rtw_efuse_access Fail!!\n", __func__); 5876 err = -EFAULT; 5877 goto exit; 5878 } 5879 5880 sprintf(extra, "\n"); 5881 for (i = 0; i < mapLen; i++) { 5882 sprintf(extra, "%s%02X", extra, rawdata[i]); 5883 5884 if ((i & 0xF) == 0xF) 5885 sprintf(extra, "%s\n", extra); 5886 else if ((i & 0x7) == 0x7) 5887 sprintf(extra, "%s\t", extra); 5888 else 5889 sprintf(extra, "%s ", extra); 5890 } 5891 } else if (strcmp(tmp[0], "mac") == 0) { 5892 cnts = 6; 5893 5894 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5895 if ((addr + cnts) > max_available_size) { 5896 DBG_88E("%s: addr(0x%02x)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5897 err = -EFAULT; 5898 goto exit; 5899 } 5900 5901 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 5902 DBG_88E("%s: rtw_efuse_map_read error!\n", __func__); 5903 err = -EFAULT; 5904 goto exit; 5905 } 5906 5907 *extra = 0; 5908 for (i = 0; i < cnts; i++) { 5909 sprintf(extra, "%s%02X", extra, data[i]); 5910 if (i != (cnts-1)) 5911 sprintf(extra, "%s:", extra); 5912 } 5913 } else if (strcmp(tmp[0], "vidpid") == 0) { 5914 cnts = 4; 5915 5916 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5917 if ((addr + cnts) > max_available_size) { 5918 DBG_88E("%s: addr(0x%02x)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5919 err = -EFAULT; 5920 goto exit; 5921 } 5922 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 5923 DBG_88E("%s: rtw_efuse_access error!!\n", __func__); 5924 err = -EFAULT; 5925 goto exit; 5926 } 5927 5928 *extra = 0; 5929 for (i = 0; i < cnts; i++) { 5930 sprintf(extra, "%s0x%02X", extra, data[i]); 5931 if (i != (cnts-1)) 5932 sprintf(extra, "%s,", extra); 5933 } 5934 } else if (strcmp(tmp[0], "ableraw") == 0) { 5935 efuse_GetCurrentSize(padapter, &raw_cursize); 5936 raw_maxsize = efuse_GetMaxSize(padapter); 5937 sprintf(extra, "[available raw size] = %d bytes", raw_maxsize-raw_cursize); 5938 } else if (strcmp(tmp[0], "btfmap") == 0) { 5939 mapLen = EFUSE_BT_MAX_MAP_LEN; 5940 if (rtw_BT_efuse_map_read(padapter, 0, mapLen, pEfuseHal->BTEfuseInitMap) == _FAIL) { 5941 DBG_88E("%s: rtw_BT_efuse_map_read Fail!!\n", __func__); 5942 err = -EFAULT; 5943 goto exit; 5944 } 5945 5946 sprintf(extra, "\n"); 5947 for (i = 0; i < 512; i += 16) { 5948 /* set 512 because the iwpriv's extra size have limit 0x7FF */ 5949 sprintf(extra, "%s0x%03x\t", extra, i); 5950 for (j = 0; j < 8; j++) 5951 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5952 sprintf(extra, "%s\t", extra); 5953 for (; j < 16; j++) 5954 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5955 sprintf(extra, "%s\n", extra); 5956 } 5957 } else if (strcmp(tmp[0], "btbmap") == 0) { 5958 mapLen = EFUSE_BT_MAX_MAP_LEN; 5959 if (rtw_BT_efuse_map_read(padapter, 0, mapLen, pEfuseHal->BTEfuseInitMap) == _FAIL) { 5960 DBG_88E("%s: rtw_BT_efuse_map_read Fail!!\n", __func__); 5961 err = -EFAULT; 5962 goto exit; 5963 } 5964 5965 sprintf(extra, "\n"); 5966 for (i = 512; i < 1024; i += 16) { 5967 sprintf(extra, "%s0x%03x\t", extra, i); 5968 for (j = 0; j < 8; j++) 5969 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5970 sprintf(extra, "%s\t", extra); 5971 for (; j < 16; j++) 5972 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5973 sprintf(extra, "%s\n", extra); 5974 } 5975 } else if (strcmp(tmp[0], "btrmap") == 0) { 5976 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 5977 err = -EINVAL; 5978 goto exit; 5979 } 5980 5981 /* rmap addr cnts */ 5982 addr = simple_strtoul(tmp[1], &ptmp, 16); 5983 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 5984 5985 cnts = simple_strtoul(tmp[2], &ptmp, 10); 5986 if (cnts == 0) { 5987 DBG_88E("%s: btrmap Fail!! cnts error!\n", __func__); 5988 err = -EINVAL; 5989 goto exit; 5990 } 5991 DBG_88E("%s: cnts =%d\n", __func__, cnts); 5992 5993 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5994 if ((addr + cnts) > max_available_size) { 5995 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5996 err = -EFAULT; 5997 goto exit; 5998 } 5999 6000 if (rtw_BT_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 6001 DBG_88E("%s: rtw_BT_efuse_map_read error!!\n", __func__); 6002 err = -EFAULT; 6003 goto exit; 6004 } 6005 6006 *extra = 0; 6007 for (i = 0; i < cnts; i++) 6008 sprintf(extra, "%s 0x%02X ", extra, data[i]); 6009 } else if (strcmp(tmp[0], "btffake") == 0) { 6010 sprintf(extra, "\n"); 6011 for (i = 0; i < 512; i += 16) { 6012 sprintf(extra, "%s0x%03x\t", extra, i); 6013 for (j = 0; j < 8; j++) 6014 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6015 sprintf(extra, "%s\t", extra); 6016 for (; j < 16; j++) 6017 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6018 sprintf(extra, "%s\n", extra); 6019 } 6020 } else if (strcmp(tmp[0], "btbfake") == 0) { 6021 sprintf(extra, "\n"); 6022 for (i = 512; i < 1024; i += 16) { 6023 sprintf(extra, "%s0x%03x\t", extra, i); 6024 for (j = 0; j < 8; j++) 6025 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6026 sprintf(extra, "%s\t", extra); 6027 for (; j < 16; j++) 6028 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6029 sprintf(extra, "%s\n", extra); 6030 } 6031 } else if (strcmp(tmp[0], "wlrfkmap") == 0) { 6032 sprintf(extra, "\n"); 6033 for (i = 0; i < EFUSE_MAP_SIZE; i += 16) { 6034 sprintf(extra, "%s0x%02x\t", extra, i); 6035 for (j = 0; j < 8; j++) 6036 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseModifiedMap[i+j]); 6037 sprintf(extra, "%s\t", extra); 6038 for (; j < 16; j++) 6039 sprintf(extra, "%s %02X", extra, pEfuseHal->fakeEfuseModifiedMap[i+j]); 6040 sprintf(extra, "%s\n", extra); 6041 } 6042 } else { 6043 sprintf(extra, "Command not found!"); 6044 } 6045 6046exit: 6047 kfree(data); 6048 kfree(rawdata); 6049 if (!err) 6050 wrqu->length = strlen(extra); 6051 6052 rtw_pm_set_ips(padapter, ips_mode); 6053 rtw_pm_set_lps(padapter, lps_mode); 6054 padapter->registrypriv.fw_iol = org_fw_iol;/* 0:Disable, 1:enable, 2:by usb speed */ 6055 return err; 6056} 6057 6058static int rtw_mp_efuse_set(struct net_device *dev, 6059 struct iw_request_info *info, 6060 union iwreq_data *wdata, char *extra) 6061{ 6062 struct adapter *padapter; 6063 struct pwrctrl_priv *pwrctrlpriv; 6064 struct hal_data_8188e *haldata; 6065 struct efuse_hal *pEfuseHal; 6066 6067 u8 ips_mode = 0, lps_mode = 0; 6068 u32 i, jj, kk; 6069 u8 *setdata = NULL; 6070 u8 *ShadowMapBT = NULL; 6071 u8 *ShadowMapWiFi = NULL; 6072 u8 *setrawdata = NULL; 6073 char *pch, *ptmp, *token, *tmp[3] = {NULL, NULL, NULL}; 6074 u16 addr = 0, cnts = 0, max_available_size = 0; 6075 int err; 6076 6077 padapter = rtw_netdev_priv(dev); 6078 pwrctrlpriv = &padapter->pwrctrlpriv; 6079 haldata = GET_HAL_DATA(padapter); 6080 pEfuseHal = &haldata->EfuseHal; 6081 err = 0; 6082 setdata = _rtw_zmalloc(1024); 6083 if (setdata == NULL) { 6084 err = -ENOMEM; 6085 goto exit; 6086 } 6087 ShadowMapBT = _rtw_malloc(EFUSE_BT_MAX_MAP_LEN); 6088 if (ShadowMapBT == NULL) { 6089 err = -ENOMEM; 6090 goto exit; 6091 } 6092 ShadowMapWiFi = _rtw_malloc(EFUSE_MAP_SIZE); 6093 if (ShadowMapWiFi == NULL) { 6094 err = -ENOMEM; 6095 goto exit; 6096 } 6097 setrawdata = _rtw_malloc(EFUSE_MAX_SIZE); 6098 if (setrawdata == NULL) { 6099 err = -ENOMEM; 6100 goto exit; 6101 } 6102 6103 lps_mode = pwrctrlpriv->power_mgnt;/* keep org value */ 6104 rtw_pm_set_lps(padapter, PS_MODE_ACTIVE); 6105 6106 ips_mode = pwrctrlpriv->ips_mode;/* keep org value */ 6107 rtw_pm_set_ips(padapter, IPS_NONE); 6108 6109 pch = extra; 6110 DBG_88E("%s: in =%s\n", __func__, extra); 6111 6112 i = 0; 6113 while ((token = strsep(&pch, ",")) != NULL) { 6114 if (i > 2) 6115 break; 6116 tmp[i] = token; 6117 i++; 6118 } 6119 6120 /* tmp[0],[1],[2] */ 6121 /* wmap, addr, 00e04c871200 */ 6122 if (strcmp(tmp[0], "wmap") == 0) { 6123 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6124 err = -EINVAL; 6125 goto exit; 6126 } 6127 6128 addr = simple_strtoul(tmp[1], &ptmp, 16); 6129 addr &= 0xFFF; 6130 6131 cnts = strlen(tmp[2]); 6132 if (cnts%2) { 6133 err = -EINVAL; 6134 goto exit; 6135 } 6136 cnts /= 2; 6137 if (cnts == 0) { 6138 err = -EINVAL; 6139 goto exit; 6140 } 6141 6142 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6143 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6144 DBG_88E("%s: map data =%s\n", __func__, tmp[2]); 6145 6146 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6147 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6148 /* Change to check TYPE_EFUSE_MAP_LEN, because 8188E raw 256, logic map over 256. */ 6149 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&max_available_size, false); 6150 if ((addr+cnts) > max_available_size) { 6151 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6152 err = -EFAULT; 6153 goto exit; 6154 } 6155 6156 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6157 DBG_88E("%s: rtw_efuse_map_write error!!\n", __func__); 6158 err = -EFAULT; 6159 goto exit; 6160 } 6161 } else if (strcmp(tmp[0], "wraw") == 0) { 6162 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6163 err = -EINVAL; 6164 goto exit; 6165 } 6166 6167 addr = simple_strtoul(tmp[1], &ptmp, 16); 6168 addr &= 0xFFF; 6169 6170 cnts = strlen(tmp[2]); 6171 if (cnts%2) { 6172 err = -EINVAL; 6173 goto exit; 6174 } 6175 cnts /= 2; 6176 if (cnts == 0) { 6177 err = -EINVAL; 6178 goto exit; 6179 } 6180 6181 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6182 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6183 DBG_88E("%s: raw data =%s\n", __func__, tmp[2]); 6184 6185 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6186 setrawdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6187 6188 if (rtw_efuse_access(padapter, true, addr, cnts, setrawdata) == _FAIL) { 6189 DBG_88E("%s: rtw_efuse_access error!!\n", __func__); 6190 err = -EFAULT; 6191 goto exit; 6192 } 6193 } else if (strcmp(tmp[0], "mac") == 0) { 6194 if (tmp[1] == NULL) { 6195 err = -EINVAL; 6196 goto exit; 6197 } 6198 6199 /* mac, 00e04c871200 */ 6200 addr = EEPROM_MAC_ADDR_88EU; 6201 cnts = strlen(tmp[1]); 6202 if (cnts%2) { 6203 err = -EINVAL; 6204 goto exit; 6205 } 6206 cnts /= 2; 6207 if (cnts == 0) { 6208 err = -EINVAL; 6209 goto exit; 6210 } 6211 if (cnts > 6) { 6212 DBG_88E("%s: error data for mac addr =\"%s\"\n", __func__, tmp[1]); 6213 err = -EFAULT; 6214 goto exit; 6215 } 6216 6217 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6218 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6219 DBG_88E("%s: MAC address =%s\n", __func__, tmp[1]); 6220 6221 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6222 setdata[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]); 6223 /* Change to check TYPE_EFUSE_MAP_LEN, because 8188E raw 256, logic map over 256. */ 6224 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&max_available_size, false); 6225 if ((addr+cnts) > max_available_size) { 6226 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6227 err = -EFAULT; 6228 goto exit; 6229 } 6230 6231 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6232 DBG_88E("%s: rtw_efuse_map_write error!!\n", __func__); 6233 err = -EFAULT; 6234 goto exit; 6235 } 6236 } else if (strcmp(tmp[0], "vidpid") == 0) { 6237 if (tmp[1] == NULL) { 6238 err = -EINVAL; 6239 goto exit; 6240 } 6241 6242 /* pidvid, da0b7881 */ 6243 addr = EEPROM_VID_88EE; 6244 cnts = strlen(tmp[1]); 6245 if (cnts%2) { 6246 err = -EINVAL; 6247 goto exit; 6248 } 6249 cnts /= 2; 6250 if (cnts == 0) { 6251 err = -EINVAL; 6252 goto exit; 6253 } 6254 6255 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6256 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6257 DBG_88E("%s: VID/PID =%s\n", __func__, tmp[1]); 6258 6259 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6260 setdata[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]); 6261 6262 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6263 if ((addr+cnts) > max_available_size) { 6264 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6265 err = -EFAULT; 6266 goto exit; 6267 } 6268 6269 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6270 DBG_88E("%s: rtw_efuse_map_write error!!\n", __func__); 6271 err = -EFAULT; 6272 goto exit; 6273 } 6274 } else if (strcmp(tmp[0], "btwmap") == 0) { 6275 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6276 err = -EINVAL; 6277 goto exit; 6278 } 6279 6280 addr = simple_strtoul(tmp[1], &ptmp, 16); 6281 addr &= 0xFFF; 6282 6283 cnts = strlen(tmp[2]); 6284 if (cnts%2) { 6285 err = -EINVAL; 6286 goto exit; 6287 } 6288 cnts /= 2; 6289 if (cnts == 0) { 6290 err = -EINVAL; 6291 goto exit; 6292 } 6293 6294 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6295 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6296 DBG_88E("%s: BT data =%s\n", __func__, tmp[2]); 6297 6298 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6299 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6300 6301 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6302 if ((addr+cnts) > max_available_size) { 6303 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6304 err = -EFAULT; 6305 goto exit; 6306 } 6307 6308 if (rtw_BT_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6309 DBG_88E("%s: rtw_BT_efuse_map_write error!!\n", __func__); 6310 err = -EFAULT; 6311 goto exit; 6312 } 6313 } else if (strcmp(tmp[0], "btwfake") == 0) { 6314 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6315 err = -EINVAL; 6316 goto exit; 6317 } 6318 6319 addr = simple_strtoul(tmp[1], &ptmp, 16); 6320 addr &= 0xFFF; 6321 6322 cnts = strlen(tmp[2]); 6323 if (cnts%2) { 6324 err = -EINVAL; 6325 goto exit; 6326 } 6327 cnts /= 2; 6328 if (cnts == 0) { 6329 err = -EINVAL; 6330 goto exit; 6331 } 6332 6333 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6334 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6335 DBG_88E("%s: BT tmp data =%s\n", __func__, tmp[2]); 6336 6337 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6338 pEfuseHal->fakeBTEfuseModifiedMap[addr+jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6339 } else if (strcmp(tmp[0], "btdumpfake") == 0) { 6340 if (rtw_BT_efuse_map_read(padapter, 0, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _SUCCESS) { 6341 DBG_88E("%s: BT read all map success\n", __func__); 6342 } else { 6343 DBG_88E("%s: BT read all map Fail!\n", __func__); 6344 err = -EFAULT; 6345 } 6346 } else if (strcmp(tmp[0], "wldumpfake") == 0) { 6347 if (rtw_efuse_map_read(padapter, 0, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeEfuseModifiedMap) == _SUCCESS) { 6348 DBG_88E("%s: BT read all map success\n", __func__); 6349 } else { 6350 DBG_88E("%s: BT read all map Fail\n", __func__); 6351 err = -EFAULT; 6352 } 6353 } else if (strcmp(tmp[0], "btfk2map") == 0) { 6354 memcpy(pEfuseHal->BTEfuseModifiedMap, pEfuseHal->fakeBTEfuseModifiedMap, EFUSE_BT_MAX_MAP_LEN); 6355 6356 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6357 if (max_available_size < 1) { 6358 err = -EFAULT; 6359 goto exit; 6360 } 6361 6362 if (rtw_BT_efuse_map_write(padapter, 0x00, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _FAIL) { 6363 DBG_88E("%s: rtw_BT_efuse_map_write error!\n", __func__); 6364 err = -EFAULT; 6365 goto exit; 6366 } 6367 } else if (strcmp(tmp[0], "wlfk2map") == 0) { 6368 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6369 if (max_available_size < 1) { 6370 err = -EFAULT; 6371 goto exit; 6372 } 6373 6374 if (rtw_efuse_map_write(padapter, 0x00, EFUSE_MAX_MAP_LEN, pEfuseHal->fakeEfuseModifiedMap) == _FAIL) { 6375 DBG_88E("%s: rtw_efuse_map_write error!\n", __func__); 6376 err = -EFAULT; 6377 goto exit; 6378 } 6379 } else if (strcmp(tmp[0], "wlwfake") == 0) { 6380 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6381 err = -EINVAL; 6382 goto exit; 6383 } 6384 6385 addr = simple_strtoul(tmp[1], &ptmp, 16); 6386 addr &= 0xFFF; 6387 6388 cnts = strlen(tmp[2]); 6389 if (cnts%2) { 6390 err = -EINVAL; 6391 goto exit; 6392 } 6393 cnts /= 2; 6394 if (cnts == 0) { 6395 err = -EINVAL; 6396 goto exit; 6397 } 6398 6399 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6400 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6401 DBG_88E("%s: map tmp data =%s\n", __func__, tmp[2]); 6402 6403 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6404 pEfuseHal->fakeEfuseModifiedMap[addr+jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6405 } 6406 6407exit: 6408 kfree(setdata); 6409 kfree(ShadowMapBT); 6410 kfree(ShadowMapWiFi); 6411 kfree(setrawdata); 6412 6413 rtw_pm_set_ips(padapter, ips_mode); 6414 rtw_pm_set_lps(padapter, lps_mode); 6415 6416 return err; 6417} 6418 6419/* 6420 * Input Format: %s,%d,%d 6421 * %s is width, could be 6422 * "b" for 1 byte 6423 * "w" for WORD (2 bytes) 6424 * "dw" for DWORD (4 bytes) 6425 * 1st %d is address(offset) 6426 * 2st %d is data to write 6427 */ 6428static int rtw_mp_write_reg(struct net_device *dev, 6429 struct iw_request_info *info, 6430 struct iw_point *wrqu, char *extra) 6431{ 6432 char *pch, *pnext, *ptmp; 6433 char *width_str; 6434 char width; 6435 u32 addr, data; 6436 int ret; 6437 struct adapter *padapter = rtw_netdev_priv(dev); 6438 6439 pch = extra; 6440 pnext = strpbrk(pch, ",.-"); 6441 if (pnext == NULL) 6442 return -EINVAL; 6443 *pnext = 0; 6444 width_str = pch; 6445 6446 pch = pnext + 1; 6447 pnext = strpbrk(pch, ",.-"); 6448 if (pnext == NULL) 6449 return -EINVAL; 6450 *pnext = 0; 6451 addr = simple_strtoul(pch, &ptmp, 16); 6452 if (addr > 0x3FFF) 6453 return -EINVAL; 6454 6455 pch = pnext + 1; 6456 if ((pch - extra) >= wrqu->length) 6457 return -EINVAL; 6458 data = simple_strtoul(pch, &ptmp, 16); 6459 6460 ret = 0; 6461 width = width_str[0]; 6462 switch (width) { 6463 case 'b': 6464 /* 1 byte */ 6465 if (data > 0xFF) { 6466 ret = -EINVAL; 6467 break; 6468 } 6469 rtw_write8(padapter, addr, data); 6470 break; 6471 case 'w': 6472 /* 2 bytes */ 6473 if (data > 0xFFFF) { 6474 ret = -EINVAL; 6475 break; 6476 } 6477 rtw_write16(padapter, addr, data); 6478 break; 6479 case 'd': 6480 /* 4 bytes */ 6481 rtw_write32(padapter, addr, data); 6482 break; 6483 default: 6484 ret = -EINVAL; 6485 break; 6486 } 6487 6488 return ret; 6489} 6490 6491/* 6492 * Input Format: %s,%d 6493 * %s is width, could be 6494 * "b" for 1 byte 6495 * "w" for WORD (2 bytes) 6496 * "dw" for DWORD (4 bytes) 6497 * %d is address(offset) 6498 * 6499 * Return: 6500 * %d for data readed 6501 */ 6502static int rtw_mp_read_reg(struct net_device *dev, 6503 struct iw_request_info *info, 6504 struct iw_point *wrqu, char *extra) 6505{ 6506 struct adapter *padapter = rtw_netdev_priv(dev); 6507 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6508 char *pch, *pnext, *ptmp; 6509 char *width_str; 6510 char width; 6511 char data[20], tmp[20]; 6512 u32 addr; 6513 u32 ret, i = 0, j = 0, strtout = 0; 6514 6515 if (!input) 6516 return -ENOMEM; 6517 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6518 kfree(input); 6519 return -EFAULT; 6520 } 6521 _rtw_memset(data, 0, 20); 6522 _rtw_memset(tmp, 0, 20); 6523 _rtw_memset(extra, 0, wrqu->length); 6524 6525 pch = input; 6526 pnext = strpbrk(pch, ",.-"); 6527 if (pnext == NULL) { 6528 kfree(input); 6529 return -EINVAL; 6530 } 6531 *pnext = 0; 6532 width_str = pch; 6533 6534 pch = pnext + 1; 6535 if ((pch - input) >= wrqu->length) { 6536 kfree(input); 6537 return -EINVAL; 6538 } 6539 kfree(input); 6540 addr = simple_strtoul(pch, &ptmp, 16); 6541 if (addr > 0x3FFF) 6542 return -EINVAL; 6543 6544 ret = 0; 6545 width = width_str[0]; 6546 switch (width) { 6547 case 'b': 6548 /* 1 byte */ 6549 sprintf(extra, "%d\n", rtw_read8(padapter, addr)); 6550 wrqu->length = strlen(extra); 6551 break; 6552 case 'w': 6553 /* 2 bytes */ 6554 sprintf(data, "%04x\n", rtw_read16(padapter, addr)); 6555 for (i = 0; i <= strlen(data); i++) { 6556 if (i%2 == 0) { 6557 tmp[j] = ' '; 6558 j++; 6559 } 6560 if (data[i] != '\0') 6561 tmp[j] = data[i]; 6562 j++; 6563 } 6564 pch = tmp; 6565 DBG_88E("pch =%s", pch); 6566 6567 while (*pch != '\0') { 6568 pnext = strpbrk(pch, " "); 6569 if (!pnext) 6570 break; 6571 6572 pnext++; 6573 if (*pnext != '\0') { 6574 strtout = simple_strtoul(pnext, &ptmp, 16); 6575 sprintf(extra, "%s %d", extra, strtout); 6576 } else { 6577 break; 6578 } 6579 pch = pnext; 6580 } 6581 wrqu->length = 6; 6582 break; 6583 case 'd': 6584 /* 4 bytes */ 6585 sprintf(data, "%08x", rtw_read32(padapter, addr)); 6586 /* add read data format blank */ 6587 for (i = 0; i <= strlen(data); i++) { 6588 if (i%2 == 0) { 6589 tmp[j] = ' '; 6590 j++; 6591 } 6592 if (data[i] != '\0') 6593 tmp[j] = data[i]; 6594 6595 j++; 6596 } 6597 pch = tmp; 6598 DBG_88E("pch =%s", pch); 6599 6600 while (*pch != '\0') { 6601 pnext = strpbrk(pch, " "); 6602 if (!pnext) 6603 break; 6604 pnext++; 6605 if (*pnext != '\0') { 6606 strtout = simple_strtoul(pnext, &ptmp, 16); 6607 sprintf(extra, "%s %d", extra, strtout); 6608 } else { 6609 break; 6610 } 6611 pch = pnext; 6612 } 6613 wrqu->length = strlen(extra); 6614 break; 6615 default: 6616 wrqu->length = 0; 6617 ret = -EINVAL; 6618 break; 6619 } 6620 6621 return ret; 6622} 6623 6624/* 6625 * Input Format: %d,%x,%x 6626 * %d is RF path, should be smaller than MAX_RF_PATH_NUMS 6627 * 1st %x is address(offset) 6628 * 2st %x is data to write 6629 */ 6630 static int rtw_mp_write_rf(struct net_device *dev, 6631 struct iw_request_info *info, 6632 struct iw_point *wrqu, char *extra) 6633{ 6634 u32 path, addr, data; 6635 int ret; 6636 struct adapter *padapter = rtw_netdev_priv(dev); 6637 6638 ret = sscanf(extra, "%d,%x,%x", &path, &addr, &data); 6639 if (ret < 3) 6640 return -EINVAL; 6641 6642 if (path >= MAX_RF_PATH_NUMS) 6643 return -EINVAL; 6644 if (addr > 0xFF) 6645 return -EINVAL; 6646 if (data > 0xFFFFF) 6647 return -EINVAL; 6648 6649 _rtw_memset(extra, 0, wrqu->length); 6650 6651 write_rfreg(padapter, path, addr, data); 6652 6653 sprintf(extra, "write_rf completed\n"); 6654 wrqu->length = strlen(extra); 6655 6656 return 0; 6657} 6658 6659/* 6660 * Input Format: %d,%x 6661 * %d is RF path, should be smaller than MAX_RF_PATH_NUMS 6662 * %x is address(offset) 6663 * 6664 * Return: 6665 * %d for data readed 6666 */ 6667static int rtw_mp_read_rf(struct net_device *dev, 6668 struct iw_request_info *info, 6669 struct iw_point *wrqu, char *extra) 6670{ 6671 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6672 char *pch, *pnext, *ptmp; 6673 char data[20], tmp[20]; 6674 u32 path, addr; 6675 u32 ret, i = 0, j = 0, strtou = 0; 6676 struct adapter *padapter = rtw_netdev_priv(dev); 6677 6678 if (!input) 6679 return -ENOMEM; 6680 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6681 kfree(input); 6682 return -EFAULT; 6683 } 6684 ret = sscanf(input, "%d,%x", &path, &addr); 6685 kfree(input); 6686 if (ret < 2) 6687 return -EINVAL; 6688 6689 if (path >= MAX_RF_PATH_NUMS) 6690 return -EINVAL; 6691 if (addr > 0xFF) 6692 return -EINVAL; 6693 6694 _rtw_memset(extra, 0, wrqu->length); 6695 6696 sprintf(data, "%08x", read_rfreg(padapter, path, addr)); 6697 /* add read data format blank */ 6698 for (i = 0; i <= strlen(data); i++) { 6699 if (i%2 == 0) { 6700 tmp[j] = ' '; 6701 j++; 6702 } 6703 tmp[j] = data[i]; 6704 j++; 6705 } 6706 pch = tmp; 6707 DBG_88E("pch =%s", pch); 6708 6709 while (*pch != '\0') { 6710 pnext = strpbrk(pch, " "); 6711 pnext++; 6712 if (*pnext != '\0') { 6713 strtou = simple_strtoul(pnext, &ptmp, 16); 6714 sprintf(extra, "%s %d", extra, strtou); 6715 } else { 6716 break; 6717 } 6718 pch = pnext; 6719 } 6720 wrqu->length = strlen(extra); 6721 return 0; 6722} 6723 6724static int rtw_mp_start(struct net_device *dev, 6725 struct iw_request_info *info, 6726 struct iw_point *wrqu, char *extra) 6727{ 6728 struct adapter *padapter = rtw_netdev_priv(dev); 6729 6730 if (padapter->registrypriv.mp_mode == 0) { 6731 padapter->registrypriv.mp_mode = 1; 6732 6733 rtw_pm_set_ips(padapter, IPS_NONE); 6734 LeaveAllPowerSaveMode(padapter); 6735 6736 MPT_InitializeAdapter(padapter, 1); 6737 } 6738 if (padapter->registrypriv.mp_mode == 0) 6739 return -EPERM; 6740 if (padapter->mppriv.mode == MP_OFF) { 6741 if (mp_start_test(padapter) == _FAIL) 6742 return -EPERM; 6743 padapter->mppriv.mode = MP_ON; 6744 } 6745 return 0; 6746} 6747 6748static int rtw_mp_stop(struct net_device *dev, 6749 struct iw_request_info *info, 6750 struct iw_point *wrqu, char *extra) 6751{ 6752 struct adapter *padapter = rtw_netdev_priv(dev); 6753 6754 if (padapter->registrypriv.mp_mode == 1) { 6755 MPT_DeInitAdapter(padapter); 6756 padapter->registrypriv.mp_mode = 0; 6757 } 6758 6759 if (padapter->mppriv.mode != MP_OFF) { 6760 mp_stop_test(padapter); 6761 padapter->mppriv.mode = MP_OFF; 6762 } 6763 6764 return 0; 6765} 6766 6767extern int wifirate2_ratetbl_inx(unsigned char rate); 6768 6769static int rtw_mp_rate(struct net_device *dev, 6770 struct iw_request_info *info, 6771 struct iw_point *wrqu, char *extra) 6772{ 6773 u32 rate = MPT_RATE_1M; 6774 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6775 struct adapter *padapter = rtw_netdev_priv(dev); 6776 6777 if (!input) 6778 return -ENOMEM; 6779 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6780 kfree(input); 6781 return -EFAULT; 6782 } 6783 rate = rtw_atoi(input); 6784 sprintf(extra, "Set data rate to %d", rate); 6785 kfree(input); 6786 if (rate <= 0x7f) 6787 rate = wifirate2_ratetbl_inx((u8)rate); 6788 else 6789 rate = (rate-0x80+MPT_RATE_MCS0); 6790 6791 if (rate >= MPT_RATE_LAST) 6792 return -EINVAL; 6793 6794 padapter->mppriv.rateidx = rate; 6795 Hal_SetDataRate(padapter); 6796 6797 wrqu->length = strlen(extra) + 1; 6798 return 0; 6799} 6800 6801static int rtw_mp_channel(struct net_device *dev, 6802 struct iw_request_info *info, 6803 struct iw_point *wrqu, char *extra) 6804{ 6805 struct adapter *padapter = rtw_netdev_priv(dev); 6806 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6807 u32 channel = 1; 6808 6809 if (!input) 6810 return -ENOMEM; 6811 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6812 kfree(input); 6813 return -EFAULT; 6814 } 6815 channel = rtw_atoi(input); 6816 sprintf(extra, "Change channel %d to channel %d", padapter->mppriv.channel, channel); 6817 6818 padapter->mppriv.channel = channel; 6819 Hal_SetChannel(padapter); 6820 6821 wrqu->length = strlen(extra) + 1; 6822 kfree(input); 6823 return 0; 6824} 6825 6826static int rtw_mp_bandwidth(struct net_device *dev, 6827 struct iw_request_info *info, 6828 struct iw_point *wrqu, char *extra) 6829{ 6830 u32 bandwidth = 0, sg = 0; 6831 struct adapter *padapter = rtw_netdev_priv(dev); 6832 6833 sscanf(extra, "40M =%d, shortGI =%d", &bandwidth, &sg); 6834 6835 if (bandwidth != HT_CHANNEL_WIDTH_40) 6836 bandwidth = HT_CHANNEL_WIDTH_20; 6837 6838 padapter->mppriv.bandwidth = (u8)bandwidth; 6839 padapter->mppriv.preamble = sg; 6840 6841 SetBandwidth(padapter); 6842 6843 return 0; 6844} 6845 6846static int rtw_mp_txpower(struct net_device *dev, 6847 struct iw_request_info *info, 6848 struct iw_point *wrqu, char *extra) 6849{ 6850 u32 idx_a = 0, idx_b = 0; 6851 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6852 struct adapter *padapter = rtw_netdev_priv(dev); 6853 6854 if (!input) 6855 return -ENOMEM; 6856 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6857 kfree(input); 6858 return -EFAULT; 6859 } 6860 sscanf(input, "patha =%d, pathb =%d", &idx_a, &idx_b); 6861 6862 sprintf(extra, "Set power level path_A:%d path_B:%d", idx_a, idx_b); 6863 padapter->mppriv.txpoweridx = (u8)idx_a; 6864 padapter->mppriv.txpoweridx_b = (u8)idx_b; 6865 padapter->mppriv.bSetTxPower = 1; 6866 Hal_SetAntennaPathPower(padapter); 6867 6868 wrqu->length = strlen(extra) + 1; 6869 kfree(input); 6870 return 0; 6871} 6872 6873static int rtw_mp_ant_tx(struct net_device *dev, 6874 struct iw_request_info *info, 6875 struct iw_point *wrqu, char *extra) 6876{ 6877 u8 i; 6878 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6879 u16 antenna = 0; 6880 struct adapter *padapter = rtw_netdev_priv(dev); 6881 6882 if (!input) 6883 return -ENOMEM; 6884 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6885 kfree(input); 6886 return -EFAULT; 6887 } 6888 6889 sprintf(extra, "switch Tx antenna to %s", input); 6890 6891 for (i = 0; i < strlen(input); i++) { 6892 switch (input[i]) { 6893 case 'a': 6894 antenna |= ANTENNA_A; 6895 break; 6896 case 'b': 6897 antenna |= ANTENNA_B; 6898 break; 6899 } 6900 } 6901 padapter->mppriv.antenna_tx = antenna; 6902 6903 Hal_SetAntenna(padapter); 6904 6905 wrqu->length = strlen(extra) + 1; 6906 kfree(input); 6907 return 0; 6908} 6909 6910static int rtw_mp_ant_rx(struct net_device *dev, 6911 struct iw_request_info *info, 6912 struct iw_point *wrqu, char *extra) 6913{ 6914 u8 i; 6915 u16 antenna = 0; 6916 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6917 struct adapter *padapter = rtw_netdev_priv(dev); 6918 6919 if (!input) 6920 return -ENOMEM; 6921 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6922 kfree(input); 6923 return -EFAULT; 6924 } 6925 _rtw_memset(extra, 0, wrqu->length); 6926 6927 sprintf(extra, "switch Rx antenna to %s", input); 6928 6929 for (i = 0; i < strlen(input); i++) { 6930 switch (input[i]) { 6931 case 'a': 6932 antenna |= ANTENNA_A; 6933 break; 6934 case 'b': 6935 antenna |= ANTENNA_B; 6936 break; 6937 } 6938 } 6939 6940 padapter->mppriv.antenna_rx = antenna; 6941 Hal_SetAntenna(padapter); 6942 wrqu->length = strlen(extra); 6943 kfree(input); 6944 return 0; 6945} 6946 6947static int rtw_mp_ctx(struct net_device *dev, 6948 struct iw_request_info *info, 6949 struct iw_point *wrqu, char *extra) 6950{ 6951 u32 pkTx = 1, countPkTx = 1, cotuTx = 1, CarrSprTx = 1, scTx = 1, sgleTx = 1, stop = 1; 6952 u32 bStartTest = 1; 6953 u32 count = 0; 6954 struct mp_priv *pmp_priv; 6955 struct pkt_attrib *pattrib; 6956 6957 struct adapter *padapter = rtw_netdev_priv(dev); 6958 6959 pmp_priv = &padapter->mppriv; 6960 6961 if (copy_from_user(extra, wrqu->pointer, wrqu->length)) 6962 return -EFAULT; 6963 6964 DBG_88E("%s: in =%s\n", __func__, extra); 6965 6966 countPkTx = strncmp(extra, "count =", 5); /* strncmp true is 0 */ 6967 cotuTx = strncmp(extra, "background", 20); 6968 CarrSprTx = strncmp(extra, "background, cs", 20); 6969 scTx = strncmp(extra, "background, sc", 20); 6970 sgleTx = strncmp(extra, "background, stone", 20); 6971 pkTx = strncmp(extra, "background, pkt", 20); 6972 stop = strncmp(extra, "stop", 4); 6973 sscanf(extra, "count =%d, pkt", &count); 6974 6975 _rtw_memset(extra, '\0', sizeof(*extra)); 6976 6977 if (stop == 0) { 6978 bStartTest = 0; /* To set Stop */ 6979 pmp_priv->tx.stop = 1; 6980 sprintf(extra, "Stop continuous Tx"); 6981 } else { 6982 bStartTest = 1; 6983 if (pmp_priv->mode != MP_ON) { 6984 if (pmp_priv->tx.stop != 1) { 6985 DBG_88E("%s: MP_MODE != ON %d\n", __func__, pmp_priv->mode); 6986 return -EFAULT; 6987 } 6988 } 6989 } 6990 6991 if (pkTx == 0 || countPkTx == 0) 6992 pmp_priv->mode = MP_PACKET_TX; 6993 if (sgleTx == 0) 6994 pmp_priv->mode = MP_SINGLE_TONE_TX; 6995 if (cotuTx == 0) 6996 pmp_priv->mode = MP_CONTINUOUS_TX; 6997 if (CarrSprTx == 0) 6998 pmp_priv->mode = MP_CARRIER_SUPPRISSION_TX; 6999 if (scTx == 0) 7000 pmp_priv->mode = MP_SINGLE_CARRIER_TX; 7001 7002 switch (pmp_priv->mode) { 7003 case MP_PACKET_TX: 7004 if (bStartTest == 0) { 7005 pmp_priv->tx.stop = 1; 7006 pmp_priv->mode = MP_ON; 7007 sprintf(extra, "Stop continuous Tx"); 7008 } else if (pmp_priv->tx.stop == 1) { 7009 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500 count =%u,\n", count); 7010 pmp_priv->tx.stop = 0; 7011 pmp_priv->tx.count = count; 7012 pmp_priv->tx.payload = 2; 7013 pattrib = &pmp_priv->tx.attrib; 7014 pattrib->pktlen = 1500; 7015 _rtw_memset(pattrib->dst, 0xFF, ETH_ALEN); 7016 SetPacketTx(padapter); 7017 } else { 7018 return -EFAULT; 7019 } 7020 wrqu->length = strlen(extra); 7021 return 0; 7022 case MP_SINGLE_TONE_TX: 7023 if (bStartTest != 0) 7024 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7025 Hal_SetSingleToneTx(padapter, (u8)bStartTest); 7026 break; 7027 case MP_CONTINUOUS_TX: 7028 if (bStartTest != 0) 7029 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7030 Hal_SetContinuousTx(padapter, (u8)bStartTest); 7031 break; 7032 case MP_CARRIER_SUPPRISSION_TX: 7033 if (bStartTest != 0) { 7034 if (pmp_priv->rateidx <= MPT_RATE_11M) { 7035 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7036 Hal_SetCarrierSuppressionTx(padapter, (u8)bStartTest); 7037 } else { 7038 sprintf(extra, "Specify carrier suppression but not CCK rate"); 7039 } 7040 } 7041 break; 7042 case MP_SINGLE_CARRIER_TX: 7043 if (bStartTest != 0) 7044 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7045 Hal_SetSingleCarrierTx(padapter, (u8)bStartTest); 7046 break; 7047 default: 7048 sprintf(extra, "Error! Continuous-Tx is not on-going."); 7049 return -EFAULT; 7050 } 7051 7052 if (bStartTest == 1 && pmp_priv->mode != MP_ON) { 7053 struct mp_priv *pmp_priv = &padapter->mppriv; 7054 if (pmp_priv->tx.stop == 0) { 7055 pmp_priv->tx.stop = 1; 7056 rtw_msleep_os(5); 7057 } 7058 pmp_priv->tx.stop = 0; 7059 pmp_priv->tx.count = 1; 7060 SetPacketTx(padapter); 7061 } else { 7062 pmp_priv->mode = MP_ON; 7063 } 7064 7065 wrqu->length = strlen(extra); 7066 return 0; 7067} 7068 7069static int rtw_mp_arx(struct net_device *dev, 7070 struct iw_request_info *info, 7071 struct iw_point *wrqu, char *extra) 7072{ 7073 u8 bStartRx = 0, bStopRx = 0, bQueryPhy; 7074 u32 cckok = 0, cckcrc = 0, ofdmok = 0, ofdmcrc = 0, htok = 0, htcrc = 0, OFDM_FA = 0, CCK_FA = 0; 7075 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7076 struct adapter *padapter = rtw_netdev_priv(dev); 7077 7078 if (!input) 7079 return -ENOMEM; 7080 7081 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7082 kfree(input); 7083 return -EFAULT; 7084 } 7085 DBG_88E("%s: %s\n", __func__, input); 7086 7087 bStartRx = (strncmp(input, "start", 5) == 0) ? 1 : 0; /* strncmp true is 0 */ 7088 bStopRx = (strncmp(input, "stop", 5) == 0) ? 1 : 0; /* strncmp true is 0 */ 7089 bQueryPhy = (strncmp(input, "phy", 3) == 0) ? 1 : 0; /* strncmp true is 0 */ 7090 7091 if (bStartRx) { 7092 sprintf(extra, "start"); 7093 SetPacketRx(padapter, bStartRx); 7094 } else if (bStopRx) { 7095 SetPacketRx(padapter, 0); 7096 sprintf(extra, "Received packet OK:%d CRC error:%d", padapter->mppriv.rx_pktcount, padapter->mppriv.rx_crcerrpktcount); 7097 } else if (bQueryPhy) { 7098 /* 7099 OFDM FA 7100 RegCF0[15:0] 7101 RegCF2[31:16] 7102 RegDA0[31:16] 7103 RegDA4[15:0] 7104 RegDA4[31:16] 7105 RegDA8[15:0] 7106 CCK FA 7107 (RegA5B<<8) | RegA5C 7108 */ 7109 cckok = read_bbreg(padapter, 0xf88, 0xffffffff); 7110 cckcrc = read_bbreg(padapter, 0xf84, 0xffffffff); 7111 ofdmok = read_bbreg(padapter, 0xf94, 0x0000FFFF); 7112 ofdmcrc = read_bbreg(padapter, 0xf94, 0xFFFF0000); 7113 htok = read_bbreg(padapter, 0xf90, 0x0000FFFF); 7114 htcrc = read_bbreg(padapter, 0xf90, 0xFFFF0000); 7115 7116 OFDM_FA = read_bbreg(padapter, 0xcf0, 0x0000FFFF); 7117 OFDM_FA = read_bbreg(padapter, 0xcf2, 0xFFFF0000); 7118 OFDM_FA = read_bbreg(padapter, 0xda0, 0xFFFF0000); 7119 OFDM_FA = read_bbreg(padapter, 0xda4, 0x0000FFFF); 7120 OFDM_FA = read_bbreg(padapter, 0xda4, 0xFFFF0000); 7121 OFDM_FA = read_bbreg(padapter, 0xda8, 0x0000FFFF); 7122 CCK_FA = (rtw_read8(padapter, 0xa5b)<<8) | (rtw_read8(padapter, 0xa5c)); 7123 7124 sprintf(extra, "Phy Received packet OK:%d CRC error:%d FA Counter: %d", cckok+ofdmok+htok, cckcrc+ofdmcrc+htcrc, OFDM_FA+CCK_FA); 7125 } 7126 wrqu->length = strlen(extra) + 1; 7127 kfree(input); 7128 return 0; 7129} 7130 7131static int rtw_mp_trx_query(struct net_device *dev, 7132 struct iw_request_info *info, 7133 struct iw_point *wrqu, char *extra) 7134{ 7135 u32 txok, txfail, rxok, rxfail; 7136 struct adapter *padapter = rtw_netdev_priv(dev); 7137 7138 txok = padapter->mppriv.tx.sended; 7139 txfail = 0; 7140 rxok = padapter->mppriv.rx_pktcount; 7141 rxfail = padapter->mppriv.rx_crcerrpktcount; 7142 7143 _rtw_memset(extra, '\0', 128); 7144 7145 sprintf(extra, "Tx OK:%d, Tx Fail:%d, Rx OK:%d, CRC error:%d ", txok, txfail, rxok, rxfail); 7146 7147 wrqu->length = strlen(extra)+1; 7148 7149 return 0; 7150} 7151 7152static int rtw_mp_pwrtrk(struct net_device *dev, 7153 struct iw_request_info *info, 7154 struct iw_point *wrqu, char *extra) 7155{ 7156 u8 enable; 7157 u32 thermal; 7158 s32 ret; 7159 struct adapter *padapter = rtw_netdev_priv(dev); 7160 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7161 7162 if (!input) 7163 return -ENOMEM; 7164 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7165 kfree(input); 7166 return -EFAULT; 7167 } 7168 _rtw_memset(extra, 0, wrqu->length); 7169 7170 enable = 1; 7171 if (wrqu->length > 1) {/* not empty string */ 7172 if (strncmp(input, "stop", 4) == 0) { 7173 enable = 0; 7174 sprintf(extra, "mp tx power tracking stop"); 7175 } else if (sscanf(input, "ther =%d", &thermal)) { 7176 ret = Hal_SetThermalMeter(padapter, (u8)thermal); 7177 if (ret == _FAIL) 7178 return -EPERM; 7179 sprintf(extra, "mp tx power tracking start, target value =%d ok ", thermal); 7180 } else { 7181 kfree(input); 7182 return -EINVAL; 7183 } 7184 } 7185 7186 kfree(input); 7187 ret = Hal_SetPowerTracking(padapter, enable); 7188 if (ret == _FAIL) 7189 return -EPERM; 7190 7191 wrqu->length = strlen(extra); 7192 return 0; 7193} 7194 7195static int rtw_mp_psd(struct net_device *dev, 7196 struct iw_request_info *info, 7197 struct iw_point *wrqu, char *extra) 7198{ 7199 struct adapter *padapter = rtw_netdev_priv(dev); 7200 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7201 7202 if (!input) 7203 return -ENOMEM; 7204 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7205 kfree(input); 7206 return -EFAULT; 7207 } 7208 7209 strcpy(extra, input); 7210 7211 wrqu->length = mp_query_psd(padapter, extra); 7212 kfree(input); 7213 return 0; 7214} 7215 7216static int rtw_mp_thermal(struct net_device *dev, 7217 struct iw_request_info *info, 7218 struct iw_point *wrqu, char *extra) 7219{ 7220 u8 val; 7221 u16 bwrite = 1; 7222 u16 addr = EEPROM_THERMAL_METER_88E; 7223 7224 u16 cnt = 1; 7225 u16 max_available_size = 0; 7226 struct adapter *padapter = rtw_netdev_priv(dev); 7227 7228 if (copy_from_user(extra, wrqu->pointer, wrqu->length)) 7229 return -EFAULT; 7230 7231 bwrite = strncmp(extra, "write", 6); /* strncmp true is 0 */ 7232 7233 Hal_GetThermalMeter(padapter, &val); 7234 7235 if (bwrite == 0) { 7236 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 7237 if (2 > max_available_size) { 7238 DBG_88E("no available efuse!\n"); 7239 return -EFAULT; 7240 } 7241 if (rtw_efuse_map_write(padapter, addr, cnt, &val) == _FAIL) { 7242 DBG_88E("rtw_efuse_map_write error\n"); 7243 return -EFAULT; 7244 } else { 7245 sprintf(extra, " efuse write ok :%d", val); 7246 } 7247 } else { 7248 sprintf(extra, "%d", val); 7249 } 7250 wrqu->length = strlen(extra); 7251 7252 return 0; 7253} 7254 7255static int rtw_mp_reset_stats(struct net_device *dev, 7256 struct iw_request_info *info, 7257 struct iw_point *wrqu, char *extra) 7258{ 7259 struct mp_priv *pmp_priv; 7260 struct adapter *padapter = rtw_netdev_priv(dev); 7261 7262 pmp_priv = &padapter->mppriv; 7263 7264 pmp_priv->tx.sended = 0; 7265 pmp_priv->tx_pktcount = 0; 7266 pmp_priv->rx_pktcount = 0; 7267 pmp_priv->rx_crcerrpktcount = 0; 7268 7269 /* reset phy counter */ 7270 write_bbreg(padapter, 0xf14, BIT16, 0x1); 7271 rtw_msleep_os(10); 7272 write_bbreg(padapter, 0xf14, BIT16, 0x0); 7273 7274 return 0; 7275} 7276 7277static int rtw_mp_dump(struct net_device *dev, 7278 struct iw_request_info *info, 7279 struct iw_point *wrqu, char *extra) 7280{ 7281 u32 value; 7282 u8 rf_type, path_nums = 0; 7283 u32 i, j = 1, path; 7284 struct adapter *padapter = rtw_netdev_priv(dev); 7285 7286 if (strncmp(extra, "all", 4) == 0) { 7287 DBG_88E("\n ======= MAC REG =======\n"); 7288 for (i = 0x0; i < 0x300; i += 4) { 7289 if (j%4 == 1) 7290 DBG_88E("0x%02x", i); 7291 DBG_88E(" 0x%08x ", rtw_read32(padapter, i)); 7292 if ((j++)%4 == 0) 7293 DBG_88E("\n"); 7294 } 7295 for (i = 0x400; i < 0x1000; i += 4) { 7296 if (j%4 == 1) 7297 DBG_88E("0x%02x", i); 7298 DBG_88E(" 0x%08x ", rtw_read32(padapter, i)); 7299 if ((j++)%4 == 0) 7300 DBG_88E("\n"); 7301 } 7302 7303 j = 1; 7304 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type)); 7305 7306 DBG_88E("\n ======= RF REG =======\n"); 7307 if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) 7308 path_nums = 1; 7309 else 7310 path_nums = 2; 7311 7312 for (path = 0; path < path_nums; path++) { 7313 for (i = 0; i < 0x34; i++) { 7314 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); 7315 if (j%4 == 1) 7316 DBG_88E("0x%02x ", i); 7317 DBG_88E(" 0x%08x ", value); 7318 if ((j++)%4 == 0) 7319 DBG_88E("\n"); 7320 } 7321 } 7322 } 7323 return 0; 7324} 7325 7326static int rtw_mp_phypara(struct net_device *dev, 7327 struct iw_request_info *info, 7328 struct iw_point *wrqu, char *extra) 7329{ 7330 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7331 u32 valxcap; 7332 7333 if (!input) 7334 return -ENOMEM; 7335 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7336 kfree(input); 7337 return -EFAULT; 7338 } 7339 7340 DBG_88E("%s:iwpriv in =%s\n", __func__, input); 7341 7342 sscanf(input, "xcap =%d", &valxcap); 7343 7344 kfree(input); 7345 return 0; 7346} 7347 7348static int rtw_mp_SetRFPath(struct net_device *dev, 7349 struct iw_request_info *info, 7350 union iwreq_data *wrqu, char *extra) 7351{ 7352 struct adapter *padapter = rtw_netdev_priv(dev); 7353 char *input = kmalloc(wrqu->data.length, GFP_KERNEL); 7354 u8 bMain = 1, bTurnoff = 1; 7355 7356 if (!input) 7357 return -ENOMEM; 7358 if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length)) 7359 return -EFAULT; 7360 DBG_88E("%s:iwpriv in =%s\n", __func__, input); 7361 7362 bMain = strncmp(input, "1", 2); /* strncmp true is 0 */ 7363 bTurnoff = strncmp(input, "0", 3); /* strncmp true is 0 */ 7364 7365 if (bMain == 0) { 7366 MP_PHY_SetRFPathSwitch(padapter, true); 7367 DBG_88E("%s:PHY_SetRFPathSwitch = true\n", __func__); 7368 } else if (bTurnoff == 0) { 7369 MP_PHY_SetRFPathSwitch(padapter, false); 7370 DBG_88E("%s:PHY_SetRFPathSwitch = false\n", __func__); 7371 } 7372 kfree(input); 7373 return 0; 7374} 7375 7376static int rtw_mp_QueryDrv(struct net_device *dev, 7377 struct iw_request_info *info, 7378 union iwreq_data *wrqu, char *extra) 7379{ 7380 struct adapter *padapter = rtw_netdev_priv(dev); 7381 char *input = kmalloc(wrqu->data.length, GFP_KERNEL); 7382 u8 qAutoLoad = 1; 7383 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter); 7384 7385 if (!input) 7386 return -ENOMEM; 7387 7388 if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length)) 7389 return -EFAULT; 7390 DBG_88E("%s:iwpriv in =%s\n", __func__, input); 7391 7392 qAutoLoad = strncmp(input, "autoload", 8); /* strncmp true is 0 */ 7393 7394 if (qAutoLoad == 0) { 7395 DBG_88E("%s:qAutoLoad\n", __func__); 7396 7397 if (pEEPROM->bautoload_fail_flag) 7398 sprintf(extra, "fail"); 7399 else 7400 sprintf(extra, "ok"); 7401 } 7402 wrqu->data.length = strlen(extra) + 1; 7403 kfree(input); 7404 return 0; 7405} 7406 7407static int rtw_mp_set(struct net_device *dev, 7408 struct iw_request_info *info, 7409 union iwreq_data *wdata, char *extra) 7410{ 7411 struct iw_point *wrqu = (struct iw_point *)wdata; 7412 u32 subcmd = wrqu->flags; 7413 struct adapter *padapter = rtw_netdev_priv(dev); 7414 7415 if (padapter == NULL) 7416 return -ENETDOWN; 7417 7418 if (extra == NULL) { 7419 wrqu->length = 0; 7420 return -EIO; 7421 } 7422 7423 switch (subcmd) { 7424 case MP_START: 7425 DBG_88E("set case mp_start\n"); 7426 rtw_mp_start(dev, info, wrqu, extra); 7427 break; 7428 case MP_STOP: 7429 DBG_88E("set case mp_stop\n"); 7430 rtw_mp_stop(dev, info, wrqu, extra); 7431 break; 7432 case MP_BANDWIDTH: 7433 DBG_88E("set case mp_bandwidth\n"); 7434 rtw_mp_bandwidth(dev, info, wrqu, extra); 7435 break; 7436 case MP_RESET_STATS: 7437 DBG_88E("set case MP_RESET_STATS\n"); 7438 rtw_mp_reset_stats(dev, info, wrqu, extra); 7439 break; 7440 case MP_SetRFPathSwh: 7441 DBG_88E("set MP_SetRFPathSwitch\n"); 7442 rtw_mp_SetRFPath(dev, info, wdata, extra); 7443 break; 7444 case CTA_TEST: 7445 DBG_88E("set CTA_TEST\n"); 7446 rtw_cta_test_start(dev, info, wdata, extra); 7447 break; 7448 } 7449 7450 return 0; 7451} 7452 7453static int rtw_mp_get(struct net_device *dev, 7454 struct iw_request_info *info, 7455 union iwreq_data *wdata, char *extra) 7456{ 7457 struct iw_point *wrqu = (struct iw_point *)wdata; 7458 u32 subcmd = wrqu->flags; 7459 struct adapter *padapter = rtw_netdev_priv(dev); 7460 7461 if (padapter == NULL) 7462 return -ENETDOWN; 7463 if (extra == NULL) { 7464 wrqu->length = 0; 7465 return -EIO; 7466 } 7467 7468 switch (subcmd) { 7469 case WRITE_REG: 7470 rtw_mp_write_reg(dev, info, wrqu, extra); 7471 break; 7472 case WRITE_RF: 7473 rtw_mp_write_rf(dev, info, wrqu, extra); 7474 break; 7475 case MP_PHYPARA: 7476 DBG_88E("mp_get MP_PHYPARA\n"); 7477 rtw_mp_phypara(dev, info, wrqu, extra); 7478 break; 7479 case MP_CHANNEL: 7480 DBG_88E("set case mp_channel\n"); 7481 rtw_mp_channel(dev, info, wrqu, extra); 7482 break; 7483 case READ_REG: 7484 DBG_88E("mp_get READ_REG\n"); 7485 rtw_mp_read_reg(dev, info, wrqu, extra); 7486 break; 7487 case READ_RF: 7488 DBG_88E("mp_get READ_RF\n"); 7489 rtw_mp_read_rf(dev, info, wrqu, extra); 7490 break; 7491 case MP_RATE: 7492 DBG_88E("set case mp_rate\n"); 7493 rtw_mp_rate(dev, info, wrqu, extra); 7494 break; 7495 case MP_TXPOWER: 7496 DBG_88E("set case MP_TXPOWER\n"); 7497 rtw_mp_txpower(dev, info, wrqu, extra); 7498 break; 7499 case MP_ANT_TX: 7500 DBG_88E("set case MP_ANT_TX\n"); 7501 rtw_mp_ant_tx(dev, info, wrqu, extra); 7502 break; 7503 case MP_ANT_RX: 7504 DBG_88E("set case MP_ANT_RX\n"); 7505 rtw_mp_ant_rx(dev, info, wrqu, extra); 7506 break; 7507 case MP_QUERY: 7508 rtw_mp_trx_query(dev, info, wrqu, extra); 7509 break; 7510 case MP_CTX: 7511 DBG_88E("set case MP_CTX\n"); 7512 rtw_mp_ctx(dev, info, wrqu, extra); 7513 break; 7514 case MP_ARX: 7515 DBG_88E("set case MP_ARX\n"); 7516 rtw_mp_arx(dev, info, wrqu, extra); 7517 break; 7518 case EFUSE_GET: 7519 DBG_88E("efuse get EFUSE_GET\n"); 7520 rtw_mp_efuse_get(dev, info, wdata, extra); 7521 break; 7522 case MP_DUMP: 7523 DBG_88E("set case MP_DUMP\n"); 7524 rtw_mp_dump(dev, info, wrqu, extra); 7525 break; 7526 case MP_PSD: 7527 DBG_88E("set case MP_PSD\n"); 7528 rtw_mp_psd(dev, info, wrqu, extra); 7529 break; 7530 case MP_THER: 7531 DBG_88E("set case MP_THER\n"); 7532 rtw_mp_thermal(dev, info, wrqu, extra); 7533 break; 7534 case MP_QueryDrvStats: 7535 DBG_88E("mp_get MP_QueryDrvStats\n"); 7536 rtw_mp_QueryDrv (dev, info, wdata, extra); 7537 break; 7538 case MP_PWRTRK: 7539 DBG_88E("set case MP_PWRTRK\n"); 7540 rtw_mp_pwrtrk(dev, info, wrqu, extra); 7541 break; 7542 case EFUSE_SET: 7543 DBG_88E("set case efuse set\n"); 7544 rtw_mp_efuse_set(dev, info, wdata, extra); 7545 break; 7546 } 7547 7548 rtw_msleep_os(10); /* delay 5ms for sending pkt before exit adb shell operation */ 7549 return 0; 7550} 7551 7552static int rtw_tdls(struct net_device *dev, 7553 struct iw_request_info *info, 7554 union iwreq_data *wrqu, char *extra) 7555{ 7556 return 0; 7557} 7558 7559static int rtw_tdls_get(struct net_device *dev, 7560 struct iw_request_info *info, 7561 union iwreq_data *wrqu, char *extra) 7562{ 7563 return 0; 7564} 7565 7566static int rtw_test( 7567 struct net_device *dev, 7568 struct iw_request_info *info, 7569 union iwreq_data *wrqu, char *extra) 7570{ 7571 u32 len; 7572 u8 *pbuf, *pch; 7573 char *ptmp; 7574 u8 *delim = ","; 7575 7576 DBG_88E("+%s\n", __func__); 7577 len = wrqu->data.length; 7578 7579 pbuf = (u8 *)rtw_zmalloc(len); 7580 if (pbuf == NULL) { 7581 DBG_88E("%s: no memory!\n", __func__); 7582 return -ENOMEM; 7583 } 7584 7585 if (copy_from_user(pbuf, wrqu->data.pointer, len)) { 7586 kfree(pbuf); 7587 DBG_88E("%s: copy from user fail!\n", __func__); 7588 return -EFAULT; 7589 } 7590 DBG_88E("%s: string =\"%s\"\n", __func__, pbuf); 7591 7592 ptmp = (char *)pbuf; 7593 pch = strsep(&ptmp, delim); 7594 if ((pch == NULL) || (strlen(pch) == 0)) { 7595 kfree(pbuf); 7596 DBG_88E("%s: parameter error(level 1)!\n", __func__); 7597 return -EFAULT; 7598 } 7599 kfree(pbuf); 7600 return 0; 7601} 7602 7603static iw_handler rtw_handlers[] = { 7604 NULL, /* SIOCSIWCOMMIT */ 7605 rtw_wx_get_name, /* SIOCGIWNAME */ 7606 dummy, /* SIOCSIWNWID */ 7607 dummy, /* SIOCGIWNWID */ 7608 rtw_wx_set_freq, /* SIOCSIWFREQ */ 7609 rtw_wx_get_freq, /* SIOCGIWFREQ */ 7610 rtw_wx_set_mode, /* SIOCSIWMODE */ 7611 rtw_wx_get_mode, /* SIOCGIWMODE */ 7612 dummy, /* SIOCSIWSENS */ 7613 rtw_wx_get_sens, /* SIOCGIWSENS */ 7614 NULL, /* SIOCSIWRANGE */ 7615 rtw_wx_get_range, /* SIOCGIWRANGE */ 7616 rtw_wx_set_priv, /* SIOCSIWPRIV */ 7617 NULL, /* SIOCGIWPRIV */ 7618 NULL, /* SIOCSIWSTATS */ 7619 NULL, /* SIOCGIWSTATS */ 7620 dummy, /* SIOCSIWSPY */ 7621 dummy, /* SIOCGIWSPY */ 7622 NULL, /* SIOCGIWTHRSPY */ 7623 NULL, /* SIOCWIWTHRSPY */ 7624 rtw_wx_set_wap, /* SIOCSIWAP */ 7625 rtw_wx_get_wap, /* SIOCGIWAP */ 7626 rtw_wx_set_mlme, /* request MLME operation; uses struct iw_mlme */ 7627 dummy, /* SIOCGIWAPLIST -- depricated */ 7628 rtw_wx_set_scan, /* SIOCSIWSCAN */ 7629 rtw_wx_get_scan, /* SIOCGIWSCAN */ 7630 rtw_wx_set_essid, /* SIOCSIWESSID */ 7631 rtw_wx_get_essid, /* SIOCGIWESSID */ 7632 dummy, /* SIOCSIWNICKN */ 7633 rtw_wx_get_nick, /* SIOCGIWNICKN */ 7634 NULL, /* -- hole -- */ 7635 NULL, /* -- hole -- */ 7636 rtw_wx_set_rate, /* SIOCSIWRATE */ 7637 rtw_wx_get_rate, /* SIOCGIWRATE */ 7638 rtw_wx_set_rts, /* SIOCSIWRTS */ 7639 rtw_wx_get_rts, /* SIOCGIWRTS */ 7640 rtw_wx_set_frag, /* SIOCSIWFRAG */ 7641 rtw_wx_get_frag, /* SIOCGIWFRAG */ 7642 dummy, /* SIOCSIWTXPOW */ 7643 dummy, /* SIOCGIWTXPOW */ 7644 dummy, /* SIOCSIWRETRY */ 7645 rtw_wx_get_retry, /* SIOCGIWRETRY */ 7646 rtw_wx_set_enc, /* SIOCSIWENCODE */ 7647 rtw_wx_get_enc, /* SIOCGIWENCODE */ 7648 dummy, /* SIOCSIWPOWER */ 7649 rtw_wx_get_power, /* SIOCGIWPOWER */ 7650 NULL, /*---hole---*/ 7651 NULL, /*---hole---*/ 7652 rtw_wx_set_gen_ie, /* SIOCSIWGENIE */ 7653 NULL, /* SIOCGWGENIE */ 7654 rtw_wx_set_auth, /* SIOCSIWAUTH */ 7655 NULL, /* SIOCGIWAUTH */ 7656 rtw_wx_set_enc_ext, /* SIOCSIWENCODEEXT */ 7657 NULL, /* SIOCGIWENCODEEXT */ 7658 rtw_wx_set_pmkid, /* SIOCSIWPMKSA */ 7659 NULL, /*---hole---*/ 7660}; 7661 7662static const struct iw_priv_args rtw_private_args[] = { 7663 { 7664 SIOCIWFIRSTPRIV + 0x0, 7665 IW_PRIV_TYPE_CHAR | 0x7FF, 0, "write" 7666 }, 7667 { 7668 SIOCIWFIRSTPRIV + 0x1, 7669 IW_PRIV_TYPE_CHAR | 0x7FF, 7670 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "read" 7671 }, 7672 { 7673 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext" 7674 }, 7675 { 7676 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl" 7677 }, 7678 { 7679 SIOCIWFIRSTPRIV + 0x4, 7680 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo" 7681 }, 7682 { 7683 SIOCIWFIRSTPRIV + 0x5, 7684 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setpid" 7685 }, 7686 { 7687 SIOCIWFIRSTPRIV + 0x6, 7688 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start" 7689 }, 7690 { 7691 SIOCIWFIRSTPRIV + 0x7, 7692 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "get_sensitivity" 7693 }, 7694 { 7695 SIOCIWFIRSTPRIV + 0x8, 7696 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_prob_req_ie" 7697 }, 7698 { 7699 SIOCIWFIRSTPRIV + 0x9, 7700 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_assoc_req_ie" 7701 }, 7702 7703 { 7704 SIOCIWFIRSTPRIV + 0xA, 7705 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "channel_plan" 7706 }, 7707 7708 { 7709 SIOCIWFIRSTPRIV + 0xB, 7710 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "dbg" 7711 }, 7712 { 7713 SIOCIWFIRSTPRIV + 0xC, 7714 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 0, "rfw" 7715 }, 7716 { 7717 SIOCIWFIRSTPRIV + 0xD, 7718 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "rfr" 7719 }, 7720 { 7721 SIOCIWFIRSTPRIV + 0x10, 7722 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, 0, "p2p_set" 7723 }, 7724 { 7725 SIOCIWFIRSTPRIV + 0x11, 7726 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | P2P_PRIVATE_IOCTL_SET_LEN, "p2p_get" 7727 }, 7728 { 7729 SIOCIWFIRSTPRIV + 0x12, 7730 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, IW_PRIV_TYPE_CHAR | IFNAMSIZ, "p2p_get2" 7731 }, 7732 {SIOCIWFIRSTPRIV + 0x13, IW_PRIV_TYPE_CHAR | 128, 0, "NULL"}, 7733 { 7734 SIOCIWFIRSTPRIV + 0x14, 7735 IW_PRIV_TYPE_CHAR | 64, 0, "tdls" 7736 }, 7737 { 7738 SIOCIWFIRSTPRIV + 0x15, 7739 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | P2P_PRIVATE_IOCTL_SET_LEN, "tdls_get" 7740 }, 7741 { 7742 SIOCIWFIRSTPRIV + 0x16, 7743 IW_PRIV_TYPE_CHAR | 64, 0, "pm_set" 7744 }, 7745 7746 {SIOCIWFIRSTPRIV + 0x18, IW_PRIV_TYPE_CHAR | IFNAMSIZ, 0, "rereg_nd_name"}, 7747 7748 {SIOCIWFIRSTPRIV + 0x1A, IW_PRIV_TYPE_CHAR | 1024, 0, "efuse_set"}, 7749 {SIOCIWFIRSTPRIV + 0x1B, IW_PRIV_TYPE_CHAR | 128, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"}, 7750 {SIOCIWFIRSTPRIV + 0x1D, IW_PRIV_TYPE_CHAR | 40, IW_PRIV_TYPE_CHAR | 0x7FF, "test" 7751 }, 7752 7753 {SIOCIWFIRSTPRIV + 0x0E, IW_PRIV_TYPE_CHAR | 1024, 0, ""}, /* set */ 7754 {SIOCIWFIRSTPRIV + 0x0F, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, ""},/* get */ 7755/* --- sub-ioctls definitions --- */ 7756 7757 {MP_START, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_start"}, /* set */ 7758 {MP_PHYPARA, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_phypara"},/* get */ 7759 {MP_STOP, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_stop"}, /* set */ 7760 {MP_CHANNEL, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_channel"},/* get */ 7761 {MP_BANDWIDTH, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_bandwidth"}, /* set */ 7762 {MP_RATE, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate"},/* get */ 7763 {MP_RESET_STATS, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_reset_stats"}, 7764 {MP_QUERY, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_query"}, /* get */ 7765 {READ_REG, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_reg"}, 7766 {MP_RATE, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate"}, 7767 {READ_RF, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_rf"}, 7768 {MP_PSD, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_psd"}, 7769 {MP_DUMP, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_dump"}, 7770 {MP_TXPOWER, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_txpower"}, 7771 {MP_ANT_TX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_tx"}, 7772 {MP_ANT_RX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_rx"}, 7773 {WRITE_REG, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "write_reg"}, 7774 {WRITE_RF, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "write_rf"}, 7775 {MP_CTX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ctx"}, 7776 {MP_ARX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_arx"}, 7777 {MP_THER, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ther"}, 7778 {EFUSE_SET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_set"}, 7779 {EFUSE_GET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"}, 7780 {MP_PWRTRK, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_pwrtrk"}, 7781 {MP_QueryDrvStats, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_drvquery"}, 7782 {MP_IOCTL, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_ioctl"}, /* mp_ioctl */ 7783 {MP_SetRFPathSwh, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_setrfpath"}, 7784 {CTA_TEST, IW_PRIV_TYPE_CHAR | 1024, 0, "cta_test"}, 7785}; 7786 7787static iw_handler rtw_private_handler[] = { 7788rtw_wx_write32, /* 0x00 */ 7789rtw_wx_read32, /* 0x01 */ 7790rtw_drvext_hdl, /* 0x02 */ 7791rtw_mp_ioctl_hdl, /* 0x03 */ 7792 7793/* for MM DTV platform */ 7794 rtw_get_ap_info, /* 0x04 */ 7795 7796 rtw_set_pid, /* 0x05 */ 7797 rtw_wps_start, /* 0x06 */ 7798 7799 rtw_wx_get_sensitivity, /* 0x07 */ 7800 rtw_wx_set_mtk_wps_probe_ie, /* 0x08 */ 7801 rtw_wx_set_mtk_wps_ie, /* 0x09 */ 7802 7803/* Set Channel depend on the country code */ 7804 rtw_wx_set_channel_plan, /* 0x0A */ 7805 7806 rtw_dbg_port, /* 0x0B */ 7807 rtw_wx_write_rf, /* 0x0C */ 7808 rtw_wx_read_rf, /* 0x0D */ 7809 7810 rtw_mp_set, /* 0x0E */ 7811 rtw_mp_get, /* 0x0F */ 7812 rtw_p2p_set, /* 0x10 */ 7813 rtw_p2p_get, /* 0x11 */ 7814 rtw_p2p_get2, /* 0x12 */ 7815 7816 NULL, /* 0x13 */ 7817 rtw_tdls, /* 0x14 */ 7818 rtw_tdls_get, /* 0x15 */ 7819 7820 rtw_pm_set, /* 0x16 */ 7821 rtw_wx_priv_null, /* 0x17 */ 7822 rtw_rereg_nd_name, /* 0x18 */ 7823 rtw_wx_priv_null, /* 0x19 */ 7824 7825 rtw_mp_efuse_set, /* 0x1A */ 7826 rtw_mp_efuse_get, /* 0x1B */ 7827 NULL, /* 0x1C is reserved for hostapd */ 7828 rtw_test, /* 0x1D */ 7829}; 7830 7831static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev) 7832{ 7833 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 7834 struct iw_statistics *piwstats = &padapter->iwstats; 7835 int tmp_level = 0; 7836 int tmp_qual = 0; 7837 int tmp_noise = 0; 7838 7839 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 7840 piwstats->qual.qual = 0; 7841 piwstats->qual.level = 0; 7842 piwstats->qual.noise = 0; 7843 } else { 7844 tmp_level = padapter->recvpriv.signal_strength; 7845 tmp_qual = padapter->recvpriv.signal_qual; 7846 tmp_noise = padapter->recvpriv.noise; 7847 7848 piwstats->qual.level = tmp_level; 7849 piwstats->qual.qual = tmp_qual; 7850 piwstats->qual.noise = tmp_noise; 7851 } 7852 piwstats->qual.updated = IW_QUAL_ALL_UPDATED;/* IW_QUAL_DBM; */ 7853 return &padapter->iwstats; 7854} 7855 7856struct iw_handler_def rtw_handlers_def = { 7857 .standard = rtw_handlers, 7858 .num_standard = sizeof(rtw_handlers) / sizeof(iw_handler), 7859 .private = rtw_private_handler, 7860 .private_args = (struct iw_priv_args *)rtw_private_args, 7861 .num_private = sizeof(rtw_private_handler) / sizeof(iw_handler), 7862 .num_private_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args), 7863 .get_wireless_stats = rtw_get_wireless_stats, 7864}; 7865 7866/* copy from net/wireless/wext.c start */ 7867/* ---------------------------------------------------------------- */ 7868/* 7869 * Calculate size of private arguments 7870 */ 7871static const char iw_priv_type_size[] = { 7872 0, /* IW_PRIV_TYPE_NONE */ 7873 1, /* IW_PRIV_TYPE_BYTE */ 7874 1, /* IW_PRIV_TYPE_CHAR */ 7875 0, /* Not defined */ 7876 sizeof(__u32), /* IW_PRIV_TYPE_INT */ 7877 sizeof(struct iw_freq), /* IW_PRIV_TYPE_FLOAT */ 7878 sizeof(struct sockaddr), /* IW_PRIV_TYPE_ADDR */ 7879 0, /* Not defined */ 7880}; 7881 7882static int get_priv_size(__u16 args) 7883{ 7884 int num = args & IW_PRIV_SIZE_MASK; 7885 int type = (args & IW_PRIV_TYPE_MASK) >> 12; 7886 7887 return num * iw_priv_type_size[type]; 7888} 7889/* copy from net/wireless/wext.c end */ 7890 7891static int rtw_ioctl_wext_private(struct net_device *dev, union iwreq_data *wrq_data) 7892{ 7893 int err = 0; 7894 u8 *input = NULL; 7895 u32 input_len = 0; 7896 const char delim[] = " "; 7897 u8 *output = NULL; 7898 u32 output_len = 0; 7899 u32 count = 0; 7900 u8 *buffer = NULL; 7901 u32 buffer_len = 0; 7902 char *ptr = NULL; 7903 u8 cmdname[17] = {0}; /* IFNAMSIZ+1 */ 7904 u32 cmdlen; 7905 s32 len; 7906 u8 *extra = NULL; 7907 u32 extra_size = 0; 7908 7909 s32 k; 7910 const iw_handler *priv; /* Private ioctl */ 7911 const struct iw_priv_args *priv_args; /* Private ioctl description */ 7912 u32 num_priv_args; /* Number of descriptions */ 7913 iw_handler handler; 7914 int temp; 7915 int subcmd = 0; /* sub-ioctl index */ 7916 int offset = 0; /* Space for sub-ioctl index */ 7917 7918 union iwreq_data wdata; 7919 7920 memcpy(&wdata, wrq_data, sizeof(wdata)); 7921 7922 input_len = wdata.data.length; 7923 input = rtw_zmalloc(input_len); 7924 if (NULL == input) 7925 return -ENOMEM; 7926 if (copy_from_user(input, wdata.data.pointer, input_len)) { 7927 err = -EFAULT; 7928 goto exit; 7929 } 7930 ptr = input; 7931 len = input_len; 7932 7933 sscanf(ptr, "%16s", cmdname); 7934 cmdlen = strlen(cmdname); 7935 DBG_88E("%s: cmd =%s\n", __func__, cmdname); 7936 7937 /* skip command string */ 7938 if (cmdlen > 0) 7939 cmdlen += 1; /* skip one space */ 7940 ptr += cmdlen; 7941 len -= cmdlen; 7942 DBG_88E("%s: parameters =%s\n", __func__, ptr); 7943 7944 priv = rtw_private_handler; 7945 priv_args = rtw_private_args; 7946 num_priv_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args); 7947 7948 if (num_priv_args == 0) { 7949 err = -EOPNOTSUPP; 7950 goto exit; 7951 } 7952 7953 /* Search the correct ioctl */ 7954 k = -1; 7955 while ((++k < num_priv_args) && strcmp(priv_args[k].name, cmdname)); 7956 7957 /* If not found... */ 7958 if (k == num_priv_args) { 7959 err = -EOPNOTSUPP; 7960 goto exit; 7961 } 7962 7963 /* Watch out for sub-ioctls ! */ 7964 if (priv_args[k].cmd < SIOCDEVPRIVATE) { 7965 int j = -1; 7966 7967 /* Find the matching *real* ioctl */ 7968 while ((++j < num_priv_args) && ((priv_args[j].name[0] != '\0') || 7969 (priv_args[j].set_args != priv_args[k].set_args) || 7970 (priv_args[j].get_args != priv_args[k].get_args))); 7971 7972 /* If not found... */ 7973 if (j == num_priv_args) { 7974 err = -EINVAL; 7975 goto exit; 7976 } 7977 7978 /* Save sub-ioctl number */ 7979 subcmd = priv_args[k].cmd; 7980 /* Reserve one int (simplify alignment issues) */ 7981 offset = sizeof(__u32); 7982 /* Use real ioctl definition from now on */ 7983 k = j; 7984 } 7985 7986 buffer = rtw_zmalloc(4096); 7987 if (NULL == buffer) { 7988 err = -ENOMEM; 7989 goto exit; 7990 } 7991 7992 /* If we have to set some data */ 7993 if ((priv_args[k].set_args & IW_PRIV_TYPE_MASK) && 7994 (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) { 7995 u8 *str; 7996 7997 switch (priv_args[k].set_args & IW_PRIV_TYPE_MASK) { 7998 case IW_PRIV_TYPE_BYTE: 7999 /* Fetch args */ 8000 count = 0; 8001 do { 8002 str = strsep(&ptr, delim); 8003 if (NULL == str) 8004 break; 8005 sscanf(str, "%i", &temp); 8006 buffer[count++] = (u8)temp; 8007 } while (1); 8008 buffer_len = count; 8009 /* Number of args to fetch */ 8010 wdata.data.length = count; 8011 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) 8012 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK; 8013 break; 8014 case IW_PRIV_TYPE_INT: 8015 /* Fetch args */ 8016 count = 0; 8017 do { 8018 str = strsep(&ptr, delim); 8019 if (NULL == str) 8020 break; 8021 sscanf(str, "%i", &temp); 8022 ((s32 *)buffer)[count++] = (s32)temp; 8023 } while (1); 8024 buffer_len = count * sizeof(s32); 8025 /* Number of args to fetch */ 8026 wdata.data.length = count; 8027 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) 8028 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK; 8029 break; 8030 case IW_PRIV_TYPE_CHAR: 8031 if (len > 0) { 8032 /* Size of the string to fetch */ 8033 wdata.data.length = len; 8034 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) 8035 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK; 8036 8037 /* Fetch string */ 8038 memcpy(buffer, ptr, wdata.data.length); 8039 } else { 8040 wdata.data.length = 1; 8041 buffer[0] = '\0'; 8042 } 8043 buffer_len = wdata.data.length; 8044 break; 8045 default: 8046 DBG_88E("%s: Not yet implemented...\n", __func__); 8047 err = -1; 8048 goto exit; 8049 } 8050 8051 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) && 8052 (wdata.data.length != (priv_args[k].set_args & IW_PRIV_SIZE_MASK))) { 8053 DBG_88E("%s: The command %s needs exactly %d argument(s)...\n", 8054 __func__, cmdname, priv_args[k].set_args & IW_PRIV_SIZE_MASK); 8055 err = -EINVAL; 8056 goto exit; 8057 } 8058 } else { 8059 /* if args to set */ 8060 wdata.data.length = 0L; 8061 } 8062 8063 /* Those two tests are important. They define how the driver 8064 * will have to handle the data */ 8065 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) && 8066 ((get_priv_size(priv_args[k].set_args) + offset) <= IFNAMSIZ)) { 8067 /* First case : all SET args fit within wrq */ 8068 if (offset) 8069 wdata.mode = subcmd; 8070 memcpy(wdata.name + offset, buffer, IFNAMSIZ - offset); 8071 } else { 8072 if ((priv_args[k].set_args == 0) && 8073 (priv_args[k].get_args & IW_PRIV_SIZE_FIXED) && 8074 (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ)) { 8075 /* Second case : no SET args, GET args fit within wrq */ 8076 if (offset) 8077 wdata.mode = subcmd; 8078 } else { 8079 /* Third case : args won't fit in wrq, or variable number of args */ 8080 if (copy_to_user(wdata.data.pointer, buffer, buffer_len)) { 8081 err = -EFAULT; 8082 goto exit; 8083 } 8084 wdata.data.flags = subcmd; 8085 } 8086 } 8087 8088 kfree(input); 8089 input = NULL; 8090 8091 extra_size = 0; 8092 if (IW_IS_SET(priv_args[k].cmd)) { 8093 /* Size of set arguments */ 8094 extra_size = get_priv_size(priv_args[k].set_args); 8095 8096 /* Does it fits in iwr ? */ 8097 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) && 8098 ((extra_size + offset) <= IFNAMSIZ)) 8099 extra_size = 0; 8100 } else { 8101 /* Size of get arguments */ 8102 extra_size = get_priv_size(priv_args[k].get_args); 8103 8104 /* Does it fits in iwr ? */ 8105 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) && 8106 (extra_size <= IFNAMSIZ)) 8107 extra_size = 0; 8108 } 8109 8110 if (extra_size == 0) { 8111 extra = (u8 *)&wdata; 8112 kfree(buffer); 8113 buffer = NULL; 8114 } else { 8115 extra = buffer; 8116 } 8117 8118 handler = priv[priv_args[k].cmd - SIOCIWFIRSTPRIV]; 8119 err = handler(dev, NULL, &wdata, extra); 8120 8121 /* If we have to get some data */ 8122 if ((priv_args[k].get_args & IW_PRIV_TYPE_MASK) && 8123 (priv_args[k].get_args & IW_PRIV_SIZE_MASK)) { 8124 int j; 8125 int n = 0; /* number of args */ 8126 u8 str[20] = {0}; 8127 8128 /* Check where is the returned data */ 8129 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) && 8130 (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ)) 8131 n = priv_args[k].get_args & IW_PRIV_SIZE_MASK; 8132 else 8133 n = wdata.data.length; 8134 8135 output = rtw_zmalloc(4096); 8136 if (NULL == output) { 8137 err = -ENOMEM; 8138 goto exit; 8139 } 8140 switch (priv_args[k].get_args & IW_PRIV_TYPE_MASK) { 8141 case IW_PRIV_TYPE_BYTE: 8142 /* Display args */ 8143 for (j = 0; j < n; j++) { 8144 sprintf(str, "%d ", extra[j]); 8145 len = strlen(str); 8146 output_len = strlen(output); 8147 if ((output_len + len + 1) > 4096) { 8148 err = -E2BIG; 8149 goto exit; 8150 } 8151 memcpy(output+output_len, str, len); 8152 } 8153 break; 8154 case IW_PRIV_TYPE_INT: 8155 /* Display args */ 8156 for (j = 0; j < n; j++) { 8157 sprintf(str, "%d ", ((__s32 *)extra)[j]); 8158 len = strlen(str); 8159 output_len = strlen(output); 8160 if ((output_len + len + 1) > 4096) { 8161 err = -E2BIG; 8162 goto exit; 8163 } 8164 memcpy(output+output_len, str, len); 8165 } 8166 break; 8167 case IW_PRIV_TYPE_CHAR: 8168 /* Display args */ 8169 memcpy(output, extra, n); 8170 break; 8171 default: 8172 DBG_88E("%s: Not yet implemented...\n", __func__); 8173 err = -1; 8174 goto exit; 8175 } 8176 8177 output_len = strlen(output) + 1; 8178 wrq_data->data.length = output_len; 8179 if (copy_to_user(wrq_data->data.pointer, output, output_len)) { 8180 err = -EFAULT; 8181 goto exit; 8182 } 8183 } else { 8184 /* if args to set */ 8185 wrq_data->data.length = 0; 8186 } 8187 8188exit: 8189 kfree(input); 8190 kfree(buffer); 8191 kfree(output); 8192 return err; 8193} 8194 8195#include <rtw_android.h> 8196int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 8197{ 8198 struct iwreq *wrq = (struct iwreq *)rq; 8199 int ret = 0; 8200 8201 switch (cmd) { 8202 case RTL_IOCTL_WPA_SUPPLICANT: 8203 ret = wpa_supplicant_ioctl(dev, &wrq->u.data); 8204 break; 8205#ifdef CONFIG_88EU_AP_MODE 8206 case RTL_IOCTL_HOSTAPD: 8207 ret = rtw_hostapd_ioctl(dev, &wrq->u.data); 8208 break; 8209#endif /* CONFIG_88EU_AP_MODE */ 8210 case SIOCDEVPRIVATE: 8211 ret = rtw_ioctl_wext_private(dev, &wrq->u); 8212 break; 8213 case (SIOCDEVPRIVATE+1): 8214 ret = rtw_android_priv_cmd(dev, rq, cmd); 8215 break; 8216 default: 8217 ret = -EOPNOTSUPP; 8218 break; 8219 } 8220 return ret; 8221} 8222