ioctl_linux.c revision 5a2d8292f1051c1d1c08fc1732c74ac12ef61452
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) == true) 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 = 20 + -98; 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 choosen 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 _enter_critical_bh(&queue->lock, &irqL); 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 _enter_critical_bh(&pmlmepriv->lock, &irqL); 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 paramater 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&queue->lock, &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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) == true) { 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 intented 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 initation procedure is support 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); 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) == true) { 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) == true) { 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 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL); 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 keylen = 16; 4888 default: 4889 keylen = 16; 4890 } 4891 4892 memcpy(&(psetkeyparm->key[0]), key, keylen); 4893 4894 pcmd->cmdcode = _SetKey_CMD_; 4895 pcmd->parmbuf = (u8 *)psetkeyparm; 4896 pcmd->cmdsz = (sizeof(struct setkey_parm)); 4897 pcmd->rsp = NULL; 4898 pcmd->rspsz = 0; 4899 4900 _rtw_init_listhead(&pcmd->list); 4901 4902 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 4903 4904exit: 4905 4906 return res; 4907} 4908 4909static int set_wep_key(struct adapter *padapter, u8 *key, u8 keylen, int keyid) 4910{ 4911 u8 alg; 4912 4913 switch (keylen) { 4914 case 5: 4915 alg = _WEP40_; 4916 break; 4917 case 13: 4918 alg = _WEP104_; 4919 break; 4920 default: 4921 alg = _NO_PRIVACY_; 4922 } 4923 4924 return set_group_key(padapter, key, alg, keyid); 4925} 4926 4927static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 4928{ 4929 int ret = 0; 4930 u32 wep_key_idx, wep_key_len, wep_total_len; 4931 struct ndis_802_11_wep *pwep = NULL; 4932 struct sta_info *psta = NULL, *pbcmc_sta = NULL; 4933 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 4934 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 4935 struct security_priv *psecuritypriv = &(padapter->securitypriv); 4936 struct sta_priv *pstapriv = &padapter->stapriv; 4937 4938 DBG_88E("%s\n", __func__); 4939 param->u.crypt.err = 0; 4940 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 4941 if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) { 4942 ret = -EINVAL; 4943 goto exit; 4944 } 4945 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 4946 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 4947 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 4948 if (param->u.crypt.idx >= WEP_KEYS) { 4949 ret = -EINVAL; 4950 goto exit; 4951 } 4952 } else { 4953 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 4954 if (!psta) { 4955 DBG_88E("rtw_set_encryption(), sta has already been removed or never been added\n"); 4956 goto exit; 4957 } 4958 } 4959 4960 if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) { 4961 /* todo:clear default encryption keys */ 4962 4963 DBG_88E("clear default encryption keys, keyid =%d\n", param->u.crypt.idx); 4964 goto exit; 4965 } 4966 if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) { 4967 DBG_88E("r871x_set_encryption, crypt.alg = WEP\n"); 4968 wep_key_idx = param->u.crypt.idx; 4969 wep_key_len = param->u.crypt.key_len; 4970 DBG_88E("r871x_set_encryption, wep_key_idx=%d, len=%d\n", wep_key_idx, wep_key_len); 4971 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) { 4972 ret = -EINVAL; 4973 goto exit; 4974 } 4975 4976 if (wep_key_len > 0) { 4977 wep_key_len = wep_key_len <= 5 ? 5 : 13; 4978 wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial); 4979 pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len); 4980 if (pwep == NULL) { 4981 DBG_88E(" r871x_set_encryption: pwep allocate fail !!!\n"); 4982 goto exit; 4983 } 4984 4985 _rtw_memset(pwep, 0, wep_total_len); 4986 4987 pwep->KeyLength = wep_key_len; 4988 pwep->Length = wep_total_len; 4989 } 4990 4991 pwep->KeyIndex = wep_key_idx; 4992 4993 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength); 4994 4995 if (param->u.crypt.set_tx) { 4996 DBG_88E("wep, set_tx = 1\n"); 4997 4998 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 4999 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_; 5000 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 5001 5002 if (pwep->KeyLength == 13) { 5003 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_; 5004 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 5005 } 5006 5007 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx; 5008 5009 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength); 5010 5011 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength; 5012 5013 set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx); 5014 } else { 5015 DBG_88E("wep, set_tx = 0\n"); 5016 5017 /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */ 5018 /* psecuritypriv->dot11PrivacyKeyIndex = keyid", but can rtw_set_key to cam */ 5019 5020 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength); 5021 5022 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength; 5023 5024 set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx); 5025 } 5026 5027 goto exit; 5028 } 5029 5030 if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /* group key */ 5031 if (param->u.crypt.set_tx == 1) { 5032 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 5033 DBG_88E("%s, set group_key, WEP\n", __func__); 5034 5035 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5036 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5037 5038 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 5039 if (param->u.crypt.key_len == 13) 5040 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 5041 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 5042 DBG_88E("%s, set group_key, TKIP\n", __func__); 5043 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 5044 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5045 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5046 /* set mic key */ 5047 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 5048 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 5049 5050 psecuritypriv->busetkipkey = true; 5051 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 5052 DBG_88E("%s, set group_key, CCMP\n", __func__); 5053 psecuritypriv->dot118021XGrpPrivacy = _AES_; 5054 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5055 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5056 } else { 5057 DBG_88E("%s, set group_key, none\n", __func__); 5058 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 5059 } 5060 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 5061 psecuritypriv->binstallGrpkey = true; 5062 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 5063 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 5064 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 5065 if (pbcmc_sta) { 5066 pbcmc_sta->ieee8021x_blocked = false; 5067 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 5068 } 5069 } 5070 goto exit; 5071 } 5072 5073 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */ 5074 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 5075 if (param->u.crypt.set_tx == 1) { 5076 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5077 5078 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 5079 DBG_88E("%s, set pairwise key, WEP\n", __func__); 5080 5081 psta->dot118021XPrivacy = _WEP40_; 5082 if (param->u.crypt.key_len == 13) 5083 psta->dot118021XPrivacy = _WEP104_; 5084 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 5085 DBG_88E("%s, set pairwise key, TKIP\n", __func__); 5086 5087 psta->dot118021XPrivacy = _TKIP_; 5088 5089 /* set mic key */ 5090 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 5091 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 5092 5093 psecuritypriv->busetkipkey = true; 5094 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 5095 DBG_88E("%s, set pairwise key, CCMP\n", __func__); 5096 5097 psta->dot118021XPrivacy = _AES_; 5098 } else { 5099 DBG_88E("%s, set pairwise key, none\n", __func__); 5100 5101 psta->dot118021XPrivacy = _NO_PRIVACY_; 5102 } 5103 5104 set_pairwise_key(padapter, psta); 5105 5106 psta->ieee8021x_blocked = false; 5107 } else { /* group key??? */ 5108 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 5109 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5110 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5111 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 5112 if (param->u.crypt.key_len == 13) 5113 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 5114 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 5115 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 5116 5117 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5118 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5119 5120 /* set mic key */ 5121 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 5122 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 5123 5124 psecuritypriv->busetkipkey = true; 5125 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 5126 psecuritypriv->dot118021XGrpPrivacy = _AES_; 5127 5128 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, 5129 param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 5130 } else { 5131 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 5132 } 5133 5134 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 5135 5136 psecuritypriv->binstallGrpkey = true; 5137 5138 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 5139 5140 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 5141 5142 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 5143 if (pbcmc_sta) { 5144 pbcmc_sta->ieee8021x_blocked = false; 5145 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 5146 } 5147 } 5148 } 5149 } 5150 5151exit: 5152 5153 kfree(pwep); 5154 5155 return ret; 5156} 5157 5158static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len) 5159{ 5160 int ret = 0; 5161 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5162 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5163 struct sta_priv *pstapriv = &padapter->stapriv; 5164 unsigned char *pbuf = param->u.bcn_ie.buf; 5165 5166 DBG_88E("%s, len =%d\n", __func__, len); 5167 5168 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5169 return -EINVAL; 5170 5171 memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2); 5172 5173 if ((pstapriv->max_num_sta > NUM_STA) || (pstapriv->max_num_sta <= 0)) 5174 pstapriv->max_num_sta = NUM_STA; 5175 5176 if (rtw_check_beacon_data(padapter, pbuf, (len-12-2)) == _SUCCESS)/* 12 = param header, 2:no packed */ 5177 ret = 0; 5178 else 5179 ret = -EINVAL; 5180 5181 return ret; 5182} 5183 5184static int rtw_hostapd_sta_flush(struct net_device *dev) 5185{ 5186 int ret = 0; 5187 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5188 5189 DBG_88E("%s\n", __func__); 5190 5191 flush_all_cam_entry(padapter); /* clear CAM */ 5192 5193 ret = rtw_sta_flush(padapter); 5194 5195 return ret; 5196} 5197 5198static int rtw_add_sta(struct net_device *dev, struct ieee_param *param) 5199{ 5200 int ret = 0; 5201 struct sta_info *psta = NULL; 5202 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5203 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5204 struct sta_priv *pstapriv = &padapter->stapriv; 5205 5206 DBG_88E("rtw_add_sta(aid =%d) =%pM\n", param->u.add_sta.aid, (param->sta_addr)); 5207 5208 if (!check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE))) 5209 return -EINVAL; 5210 5211 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5212 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5213 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5214 return -EINVAL; 5215 5216 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 5217 if (psta) { 5218 int flags = param->u.add_sta.flags; 5219 5220 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */ 5221 5222 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16); 5223 5224 /* check wmm cap. */ 5225 if (WLAN_STA_WME&flags) 5226 psta->qos_option = 1; 5227 else 5228 psta->qos_option = 0; 5229 5230 if (pmlmepriv->qospriv.qos_option == 0) 5231 psta->qos_option = 0; 5232 5233 /* chec 802.11n ht cap. */ 5234 if (WLAN_STA_HT&flags) { 5235 psta->htpriv.ht_option = true; 5236 psta->qos_option = 1; 5237 memcpy((void *)&psta->htpriv.ht_cap, (void *)¶m->u.add_sta.ht_cap, sizeof(struct rtw_ieee80211_ht_cap)); 5238 } else { 5239 psta->htpriv.ht_option = false; 5240 } 5241 5242 if (pmlmepriv->htpriv.ht_option == false) 5243 psta->htpriv.ht_option = false; 5244 5245 update_sta_info_apmode(padapter, psta); 5246 } else { 5247 ret = -ENOMEM; 5248 } 5249 5250 return ret; 5251} 5252 5253static int rtw_del_sta(struct net_device *dev, struct ieee_param *param) 5254{ 5255 unsigned long irqL; 5256 int ret = 0; 5257 struct sta_info *psta = NULL; 5258 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5259 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5260 struct sta_priv *pstapriv = &padapter->stapriv; 5261 int updated = 0; 5262 5263 DBG_88E("rtw_del_sta =%pM\n", (param->sta_addr)); 5264 5265 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 5266 return -EINVAL; 5267 5268 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5269 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5270 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5271 return -EINVAL; 5272 5273 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 5274 if (psta) { 5275 _enter_critical_bh(&pstapriv->asoc_list_lock, &irqL); 5276 if (!rtw_is_list_empty(&psta->asoc_list)) { 5277 rtw_list_delete(&psta->asoc_list); 5278 pstapriv->asoc_list_cnt--; 5279 updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING); 5280 } 5281 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL); 5282 associated_clients_update(padapter, updated); 5283 psta = NULL; 5284 } else { 5285 DBG_88E("rtw_del_sta(), sta has already been removed or never been added\n"); 5286 } 5287 5288 return ret; 5289} 5290 5291static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len) 5292{ 5293 int ret = 0; 5294 struct sta_info *psta = NULL; 5295 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5296 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5297 struct sta_priv *pstapriv = &padapter->stapriv; 5298 struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param; 5299 struct sta_data *psta_data = (struct sta_data *)param_ex->data; 5300 5301 DBG_88E("rtw_ioctl_get_sta_info, sta_addr: %pM\n", (param_ex->sta_addr)); 5302 5303 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 5304 return -EINVAL; 5305 5306 if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff && 5307 param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff && 5308 param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff) 5309 return -EINVAL; 5310 5311 psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr); 5312 if (psta) { 5313 psta_data->aid = (u16)psta->aid; 5314 psta_data->capability = psta->capability; 5315 psta_data->flags = psta->flags; 5316 5317/* 5318 nonerp_set : BIT(0) 5319 no_short_slot_time_set : BIT(1) 5320 no_short_preamble_set : BIT(2) 5321 no_ht_gf_set : BIT(3) 5322 no_ht_set : BIT(4) 5323 ht_20mhz_set : BIT(5) 5324*/ 5325 5326 psta_data->sta_set = ((psta->nonerp_set) | 5327 (psta->no_short_slot_time_set << 1) | 5328 (psta->no_short_preamble_set << 2) | 5329 (psta->no_ht_gf_set << 3) | 5330 (psta->no_ht_set << 4) | 5331 (psta->ht_20mhz_set << 5)); 5332 psta_data->tx_supp_rates_len = psta->bssratelen; 5333 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen); 5334 memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct rtw_ieee80211_ht_cap)); 5335 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts; 5336 psta_data->rx_bytes = psta->sta_stats.rx_bytes; 5337 psta_data->rx_drops = psta->sta_stats.rx_drops; 5338 psta_data->tx_pkts = psta->sta_stats.tx_pkts; 5339 psta_data->tx_bytes = psta->sta_stats.tx_bytes; 5340 psta_data->tx_drops = psta->sta_stats.tx_drops; 5341 } else { 5342 ret = -1; 5343 } 5344 5345 return ret; 5346} 5347 5348static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param) 5349{ 5350 int ret = 0; 5351 struct sta_info *psta = NULL; 5352 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5353 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5354 struct sta_priv *pstapriv = &padapter->stapriv; 5355 5356 DBG_88E("rtw_get_sta_wpaie, sta_addr: %pM\n", (param->sta_addr)); 5357 5358 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 5359 return -EINVAL; 5360 5361 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5362 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5363 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5364 return -EINVAL; 5365 5366 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 5367 if (psta) { 5368 if ((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_GENERIC)) { 5369 int wpa_ie_len; 5370 int copy_len; 5371 5372 wpa_ie_len = psta->wpa_ie[1]; 5373 copy_len = ((wpa_ie_len+2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)) : (wpa_ie_len+2); 5374 param->u.wpa_ie.len = copy_len; 5375 memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len); 5376 } else { 5377 DBG_88E("sta's wpa_ie is NONE\n"); 5378 } 5379 } else { 5380 ret = -1; 5381 } 5382 5383 return ret; 5384} 5385 5386static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len) 5387{ 5388 int ret = 0; 5389 unsigned char wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 5390 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5391 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5392 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 5393 int ie_len; 5394 5395 DBG_88E("%s, len =%d\n", __func__, len); 5396 5397 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5398 return -EINVAL; 5399 5400 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 5401 5402 if (pmlmepriv->wps_beacon_ie) { 5403 kfree(pmlmepriv->wps_beacon_ie); 5404 pmlmepriv->wps_beacon_ie = NULL; 5405 } 5406 5407 if (ie_len > 0) { 5408 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len); 5409 pmlmepriv->wps_beacon_ie_len = ie_len; 5410 if (pmlmepriv->wps_beacon_ie == NULL) { 5411 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5412 return -EINVAL; 5413 } 5414 5415 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len); 5416 5417 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, true); 5418 5419 pmlmeext->bstart_bss = true; 5420 } 5421 5422 return ret; 5423} 5424 5425static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len) 5426{ 5427 int ret = 0; 5428 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5429 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5430 int ie_len; 5431 5432 DBG_88E("%s, len =%d\n", __func__, len); 5433 5434 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5435 return -EINVAL; 5436 5437 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 5438 5439 if (pmlmepriv->wps_probe_resp_ie) { 5440 kfree(pmlmepriv->wps_probe_resp_ie); 5441 pmlmepriv->wps_probe_resp_ie = NULL; 5442 } 5443 5444 if (ie_len > 0) { 5445 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len); 5446 pmlmepriv->wps_probe_resp_ie_len = ie_len; 5447 if (pmlmepriv->wps_probe_resp_ie == NULL) { 5448 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5449 return -EINVAL; 5450 } 5451 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len); 5452 } 5453 5454 return ret; 5455} 5456 5457static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len) 5458{ 5459 int ret = 0; 5460 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5461 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5462 int ie_len; 5463 5464 DBG_88E("%s, len =%d\n", __func__, len); 5465 5466 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5467 return -EINVAL; 5468 5469 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 5470 5471 if (pmlmepriv->wps_assoc_resp_ie) { 5472 kfree(pmlmepriv->wps_assoc_resp_ie); 5473 pmlmepriv->wps_assoc_resp_ie = NULL; 5474 } 5475 5476 if (ie_len > 0) { 5477 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len); 5478 pmlmepriv->wps_assoc_resp_ie_len = ie_len; 5479 if (pmlmepriv->wps_assoc_resp_ie == NULL) { 5480 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5481 return -EINVAL; 5482 } 5483 5484 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len); 5485 } 5486 5487 return ret; 5488} 5489 5490static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len) 5491{ 5492 int ret = 0; 5493 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5494 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5495 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 5496 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 5497 5498 u8 value; 5499 5500 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5501 return -EINVAL; 5502 5503 if (param->u.wpa_param.name != 0) /* dummy test... */ 5504 DBG_88E("%s name(%u) != 0\n", __func__, param->u.wpa_param.name); 5505 value = param->u.wpa_param.value; 5506 5507 /* use the same definition of hostapd's ignore_broadcast_ssid */ 5508 if (value != 1 && value != 2) 5509 value = 0; 5510 DBG_88E("%s value(%u)\n", __func__, value); 5511 pmlmeinfo->hidden_ssid_mode = value; 5512 return ret; 5513} 5514 5515static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len) 5516{ 5517 int ret = 0; 5518 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5519 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5520 5521 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5522 return -EINVAL; 5523 5524 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5525 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5526 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5527 return -EINVAL; 5528 ret = rtw_acl_remove_sta(padapter, param->sta_addr); 5529 return ret; 5530} 5531 5532static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len) 5533{ 5534 int ret = 0; 5535 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5536 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5537 5538 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5539 return -EINVAL; 5540 5541 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 5542 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 5543 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) 5544 return -EINVAL; 5545 ret = rtw_acl_add_sta(padapter, param->sta_addr); 5546 return ret; 5547} 5548 5549static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len) 5550{ 5551 int ret = 0; 5552 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5553 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5554 5555 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 5556 return -EINVAL; 5557 5558 rtw_set_macaddr_acl(padapter, param->u.mlme.command); 5559 5560 return ret; 5561} 5562 5563static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p) 5564{ 5565 struct ieee_param *param; 5566 int ret = 0; 5567 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5568 5569 /* 5570 * this function is expect to call in master mode, which allows no power saving 5571 * so, we just check hw_init_completed 5572 */ 5573 5574 if (!padapter->hw_init_completed) { 5575 ret = -EPERM; 5576 goto out; 5577 } 5578 5579 if (!p->pointer) { 5580 ret = -EINVAL; 5581 goto out; 5582 } 5583 5584 param = (struct ieee_param *)rtw_malloc(p->length); 5585 if (param == NULL) { 5586 ret = -ENOMEM; 5587 goto out; 5588 } 5589 5590 if (copy_from_user(param, p->pointer, p->length)) { 5591 kfree(param); 5592 ret = -EFAULT; 5593 goto out; 5594 } 5595 5596 switch (param->cmd) { 5597 case RTL871X_HOSTAPD_FLUSH: 5598 ret = rtw_hostapd_sta_flush(dev); 5599 break; 5600 case RTL871X_HOSTAPD_ADD_STA: 5601 ret = rtw_add_sta(dev, param); 5602 break; 5603 case RTL871X_HOSTAPD_REMOVE_STA: 5604 ret = rtw_del_sta(dev, param); 5605 break; 5606 case RTL871X_HOSTAPD_SET_BEACON: 5607 ret = rtw_set_beacon(dev, param, p->length); 5608 break; 5609 case RTL871X_SET_ENCRYPTION: 5610 ret = rtw_set_encryption(dev, param, p->length); 5611 break; 5612 case RTL871X_HOSTAPD_GET_WPAIE_STA: 5613 ret = rtw_get_sta_wpaie(dev, param); 5614 break; 5615 case RTL871X_HOSTAPD_SET_WPS_BEACON: 5616 ret = rtw_set_wps_beacon(dev, param, p->length); 5617 break; 5618 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP: 5619 ret = rtw_set_wps_probe_resp(dev, param, p->length); 5620 break; 5621 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP: 5622 ret = rtw_set_wps_assoc_resp(dev, param, p->length); 5623 break; 5624 case RTL871X_HOSTAPD_SET_HIDDEN_SSID: 5625 ret = rtw_set_hidden_ssid(dev, param, p->length); 5626 break; 5627 case RTL871X_HOSTAPD_GET_INFO_STA: 5628 ret = rtw_ioctl_get_sta_data(dev, param, p->length); 5629 break; 5630 case RTL871X_HOSTAPD_SET_MACADDR_ACL: 5631 ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length); 5632 break; 5633 case RTL871X_HOSTAPD_ACL_ADD_STA: 5634 ret = rtw_ioctl_acl_add_sta(dev, param, p->length); 5635 break; 5636 case RTL871X_HOSTAPD_ACL_REMOVE_STA: 5637 ret = rtw_ioctl_acl_remove_sta(dev, param, p->length); 5638 break; 5639 default: 5640 DBG_88E("Unknown hostapd request: %d\n", param->cmd); 5641 ret = -EOPNOTSUPP; 5642 break; 5643 } 5644 5645 if (ret == 0 && copy_to_user(p->pointer, param, p->length)) 5646 ret = -EFAULT; 5647 kfree(param); 5648out: 5649 return ret; 5650} 5651#endif 5652 5653#include <rtw_android.h> 5654static int rtw_wx_set_priv(struct net_device *dev, 5655 struct iw_request_info *info, 5656 union iwreq_data *awrq, 5657 char *extra) 5658{ 5659 int ret = 0; 5660 int len = 0; 5661 char *ext; 5662 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5663 struct iw_point *dwrq = (struct iw_point *)awrq; 5664 5665 if (dwrq->length == 0) 5666 return -EFAULT; 5667 5668 len = dwrq->length; 5669 ext = rtw_vmalloc(len); 5670 if (!ext) 5671 return -ENOMEM; 5672 5673 if (copy_from_user(ext, dwrq->pointer, len)) { 5674 rtw_vmfree(ext, len); 5675 return -EFAULT; 5676 } 5677 5678 /* added for wps2.0 @20110524 */ 5679 if (dwrq->flags == 0x8766 && len > 8) { 5680 u32 cp_sz; 5681 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 5682 u8 *probereq_wpsie = ext; 5683 int probereq_wpsie_len = len; 5684 u8 wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 5685 5686 if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) && 5687 (!memcmp(&probereq_wpsie[2], wps_oui, 4))) { 5688 cp_sz = probereq_wpsie_len > MAX_WPS_IE_LEN ? MAX_WPS_IE_LEN : probereq_wpsie_len; 5689 5690 pmlmepriv->wps_probe_req_ie_len = 0; 5691 kfree(pmlmepriv->wps_probe_req_ie); 5692 pmlmepriv->wps_probe_req_ie = NULL; 5693 5694 pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz); 5695 if (pmlmepriv->wps_probe_req_ie == NULL) { 5696 pr_info("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__); 5697 ret = -EINVAL; 5698 goto FREE_EXT; 5699 } 5700 memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz); 5701 pmlmepriv->wps_probe_req_ie_len = cp_sz; 5702 } 5703 goto FREE_EXT; 5704 } 5705 5706 if (len >= WEXT_CSCAN_HEADER_SIZE && 5707 !memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) { 5708 ret = rtw_wx_set_scan(dev, info, awrq, ext); 5709 goto FREE_EXT; 5710 } 5711 5712FREE_EXT: 5713 5714 rtw_vmfree(ext, len); 5715 5716 return ret; 5717} 5718 5719static int rtw_pm_set(struct net_device *dev, 5720 struct iw_request_info *info, 5721 union iwreq_data *wrqu, char *extra) 5722{ 5723 int ret = 0; 5724 unsigned mode = 0; 5725 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 5726 5727 DBG_88E("[%s] extra = %s\n", __func__, extra); 5728 5729 if (!memcmp(extra, "lps =", 4)) { 5730 sscanf(extra+4, "%u", &mode); 5731 ret = rtw_pm_set_lps(padapter, mode); 5732 } else if (!memcmp(extra, "ips =", 4)) { 5733 sscanf(extra+4, "%u", &mode); 5734 ret = rtw_pm_set_ips(padapter, mode); 5735 } else { 5736 ret = -EINVAL; 5737 } 5738 5739 return ret; 5740} 5741 5742static int rtw_mp_efuse_get(struct net_device *dev, 5743 struct iw_request_info *info, 5744 union iwreq_data *wdata, char *extra) 5745{ 5746 struct adapter *padapter = rtw_netdev_priv(dev); 5747 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter); 5748 struct hal_data_8188e *haldata = GET_HAL_DATA(padapter); 5749 struct efuse_hal *pEfuseHal; 5750 struct iw_point *wrqu; 5751 5752 u8 *PROMContent = pEEPROM->efuse_eeprom_data; 5753 u8 ips_mode = 0, lps_mode = 0; 5754 struct pwrctrl_priv *pwrctrlpriv; 5755 u8 *data = NULL; 5756 u8 *rawdata = NULL; 5757 char *pch, *ptmp, *token, *tmp[3] = {NULL, NULL, NULL}; 5758 u16 i = 0, j = 0, mapLen = 0, addr = 0, cnts = 0; 5759 u16 max_available_size = 0, raw_cursize = 0, raw_maxsize = 0; 5760 int err; 5761 u8 org_fw_iol = padapter->registrypriv.fw_iol;/* 0:Disable, 1:enable, 2:by usb speed */ 5762 5763 wrqu = (struct iw_point *)wdata; 5764 pwrctrlpriv = &padapter->pwrctrlpriv; 5765 pEfuseHal = &haldata->EfuseHal; 5766 5767 err = 0; 5768 data = _rtw_zmalloc(EFUSE_BT_MAX_MAP_LEN); 5769 if (data == NULL) { 5770 err = -ENOMEM; 5771 goto exit; 5772 } 5773 rawdata = _rtw_zmalloc(EFUSE_BT_MAX_MAP_LEN); 5774 if (rawdata == NULL) { 5775 err = -ENOMEM; 5776 goto exit; 5777 } 5778 5779 if (copy_from_user(extra, wrqu->pointer, wrqu->length)) { 5780 err = -EFAULT; 5781 goto exit; 5782 } 5783 lps_mode = pwrctrlpriv->power_mgnt;/* keep org value */ 5784 rtw_pm_set_lps(padapter, PS_MODE_ACTIVE); 5785 5786 ips_mode = pwrctrlpriv->ips_mode;/* keep org value */ 5787 rtw_pm_set_ips(padapter, IPS_NONE); 5788 5789 pch = extra; 5790 DBG_88E("%s: in =%s\n", __func__, extra); 5791 5792 i = 0; 5793 /* mac 16 "00e04c871200" rmap, 00, 2 */ 5794 while ((token = strsep(&pch, ",")) != NULL) { 5795 if (i > 2) 5796 break; 5797 tmp[i] = token; 5798 i++; 5799 } 5800 padapter->registrypriv.fw_iol = 0;/* 0:Disable, 1:enable, 2:by usb speed */ 5801 5802 if (strcmp(tmp[0], "status") == 0) { 5803 sprintf(extra, "Load File efuse =%s, Load File MAC =%s", (pEEPROM->bloadfile_fail_flag ? "FAIL" : "OK"), (pEEPROM->bloadmac_fail_flag ? "FAIL" : "OK")); 5804 5805 goto exit; 5806 } else if (strcmp(tmp[0], "filemap") == 0) { 5807 mapLen = EFUSE_MAP_SIZE; 5808 5809 sprintf(extra, "\n"); 5810 for (i = 0; i < EFUSE_MAP_SIZE; i += 16) { 5811 sprintf(extra, "%s0x%02x\t", extra, i); 5812 for (j = 0; j < 8; j++) 5813 sprintf(extra, "%s%02X ", extra, PROMContent[i+j]); 5814 sprintf(extra, "%s\t", extra); 5815 for (; j < 16; j++) 5816 sprintf(extra, "%s%02X ", extra, PROMContent[i+j]); 5817 sprintf(extra, "%s\n", extra); 5818 } 5819 } else if (strcmp(tmp[0], "realmap") == 0) { 5820 mapLen = EFUSE_MAP_SIZE; 5821 if (rtw_efuse_map_read(padapter, 0, mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL) { 5822 DBG_88E("%s: read realmap Fail!!\n", __func__); 5823 err = -EFAULT; 5824 goto exit; 5825 } 5826 5827 sprintf(extra, "\n"); 5828 for (i = 0; i < EFUSE_MAP_SIZE; i += 16) { 5829 sprintf(extra, "%s0x%02x\t", extra, i); 5830 for (j = 0; j < 8; j++) 5831 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseInitMap[i+j]); 5832 sprintf(extra, "%s\t", extra); 5833 for (; j < 16; j++) 5834 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseInitMap[i+j]); 5835 sprintf(extra, "%s\n", extra); 5836 } 5837 } else if (strcmp(tmp[0], "rmap") == 0) { 5838 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 5839 DBG_88E("%s: rmap Fail!! Parameters error!\n", __func__); 5840 err = -EINVAL; 5841 goto exit; 5842 } 5843 5844 /* rmap addr cnts */ 5845 addr = simple_strtoul(tmp[1], &ptmp, 16); 5846 DBG_88E("%s: addr =%x\n", __func__, addr); 5847 5848 cnts = simple_strtoul(tmp[2], &ptmp, 10); 5849 if (cnts == 0) { 5850 DBG_88E("%s: rmap Fail!! cnts error!\n", __func__); 5851 err = -EINVAL; 5852 goto exit; 5853 } 5854 DBG_88E("%s: cnts =%d\n", __func__, cnts); 5855 5856 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5857 if ((addr + cnts) > max_available_size) { 5858 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5859 err = -EINVAL; 5860 goto exit; 5861 } 5862 5863 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 5864 DBG_88E("%s: rtw_efuse_map_read error!\n", __func__); 5865 err = -EFAULT; 5866 goto exit; 5867 } 5868 5869 *extra = 0; 5870 for (i = 0; i < cnts; i++) 5871 sprintf(extra, "%s0x%02X ", extra, data[i]); 5872 } else if (strcmp(tmp[0], "realraw") == 0) { 5873 addr = 0; 5874 mapLen = EFUSE_MAX_SIZE; 5875 if (rtw_efuse_access(padapter, false, addr, mapLen, rawdata) == _FAIL) { 5876 DBG_88E("%s: rtw_efuse_access Fail!!\n", __func__); 5877 err = -EFAULT; 5878 goto exit; 5879 } 5880 5881 sprintf(extra, "\n"); 5882 for (i = 0; i < mapLen; i++) { 5883 sprintf(extra, "%s%02X", extra, rawdata[i]); 5884 5885 if ((i & 0xF) == 0xF) 5886 sprintf(extra, "%s\n", extra); 5887 else if ((i & 0x7) == 0x7) 5888 sprintf(extra, "%s\t", extra); 5889 else 5890 sprintf(extra, "%s ", extra); 5891 } 5892 } else if (strcmp(tmp[0], "mac") == 0) { 5893 cnts = 6; 5894 5895 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5896 if ((addr + cnts) > max_available_size) { 5897 DBG_88E("%s: addr(0x%02x)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5898 err = -EFAULT; 5899 goto exit; 5900 } 5901 5902 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 5903 DBG_88E("%s: rtw_efuse_map_read error!\n", __func__); 5904 err = -EFAULT; 5905 goto exit; 5906 } 5907 5908 *extra = 0; 5909 for (i = 0; i < cnts; i++) { 5910 sprintf(extra, "%s%02X", extra, data[i]); 5911 if (i != (cnts-1)) 5912 sprintf(extra, "%s:", extra); 5913 } 5914 } else if (strcmp(tmp[0], "vidpid") == 0) { 5915 cnts = 4; 5916 5917 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5918 if ((addr + cnts) > max_available_size) { 5919 DBG_88E("%s: addr(0x%02x)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5920 err = -EFAULT; 5921 goto exit; 5922 } 5923 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 5924 DBG_88E("%s: rtw_efuse_access error!!\n", __func__); 5925 err = -EFAULT; 5926 goto exit; 5927 } 5928 5929 *extra = 0; 5930 for (i = 0; i < cnts; i++) { 5931 sprintf(extra, "%s0x%02X", extra, data[i]); 5932 if (i != (cnts-1)) 5933 sprintf(extra, "%s,", extra); 5934 } 5935 } else if (strcmp(tmp[0], "ableraw") == 0) { 5936 efuse_GetCurrentSize(padapter, &raw_cursize); 5937 raw_maxsize = efuse_GetMaxSize(padapter); 5938 sprintf(extra, "[available raw size] = %d bytes", raw_maxsize-raw_cursize); 5939 } else if (strcmp(tmp[0], "btfmap") == 0) { 5940 mapLen = EFUSE_BT_MAX_MAP_LEN; 5941 if (rtw_BT_efuse_map_read(padapter, 0, mapLen, pEfuseHal->BTEfuseInitMap) == _FAIL) { 5942 DBG_88E("%s: rtw_BT_efuse_map_read Fail!!\n", __func__); 5943 err = -EFAULT; 5944 goto exit; 5945 } 5946 5947 sprintf(extra, "\n"); 5948 for (i = 0; i < 512; i += 16) { 5949 /* set 512 because the iwpriv's extra size have limit 0x7FF */ 5950 sprintf(extra, "%s0x%03x\t", extra, i); 5951 for (j = 0; j < 8; j++) 5952 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5953 sprintf(extra, "%s\t", extra); 5954 for (; j < 16; j++) 5955 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5956 sprintf(extra, "%s\n", extra); 5957 } 5958 } else if (strcmp(tmp[0], "btbmap") == 0) { 5959 mapLen = EFUSE_BT_MAX_MAP_LEN; 5960 if (rtw_BT_efuse_map_read(padapter, 0, mapLen, pEfuseHal->BTEfuseInitMap) == _FAIL) { 5961 DBG_88E("%s: rtw_BT_efuse_map_read Fail!!\n", __func__); 5962 err = -EFAULT; 5963 goto exit; 5964 } 5965 5966 sprintf(extra, "\n"); 5967 for (i = 512; i < 1024; i += 16) { 5968 sprintf(extra, "%s0x%03x\t", extra, i); 5969 for (j = 0; j < 8; j++) 5970 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5971 sprintf(extra, "%s\t", extra); 5972 for (; j < 16; j++) 5973 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]); 5974 sprintf(extra, "%s\n", extra); 5975 } 5976 } else if (strcmp(tmp[0], "btrmap") == 0) { 5977 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 5978 err = -EINVAL; 5979 goto exit; 5980 } 5981 5982 /* rmap addr cnts */ 5983 addr = simple_strtoul(tmp[1], &ptmp, 16); 5984 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 5985 5986 cnts = simple_strtoul(tmp[2], &ptmp, 10); 5987 if (cnts == 0) { 5988 DBG_88E("%s: btrmap Fail!! cnts error!\n", __func__); 5989 err = -EINVAL; 5990 goto exit; 5991 } 5992 DBG_88E("%s: cnts =%d\n", __func__, cnts); 5993 5994 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 5995 if ((addr + cnts) > max_available_size) { 5996 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 5997 err = -EFAULT; 5998 goto exit; 5999 } 6000 6001 if (rtw_BT_efuse_map_read(padapter, addr, cnts, data) == _FAIL) { 6002 DBG_88E("%s: rtw_BT_efuse_map_read error!!\n", __func__); 6003 err = -EFAULT; 6004 goto exit; 6005 } 6006 6007 *extra = 0; 6008 for (i = 0; i < cnts; i++) 6009 sprintf(extra, "%s 0x%02X ", extra, data[i]); 6010 } else if (strcmp(tmp[0], "btffake") == 0) { 6011 sprintf(extra, "\n"); 6012 for (i = 0; i < 512; i += 16) { 6013 sprintf(extra, "%s0x%03x\t", extra, i); 6014 for (j = 0; j < 8; j++) 6015 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6016 sprintf(extra, "%s\t", extra); 6017 for (; j < 16; j++) 6018 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6019 sprintf(extra, "%s\n", extra); 6020 } 6021 } else if (strcmp(tmp[0], "btbfake") == 0) { 6022 sprintf(extra, "\n"); 6023 for (i = 512; i < 1024; i += 16) { 6024 sprintf(extra, "%s0x%03x\t", extra, i); 6025 for (j = 0; j < 8; j++) 6026 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6027 sprintf(extra, "%s\t", extra); 6028 for (; j < 16; j++) 6029 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]); 6030 sprintf(extra, "%s\n", extra); 6031 } 6032 } else if (strcmp(tmp[0], "wlrfkmap") == 0) { 6033 sprintf(extra, "\n"); 6034 for (i = 0; i < EFUSE_MAP_SIZE; i += 16) { 6035 sprintf(extra, "%s0x%02x\t", extra, i); 6036 for (j = 0; j < 8; j++) 6037 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseModifiedMap[i+j]); 6038 sprintf(extra, "%s\t", extra); 6039 for (; j < 16; j++) 6040 sprintf(extra, "%s %02X", extra, pEfuseHal->fakeEfuseModifiedMap[i+j]); 6041 sprintf(extra, "%s\n", extra); 6042 } 6043 } else { 6044 sprintf(extra, "Command not found!"); 6045 } 6046 6047exit: 6048 kfree(data); 6049 kfree(rawdata); 6050 if (!err) 6051 wrqu->length = strlen(extra); 6052 6053 rtw_pm_set_ips(padapter, ips_mode); 6054 rtw_pm_set_lps(padapter, lps_mode); 6055 padapter->registrypriv.fw_iol = org_fw_iol;/* 0:Disable, 1:enable, 2:by usb speed */ 6056 return err; 6057} 6058 6059static int rtw_mp_efuse_set(struct net_device *dev, 6060 struct iw_request_info *info, 6061 union iwreq_data *wdata, char *extra) 6062{ 6063 struct adapter *padapter; 6064 struct pwrctrl_priv *pwrctrlpriv; 6065 struct hal_data_8188e *haldata; 6066 struct efuse_hal *pEfuseHal; 6067 6068 u8 ips_mode = 0, lps_mode = 0; 6069 u32 i, jj, kk; 6070 u8 *setdata = NULL; 6071 u8 *ShadowMapBT = NULL; 6072 u8 *ShadowMapWiFi = NULL; 6073 u8 *setrawdata = NULL; 6074 char *pch, *ptmp, *token, *tmp[3] = {NULL, NULL, NULL}; 6075 u16 addr = 0, cnts = 0, max_available_size = 0; 6076 int err; 6077 6078 padapter = rtw_netdev_priv(dev); 6079 pwrctrlpriv = &padapter->pwrctrlpriv; 6080 haldata = GET_HAL_DATA(padapter); 6081 pEfuseHal = &haldata->EfuseHal; 6082 err = 0; 6083 setdata = _rtw_zmalloc(1024); 6084 if (setdata == NULL) { 6085 err = -ENOMEM; 6086 goto exit; 6087 } 6088 ShadowMapBT = _rtw_malloc(EFUSE_BT_MAX_MAP_LEN); 6089 if (ShadowMapBT == NULL) { 6090 err = -ENOMEM; 6091 goto exit; 6092 } 6093 ShadowMapWiFi = _rtw_malloc(EFUSE_MAP_SIZE); 6094 if (ShadowMapWiFi == NULL) { 6095 err = -ENOMEM; 6096 goto exit; 6097 } 6098 setrawdata = _rtw_malloc(EFUSE_MAX_SIZE); 6099 if (setrawdata == NULL) { 6100 err = -ENOMEM; 6101 goto exit; 6102 } 6103 6104 lps_mode = pwrctrlpriv->power_mgnt;/* keep org value */ 6105 rtw_pm_set_lps(padapter, PS_MODE_ACTIVE); 6106 6107 ips_mode = pwrctrlpriv->ips_mode;/* keep org value */ 6108 rtw_pm_set_ips(padapter, IPS_NONE); 6109 6110 pch = extra; 6111 DBG_88E("%s: in =%s\n", __func__, extra); 6112 6113 i = 0; 6114 while ((token = strsep(&pch, ",")) != NULL) { 6115 if (i > 2) 6116 break; 6117 tmp[i] = token; 6118 i++; 6119 } 6120 6121 /* tmp[0],[1],[2] */ 6122 /* wmap, addr, 00e04c871200 */ 6123 if (strcmp(tmp[0], "wmap") == 0) { 6124 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6125 err = -EINVAL; 6126 goto exit; 6127 } 6128 6129 addr = simple_strtoul(tmp[1], &ptmp, 16); 6130 addr &= 0xFFF; 6131 6132 cnts = strlen(tmp[2]); 6133 if (cnts%2) { 6134 err = -EINVAL; 6135 goto exit; 6136 } 6137 cnts /= 2; 6138 if (cnts == 0) { 6139 err = -EINVAL; 6140 goto exit; 6141 } 6142 6143 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6144 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6145 DBG_88E("%s: map data =%s\n", __func__, tmp[2]); 6146 6147 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6148 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6149 /* Change to check TYPE_EFUSE_MAP_LEN, beacuse 8188E raw 256, logic map over 256. */ 6150 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&max_available_size, false); 6151 if ((addr+cnts) > max_available_size) { 6152 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6153 err = -EFAULT; 6154 goto exit; 6155 } 6156 6157 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6158 DBG_88E("%s: rtw_efuse_map_write error!!\n", __func__); 6159 err = -EFAULT; 6160 goto exit; 6161 } 6162 } else if (strcmp(tmp[0], "wraw") == 0) { 6163 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6164 err = -EINVAL; 6165 goto exit; 6166 } 6167 6168 addr = simple_strtoul(tmp[1], &ptmp, 16); 6169 addr &= 0xFFF; 6170 6171 cnts = strlen(tmp[2]); 6172 if (cnts%2) { 6173 err = -EINVAL; 6174 goto exit; 6175 } 6176 cnts /= 2; 6177 if (cnts == 0) { 6178 err = -EINVAL; 6179 goto exit; 6180 } 6181 6182 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6183 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6184 DBG_88E("%s: raw data =%s\n", __func__, tmp[2]); 6185 6186 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6187 setrawdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6188 6189 if (rtw_efuse_access(padapter, true, addr, cnts, setrawdata) == _FAIL) { 6190 DBG_88E("%s: rtw_efuse_access error!!\n", __func__); 6191 err = -EFAULT; 6192 goto exit; 6193 } 6194 } else if (strcmp(tmp[0], "mac") == 0) { 6195 if (tmp[1] == NULL) { 6196 err = -EINVAL; 6197 goto exit; 6198 } 6199 6200 /* mac, 00e04c871200 */ 6201 addr = EEPROM_MAC_ADDR_88EU; 6202 cnts = strlen(tmp[1]); 6203 if (cnts%2) { 6204 err = -EINVAL; 6205 goto exit; 6206 } 6207 cnts /= 2; 6208 if (cnts == 0) { 6209 err = -EINVAL; 6210 goto exit; 6211 } 6212 if (cnts > 6) { 6213 DBG_88E("%s: error data for mac addr =\"%s\"\n", __func__, tmp[1]); 6214 err = -EFAULT; 6215 goto exit; 6216 } 6217 6218 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6219 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6220 DBG_88E("%s: MAC address =%s\n", __func__, tmp[1]); 6221 6222 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6223 setdata[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]); 6224 /* Change to check TYPE_EFUSE_MAP_LEN, beacuse 8188E raw 256, logic map over 256. */ 6225 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&max_available_size, false); 6226 if ((addr+cnts) > max_available_size) { 6227 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6228 err = -EFAULT; 6229 goto exit; 6230 } 6231 6232 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6233 DBG_88E("%s: rtw_efuse_map_write error!!\n", __func__); 6234 err = -EFAULT; 6235 goto exit; 6236 } 6237 } else if (strcmp(tmp[0], "vidpid") == 0) { 6238 if (tmp[1] == NULL) { 6239 err = -EINVAL; 6240 goto exit; 6241 } 6242 6243 /* pidvid, da0b7881 */ 6244 addr = EEPROM_VID_88EE; 6245 cnts = strlen(tmp[1]); 6246 if (cnts%2) { 6247 err = -EINVAL; 6248 goto exit; 6249 } 6250 cnts /= 2; 6251 if (cnts == 0) { 6252 err = -EINVAL; 6253 goto exit; 6254 } 6255 6256 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6257 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6258 DBG_88E("%s: VID/PID =%s\n", __func__, tmp[1]); 6259 6260 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6261 setdata[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]); 6262 6263 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6264 if ((addr+cnts) > max_available_size) { 6265 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6266 err = -EFAULT; 6267 goto exit; 6268 } 6269 6270 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6271 DBG_88E("%s: rtw_efuse_map_write error!!\n", __func__); 6272 err = -EFAULT; 6273 goto exit; 6274 } 6275 } else if (strcmp(tmp[0], "btwmap") == 0) { 6276 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6277 err = -EINVAL; 6278 goto exit; 6279 } 6280 6281 addr = simple_strtoul(tmp[1], &ptmp, 16); 6282 addr &= 0xFFF; 6283 6284 cnts = strlen(tmp[2]); 6285 if (cnts%2) { 6286 err = -EINVAL; 6287 goto exit; 6288 } 6289 cnts /= 2; 6290 if (cnts == 0) { 6291 err = -EINVAL; 6292 goto exit; 6293 } 6294 6295 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6296 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6297 DBG_88E("%s: BT data =%s\n", __func__, tmp[2]); 6298 6299 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6300 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6301 6302 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6303 if ((addr+cnts) > max_available_size) { 6304 DBG_88E("%s: addr(0x%X)+cnts(%d) parameter error!\n", __func__, addr, cnts); 6305 err = -EFAULT; 6306 goto exit; 6307 } 6308 6309 if (rtw_BT_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL) { 6310 DBG_88E("%s: rtw_BT_efuse_map_write error!!\n", __func__); 6311 err = -EFAULT; 6312 goto exit; 6313 } 6314 } else if (strcmp(tmp[0], "btwfake") == 0) { 6315 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6316 err = -EINVAL; 6317 goto exit; 6318 } 6319 6320 addr = simple_strtoul(tmp[1], &ptmp, 16); 6321 addr &= 0xFFF; 6322 6323 cnts = strlen(tmp[2]); 6324 if (cnts%2) { 6325 err = -EINVAL; 6326 goto exit; 6327 } 6328 cnts /= 2; 6329 if (cnts == 0) { 6330 err = -EINVAL; 6331 goto exit; 6332 } 6333 6334 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6335 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6336 DBG_88E("%s: BT tmp data =%s\n", __func__, tmp[2]); 6337 6338 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6339 pEfuseHal->fakeBTEfuseModifiedMap[addr+jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6340 } else if (strcmp(tmp[0], "btdumpfake") == 0) { 6341 if (rtw_BT_efuse_map_read(padapter, 0, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _SUCCESS) { 6342 DBG_88E("%s: BT read all map success\n", __func__); 6343 } else { 6344 DBG_88E("%s: BT read all map Fail!\n", __func__); 6345 err = -EFAULT; 6346 } 6347 } else if (strcmp(tmp[0], "wldumpfake") == 0) { 6348 if (rtw_efuse_map_read(padapter, 0, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeEfuseModifiedMap) == _SUCCESS) { 6349 DBG_88E("%s: BT read all map success\n", __func__); 6350 } else { 6351 DBG_88E("%s: BT read all map Fail\n", __func__); 6352 err = -EFAULT; 6353 } 6354 } else if (strcmp(tmp[0], "btfk2map") == 0) { 6355 memcpy(pEfuseHal->BTEfuseModifiedMap, pEfuseHal->fakeBTEfuseModifiedMap, EFUSE_BT_MAX_MAP_LEN); 6356 6357 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6358 if (max_available_size < 1) { 6359 err = -EFAULT; 6360 goto exit; 6361 } 6362 6363 if (rtw_BT_efuse_map_write(padapter, 0x00, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _FAIL) { 6364 DBG_88E("%s: rtw_BT_efuse_map_write error!\n", __func__); 6365 err = -EFAULT; 6366 goto exit; 6367 } 6368 } else if (strcmp(tmp[0], "wlfk2map") == 0) { 6369 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 6370 if (max_available_size < 1) { 6371 err = -EFAULT; 6372 goto exit; 6373 } 6374 6375 if (rtw_efuse_map_write(padapter, 0x00, EFUSE_MAX_MAP_LEN, pEfuseHal->fakeEfuseModifiedMap) == _FAIL) { 6376 DBG_88E("%s: rtw_efuse_map_write error!\n", __func__); 6377 err = -EFAULT; 6378 goto exit; 6379 } 6380 } else if (strcmp(tmp[0], "wlwfake") == 0) { 6381 if ((tmp[1] == NULL) || (tmp[2] == NULL)) { 6382 err = -EINVAL; 6383 goto exit; 6384 } 6385 6386 addr = simple_strtoul(tmp[1], &ptmp, 16); 6387 addr &= 0xFFF; 6388 6389 cnts = strlen(tmp[2]); 6390 if (cnts%2) { 6391 err = -EINVAL; 6392 goto exit; 6393 } 6394 cnts /= 2; 6395 if (cnts == 0) { 6396 err = -EINVAL; 6397 goto exit; 6398 } 6399 6400 DBG_88E("%s: addr = 0x%X\n", __func__, addr); 6401 DBG_88E("%s: cnts =%d\n", __func__, cnts); 6402 DBG_88E("%s: map tmp data =%s\n", __func__, tmp[2]); 6403 6404 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) 6405 pEfuseHal->fakeEfuseModifiedMap[addr+jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]); 6406 } 6407 6408exit: 6409 kfree(setdata); 6410 kfree(ShadowMapBT); 6411 kfree(ShadowMapWiFi); 6412 kfree(setrawdata); 6413 6414 rtw_pm_set_ips(padapter, ips_mode); 6415 rtw_pm_set_lps(padapter, lps_mode); 6416 6417 return err; 6418} 6419 6420/* 6421 * Input Format: %s,%d,%d 6422 * %s is width, could be 6423 * "b" for 1 byte 6424 * "w" for WORD (2 bytes) 6425 * "dw" for DWORD (4 bytes) 6426 * 1st %d is address(offset) 6427 * 2st %d is data to write 6428 */ 6429static int rtw_mp_write_reg(struct net_device *dev, 6430 struct iw_request_info *info, 6431 struct iw_point *wrqu, char *extra) 6432{ 6433 char *pch, *pnext, *ptmp; 6434 char *width_str; 6435 char width; 6436 u32 addr, data; 6437 int ret; 6438 struct adapter *padapter = rtw_netdev_priv(dev); 6439 6440 pch = extra; 6441 pnext = strpbrk(pch, ",.-"); 6442 if (pnext == NULL) 6443 return -EINVAL; 6444 *pnext = 0; 6445 width_str = pch; 6446 6447 pch = pnext + 1; 6448 pnext = strpbrk(pch, ",.-"); 6449 if (pnext == NULL) 6450 return -EINVAL; 6451 *pnext = 0; 6452 addr = simple_strtoul(pch, &ptmp, 16); 6453 if (addr > 0x3FFF) 6454 return -EINVAL; 6455 6456 pch = pnext + 1; 6457 if ((pch - extra) >= wrqu->length) 6458 return -EINVAL; 6459 data = simple_strtoul(pch, &ptmp, 16); 6460 6461 ret = 0; 6462 width = width_str[0]; 6463 switch (width) { 6464 case 'b': 6465 /* 1 byte */ 6466 if (data > 0xFF) { 6467 ret = -EINVAL; 6468 break; 6469 } 6470 rtw_write8(padapter, addr, data); 6471 break; 6472 case 'w': 6473 /* 2 bytes */ 6474 if (data > 0xFFFF) { 6475 ret = -EINVAL; 6476 break; 6477 } 6478 rtw_write16(padapter, addr, data); 6479 break; 6480 case 'd': 6481 /* 4 bytes */ 6482 rtw_write32(padapter, addr, data); 6483 break; 6484 default: 6485 ret = -EINVAL; 6486 break; 6487 } 6488 6489 return ret; 6490} 6491 6492/* 6493 * Input Format: %s,%d 6494 * %s is width, could be 6495 * "b" for 1 byte 6496 * "w" for WORD (2 bytes) 6497 * "dw" for DWORD (4 bytes) 6498 * %d is address(offset) 6499 * 6500 * Return: 6501 * %d for data readed 6502 */ 6503static int rtw_mp_read_reg(struct net_device *dev, 6504 struct iw_request_info *info, 6505 struct iw_point *wrqu, char *extra) 6506{ 6507 struct adapter *padapter = rtw_netdev_priv(dev); 6508 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6509 char *pch, *pnext, *ptmp; 6510 char *width_str; 6511 char width; 6512 char data[20], tmp[20]; 6513 u32 addr; 6514 u32 ret, i = 0, j = 0, strtout = 0; 6515 6516 if (!input) 6517 return -ENOMEM; 6518 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6519 kfree(input); 6520 return -EFAULT; 6521 } 6522 _rtw_memset(data, 0, 20); 6523 _rtw_memset(tmp, 0, 20); 6524 _rtw_memset(extra, 0, wrqu->length); 6525 6526 pch = input; 6527 pnext = strpbrk(pch, ",.-"); 6528 if (pnext == NULL) { 6529 kfree(input); 6530 return -EINVAL; 6531 } 6532 *pnext = 0; 6533 width_str = pch; 6534 6535 pch = pnext + 1; 6536 if ((pch - input) >= wrqu->length) { 6537 kfree(input); 6538 return -EINVAL; 6539 } 6540 kfree(input); 6541 addr = simple_strtoul(pch, &ptmp, 16); 6542 if (addr > 0x3FFF) 6543 return -EINVAL; 6544 6545 ret = 0; 6546 width = width_str[0]; 6547 switch (width) { 6548 case 'b': 6549 /* 1 byte */ 6550 sprintf(extra, "%d\n", rtw_read8(padapter, addr)); 6551 wrqu->length = strlen(extra); 6552 break; 6553 case 'w': 6554 /* 2 bytes */ 6555 sprintf(data, "%04x\n", rtw_read16(padapter, addr)); 6556 for (i = 0; i <= strlen(data); i++) { 6557 if (i%2 == 0) { 6558 tmp[j] = ' '; 6559 j++; 6560 } 6561 if (data[i] != '\0') 6562 tmp[j] = data[i]; 6563 j++; 6564 } 6565 pch = tmp; 6566 DBG_88E("pch =%s", pch); 6567 6568 while (*pch != '\0') { 6569 pnext = strpbrk(pch, " "); 6570 if (!pnext) 6571 break; 6572 6573 pnext++; 6574 if (*pnext != '\0') { 6575 strtout = simple_strtoul(pnext, &ptmp, 16); 6576 sprintf(extra, "%s %d", extra, strtout); 6577 } else { 6578 break; 6579 } 6580 pch = pnext; 6581 } 6582 wrqu->length = 6; 6583 break; 6584 case 'd': 6585 /* 4 bytes */ 6586 sprintf(data, "%08x", rtw_read32(padapter, addr)); 6587 /* add read data format blank */ 6588 for (i = 0; i <= strlen(data); i++) { 6589 if (i%2 == 0) { 6590 tmp[j] = ' '; 6591 j++; 6592 } 6593 if (data[i] != '\0') 6594 tmp[j] = data[i]; 6595 6596 j++; 6597 } 6598 pch = tmp; 6599 DBG_88E("pch =%s", pch); 6600 6601 while (*pch != '\0') { 6602 pnext = strpbrk(pch, " "); 6603 if (!pnext) 6604 break; 6605 pnext++; 6606 if (*pnext != '\0') { 6607 strtout = simple_strtoul(pnext, &ptmp, 16); 6608 sprintf(extra, "%s %d", extra, strtout); 6609 } else { 6610 break; 6611 } 6612 pch = pnext; 6613 } 6614 wrqu->length = strlen(extra); 6615 break; 6616 default: 6617 wrqu->length = 0; 6618 ret = -EINVAL; 6619 break; 6620 } 6621 6622 return ret; 6623} 6624 6625/* 6626 * Input Format: %d,%x,%x 6627 * %d is RF path, should be smaller than MAX_RF_PATH_NUMS 6628 * 1st %x is address(offset) 6629 * 2st %x is data to write 6630 */ 6631 static int rtw_mp_write_rf(struct net_device *dev, 6632 struct iw_request_info *info, 6633 struct iw_point *wrqu, char *extra) 6634{ 6635 u32 path, addr, data; 6636 int ret; 6637 struct adapter *padapter = rtw_netdev_priv(dev); 6638 6639 ret = sscanf(extra, "%d,%x,%x", &path, &addr, &data); 6640 if (ret < 3) 6641 return -EINVAL; 6642 6643 if (path >= MAX_RF_PATH_NUMS) 6644 return -EINVAL; 6645 if (addr > 0xFF) 6646 return -EINVAL; 6647 if (data > 0xFFFFF) 6648 return -EINVAL; 6649 6650 _rtw_memset(extra, 0, wrqu->length); 6651 6652 write_rfreg(padapter, path, addr, data); 6653 6654 sprintf(extra, "write_rf completed\n"); 6655 wrqu->length = strlen(extra); 6656 6657 return 0; 6658} 6659 6660/* 6661 * Input Format: %d,%x 6662 * %d is RF path, should be smaller than MAX_RF_PATH_NUMS 6663 * %x is address(offset) 6664 * 6665 * Return: 6666 * %d for data readed 6667 */ 6668static int rtw_mp_read_rf(struct net_device *dev, 6669 struct iw_request_info *info, 6670 struct iw_point *wrqu, char *extra) 6671{ 6672 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6673 char *pch, *pnext, *ptmp; 6674 char data[20], tmp[20]; 6675 u32 path, addr; 6676 u32 ret, i = 0, j = 0, strtou = 0; 6677 struct adapter *padapter = rtw_netdev_priv(dev); 6678 6679 if (!input) 6680 return -ENOMEM; 6681 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6682 kfree(input); 6683 return -EFAULT; 6684 } 6685 ret = sscanf(input, "%d,%x", &path, &addr); 6686 kfree(input); 6687 if (ret < 2) 6688 return -EINVAL; 6689 6690 if (path >= MAX_RF_PATH_NUMS) 6691 return -EINVAL; 6692 if (addr > 0xFF) 6693 return -EINVAL; 6694 6695 _rtw_memset(extra, 0, wrqu->length); 6696 6697 sprintf(data, "%08x", read_rfreg(padapter, path, addr)); 6698 /* add read data format blank */ 6699 for (i = 0; i <= strlen(data); i++) { 6700 if (i%2 == 0) { 6701 tmp[j] = ' '; 6702 j++; 6703 } 6704 tmp[j] = data[i]; 6705 j++; 6706 } 6707 pch = tmp; 6708 DBG_88E("pch =%s", pch); 6709 6710 while (*pch != '\0') { 6711 pnext = strpbrk(pch, " "); 6712 pnext++; 6713 if (*pnext != '\0') { 6714 strtou = simple_strtoul(pnext, &ptmp, 16); 6715 sprintf(extra, "%s %d", extra, strtou); 6716 } else { 6717 break; 6718 } 6719 pch = pnext; 6720 } 6721 wrqu->length = strlen(extra); 6722 return 0; 6723} 6724 6725static int rtw_mp_start(struct net_device *dev, 6726 struct iw_request_info *info, 6727 struct iw_point *wrqu, char *extra) 6728{ 6729 struct adapter *padapter = rtw_netdev_priv(dev); 6730 6731 if (padapter->registrypriv.mp_mode == 0) { 6732 padapter->registrypriv.mp_mode = 1; 6733 6734 rtw_pm_set_ips(padapter, IPS_NONE); 6735 LeaveAllPowerSaveMode(padapter); 6736 6737 MPT_InitializeAdapter(padapter, 1); 6738 } 6739 if (padapter->registrypriv.mp_mode == 0) 6740 return -EPERM; 6741 if (padapter->mppriv.mode == MP_OFF) { 6742 if (mp_start_test(padapter) == _FAIL) 6743 return -EPERM; 6744 padapter->mppriv.mode = MP_ON; 6745 } 6746 return 0; 6747} 6748 6749static int rtw_mp_stop(struct net_device *dev, 6750 struct iw_request_info *info, 6751 struct iw_point *wrqu, char *extra) 6752{ 6753 struct adapter *padapter = rtw_netdev_priv(dev); 6754 6755 if (padapter->registrypriv.mp_mode == 1) { 6756 MPT_DeInitAdapter(padapter); 6757 padapter->registrypriv.mp_mode = 0; 6758 } 6759 6760 if (padapter->mppriv.mode != MP_OFF) { 6761 mp_stop_test(padapter); 6762 padapter->mppriv.mode = MP_OFF; 6763 } 6764 6765 return 0; 6766} 6767 6768extern int wifirate2_ratetbl_inx(unsigned char rate); 6769 6770static int rtw_mp_rate(struct net_device *dev, 6771 struct iw_request_info *info, 6772 struct iw_point *wrqu, char *extra) 6773{ 6774 u32 rate = MPT_RATE_1M; 6775 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6776 struct adapter *padapter = rtw_netdev_priv(dev); 6777 6778 if (!input) 6779 return -ENOMEM; 6780 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6781 kfree(input); 6782 return -EFAULT; 6783 } 6784 rate = rtw_atoi(input); 6785 sprintf(extra, "Set data rate to %d", rate); 6786 kfree(input); 6787 if (rate <= 0x7f) 6788 rate = wifirate2_ratetbl_inx((u8)rate); 6789 else 6790 rate = (rate-0x80+MPT_RATE_MCS0); 6791 6792 if (rate >= MPT_RATE_LAST) 6793 return -EINVAL; 6794 6795 padapter->mppriv.rateidx = rate; 6796 Hal_SetDataRate(padapter); 6797 6798 wrqu->length = strlen(extra) + 1; 6799 return 0; 6800} 6801 6802static int rtw_mp_channel(struct net_device *dev, 6803 struct iw_request_info *info, 6804 struct iw_point *wrqu, char *extra) 6805{ 6806 struct adapter *padapter = rtw_netdev_priv(dev); 6807 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6808 u32 channel = 1; 6809 6810 if (!input) 6811 return -ENOMEM; 6812 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6813 kfree(input); 6814 return -EFAULT; 6815 } 6816 channel = rtw_atoi(input); 6817 sprintf(extra, "Change channel %d to channel %d", padapter->mppriv.channel, channel); 6818 6819 padapter->mppriv.channel = channel; 6820 Hal_SetChannel(padapter); 6821 6822 wrqu->length = strlen(extra) + 1; 6823 kfree(input); 6824 return 0; 6825} 6826 6827static int rtw_mp_bandwidth(struct net_device *dev, 6828 struct iw_request_info *info, 6829 struct iw_point *wrqu, char *extra) 6830{ 6831 u32 bandwidth = 0, sg = 0; 6832 struct adapter *padapter = rtw_netdev_priv(dev); 6833 6834 sscanf(extra, "40M =%d, shortGI =%d", &bandwidth, &sg); 6835 6836 if (bandwidth != HT_CHANNEL_WIDTH_40) 6837 bandwidth = HT_CHANNEL_WIDTH_20; 6838 6839 padapter->mppriv.bandwidth = (u8)bandwidth; 6840 padapter->mppriv.preamble = sg; 6841 6842 SetBandwidth(padapter); 6843 6844 return 0; 6845} 6846 6847static int rtw_mp_txpower(struct net_device *dev, 6848 struct iw_request_info *info, 6849 struct iw_point *wrqu, char *extra) 6850{ 6851 u32 idx_a = 0, idx_b = 0; 6852 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6853 struct adapter *padapter = rtw_netdev_priv(dev); 6854 6855 if (!input) 6856 return -ENOMEM; 6857 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6858 kfree(input); 6859 return -EFAULT; 6860 } 6861 sscanf(input, "patha =%d, pathb =%d", &idx_a, &idx_b); 6862 6863 sprintf(extra, "Set power level path_A:%d path_B:%d", idx_a, idx_b); 6864 padapter->mppriv.txpoweridx = (u8)idx_a; 6865 padapter->mppriv.txpoweridx_b = (u8)idx_b; 6866 padapter->mppriv.bSetTxPower = 1; 6867 Hal_SetAntennaPathPower(padapter); 6868 6869 wrqu->length = strlen(extra) + 1; 6870 kfree(input); 6871 return 0; 6872} 6873 6874static int rtw_mp_ant_tx(struct net_device *dev, 6875 struct iw_request_info *info, 6876 struct iw_point *wrqu, char *extra) 6877{ 6878 u8 i; 6879 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6880 u16 antenna = 0; 6881 struct adapter *padapter = rtw_netdev_priv(dev); 6882 6883 if (!input) 6884 return -ENOMEM; 6885 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6886 kfree(input); 6887 return -EFAULT; 6888 } 6889 6890 sprintf(extra, "switch Tx antenna to %s", input); 6891 6892 for (i = 0; i < strlen(input); i++) { 6893 switch (input[i]) { 6894 case 'a': 6895 antenna |= ANTENNA_A; 6896 break; 6897 case 'b': 6898 antenna |= ANTENNA_B; 6899 break; 6900 } 6901 } 6902 padapter->mppriv.antenna_tx = antenna; 6903 6904 Hal_SetAntenna(padapter); 6905 6906 wrqu->length = strlen(extra) + 1; 6907 kfree(input); 6908 return 0; 6909} 6910 6911static int rtw_mp_ant_rx(struct net_device *dev, 6912 struct iw_request_info *info, 6913 struct iw_point *wrqu, char *extra) 6914{ 6915 u8 i; 6916 u16 antenna = 0; 6917 char *input = kmalloc(wrqu->length, GFP_KERNEL); 6918 struct adapter *padapter = rtw_netdev_priv(dev); 6919 6920 if (!input) 6921 return -ENOMEM; 6922 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 6923 kfree(input); 6924 return -EFAULT; 6925 } 6926 _rtw_memset(extra, 0, wrqu->length); 6927 6928 sprintf(extra, "switch Rx antenna to %s", input); 6929 6930 for (i = 0; i < strlen(input); i++) { 6931 switch (input[i]) { 6932 case 'a': 6933 antenna |= ANTENNA_A; 6934 break; 6935 case 'b': 6936 antenna |= ANTENNA_B; 6937 break; 6938 } 6939 } 6940 6941 padapter->mppriv.antenna_rx = antenna; 6942 Hal_SetAntenna(padapter); 6943 wrqu->length = strlen(extra); 6944 kfree(input); 6945 return 0; 6946} 6947 6948static int rtw_mp_ctx(struct net_device *dev, 6949 struct iw_request_info *info, 6950 struct iw_point *wrqu, char *extra) 6951{ 6952 u32 pkTx = 1, countPkTx = 1, cotuTx = 1, CarrSprTx = 1, scTx = 1, sgleTx = 1, stop = 1; 6953 u32 bStartTest = 1; 6954 u32 count = 0; 6955 struct mp_priv *pmp_priv; 6956 struct pkt_attrib *pattrib; 6957 6958 struct adapter *padapter = rtw_netdev_priv(dev); 6959 6960 pmp_priv = &padapter->mppriv; 6961 6962 if (copy_from_user(extra, wrqu->pointer, wrqu->length)) 6963 return -EFAULT; 6964 6965 DBG_88E("%s: in =%s\n", __func__, extra); 6966 6967 countPkTx = strncmp(extra, "count =", 5); /* strncmp true is 0 */ 6968 cotuTx = strncmp(extra, "background", 20); 6969 CarrSprTx = strncmp(extra, "background, cs", 20); 6970 scTx = strncmp(extra, "background, sc", 20); 6971 sgleTx = strncmp(extra, "background, stone", 20); 6972 pkTx = strncmp(extra, "background, pkt", 20); 6973 stop = strncmp(extra, "stop", 4); 6974 sscanf(extra, "count =%d, pkt", &count); 6975 6976 _rtw_memset(extra, '\0', sizeof(*extra)); 6977 6978 if (stop == 0) { 6979 bStartTest = 0; /* To set Stop */ 6980 pmp_priv->tx.stop = 1; 6981 sprintf(extra, "Stop continuous Tx"); 6982 } else { 6983 bStartTest = 1; 6984 if (pmp_priv->mode != MP_ON) { 6985 if (pmp_priv->tx.stop != 1) { 6986 DBG_88E("%s: MP_MODE != ON %d\n", __func__, pmp_priv->mode); 6987 return -EFAULT; 6988 } 6989 } 6990 } 6991 6992 if (pkTx == 0 || countPkTx == 0) 6993 pmp_priv->mode = MP_PACKET_TX; 6994 if (sgleTx == 0) 6995 pmp_priv->mode = MP_SINGLE_TONE_TX; 6996 if (cotuTx == 0) 6997 pmp_priv->mode = MP_CONTINUOUS_TX; 6998 if (CarrSprTx == 0) 6999 pmp_priv->mode = MP_CARRIER_SUPPRISSION_TX; 7000 if (scTx == 0) 7001 pmp_priv->mode = MP_SINGLE_CARRIER_TX; 7002 7003 switch (pmp_priv->mode) { 7004 case MP_PACKET_TX: 7005 if (bStartTest == 0) { 7006 pmp_priv->tx.stop = 1; 7007 pmp_priv->mode = MP_ON; 7008 sprintf(extra, "Stop continuous Tx"); 7009 } else if (pmp_priv->tx.stop == 1) { 7010 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500 count =%u,\n", count); 7011 pmp_priv->tx.stop = 0; 7012 pmp_priv->tx.count = count; 7013 pmp_priv->tx.payload = 2; 7014 pattrib = &pmp_priv->tx.attrib; 7015 pattrib->pktlen = 1500; 7016 _rtw_memset(pattrib->dst, 0xFF, ETH_ALEN); 7017 SetPacketTx(padapter); 7018 } else { 7019 return -EFAULT; 7020 } 7021 wrqu->length = strlen(extra); 7022 return 0; 7023 case MP_SINGLE_TONE_TX: 7024 if (bStartTest != 0) 7025 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7026 Hal_SetSingleToneTx(padapter, (u8)bStartTest); 7027 break; 7028 case MP_CONTINUOUS_TX: 7029 if (bStartTest != 0) 7030 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7031 Hal_SetContinuousTx(padapter, (u8)bStartTest); 7032 break; 7033 case MP_CARRIER_SUPPRISSION_TX: 7034 if (bStartTest != 0) { 7035 if (pmp_priv->rateidx <= MPT_RATE_11M) { 7036 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7037 Hal_SetCarrierSuppressionTx(padapter, (u8)bStartTest); 7038 } else { 7039 sprintf(extra, "Specify carrier suppression but not CCK rate"); 7040 } 7041 } 7042 break; 7043 case MP_SINGLE_CARRIER_TX: 7044 if (bStartTest != 0) 7045 sprintf(extra, "Start continuous DA = ffffffffffff len = 1500\n infinite = yes."); 7046 Hal_SetSingleCarrierTx(padapter, (u8)bStartTest); 7047 break; 7048 default: 7049 sprintf(extra, "Error! Continuous-Tx is not on-going."); 7050 return -EFAULT; 7051 } 7052 7053 if (bStartTest == 1 && pmp_priv->mode != MP_ON) { 7054 struct mp_priv *pmp_priv = &padapter->mppriv; 7055 if (pmp_priv->tx.stop == 0) { 7056 pmp_priv->tx.stop = 1; 7057 rtw_msleep_os(5); 7058 } 7059 pmp_priv->tx.stop = 0; 7060 pmp_priv->tx.count = 1; 7061 SetPacketTx(padapter); 7062 } else { 7063 pmp_priv->mode = MP_ON; 7064 } 7065 7066 wrqu->length = strlen(extra); 7067 return 0; 7068} 7069 7070static int rtw_mp_arx(struct net_device *dev, 7071 struct iw_request_info *info, 7072 struct iw_point *wrqu, char *extra) 7073{ 7074 u8 bStartRx = 0, bStopRx = 0, bQueryPhy; 7075 u32 cckok = 0, cckcrc = 0, ofdmok = 0, ofdmcrc = 0, htok = 0, htcrc = 0, OFDM_FA = 0, CCK_FA = 0; 7076 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7077 struct adapter *padapter = rtw_netdev_priv(dev); 7078 7079 if (!input) 7080 return -ENOMEM; 7081 7082 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7083 kfree(input); 7084 return -EFAULT; 7085 } 7086 DBG_88E("%s: %s\n", __func__, input); 7087 7088 bStartRx = (strncmp(input, "start", 5) == 0) ? 1 : 0; /* strncmp true is 0 */ 7089 bStopRx = (strncmp(input, "stop", 5) == 0) ? 1 : 0; /* strncmp true is 0 */ 7090 bQueryPhy = (strncmp(input, "phy", 3) == 0) ? 1 : 0; /* strncmp true is 0 */ 7091 7092 if (bStartRx) { 7093 sprintf(extra, "start"); 7094 SetPacketRx(padapter, bStartRx); 7095 } else if (bStopRx) { 7096 SetPacketRx(padapter, 0); 7097 sprintf(extra, "Received packet OK:%d CRC error:%d", padapter->mppriv.rx_pktcount, padapter->mppriv.rx_crcerrpktcount); 7098 } else if (bQueryPhy) { 7099 /* 7100 OFDM FA 7101 RegCF0[15:0] 7102 RegCF2[31:16] 7103 RegDA0[31:16] 7104 RegDA4[15:0] 7105 RegDA4[31:16] 7106 RegDA8[15:0] 7107 CCK FA 7108 (RegA5B<<8) | RegA5C 7109 */ 7110 cckok = read_bbreg(padapter, 0xf88, 0xffffffff); 7111 cckcrc = read_bbreg(padapter, 0xf84, 0xffffffff); 7112 ofdmok = read_bbreg(padapter, 0xf94, 0x0000FFFF); 7113 ofdmcrc = read_bbreg(padapter, 0xf94, 0xFFFF0000); 7114 htok = read_bbreg(padapter, 0xf90, 0x0000FFFF); 7115 htcrc = read_bbreg(padapter, 0xf90, 0xFFFF0000); 7116 7117 OFDM_FA = read_bbreg(padapter, 0xcf0, 0x0000FFFF); 7118 OFDM_FA = read_bbreg(padapter, 0xcf2, 0xFFFF0000); 7119 OFDM_FA = read_bbreg(padapter, 0xda0, 0xFFFF0000); 7120 OFDM_FA = read_bbreg(padapter, 0xda4, 0x0000FFFF); 7121 OFDM_FA = read_bbreg(padapter, 0xda4, 0xFFFF0000); 7122 OFDM_FA = read_bbreg(padapter, 0xda8, 0x0000FFFF); 7123 CCK_FA = (rtw_read8(padapter, 0xa5b)<<8) | (rtw_read8(padapter, 0xa5c)); 7124 7125 sprintf(extra, "Phy Received packet OK:%d CRC error:%d FA Counter: %d", cckok+ofdmok+htok, cckcrc+ofdmcrc+htcrc, OFDM_FA+CCK_FA); 7126 } 7127 wrqu->length = strlen(extra) + 1; 7128 kfree(input); 7129 return 0; 7130} 7131 7132static int rtw_mp_trx_query(struct net_device *dev, 7133 struct iw_request_info *info, 7134 struct iw_point *wrqu, char *extra) 7135{ 7136 u32 txok, txfail, rxok, rxfail; 7137 struct adapter *padapter = rtw_netdev_priv(dev); 7138 7139 txok = padapter->mppriv.tx.sended; 7140 txfail = 0; 7141 rxok = padapter->mppriv.rx_pktcount; 7142 rxfail = padapter->mppriv.rx_crcerrpktcount; 7143 7144 _rtw_memset(extra, '\0', 128); 7145 7146 sprintf(extra, "Tx OK:%d, Tx Fail:%d, Rx OK:%d, CRC error:%d ", txok, txfail, rxok, rxfail); 7147 7148 wrqu->length = strlen(extra)+1; 7149 7150 return 0; 7151} 7152 7153static int rtw_mp_pwrtrk(struct net_device *dev, 7154 struct iw_request_info *info, 7155 struct iw_point *wrqu, char *extra) 7156{ 7157 u8 enable; 7158 u32 thermal; 7159 s32 ret; 7160 struct adapter *padapter = rtw_netdev_priv(dev); 7161 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7162 7163 if (!input) 7164 return -ENOMEM; 7165 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7166 kfree(input); 7167 return -EFAULT; 7168 } 7169 _rtw_memset(extra, 0, wrqu->length); 7170 7171 enable = 1; 7172 if (wrqu->length > 1) {/* not empty string */ 7173 if (strncmp(input, "stop", 4) == 0) { 7174 enable = 0; 7175 sprintf(extra, "mp tx power tracking stop"); 7176 } else if (sscanf(input, "ther =%d", &thermal)) { 7177 ret = Hal_SetThermalMeter(padapter, (u8)thermal); 7178 if (ret == _FAIL) 7179 return -EPERM; 7180 sprintf(extra, "mp tx power tracking start, target value =%d ok ", thermal); 7181 } else { 7182 kfree(input); 7183 return -EINVAL; 7184 } 7185 } 7186 7187 kfree(input); 7188 ret = Hal_SetPowerTracking(padapter, enable); 7189 if (ret == _FAIL) 7190 return -EPERM; 7191 7192 wrqu->length = strlen(extra); 7193 return 0; 7194} 7195 7196static int rtw_mp_psd(struct net_device *dev, 7197 struct iw_request_info *info, 7198 struct iw_point *wrqu, char *extra) 7199{ 7200 struct adapter *padapter = rtw_netdev_priv(dev); 7201 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7202 7203 if (!input) 7204 return -ENOMEM; 7205 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7206 kfree(input); 7207 return -EFAULT; 7208 } 7209 7210 strcpy(extra, input); 7211 7212 wrqu->length = mp_query_psd(padapter, extra); 7213 kfree(input); 7214 return 0; 7215} 7216 7217static int rtw_mp_thermal(struct net_device *dev, 7218 struct iw_request_info *info, 7219 struct iw_point *wrqu, char *extra) 7220{ 7221 u8 val; 7222 u16 bwrite = 1; 7223 u16 addr = EEPROM_THERMAL_METER_88E; 7224 7225 u16 cnt = 1; 7226 u16 max_available_size = 0; 7227 struct adapter *padapter = rtw_netdev_priv(dev); 7228 7229 if (copy_from_user(extra, wrqu->pointer, wrqu->length)) 7230 return -EFAULT; 7231 7232 bwrite = strncmp(extra, "write", 6); /* strncmp true is 0 */ 7233 7234 Hal_GetThermalMeter(padapter, &val); 7235 7236 if (bwrite == 0) { 7237 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); 7238 if (2 > max_available_size) { 7239 DBG_88E("no available efuse!\n"); 7240 return -EFAULT; 7241 } 7242 if (rtw_efuse_map_write(padapter, addr, cnt, &val) == _FAIL) { 7243 DBG_88E("rtw_efuse_map_write error\n"); 7244 return -EFAULT; 7245 } else { 7246 sprintf(extra, " efuse write ok :%d", val); 7247 } 7248 } else { 7249 sprintf(extra, "%d", val); 7250 } 7251 wrqu->length = strlen(extra); 7252 7253 return 0; 7254} 7255 7256static int rtw_mp_reset_stats(struct net_device *dev, 7257 struct iw_request_info *info, 7258 struct iw_point *wrqu, char *extra) 7259{ 7260 struct mp_priv *pmp_priv; 7261 struct adapter *padapter = rtw_netdev_priv(dev); 7262 7263 pmp_priv = &padapter->mppriv; 7264 7265 pmp_priv->tx.sended = 0; 7266 pmp_priv->tx_pktcount = 0; 7267 pmp_priv->rx_pktcount = 0; 7268 pmp_priv->rx_crcerrpktcount = 0; 7269 7270 /* reset phy counter */ 7271 write_bbreg(padapter, 0xf14, BIT16, 0x1); 7272 rtw_msleep_os(10); 7273 write_bbreg(padapter, 0xf14, BIT16, 0x0); 7274 7275 return 0; 7276} 7277 7278static int rtw_mp_dump(struct net_device *dev, 7279 struct iw_request_info *info, 7280 struct iw_point *wrqu, char *extra) 7281{ 7282 u32 value; 7283 u8 rf_type, path_nums = 0; 7284 u32 i, j = 1, path; 7285 struct adapter *padapter = rtw_netdev_priv(dev); 7286 7287 if (strncmp(extra, "all", 4) == 0) { 7288 DBG_88E("\n ======= MAC REG =======\n"); 7289 for (i = 0x0; i < 0x300; i += 4) { 7290 if (j%4 == 1) 7291 DBG_88E("0x%02x", i); 7292 DBG_88E(" 0x%08x ", rtw_read32(padapter, i)); 7293 if ((j++)%4 == 0) 7294 DBG_88E("\n"); 7295 } 7296 for (i = 0x400; i < 0x1000; i += 4) { 7297 if (j%4 == 1) 7298 DBG_88E("0x%02x", i); 7299 DBG_88E(" 0x%08x ", rtw_read32(padapter, i)); 7300 if ((j++)%4 == 0) 7301 DBG_88E("\n"); 7302 } 7303 7304 j = 1; 7305 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type)); 7306 7307 DBG_88E("\n ======= RF REG =======\n"); 7308 if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) 7309 path_nums = 1; 7310 else 7311 path_nums = 2; 7312 7313 for (path = 0; path < path_nums; path++) { 7314 for (i = 0; i < 0x34; i++) { 7315 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); 7316 if (j%4 == 1) 7317 DBG_88E("0x%02x ", i); 7318 DBG_88E(" 0x%08x ", value); 7319 if ((j++)%4 == 0) 7320 DBG_88E("\n"); 7321 } 7322 } 7323 } 7324 return 0; 7325} 7326 7327static int rtw_mp_phypara(struct net_device *dev, 7328 struct iw_request_info *info, 7329 struct iw_point *wrqu, char *extra) 7330{ 7331 char *input = kmalloc(wrqu->length, GFP_KERNEL); 7332 u32 valxcap; 7333 7334 if (!input) 7335 return -ENOMEM; 7336 if (copy_from_user(input, wrqu->pointer, wrqu->length)) { 7337 kfree(input); 7338 return -EFAULT; 7339 } 7340 7341 DBG_88E("%s:iwpriv in =%s\n", __func__, input); 7342 7343 sscanf(input, "xcap =%d", &valxcap); 7344 7345 kfree(input); 7346 return 0; 7347} 7348 7349static int rtw_mp_SetRFPath(struct net_device *dev, 7350 struct iw_request_info *info, 7351 union iwreq_data *wrqu, char *extra) 7352{ 7353 struct adapter *padapter = rtw_netdev_priv(dev); 7354 char *input = kmalloc(wrqu->data.length, GFP_KERNEL); 7355 u8 bMain = 1, bTurnoff = 1; 7356 7357 if (!input) 7358 return -ENOMEM; 7359 if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length)) 7360 return -EFAULT; 7361 DBG_88E("%s:iwpriv in =%s\n", __func__, input); 7362 7363 bMain = strncmp(input, "1", 2); /* strncmp true is 0 */ 7364 bTurnoff = strncmp(input, "0", 3); /* strncmp true is 0 */ 7365 7366 if (bMain == 0) { 7367 MP_PHY_SetRFPathSwitch(padapter, true); 7368 DBG_88E("%s:PHY_SetRFPathSwitch = true\n", __func__); 7369 } else if (bTurnoff == 0) { 7370 MP_PHY_SetRFPathSwitch(padapter, false); 7371 DBG_88E("%s:PHY_SetRFPathSwitch = false\n", __func__); 7372 } 7373 kfree(input); 7374 return 0; 7375} 7376 7377static int rtw_mp_QueryDrv(struct net_device *dev, 7378 struct iw_request_info *info, 7379 union iwreq_data *wrqu, char *extra) 7380{ 7381 struct adapter *padapter = rtw_netdev_priv(dev); 7382 char *input = kmalloc(wrqu->data.length, GFP_KERNEL); 7383 u8 qAutoLoad = 1; 7384 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter); 7385 7386 if (!input) 7387 return -ENOMEM; 7388 7389 if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length)) 7390 return -EFAULT; 7391 DBG_88E("%s:iwpriv in =%s\n", __func__, input); 7392 7393 qAutoLoad = strncmp(input, "autoload", 8); /* strncmp true is 0 */ 7394 7395 if (qAutoLoad == 0) { 7396 DBG_88E("%s:qAutoLoad\n", __func__); 7397 7398 if (pEEPROM->bautoload_fail_flag) 7399 sprintf(extra, "fail"); 7400 else 7401 sprintf(extra, "ok"); 7402 } 7403 wrqu->data.length = strlen(extra) + 1; 7404 kfree(input); 7405 return 0; 7406} 7407 7408static int rtw_mp_set(struct net_device *dev, 7409 struct iw_request_info *info, 7410 union iwreq_data *wdata, char *extra) 7411{ 7412 struct iw_point *wrqu = (struct iw_point *)wdata; 7413 u32 subcmd = wrqu->flags; 7414 struct adapter *padapter = rtw_netdev_priv(dev); 7415 7416 if (padapter == NULL) 7417 return -ENETDOWN; 7418 7419 if (extra == NULL) { 7420 wrqu->length = 0; 7421 return -EIO; 7422 } 7423 7424 switch (subcmd) { 7425 case MP_START: 7426 DBG_88E("set case mp_start\n"); 7427 rtw_mp_start(dev, info, wrqu, extra); 7428 break; 7429 case MP_STOP: 7430 DBG_88E("set case mp_stop\n"); 7431 rtw_mp_stop(dev, info, wrqu, extra); 7432 break; 7433 case MP_BANDWIDTH: 7434 DBG_88E("set case mp_bandwidth\n"); 7435 rtw_mp_bandwidth(dev, info, wrqu, extra); 7436 break; 7437 case MP_RESET_STATS: 7438 DBG_88E("set case MP_RESET_STATS\n"); 7439 rtw_mp_reset_stats(dev, info, wrqu, extra); 7440 break; 7441 case MP_SetRFPathSwh: 7442 DBG_88E("set MP_SetRFPathSwitch\n"); 7443 rtw_mp_SetRFPath(dev, info, wdata, extra); 7444 break; 7445 case CTA_TEST: 7446 DBG_88E("set CTA_TEST\n"); 7447 rtw_cta_test_start(dev, info, wdata, extra); 7448 break; 7449 } 7450 7451 return 0; 7452} 7453 7454static int rtw_mp_get(struct net_device *dev, 7455 struct iw_request_info *info, 7456 union iwreq_data *wdata, char *extra) 7457{ 7458 struct iw_point *wrqu = (struct iw_point *)wdata; 7459 u32 subcmd = wrqu->flags; 7460 struct adapter *padapter = rtw_netdev_priv(dev); 7461 7462 if (padapter == NULL) 7463 return -ENETDOWN; 7464 if (extra == NULL) { 7465 wrqu->length = 0; 7466 return -EIO; 7467 } 7468 7469 switch (subcmd) { 7470 case WRITE_REG: 7471 rtw_mp_write_reg(dev, info, wrqu, extra); 7472 break; 7473 case WRITE_RF: 7474 rtw_mp_write_rf(dev, info, wrqu, extra); 7475 break; 7476 case MP_PHYPARA: 7477 DBG_88E("mp_get MP_PHYPARA\n"); 7478 rtw_mp_phypara(dev, info, wrqu, extra); 7479 break; 7480 case MP_CHANNEL: 7481 DBG_88E("set case mp_channel\n"); 7482 rtw_mp_channel(dev, info, wrqu, extra); 7483 break; 7484 case READ_REG: 7485 DBG_88E("mp_get READ_REG\n"); 7486 rtw_mp_read_reg(dev, info, wrqu, extra); 7487 break; 7488 case READ_RF: 7489 DBG_88E("mp_get READ_RF\n"); 7490 rtw_mp_read_rf(dev, info, wrqu, extra); 7491 break; 7492 case MP_RATE: 7493 DBG_88E("set case mp_rate\n"); 7494 rtw_mp_rate(dev, info, wrqu, extra); 7495 break; 7496 case MP_TXPOWER: 7497 DBG_88E("set case MP_TXPOWER\n"); 7498 rtw_mp_txpower(dev, info, wrqu, extra); 7499 break; 7500 case MP_ANT_TX: 7501 DBG_88E("set case MP_ANT_TX\n"); 7502 rtw_mp_ant_tx(dev, info, wrqu, extra); 7503 break; 7504 case MP_ANT_RX: 7505 DBG_88E("set case MP_ANT_RX\n"); 7506 rtw_mp_ant_rx(dev, info, wrqu, extra); 7507 break; 7508 case MP_QUERY: 7509 rtw_mp_trx_query(dev, info, wrqu, extra); 7510 break; 7511 case MP_CTX: 7512 DBG_88E("set case MP_CTX\n"); 7513 rtw_mp_ctx(dev, info, wrqu, extra); 7514 break; 7515 case MP_ARX: 7516 DBG_88E("set case MP_ARX\n"); 7517 rtw_mp_arx(dev, info, wrqu, extra); 7518 break; 7519 case EFUSE_GET: 7520 DBG_88E("efuse get EFUSE_GET\n"); 7521 rtw_mp_efuse_get(dev, info, wdata, extra); 7522 break; 7523 case MP_DUMP: 7524 DBG_88E("set case MP_DUMP\n"); 7525 rtw_mp_dump(dev, info, wrqu, extra); 7526 break; 7527 case MP_PSD: 7528 DBG_88E("set case MP_PSD\n"); 7529 rtw_mp_psd(dev, info, wrqu, extra); 7530 break; 7531 case MP_THER: 7532 DBG_88E("set case MP_THER\n"); 7533 rtw_mp_thermal(dev, info, wrqu, extra); 7534 break; 7535 case MP_QueryDrvStats: 7536 DBG_88E("mp_get MP_QueryDrvStats\n"); 7537 rtw_mp_QueryDrv (dev, info, wdata, extra); 7538 break; 7539 case MP_PWRTRK: 7540 DBG_88E("set case MP_PWRTRK\n"); 7541 rtw_mp_pwrtrk(dev, info, wrqu, extra); 7542 break; 7543 case EFUSE_SET: 7544 DBG_88E("set case efuse set\n"); 7545 rtw_mp_efuse_set(dev, info, wdata, extra); 7546 break; 7547 } 7548 7549 rtw_msleep_os(10); /* delay 5ms for sending pkt before exit adb shell operation */ 7550 return 0; 7551} 7552 7553static int rtw_tdls(struct net_device *dev, 7554 struct iw_request_info *info, 7555 union iwreq_data *wrqu, char *extra) 7556{ 7557 return 0; 7558} 7559 7560static int rtw_tdls_get(struct net_device *dev, 7561 struct iw_request_info *info, 7562 union iwreq_data *wrqu, char *extra) 7563{ 7564 return 0; 7565} 7566 7567static int rtw_test( 7568 struct net_device *dev, 7569 struct iw_request_info *info, 7570 union iwreq_data *wrqu, char *extra) 7571{ 7572 u32 len; 7573 u8 *pbuf, *pch; 7574 char *ptmp; 7575 u8 *delim = ","; 7576 7577 DBG_88E("+%s\n", __func__); 7578 len = wrqu->data.length; 7579 7580 pbuf = (u8 *)rtw_zmalloc(len); 7581 if (pbuf == NULL) { 7582 DBG_88E("%s: no memory!\n", __func__); 7583 return -ENOMEM; 7584 } 7585 7586 if (copy_from_user(pbuf, wrqu->data.pointer, len)) { 7587 kfree(pbuf); 7588 DBG_88E("%s: copy from user fail!\n", __func__); 7589 return -EFAULT; 7590 } 7591 DBG_88E("%s: string =\"%s\"\n", __func__, pbuf); 7592 7593 ptmp = (char *)pbuf; 7594 pch = strsep(&ptmp, delim); 7595 if ((pch == NULL) || (strlen(pch) == 0)) { 7596 kfree(pbuf); 7597 DBG_88E("%s: parameter error(level 1)!\n", __func__); 7598 return -EFAULT; 7599 } 7600 kfree(pbuf); 7601 return 0; 7602} 7603 7604static iw_handler rtw_handlers[] = { 7605 NULL, /* SIOCSIWCOMMIT */ 7606 rtw_wx_get_name, /* SIOCGIWNAME */ 7607 dummy, /* SIOCSIWNWID */ 7608 dummy, /* SIOCGIWNWID */ 7609 rtw_wx_set_freq, /* SIOCSIWFREQ */ 7610 rtw_wx_get_freq, /* SIOCGIWFREQ */ 7611 rtw_wx_set_mode, /* SIOCSIWMODE */ 7612 rtw_wx_get_mode, /* SIOCGIWMODE */ 7613 dummy, /* SIOCSIWSENS */ 7614 rtw_wx_get_sens, /* SIOCGIWSENS */ 7615 NULL, /* SIOCSIWRANGE */ 7616 rtw_wx_get_range, /* SIOCGIWRANGE */ 7617 rtw_wx_set_priv, /* SIOCSIWPRIV */ 7618 NULL, /* SIOCGIWPRIV */ 7619 NULL, /* SIOCSIWSTATS */ 7620 NULL, /* SIOCGIWSTATS */ 7621 dummy, /* SIOCSIWSPY */ 7622 dummy, /* SIOCGIWSPY */ 7623 NULL, /* SIOCGIWTHRSPY */ 7624 NULL, /* SIOCWIWTHRSPY */ 7625 rtw_wx_set_wap, /* SIOCSIWAP */ 7626 rtw_wx_get_wap, /* SIOCGIWAP */ 7627 rtw_wx_set_mlme, /* request MLME operation; uses struct iw_mlme */ 7628 dummy, /* SIOCGIWAPLIST -- depricated */ 7629 rtw_wx_set_scan, /* SIOCSIWSCAN */ 7630 rtw_wx_get_scan, /* SIOCGIWSCAN */ 7631 rtw_wx_set_essid, /* SIOCSIWESSID */ 7632 rtw_wx_get_essid, /* SIOCGIWESSID */ 7633 dummy, /* SIOCSIWNICKN */ 7634 rtw_wx_get_nick, /* SIOCGIWNICKN */ 7635 NULL, /* -- hole -- */ 7636 NULL, /* -- hole -- */ 7637 rtw_wx_set_rate, /* SIOCSIWRATE */ 7638 rtw_wx_get_rate, /* SIOCGIWRATE */ 7639 rtw_wx_set_rts, /* SIOCSIWRTS */ 7640 rtw_wx_get_rts, /* SIOCGIWRTS */ 7641 rtw_wx_set_frag, /* SIOCSIWFRAG */ 7642 rtw_wx_get_frag, /* SIOCGIWFRAG */ 7643 dummy, /* SIOCSIWTXPOW */ 7644 dummy, /* SIOCGIWTXPOW */ 7645 dummy, /* SIOCSIWRETRY */ 7646 rtw_wx_get_retry, /* SIOCGIWRETRY */ 7647 rtw_wx_set_enc, /* SIOCSIWENCODE */ 7648 rtw_wx_get_enc, /* SIOCGIWENCODE */ 7649 dummy, /* SIOCSIWPOWER */ 7650 rtw_wx_get_power, /* SIOCGIWPOWER */ 7651 NULL, /*---hole---*/ 7652 NULL, /*---hole---*/ 7653 rtw_wx_set_gen_ie, /* SIOCSIWGENIE */ 7654 NULL, /* SIOCGWGENIE */ 7655 rtw_wx_set_auth, /* SIOCSIWAUTH */ 7656 NULL, /* SIOCGIWAUTH */ 7657 rtw_wx_set_enc_ext, /* SIOCSIWENCODEEXT */ 7658 NULL, /* SIOCGIWENCODEEXT */ 7659 rtw_wx_set_pmkid, /* SIOCSIWPMKSA */ 7660 NULL, /*---hole---*/ 7661}; 7662 7663static const struct iw_priv_args rtw_private_args[] = { 7664 { 7665 SIOCIWFIRSTPRIV + 0x0, 7666 IW_PRIV_TYPE_CHAR | 0x7FF, 0, "write" 7667 }, 7668 { 7669 SIOCIWFIRSTPRIV + 0x1, 7670 IW_PRIV_TYPE_CHAR | 0x7FF, 7671 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "read" 7672 }, 7673 { 7674 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext" 7675 }, 7676 { 7677 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl" 7678 }, 7679 { 7680 SIOCIWFIRSTPRIV + 0x4, 7681 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo" 7682 }, 7683 { 7684 SIOCIWFIRSTPRIV + 0x5, 7685 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setpid" 7686 }, 7687 { 7688 SIOCIWFIRSTPRIV + 0x6, 7689 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start" 7690 }, 7691 { 7692 SIOCIWFIRSTPRIV + 0x7, 7693 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "get_sensitivity" 7694 }, 7695 { 7696 SIOCIWFIRSTPRIV + 0x8, 7697 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_prob_req_ie" 7698 }, 7699 { 7700 SIOCIWFIRSTPRIV + 0x9, 7701 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_assoc_req_ie" 7702 }, 7703 7704 { 7705 SIOCIWFIRSTPRIV + 0xA, 7706 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "channel_plan" 7707 }, 7708 7709 { 7710 SIOCIWFIRSTPRIV + 0xB, 7711 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "dbg" 7712 }, 7713 { 7714 SIOCIWFIRSTPRIV + 0xC, 7715 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 0, "rfw" 7716 }, 7717 { 7718 SIOCIWFIRSTPRIV + 0xD, 7719 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "rfr" 7720 }, 7721 { 7722 SIOCIWFIRSTPRIV + 0x10, 7723 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, 0, "p2p_set" 7724 }, 7725 { 7726 SIOCIWFIRSTPRIV + 0x11, 7727 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | P2P_PRIVATE_IOCTL_SET_LEN, "p2p_get" 7728 }, 7729 { 7730 SIOCIWFIRSTPRIV + 0x12, 7731 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, IW_PRIV_TYPE_CHAR | IFNAMSIZ, "p2p_get2" 7732 }, 7733 {SIOCIWFIRSTPRIV + 0x13, IW_PRIV_TYPE_CHAR | 128, 0, "NULL"}, 7734 { 7735 SIOCIWFIRSTPRIV + 0x14, 7736 IW_PRIV_TYPE_CHAR | 64, 0, "tdls" 7737 }, 7738 { 7739 SIOCIWFIRSTPRIV + 0x15, 7740 IW_PRIV_TYPE_CHAR | P2P_PRIVATE_IOCTL_SET_LEN, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | P2P_PRIVATE_IOCTL_SET_LEN, "tdls_get" 7741 }, 7742 { 7743 SIOCIWFIRSTPRIV + 0x16, 7744 IW_PRIV_TYPE_CHAR | 64, 0, "pm_set" 7745 }, 7746 7747 {SIOCIWFIRSTPRIV + 0x18, IW_PRIV_TYPE_CHAR | IFNAMSIZ, 0, "rereg_nd_name"}, 7748 7749 {SIOCIWFIRSTPRIV + 0x1A, IW_PRIV_TYPE_CHAR | 1024, 0, "efuse_set"}, 7750 {SIOCIWFIRSTPRIV + 0x1B, IW_PRIV_TYPE_CHAR | 128, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"}, 7751 {SIOCIWFIRSTPRIV + 0x1D, IW_PRIV_TYPE_CHAR | 40, IW_PRIV_TYPE_CHAR | 0x7FF, "test" 7752 }, 7753 7754 {SIOCIWFIRSTPRIV + 0x0E, IW_PRIV_TYPE_CHAR | 1024, 0, ""}, /* set */ 7755 {SIOCIWFIRSTPRIV + 0x0F, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, ""},/* get */ 7756/* --- sub-ioctls definitions --- */ 7757 7758 {MP_START, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_start"}, /* set */ 7759 {MP_PHYPARA, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_phypara"},/* get */ 7760 {MP_STOP, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_stop"}, /* set */ 7761 {MP_CHANNEL, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_channel"},/* get */ 7762 {MP_BANDWIDTH, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_bandwidth"}, /* set */ 7763 {MP_RATE, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate"},/* get */ 7764 {MP_RESET_STATS, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_reset_stats"}, 7765 {MP_QUERY, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_query"}, /* get */ 7766 {READ_REG, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_reg"}, 7767 {MP_RATE, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate"}, 7768 {READ_RF, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_rf"}, 7769 {MP_PSD, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_psd"}, 7770 {MP_DUMP, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_dump"}, 7771 {MP_TXPOWER, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_txpower"}, 7772 {MP_ANT_TX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_tx"}, 7773 {MP_ANT_RX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_rx"}, 7774 {WRITE_REG, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "write_reg"}, 7775 {WRITE_RF, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "write_rf"}, 7776 {MP_CTX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ctx"}, 7777 {MP_ARX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_arx"}, 7778 {MP_THER, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ther"}, 7779 {EFUSE_SET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_set"}, 7780 {EFUSE_GET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"}, 7781 {MP_PWRTRK, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_pwrtrk"}, 7782 {MP_QueryDrvStats, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_drvquery"}, 7783 {MP_IOCTL, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_ioctl"}, /* mp_ioctl */ 7784 {MP_SetRFPathSwh, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_setrfpath"}, 7785 {CTA_TEST, IW_PRIV_TYPE_CHAR | 1024, 0, "cta_test"}, 7786}; 7787 7788static iw_handler rtw_private_handler[] = { 7789rtw_wx_write32, /* 0x00 */ 7790rtw_wx_read32, /* 0x01 */ 7791rtw_drvext_hdl, /* 0x02 */ 7792rtw_mp_ioctl_hdl, /* 0x03 */ 7793 7794/* for MM DTV platform */ 7795 rtw_get_ap_info, /* 0x04 */ 7796 7797 rtw_set_pid, /* 0x05 */ 7798 rtw_wps_start, /* 0x06 */ 7799 7800 rtw_wx_get_sensitivity, /* 0x07 */ 7801 rtw_wx_set_mtk_wps_probe_ie, /* 0x08 */ 7802 rtw_wx_set_mtk_wps_ie, /* 0x09 */ 7803 7804/* Set Channel depend on the country code */ 7805 rtw_wx_set_channel_plan, /* 0x0A */ 7806 7807 rtw_dbg_port, /* 0x0B */ 7808 rtw_wx_write_rf, /* 0x0C */ 7809 rtw_wx_read_rf, /* 0x0D */ 7810 7811 rtw_mp_set, /* 0x0E */ 7812 rtw_mp_get, /* 0x0F */ 7813 rtw_p2p_set, /* 0x10 */ 7814 rtw_p2p_get, /* 0x11 */ 7815 rtw_p2p_get2, /* 0x12 */ 7816 7817 NULL, /* 0x13 */ 7818 rtw_tdls, /* 0x14 */ 7819 rtw_tdls_get, /* 0x15 */ 7820 7821 rtw_pm_set, /* 0x16 */ 7822 rtw_wx_priv_null, /* 0x17 */ 7823 rtw_rereg_nd_name, /* 0x18 */ 7824 rtw_wx_priv_null, /* 0x19 */ 7825 7826 rtw_mp_efuse_set, /* 0x1A */ 7827 rtw_mp_efuse_get, /* 0x1B */ 7828 NULL, /* 0x1C is reserved for hostapd */ 7829 rtw_test, /* 0x1D */ 7830}; 7831 7832static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev) 7833{ 7834 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); 7835 struct iw_statistics *piwstats = &padapter->iwstats; 7836 int tmp_level = 0; 7837 int tmp_qual = 0; 7838 int tmp_noise = 0; 7839 7840 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 7841 piwstats->qual.qual = 0; 7842 piwstats->qual.level = 0; 7843 piwstats->qual.noise = 0; 7844 } else { 7845 tmp_level = padapter->recvpriv.signal_strength; 7846 tmp_qual = padapter->recvpriv.signal_qual; 7847 tmp_noise = padapter->recvpriv.noise; 7848 7849 piwstats->qual.level = tmp_level; 7850 piwstats->qual.qual = tmp_qual; 7851 piwstats->qual.noise = tmp_noise; 7852 } 7853 piwstats->qual.updated = IW_QUAL_ALL_UPDATED;/* IW_QUAL_DBM; */ 7854 return &padapter->iwstats; 7855} 7856 7857struct iw_handler_def rtw_handlers_def = { 7858 .standard = rtw_handlers, 7859 .num_standard = sizeof(rtw_handlers) / sizeof(iw_handler), 7860 .private = rtw_private_handler, 7861 .private_args = (struct iw_priv_args *)rtw_private_args, 7862 .num_private = sizeof(rtw_private_handler) / sizeof(iw_handler), 7863 .num_private_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args), 7864 .get_wireless_stats = rtw_get_wireless_stats, 7865}; 7866 7867/* copy from net/wireless/wext.c start */ 7868/* ---------------------------------------------------------------- */ 7869/* 7870 * Calculate size of private arguments 7871 */ 7872static const char iw_priv_type_size[] = { 7873 0, /* IW_PRIV_TYPE_NONE */ 7874 1, /* IW_PRIV_TYPE_BYTE */ 7875 1, /* IW_PRIV_TYPE_CHAR */ 7876 0, /* Not defined */ 7877 sizeof(__u32), /* IW_PRIV_TYPE_INT */ 7878 sizeof(struct iw_freq), /* IW_PRIV_TYPE_FLOAT */ 7879 sizeof(struct sockaddr), /* IW_PRIV_TYPE_ADDR */ 7880 0, /* Not defined */ 7881}; 7882 7883static int get_priv_size(__u16 args) 7884{ 7885 int num = args & IW_PRIV_SIZE_MASK; 7886 int type = (args & IW_PRIV_TYPE_MASK) >> 12; 7887 7888 return num * iw_priv_type_size[type]; 7889} 7890/* copy from net/wireless/wext.c end */ 7891 7892static int rtw_ioctl_wext_private(struct net_device *dev, union iwreq_data *wrq_data) 7893{ 7894 int err = 0; 7895 u8 *input = NULL; 7896 u32 input_len = 0; 7897 const char delim[] = " "; 7898 u8 *output = NULL; 7899 u32 output_len = 0; 7900 u32 count = 0; 7901 u8 *buffer = NULL; 7902 u32 buffer_len = 0; 7903 char *ptr = NULL; 7904 u8 cmdname[17] = {0}; /* IFNAMSIZ+1 */ 7905 u32 cmdlen; 7906 s32 len; 7907 u8 *extra = NULL; 7908 u32 extra_size = 0; 7909 7910 s32 k; 7911 const iw_handler *priv; /* Private ioctl */ 7912 const struct iw_priv_args *priv_args; /* Private ioctl description */ 7913 u32 num_priv_args; /* Number of descriptions */ 7914 iw_handler handler; 7915 int temp; 7916 int subcmd = 0; /* sub-ioctl index */ 7917 int offset = 0; /* Space for sub-ioctl index */ 7918 7919 union iwreq_data wdata; 7920 7921 memcpy(&wdata, wrq_data, sizeof(wdata)); 7922 7923 input_len = wdata.data.length; 7924 input = rtw_zmalloc(input_len); 7925 if (NULL == input) 7926 return -ENOMEM; 7927 if (copy_from_user(input, wdata.data.pointer, input_len)) { 7928 err = -EFAULT; 7929 goto exit; 7930 } 7931 ptr = input; 7932 len = input_len; 7933 7934 sscanf(ptr, "%16s", cmdname); 7935 cmdlen = strlen(cmdname); 7936 DBG_88E("%s: cmd =%s\n", __func__, cmdname); 7937 7938 /* skip command string */ 7939 if (cmdlen > 0) 7940 cmdlen += 1; /* skip one space */ 7941 ptr += cmdlen; 7942 len -= cmdlen; 7943 DBG_88E("%s: parameters =%s\n", __func__, ptr); 7944 7945 priv = rtw_private_handler; 7946 priv_args = rtw_private_args; 7947 num_priv_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args); 7948 7949 if (num_priv_args == 0) { 7950 err = -EOPNOTSUPP; 7951 goto exit; 7952 } 7953 7954 /* Search the correct ioctl */ 7955 k = -1; 7956 while ((++k < num_priv_args) && strcmp(priv_args[k].name, cmdname)); 7957 7958 /* If not found... */ 7959 if (k == num_priv_args) { 7960 err = -EOPNOTSUPP; 7961 goto exit; 7962 } 7963 7964 /* Watch out for sub-ioctls ! */ 7965 if (priv_args[k].cmd < SIOCDEVPRIVATE) { 7966 int j = -1; 7967 7968 /* Find the matching *real* ioctl */ 7969 while ((++j < num_priv_args) && ((priv_args[j].name[0] != '\0') || 7970 (priv_args[j].set_args != priv_args[k].set_args) || 7971 (priv_args[j].get_args != priv_args[k].get_args))); 7972 7973 /* If not found... */ 7974 if (j == num_priv_args) { 7975 err = -EINVAL; 7976 goto exit; 7977 } 7978 7979 /* Save sub-ioctl number */ 7980 subcmd = priv_args[k].cmd; 7981 /* Reserve one int (simplify alignment issues) */ 7982 offset = sizeof(__u32); 7983 /* Use real ioctl definition from now on */ 7984 k = j; 7985 } 7986 7987 buffer = rtw_zmalloc(4096); 7988 if (NULL == buffer) { 7989 err = -ENOMEM; 7990 goto exit; 7991 } 7992 7993 /* If we have to set some data */ 7994 if ((priv_args[k].set_args & IW_PRIV_TYPE_MASK) && 7995 (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) { 7996 u8 *str; 7997 7998 switch (priv_args[k].set_args & IW_PRIV_TYPE_MASK) { 7999 case IW_PRIV_TYPE_BYTE: 8000 /* Fetch args */ 8001 count = 0; 8002 do { 8003 str = strsep(&ptr, delim); 8004 if (NULL == str) 8005 break; 8006 sscanf(str, "%i", &temp); 8007 buffer[count++] = (u8)temp; 8008 } while (1); 8009 buffer_len = count; 8010 /* Number of args to fetch */ 8011 wdata.data.length = count; 8012 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) 8013 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK; 8014 break; 8015 case IW_PRIV_TYPE_INT: 8016 /* Fetch args */ 8017 count = 0; 8018 do { 8019 str = strsep(&ptr, delim); 8020 if (NULL == str) 8021 break; 8022 sscanf(str, "%i", &temp); 8023 ((s32 *)buffer)[count++] = (s32)temp; 8024 } while (1); 8025 buffer_len = count * sizeof(s32); 8026 /* Number of args to fetch */ 8027 wdata.data.length = count; 8028 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) 8029 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK; 8030 break; 8031 case IW_PRIV_TYPE_CHAR: 8032 if (len > 0) { 8033 /* Size of the string to fetch */ 8034 wdata.data.length = len; 8035 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) 8036 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK; 8037 8038 /* Fetch string */ 8039 memcpy(buffer, ptr, wdata.data.length); 8040 } else { 8041 wdata.data.length = 1; 8042 buffer[0] = '\0'; 8043 } 8044 buffer_len = wdata.data.length; 8045 break; 8046 default: 8047 DBG_88E("%s: Not yet implemented...\n", __func__); 8048 err = -1; 8049 goto exit; 8050 } 8051 8052 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) && 8053 (wdata.data.length != (priv_args[k].set_args & IW_PRIV_SIZE_MASK))) { 8054 DBG_88E("%s: The command %s needs exactly %d argument(s)...\n", 8055 __func__, cmdname, priv_args[k].set_args & IW_PRIV_SIZE_MASK); 8056 err = -EINVAL; 8057 goto exit; 8058 } 8059 } else { 8060 /* if args to set */ 8061 wdata.data.length = 0L; 8062 } 8063 8064 /* Those two tests are important. They define how the driver 8065 * will have to handle the data */ 8066 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) && 8067 ((get_priv_size(priv_args[k].set_args) + offset) <= IFNAMSIZ)) { 8068 /* First case : all SET args fit within wrq */ 8069 if (offset) 8070 wdata.mode = subcmd; 8071 memcpy(wdata.name + offset, buffer, IFNAMSIZ - offset); 8072 } else { 8073 if ((priv_args[k].set_args == 0) && 8074 (priv_args[k].get_args & IW_PRIV_SIZE_FIXED) && 8075 (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ)) { 8076 /* Second case : no SET args, GET args fit within wrq */ 8077 if (offset) 8078 wdata.mode = subcmd; 8079 } else { 8080 /* Third case : args won't fit in wrq, or variable number of args */ 8081 if (copy_to_user(wdata.data.pointer, buffer, buffer_len)) { 8082 err = -EFAULT; 8083 goto exit; 8084 } 8085 wdata.data.flags = subcmd; 8086 } 8087 } 8088 8089 kfree(input); 8090 input = NULL; 8091 8092 extra_size = 0; 8093 if (IW_IS_SET(priv_args[k].cmd)) { 8094 /* Size of set arguments */ 8095 extra_size = get_priv_size(priv_args[k].set_args); 8096 8097 /* Does it fits in iwr ? */ 8098 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) && 8099 ((extra_size + offset) <= IFNAMSIZ)) 8100 extra_size = 0; 8101 } else { 8102 /* Size of get arguments */ 8103 extra_size = get_priv_size(priv_args[k].get_args); 8104 8105 /* Does it fits in iwr ? */ 8106 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) && 8107 (extra_size <= IFNAMSIZ)) 8108 extra_size = 0; 8109 } 8110 8111 if (extra_size == 0) { 8112 extra = (u8 *)&wdata; 8113 kfree(buffer); 8114 buffer = NULL; 8115 } else { 8116 extra = buffer; 8117 } 8118 8119 handler = priv[priv_args[k].cmd - SIOCIWFIRSTPRIV]; 8120 err = handler(dev, NULL, &wdata, extra); 8121 8122 /* If we have to get some data */ 8123 if ((priv_args[k].get_args & IW_PRIV_TYPE_MASK) && 8124 (priv_args[k].get_args & IW_PRIV_SIZE_MASK)) { 8125 int j; 8126 int n = 0; /* number of args */ 8127 u8 str[20] = {0}; 8128 8129 /* Check where is the returned data */ 8130 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) && 8131 (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ)) 8132 n = priv_args[k].get_args & IW_PRIV_SIZE_MASK; 8133 else 8134 n = wdata.data.length; 8135 8136 output = rtw_zmalloc(4096); 8137 if (NULL == output) { 8138 err = -ENOMEM; 8139 goto exit; 8140 } 8141 switch (priv_args[k].get_args & IW_PRIV_TYPE_MASK) { 8142 case IW_PRIV_TYPE_BYTE: 8143 /* Display args */ 8144 for (j = 0; j < n; j++) { 8145 sprintf(str, "%d ", extra[j]); 8146 len = strlen(str); 8147 output_len = strlen(output); 8148 if ((output_len + len + 1) > 4096) { 8149 err = -E2BIG; 8150 goto exit; 8151 } 8152 memcpy(output+output_len, str, len); 8153 } 8154 break; 8155 case IW_PRIV_TYPE_INT: 8156 /* Display args */ 8157 for (j = 0; j < n; j++) { 8158 sprintf(str, "%d ", ((__s32 *)extra)[j]); 8159 len = strlen(str); 8160 output_len = strlen(output); 8161 if ((output_len + len + 1) > 4096) { 8162 err = -E2BIG; 8163 goto exit; 8164 } 8165 memcpy(output+output_len, str, len); 8166 } 8167 break; 8168 case IW_PRIV_TYPE_CHAR: 8169 /* Display args */ 8170 memcpy(output, extra, n); 8171 break; 8172 default: 8173 DBG_88E("%s: Not yet implemented...\n", __func__); 8174 err = -1; 8175 goto exit; 8176 } 8177 8178 output_len = strlen(output) + 1; 8179 wrq_data->data.length = output_len; 8180 if (copy_to_user(wrq_data->data.pointer, output, output_len)) { 8181 err = -EFAULT; 8182 goto exit; 8183 } 8184 } else { 8185 /* if args to set */ 8186 wrq_data->data.length = 0; 8187 } 8188 8189exit: 8190 kfree(input); 8191 kfree(buffer); 8192 kfree(output); 8193 return err; 8194} 8195 8196#include <rtw_android.h> 8197int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 8198{ 8199 struct iwreq *wrq = (struct iwreq *)rq; 8200 int ret = 0; 8201 8202 switch (cmd) { 8203 case RTL_IOCTL_WPA_SUPPLICANT: 8204 ret = wpa_supplicant_ioctl(dev, &wrq->u.data); 8205 break; 8206#ifdef CONFIG_88EU_AP_MODE 8207 case RTL_IOCTL_HOSTAPD: 8208 ret = rtw_hostapd_ioctl(dev, &wrq->u.data); 8209 break; 8210#endif /* CONFIG_88EU_AP_MODE */ 8211 case SIOCDEVPRIVATE: 8212 ret = rtw_ioctl_wext_private(dev, &wrq->u); 8213 break; 8214 case (SIOCDEVPRIVATE+1): 8215 ret = rtw_android_priv_cmd(dev, rq, cmd); 8216 break; 8217 default: 8218 ret = -EOPNOTSUPP; 8219 break; 8220 } 8221 return ret; 8222} 8223