/drivers/staging/rtl8712/rtl871x_ioctl_linux.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 2251 lines · 1998 code · 116 blank · 137 comment · 363 complexity · 93e715edcb86b7a79ec7c5a9857a953b MD5 · raw file 

    

  1. /******************************************************************************
    2. 

  2.  * rtl871x_ioctl_linux.c
    3. 

  3.  *
    4. 

  4.  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
    5. 

  5.  * Linux device driver for RTL8192SU
    6. 

  6.  *
    7. 

  7.  * This program is free software; you can redistribute it and/or modify it
    8. 

  8.  * under the terms of version 2 of the GNU General Public License as
    9. 

  9.  * published by the Free Software Foundation.
    10. 

  10.  *
    11. 

  11.  * This program is distributed in the hope that it will be useful, but WITHOUT
    12. 

  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    13. 

  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    14. 

  14.  * more details.
    15. 

  15.  *
    16. 

  16.  * You should have received a copy of the GNU General Public License along with
    17. 

  17.  * this program; if not, write to the Free Software Foundation, Inc.,
    18. 

  18.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
    19. 

  19.  *
    20. 

  20.  * Modifications for inclusion into the Linux staging tree are
    21. 

  21.  * Copyright(c) 2010 Larry Finger. All rights reserved.
    22. 

  22.  *
    23. 

  23.  * Contact information:
    24. 

  24.  * WLAN FAE <wlanfae@realtek.com>
    25. 

  25.  * Larry Finger <Larry.Finger@lwfinger.net>
    26. 

  26.  *
    27. 

  27.  ******************************************************************************/
    28. 

  28. 

  29. #define _RTL871X_IOCTL_LINUX_C_
    30. 

  30. #define _RTL871X_MP_IOCTL_C_
    31. 

  31. 

  32. #include "osdep_service.h"
    33. 

  33. #include "drv_types.h"
    34. 

  34. #include "wlan_bssdef.h"
    35. 

  35. #include "rtl871x_debug.h"
    36. 

  36. #include "wifi.h"
    37. 

  37. #include "rtl871x_mlme.h"
    38. 

  38. #include "rtl871x_ioctl.h"
    39. 

  39. #include "rtl871x_ioctl_set.h"
    40. 

  40. #include "rtl871x_mp_ioctl.h"
    41. 

  41. #include "mlme_osdep.h"
    42. 

  42. 

  43. #define RTL_IOCTL_WPA_SUPPLICANT	(SIOCIWFIRSTPRIV + 30)
    44. 

  44. 

  45. #define SCAN_ITEM_SIZE 768
    46. 

  46. #define MAX_CUSTOM_LEN 64
    47. 

  47. #define RATE_COUNT 4
    48. 

  48. 

  49. 

  50. static const u32 rtl8180_rates[] = {1000000, 2000000, 5500000, 11000000,
    51. 

  51. 		       6000000, 9000000, 12000000, 18000000,
    52. 

  52. 		       24000000, 36000000, 48000000, 54000000};
    53. 

  53. 

  54. static const long ieee80211_wlan_frequencies[] = {
    55. 

  55. 	2412, 2417, 2422, 2427,
    56. 

  56. 	2432, 2437, 2442, 2447,
    57. 

  57. 	2452, 2457, 2462, 2467,
    58. 

  58. 	2472, 2484
    59. 

  59. };
    60. 

  60. 

  61. static const char * const iw_operation_mode[] = {
    62. 

  62. 	"Auto", "Ad-Hoc", "Managed",  "Master", "Repeater", "Secondary",
    63. 

  63. 	 "Monitor"
    64. 

  64. };
    65. 

  65. 

  66. /**
    67. 

  67.  * hwaddr_aton - Convert ASCII string to MAC address
    68. 

  68.  * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
    69. 

  69.  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
    70. 

  70.  * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
    71. 

  71.  */
    72. 

  72. static int hwaddr_aton_i(const char *txt, u8 *addr)
    73. 

  73. {
    74. 

  74. 	int i;
    75. 

  75. 

  76. 	for (i = 0; i < 6; i++) {
    77. 

  77. 		int a, b;
    78. 

  78. 

  79. 		a = hex_to_bin(*txt++);
    80. 

  80. 		if (a < 0)
    81. 

  81. 			return -1;
    82. 

  82. 		b = hex_to_bin(*txt++);
    83. 

  83. 		if (b < 0)
    84. 

  84. 			return -1;
    85. 

  85. 		*addr++ = (a << 4) | b;
    86. 

  86. 		if (i < 5 && *txt++ != ':')
    87. 

  87. 			return -1;
    88. 

  88. 	}
    89. 

  89. 	return 0;
    90. 

  90. }
    91. 

  91. 

  92. void r8712_indicate_wx_assoc_event(struct _adapter *padapter)
    93. 

  93. {
    94. 

  94. 	union iwreq_data wrqu;
    95. 

  95. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    96. 

  96. 

  97. 	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
    98. 

  98. 	memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress,
    99. 

  99. 		ETH_ALEN);
    100. 

  100. 	wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
    101. 

  101. }
    102. 

  102. 

  103. void r8712_indicate_wx_disassoc_event(struct _adapter *padapter)
    104. 

  104. {
    105. 

  105. 	union iwreq_data wrqu;
    106. 

  106. 

  107. 	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
    108. 

  108. 	memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
    109. 

  109. 	wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
    110. 

  110. }
    111. 

  111. 

  112. static inline void handle_pairwise_key(struct sta_info *psta,
    113. 

  113. 				       struct ieee_param *param,
    114. 

  114. 				       struct _adapter *padapter)
    115. 

  115. {
    116. 

  116. 	/* pairwise key */
    117. 

  117. 	memcpy(psta->x_UncstKey.skey, param->u.crypt.key,
    118. 

  118. 	       (param->u.crypt. key_len > 16 ? 16 : param->u.crypt.key_len));
    119. 

  119. 	if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
    120. 

  120. 		memcpy(psta->tkiptxmickey. skey, &(param->u.crypt.
    121. 

  121. 			key[16]), 8);
    122. 

  122. 		memcpy(psta->tkiprxmickey. skey, &(param->u.crypt.
    123. 

  123. 			key[24]), 8);
    124. 

  124. 		padapter->securitypriv. busetkipkey = false;
    125. 

  125. 		_set_timer(&padapter->securitypriv.tkip_timer, 50);
    126. 

  126. 	}
    127. 

  127. 	r8712_setstakey_cmd(padapter, (unsigned char *)psta, true);
    128. 

  128. }
    129. 

  129. 

  130. static inline void handle_group_key(struct ieee_param *param,
    131. 

  131. 				    struct _adapter *padapter)
    132. 

  132. {
    133. 

  133. 	if (0 < param->u.crypt.idx &&
    134. 

  134. 	    param->u.crypt.idx < 3) {
    135. 

  135. 		/* group key idx is 1 or 2 */
    136. 

  136. 		memcpy(padapter->securitypriv.XGrpKey[param->u.crypt.
    137. 

  137. 			idx-1].skey, param->u.crypt.key, (param->u.crypt.key_len
    138. 

  138. 			> 16 ? 16 : param->u.crypt.key_len));
    139. 

  139. 		memcpy(padapter->securitypriv.XGrptxmickey[param->
    140. 

  140. 			u.crypt.idx-1].skey, &(param->u.crypt.key[16]), 8);
    141. 

  141. 		memcpy(padapter->securitypriv. XGrprxmickey[param->
    142. 

  142. 			u.crypt.idx-1].skey, &(param->u.crypt.key[24]), 8);
    143. 

  143. 		padapter->securitypriv.binstallGrpkey = true;
    144. 

  144. 		r8712_set_key(padapter, &padapter->securitypriv,
    145. 

  145. 			param->u.crypt.idx);
    146. 

  146. 		if (padapter->registrypriv.power_mgnt > PS_MODE_ACTIVE) {
    147. 

  147. 			if (padapter->registrypriv.power_mgnt != padapter->
    148. 

  148. 			    pwrctrlpriv.pwr_mode)
    149. 

  149. 				_set_timer(&(padapter->mlmepriv.dhcp_timer),
    150. 

  150. 					   60000);
    151. 

  151. 		}
    152. 

  152. 	}
    153. 

  153. }
    154. 

  154. 

  155. static inline char *translate_scan(struct _adapter *padapter,
    156. 

  156. 				   struct iw_request_info *info,
    157. 

  157. 				   struct wlan_network *pnetwork,
    158. 

  158. 				   char *start, char *stop)
    159. 

  159. {
    160. 

  160. 	struct iw_event iwe;
    161. 

  161. 	struct ieee80211_ht_cap *pht_capie;
    162. 

  162. 	char *current_val;
    163. 

  163. 	u8 *buf = (u8 *)_malloc(pnetwork->network.IELength * 2);
    164. 

  164. 	u8 *wpa_ie = (u8 *)_malloc(255);
    165. 

  165. 	u8 *rsn_ie = (u8 *)_malloc(255);
    166. 

  166. 	u8 *wps_ie = (u8 *)_malloc(MAX_WPS_IE_LEN);
    167. 

  167. 	s8 *p;
    168. 

  168. 	u32 i = 0, ht_ielen = 0;
    169. 

  169. 	u16	cap, ht_cap = false, mcs_rate;
    170. 

  170. 	u8	rssi, bw_40MHz = 0, short_GI = 0;
    171. 

  171. 

  172. 	if ((pnetwork->network.Configuration.DSConfig < 1) ||
    173. 

  173. 	    (pnetwork->network.Configuration.DSConfig > 14)) {
    174. 

  174. 		if (pnetwork->network.Configuration.DSConfig < 1)
    175. 

  175. 			pnetwork->network.Configuration.DSConfig = 1;
    176. 

  176. 		else
    177. 

  177. 			pnetwork->network.Configuration.DSConfig = 14;
    178. 

  178. 	}
    179. 

  179. 	/* AP MAC address */
    180. 

  180. 	iwe.cmd = SIOCGIWAP;
    181. 

  181. 	iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
    182. 

  182. 	memcpy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress, ETH_ALEN);
    183. 

  183. 	start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
    184. 

  184. 	/* Add the ESSID */
    185. 

  185. 	iwe.cmd = SIOCGIWESSID;
    186. 

  186. 	iwe.u.data.flags = 1;
    187. 

  187. 	iwe.u.data.length = (u16)min((u16)pnetwork->network.Ssid.SsidLength,
    188. 

  188. 			    (u16)32);
    189. 

  189. 	start = iwe_stream_add_point(info, start, stop, &iwe,
    190. 

  190. 				     pnetwork->network.Ssid.Ssid);
    191. 

  191. 	/* parsing HT_CAP_IE */
    192. 

  192. 	p = r8712_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_,
    193. 

  193. 			 &ht_ielen, pnetwork->network.IELength - 12);
    194. 

  194. 	if (p && ht_ielen > 0) {
    195. 

  195. 		ht_cap = true;
    196. 

  196. 		pht_capie = (struct ieee80211_ht_cap *)(p + 2);
    197. 

  197. 		memcpy(&mcs_rate , pht_capie->supp_mcs_set, 2);
    198. 

  198. 		bw_40MHz = (pht_capie->cap_info&IEEE80211_HT_CAP_SUP_WIDTH)
    199. 

  199. 			   ? 1 : 0;
    200. 

  200. 		short_GI = (pht_capie->cap_info&(IEEE80211_HT_CAP_SGI_20 |
    201. 

  201. 			    IEEE80211_HT_CAP_SGI_40)) ? 1 : 0;
    202. 

  202. 	}
    203. 

  203. 	/* Add the protocol name */
    204. 

  204. 	iwe.cmd = SIOCGIWNAME;
    205. 

  205. 	if ((r8712_is_cckratesonly_included((u8 *)&pnetwork->network.
    206. 

  206. 	     SupportedRates)) == true) {
    207. 

  207. 		if (ht_cap == true)
    208. 

  208. 			snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn");
    209. 

  209. 		else
    210. 

  210. 			snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
    211. 

  211. 	} else if ((r8712_is_cckrates_included((u8 *)&pnetwork->network.
    212. 

  212. 		    SupportedRates)) == true) {
    213. 

  213. 		if (ht_cap == true)
    214. 

  214. 			snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn");
    215. 

  215. 		else
    216. 

  216. 			snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
    217. 

  217. 	} else {
    218. 

  218. 		if (ht_cap == true)
    219. 

  219. 			snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn");
    220. 

  220. 		else
    221. 

  221. 			snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
    222. 

  222. 	}
    223. 

  223. 	start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
    224. 

  224. 	/* Add mode */
    225. 

  225. 	iwe.cmd = SIOCGIWMODE;
    226. 

  226. 	memcpy((u8 *)&cap, r8712_get_capability_from_ie(pnetwork->network.IEs),
    227. 

  227. 		2);
    228. 

  228. 	cap = le16_to_cpu(cap);
    229. 

  229. 	if (cap & (WLAN_CAPABILITY_IBSS|WLAN_CAPABILITY_BSS)) {
    230. 

  230. 		if (cap & WLAN_CAPABILITY_BSS)
    231. 

  231. 			iwe.u.mode = (u32)IW_MODE_MASTER;
    232. 

  232. 		else
    233. 

  233. 			iwe.u.mode = (u32)IW_MODE_ADHOC;
    234. 

  234. 		start = iwe_stream_add_event(info, start, stop, &iwe,
    235. 

  235. 			IW_EV_UINT_LEN);
    236. 

  236. 	}
    237. 

  237. 	/* Add frequency/channel */
    238. 

  238. 	iwe.cmd = SIOCGIWFREQ;
    239. 

  239. 	{
    240. 

  240. 		/*  check legel index */
    241. 

  241. 		u8 dsconfig = pnetwork->network.Configuration.DSConfig;
    242. 

  242. 		if (dsconfig >= 1 && dsconfig <= sizeof(
    243. 

  243. 		    ieee80211_wlan_frequencies) / sizeof(long))
    244. 

  244. 			iwe.u.freq.m = (s32)(ieee80211_wlan_frequencies[
    245. 

  245. 				       pnetwork->network.Configuration.
    246. 

  246. 				       DSConfig - 1] * 100000);
    247. 

  247. 		else
    248. 

  248. 			iwe.u.freq.m = 0;
    249. 

  249. 	}
    250. 

  250. 	iwe.u.freq.e = (s16)1;
    251. 

  251. 	iwe.u.freq.i = (u8)pnetwork->network.Configuration.DSConfig;
    252. 

  252. 	start = iwe_stream_add_event(info, start, stop, &iwe,
    253. 

  253. 		IW_EV_FREQ_LEN);
    254. 

  254. 	/* Add encryption capability */
    255. 

  255. 	iwe.cmd = SIOCGIWENCODE;
    256. 

  256. 	if (cap & WLAN_CAPABILITY_PRIVACY)
    257. 

  257. 		iwe.u.data.flags = (u16)(IW_ENCODE_ENABLED |
    258. 

  258. 				    IW_ENCODE_NOKEY);
    259. 

  259. 	else
    260. 

  260. 		iwe.u.data.flags = (u16)(IW_ENCODE_DISABLED);
    261. 

  261. 	iwe.u.data.length = (u16)0;
    262. 

  262. 	start = iwe_stream_add_point(info, start, stop, &iwe,
    263. 

  263. 		pnetwork->network.Ssid.Ssid);
    264. 

  264. 	/*Add basic and extended rates */
    265. 

  265. 	current_val = start + iwe_stream_lcp_len(info);
    266. 

  266. 	iwe.cmd = SIOCGIWRATE;
    267. 

  267. 	iwe.u.bitrate.fixed = 0;
    268. 

  268. 	iwe.u.bitrate.disabled = 0;
    269. 

  269. 	iwe.u.bitrate.value = 0;
    270. 

  270. 	i = 0;
    271. 

  271. 	while (pnetwork->network.SupportedRates[i] != 0) {
    272. 

  272. 		/* Bit rate given in 500 kb/s units */
    273. 

  273. 		iwe.u.bitrate.value = (pnetwork->network.SupportedRates[i++] &
    274. 

  274. 				      0x7F) * 500000;
    275. 

  275. 		current_val = iwe_stream_add_value(info, start, current_val,
    276. 

  276. 			      stop, &iwe, IW_EV_PARAM_LEN);
    277. 

  277. 	}
    278. 

  278. 	/* Check if we added any event */
    279. 

  279. 	if ((current_val - start) > iwe_stream_lcp_len(info))
    280. 

  280. 		start = current_val;
    281. 

  281. 	/* parsing WPA/WPA2 IE */
    282. 

  282. 	{
    283. 

  283. 		u16 wpa_len = 0, rsn_len = 0;
    284. 

  284. 		int n;
    285. 

  285. 		sint out_len = 0;
    286. 

  286. 		out_len = r8712_get_sec_ie(pnetwork->network.IEs,
    287. 

  287. 					   pnetwork->network.
    288. 

  288. 					   IELength, rsn_ie, &rsn_len,
    289. 

  289. 					   wpa_ie, &wpa_len);
    290. 

  290. 		if (wpa_len > 0) {
    291. 

  291. 			memset(buf, 0, MAX_WPA_IE_LEN);
    292. 

  292. 			n = sprintf(buf, "wpa_ie=");
    293. 

  293. 			for (i = 0; i < wpa_len; i++) {
    294. 

  294. 				n += snprintf(buf + n, MAX_WPA_IE_LEN - n,
    295. 

  295. 							"%02x", wpa_ie[i]);
    296. 

  296. 				if (n >= MAX_WPA_IE_LEN)
    297. 

  297. 					break;
    298. 

  298. 			}
    299. 

  299. 			memset(&iwe, 0, sizeof(iwe));
    300. 

  300. 			iwe.cmd = IWEVCUSTOM;
    301. 

  301. 			iwe.u.data.length = (u16)strlen(buf);
    302. 

  302. 			start = iwe_stream_add_point(info, start, stop,
    303. 

  303. 				&iwe, buf);
    304. 

  304. 			memset(&iwe, 0, sizeof(iwe));
    305. 

  305. 			iwe.cmd = IWEVGENIE;
    306. 

  306. 			iwe.u.data.length = (u16)wpa_len;
    307. 

  307. 			start = iwe_stream_add_point(info, start, stop,
    308. 

  308. 				&iwe, wpa_ie);
    309. 

  309. 		}
    310. 

  310. 		if (rsn_len > 0) {
    311. 

  311. 			memset(buf, 0, MAX_WPA_IE_LEN);
    312. 

  312. 			n = sprintf(buf, "rsn_ie=");
    313. 

  313. 			for (i = 0; i < rsn_len; i++) {
    314. 

  314. 				n += snprintf(buf + n, MAX_WPA_IE_LEN - n,
    315. 

  315. 							"%02x", rsn_ie[i]);
    316. 

  316. 				if (n >= MAX_WPA_IE_LEN)
    317. 

  317. 					break;
    318. 

  318. 			}
    319. 

  319. 			memset(&iwe, 0, sizeof(iwe));
    320. 

  320. 			iwe.cmd = IWEVCUSTOM;
    321. 

  321. 			iwe.u.data.length = strlen(buf);
    322. 

  322. 			start = iwe_stream_add_point(info, start, stop,
    323. 

  323. 				&iwe, buf);
    324. 

  324. 			memset(&iwe, 0, sizeof(iwe));
    325. 

  325. 			iwe.cmd = IWEVGENIE;
    326. 

  326. 			iwe.u.data.length = rsn_len;
    327. 

  327. 			start = iwe_stream_add_point(info, start, stop, &iwe,
    328. 

  328. 				rsn_ie);
    329. 

  329. 		}
    330. 

  330. 	}
    331. 

  331. 

  332. 	{ /* parsing WPS IE */
    333. 

  333. 		uint wps_ielen;
    334. 

  334. 

  335. 		if (r8712_get_wps_ie(pnetwork->network.IEs,
    336. 

  336. 		    pnetwork->network.IELength,
    337. 

  337. 		    wps_ie, &wps_ielen) == true) {
    338. 

  338. 			if (wps_ielen > 2) {
    339. 

  339. 				iwe.cmd = IWEVGENIE;
    340. 

  340. 				iwe.u.data.length = (u16)wps_ielen;
    341. 

  341. 				start = iwe_stream_add_point(info, start, stop,
    342. 

  342. 					&iwe, wps_ie);
    343. 

  343. 			}
    344. 

  344. 		}
    345. 

  345. 	}
    346. 

  346. 	/* Add quality statistics */
    347. 

  347. 	iwe.cmd = IWEVQUAL;
    348. 

  348. 	rssi = r8712_signal_scale_mapping(pnetwork->network.Rssi);
    349. 

  349. 	/* we only update signal_level (signal strength) that is rssi. */
    350. 

  350. 	iwe.u.qual.updated = (u8)(IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_UPDATED |
    351. 

  351. 				  IW_QUAL_NOISE_INVALID);
    352. 

  352. 	iwe.u.qual.level = rssi;  /* signal strength */
    353. 

  353. 	iwe.u.qual.qual = 0; /* signal quality */
    354. 

  354. 	iwe.u.qual.noise = 0; /* noise level */
    355. 

  355. 	start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
    356. 

  356. 	/* how to translate rssi to ?% */
    357. 

  357. 	kfree(buf);
    358. 

  358. 	kfree(wpa_ie);
    359. 

  359. 	kfree(rsn_ie);
    360. 

  360. 	kfree(wps_ie);
    361. 

  361. 	return start;
    362. 

  362. }
    363. 

  363. 

  364. static int wpa_set_auth_algs(struct net_device *dev, u32 value)
    365. 

  365. {
    366. 

  366. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    367. 

  367. 	int ret = 0;
    368. 

  368. 

  369. 	if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) {
    370. 

  370. 		padapter->securitypriv.ndisencryptstatus =
    371. 

  371. 						 Ndis802_11Encryption1Enabled;
    372. 

  372. 		padapter->securitypriv.ndisauthtype =
    373. 

  373. 						 Ndis802_11AuthModeAutoSwitch;
    374. 

  374. 		padapter->securitypriv.AuthAlgrthm = 3;
    375. 

  375. 	} else if (value & AUTH_ALG_SHARED_KEY) {
    376. 

  376. 		padapter->securitypriv.ndisencryptstatus =
    377. 

  377. 						 Ndis802_11Encryption1Enabled;
    378. 

  378. 		padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
    379. 

  379. 		padapter->securitypriv.AuthAlgrthm = 1;
    380. 

  380. 	} else if (value & AUTH_ALG_OPEN_SYSTEM) {
    381. 

  381. 		if (padapter->securitypriv.ndisauthtype <
    382. 

  382. 						 Ndis802_11AuthModeWPAPSK) {
    383. 

  383. 			padapter->securitypriv.ndisauthtype =
    384. 

  384. 						 Ndis802_11AuthModeOpen;
    385. 

  385. 			padapter->securitypriv.AuthAlgrthm = 0;
    386. 

  386. 		}
    387. 

  387. 	} else
    388. 

  388. 		ret = -EINVAL;
    389. 

  389. 	return ret;
    390. 

  390. }
    391. 

  391. 

  392. static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param,
    393. 

  393. 			      u32 param_len)
    394. 

  394. {
    395. 

  395. 	int ret = 0;
    396. 

  396. 	u32 wep_key_idx, wep_key_len = 0;
    397. 

  397. 	struct NDIS_802_11_WEP	 *pwep = NULL;
    398. 

  398. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    399. 

  399. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    400. 

  400. 	struct security_priv *psecuritypriv = &padapter->securitypriv;
    401. 

  401. 

  402. 	param->u.crypt.err = 0;
    403. 

  403. 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
    404. 

  404. 	if (param_len != (u32)((u8 *) param->u.crypt.key - (u8 *)param) +
    405. 

  405. 			 param->u.crypt.key_len)
    406. 

  406. 		return -EINVAL;
    407. 

  407. 	if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
    408. 

  408. 	    param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
    409. 

  409. 	    param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
    410. 

  410. 		if (param->u.crypt.idx >= WEP_KEYS) {
    411. 

  411. 			/* for large key indices, set the default (0) */
    412. 

  412. 			param->u.crypt.idx = 0;
    413. 

  413. 		}
    414. 

  414. 	} else
    415. 

  415. 		return -EINVAL;
    416. 

  416. 	if (strcmp(param->u.crypt.alg, "WEP") == 0) {
    417. 

  417. 		printk(KERN_INFO "r8712u: wpa_set_encryption, crypt.alg ="
    418. 

  418. 		       " WEP\n");
    419. 

  419. 		padapter->securitypriv.ndisencryptstatus =
    420. 

  420. 			     Ndis802_11Encryption1Enabled;
    421. 

  421. 		padapter->securitypriv.PrivacyAlgrthm = _WEP40_;
    422. 

  422. 		padapter->securitypriv.XGrpPrivacy = _WEP40_;
    423. 

  423. 		wep_key_idx = param->u.crypt.idx;
    424. 

  424. 		wep_key_len = param->u.crypt.key_len;
    425. 

  425. 		if (wep_key_idx >= WEP_KEYS)
    426. 

  426. 			wep_key_idx = 0;
    427. 

  427. 		if (wep_key_len > 0) {
    428. 

  428. 			wep_key_len = wep_key_len <= 5 ? 5 : 13;
    429. 

  429. 			pwep = (struct NDIS_802_11_WEP *)_malloc((u32)
    430. 

  430. 			       (wep_key_len +
    431. 

  431. 			       FIELD_OFFSET(struct NDIS_802_11_WEP,
    432. 

  432. 			       KeyMaterial)));
    433. 

  433. 			if (pwep == NULL)
    434. 

  434. 				return -ENOMEM;
    435. 

  435. 			memset(pwep, 0, sizeof(struct NDIS_802_11_WEP));
    436. 

  436. 			pwep->KeyLength = wep_key_len;
    437. 

  437. 			pwep->Length = wep_key_len +
    438. 

  438. 				 FIELD_OFFSET(struct NDIS_802_11_WEP,
    439. 

  439. 				 KeyMaterial);
    440. 

  440. 			if (wep_key_len == 13) {
    441. 

  441. 				padapter->securitypriv.PrivacyAlgrthm =
    442. 

  442. 					 _WEP104_;
    443. 

  443. 				padapter->securitypriv.XGrpPrivacy =
    444. 

  444. 					 _WEP104_;
    445. 

  445. 			}
    446. 

  446. 		} else
    447. 

  447. 			return -EINVAL;
    448. 

  448. 		pwep->KeyIndex = wep_key_idx;
    449. 

  449. 		pwep->KeyIndex |= 0x80000000;
    450. 

  450. 		memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength);
    451. 

  451. 		if (param->u.crypt.set_tx) {
    452. 

  452. 			if (r8712_set_802_11_add_wep(padapter, pwep) ==
    453. 

  453. 			    (u8)_FAIL)
    454. 

  454. 				ret = -EOPNOTSUPP;
    455. 

  455. 		} else {
    456. 

  456. 			/* don't update "psecuritypriv->PrivacyAlgrthm" and
    457. 

  457. 			 * "psecuritypriv->PrivacyKeyIndex=keyid", but can
    458. 

  458. 			 * r8712_set_key to fw/cam
    459. 

  459. 			 */
    460. 

  460. 			if (wep_key_idx >= WEP_KEYS) {
    461. 

  461. 				ret = -EOPNOTSUPP;
    462. 

  462. 				goto exit;
    463. 

  463. 			}
    464. 

  464. 			memcpy(&(psecuritypriv->DefKey[wep_key_idx].
    465. 

  465. 				skey[0]), pwep->KeyMaterial,
    466. 

  466. 				pwep->KeyLength);
    467. 

  467. 			psecuritypriv->DefKeylen[wep_key_idx] =
    468. 

  468. 				pwep->KeyLength;
    469. 

  469. 			r8712_set_key(padapter, psecuritypriv, wep_key_idx);
    470. 

  470. 		}
    471. 

  471. 		goto exit;
    472. 

  472. 	}
    473. 

  473. 	if (padapter->securitypriv.AuthAlgrthm == 2) { /* 802_1x */
    474. 

  474. 		struct sta_info *psta, *pbcmc_sta;
    475. 

  475. 		struct sta_priv *pstapriv = &padapter->stapriv;
    476. 

  476. 

  477. 		if (check_fwstate(pmlmepriv, WIFI_STATION_STATE |
    478. 

  478. 		    WIFI_MP_STATE) == true) { /* sta mode */
    479. 

  479. 			psta = r8712_get_stainfo(pstapriv,
    480. 

  480. 						 get_bssid(pmlmepriv));
    481. 

  481. 			if (psta) {
    482. 

  482. 				psta->ieee8021x_blocked = false;
    483. 

  483. 				if ((padapter->securitypriv.ndisencryptstatus ==
    484. 

  484. 				    Ndis802_11Encryption2Enabled) ||
    485. 

  485. 				    (padapter->securitypriv.ndisencryptstatus ==
    486. 

  486. 				    Ndis802_11Encryption3Enabled))
    487. 

  487. 					psta->XPrivacy = padapter->
    488. 

  488. 					    securitypriv.PrivacyAlgrthm;
    489. 

  489. 				if (param->u.crypt.set_tx == 1)
    490. 

  490. 					handle_pairwise_key(psta, param,
    491. 

  491. 							    padapter);
    492. 

  492. 				else /* group key */
    493. 

  493. 					handle_group_key(param, padapter);
    494. 

  494. 			}
    495. 

  495. 			pbcmc_sta = r8712_get_bcmc_stainfo(padapter);
    496. 

  496. 			if (pbcmc_sta) {
    497. 

  497. 				pbcmc_sta->ieee8021x_blocked = false;
    498. 

  498. 				if ((padapter->securitypriv.ndisencryptstatus ==
    499. 

  499. 				    Ndis802_11Encryption2Enabled) ||
    500. 

  500. 				    (padapter->securitypriv.ndisencryptstatus ==
    501. 

  501. 				    Ndis802_11Encryption3Enabled))
    502. 

  502. 					pbcmc_sta->XPrivacy =
    503. 

  503. 					  padapter->securitypriv.
    504. 

  504. 					  PrivacyAlgrthm;
    505. 

  505. 			}
    506. 

  506. 		}
    507. 

  507. 	}
    508. 

  508. exit:
    509. 

  509. 	kfree((u8 *)pwep);
    510. 

  510. 	return ret;
    511. 

  511. }
    512. 

  512. 

  513. static int r871x_set_wpa_ie(struct _adapter *padapter, char *pie,
    514. 

  514. 			    unsigned short ielen)
    515. 

  515. {
    516. 

  516. 	u8 *buf = NULL, *pos = NULL;
    517. 

  517. 	int group_cipher = 0, pairwise_cipher = 0;
    518. 

  518. 	int ret = 0;
    519. 

  519. 

  520. 	if ((ielen > MAX_WPA_IE_LEN) || (pie == NULL))
    521. 

  521. 		return -EINVAL;
    522. 

  522. 	if (ielen) {
    523. 

  523. 		buf = _malloc(ielen);
    524. 

  524. 		if (buf == NULL)
    525. 

  525. 			return -ENOMEM;
    526. 

  526. 		memcpy(buf, pie , ielen);
    527. 

  527. 		pos = buf;
    528. 

  528. 		if (ielen < RSN_HEADER_LEN) {
    529. 

  529. 			ret  = -1;
    530. 

  530. 			goto exit;
    531. 

  531. 		}
    532. 

  532. 		if (r8712_parse_wpa_ie(buf, ielen, &group_cipher,
    533. 

  533. 		    &pairwise_cipher) == _SUCCESS) {
    534. 

  534. 			padapter->securitypriv.AuthAlgrthm = 2;
    535. 

  535. 			padapter->securitypriv.ndisauthtype =
    536. 

  536. 				  Ndis802_11AuthModeWPAPSK;
    537. 

  537. 		}
    538. 

  538. 		if (r8712_parse_wpa2_ie(buf, ielen, &group_cipher,
    539. 

  539. 		    &pairwise_cipher) == _SUCCESS) {
    540. 

  540. 			padapter->securitypriv.AuthAlgrthm = 2;
    541. 

  541. 			padapter->securitypriv.ndisauthtype =
    542. 

  542. 				  Ndis802_11AuthModeWPA2PSK;
    543. 

  543. 		}
    544. 

  544. 		switch (group_cipher) {
    545. 

  545. 		case WPA_CIPHER_NONE:
    546. 

  546. 			padapter->securitypriv.XGrpPrivacy =
    547. 

  547. 				 _NO_PRIVACY_;
    548. 

  548. 			padapter->securitypriv.ndisencryptstatus =
    549. 

  549. 				 Ndis802_11EncryptionDisabled;
    550. 

  550. 			break;
    551. 

  551. 		case WPA_CIPHER_WEP40:
    552. 

  552. 			padapter->securitypriv.XGrpPrivacy = _WEP40_;
    553. 

  553. 			padapter->securitypriv.ndisencryptstatus =
    554. 

  554. 				 Ndis802_11Encryption1Enabled;
    555. 

  555. 			break;
    556. 

  556. 		case WPA_CIPHER_TKIP:
    557. 

  557. 			padapter->securitypriv.XGrpPrivacy = _TKIP_;
    558. 

  558. 			padapter->securitypriv.ndisencryptstatus =
    559. 

  559. 				 Ndis802_11Encryption2Enabled;
    560. 

  560. 			break;
    561. 

  561. 		case WPA_CIPHER_CCMP:
    562. 

  562. 			padapter->securitypriv.XGrpPrivacy = _AES_;
    563. 

  563. 			padapter->securitypriv.ndisencryptstatus =
    564. 

  564. 				 Ndis802_11Encryption3Enabled;
    565. 

  565. 			break;
    566. 

  566. 		case WPA_CIPHER_WEP104:
    567. 

  567. 			padapter->securitypriv.XGrpPrivacy = _WEP104_;
    568. 

  568. 			padapter->securitypriv.ndisencryptstatus =
    569. 

  569. 				 Ndis802_11Encryption1Enabled;
    570. 

  570. 			break;
    571. 

  571. 		}
    572. 

  572. 		switch (pairwise_cipher) {
    573. 

  573. 		case WPA_CIPHER_NONE:
    574. 

  574. 			padapter->securitypriv.PrivacyAlgrthm =
    575. 

  575. 				 _NO_PRIVACY_;
    576. 

  576. 			padapter->securitypriv.ndisencryptstatus =
    577. 

  577. 				 Ndis802_11EncryptionDisabled;
    578. 

  578. 			break;
    579. 

  579. 		case WPA_CIPHER_WEP40:
    580. 

  580. 			padapter->securitypriv.PrivacyAlgrthm = _WEP40_;
    581. 

  581. 			padapter->securitypriv.ndisencryptstatus =
    582. 

  582. 				 Ndis802_11Encryption1Enabled;
    583. 

  583. 			break;
    584. 

  584. 		case WPA_CIPHER_TKIP:
    585. 

  585. 			padapter->securitypriv.PrivacyAlgrthm = _TKIP_;
    586. 

  586. 			padapter->securitypriv.ndisencryptstatus =
    587. 

  587. 				 Ndis802_11Encryption2Enabled;
    588. 

  588. 			break;
    589. 

  589. 		case WPA_CIPHER_CCMP:
    590. 

  590. 			padapter->securitypriv.PrivacyAlgrthm = _AES_;
    591. 

  591. 			padapter->securitypriv.ndisencryptstatus =
    592. 

  592. 				 Ndis802_11Encryption3Enabled;
    593. 

  593. 			break;
    594. 

  594. 		case WPA_CIPHER_WEP104:
    595. 

  595. 			padapter->securitypriv.PrivacyAlgrthm = _WEP104_;
    596. 

  596. 			padapter->securitypriv.ndisencryptstatus =
    597. 

  597. 				 Ndis802_11Encryption1Enabled;
    598. 

  598. 			break;
    599. 

  599. 		}
    600. 

  600. 		padapter->securitypriv.wps_phase = false;
    601. 

  601. 		{/* set wps_ie */
    602. 

  602. 			u16 cnt = 0;
    603. 

  603. 			u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
    604. 

  604. 

  605. 			while (cnt < ielen) {
    606. 

  606. 				eid = buf[cnt];
    607. 

  607. 

  608. 				if ((eid == _VENDOR_SPECIFIC_IE_) &&
    609. 

  609. 				    (!memcmp(&buf[cnt+2], wps_oui, 4))) {
    610. 

  610. 					printk(KERN_INFO "r8712u: "
    611. 

  611. 					       "SET WPS_IE\n");
    612. 

  612. 					padapter->securitypriv.wps_ie_len =
    613. 

  613. 					    ((buf[cnt+1] + 2) <
    614. 

  614. 					    (MAX_WPA_IE_LEN << 2)) ?
    615. 

  615. 					    (buf[cnt + 1] + 2) :
    616. 

  616. 					    (MAX_WPA_IE_LEN << 2);
    617. 

  617. 					memcpy(padapter->securitypriv.wps_ie,
    618. 

  618. 					    &buf[cnt],
    619. 

  619. 					    padapter->securitypriv.wps_ie_len);
    620. 

  620. 					padapter->securitypriv.wps_phase =
    621. 

  621. 								 true;
    622. 

  622. 					printk(KERN_INFO "r8712u: SET WPS_IE,"
    623. 

  623. 					    " wps_phase==true\n");
    624. 

  624. 					cnt += buf[cnt+1]+2;
    625. 

  625. 					break;
    626. 

  626. 				} else
    627. 

  627. 					cnt += buf[cnt + 1] + 2;
    628. 

  628. 			}
    629. 

  629. 		}
    630. 

  630. 	}
    631. 

  631. exit:
    632. 

  632. 	kfree(buf);
    633. 

  633. 	return ret;
    634. 

  634. }
    635. 

  635. 

  636. static int r8711_wx_get_name(struct net_device *dev,
    637. 

  637. 			     struct iw_request_info *info,
    638. 

  638. 			     union iwreq_data *wrqu, char *extra)
    639. 

  639. {
    640. 

  640. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    641. 

  641. 	u32 ht_ielen = 0;
    642. 

  642. 	char *p;
    643. 

  643. 	u8 ht_cap = false;
    644. 

  644. 	struct	mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
    645. 

  645. 	struct ndis_wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
    646. 

  646. 	NDIS_802_11_RATES_EX *prates = NULL;
    647. 

  647. 

  648. 	if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) ==
    649. 

  649. 	    true) {
    650. 

  650. 		/* parsing HT_CAP_IE */
    651. 

  651. 		p = r8712_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_,
    652. 

  652. 				 &ht_ielen, pcur_bss->IELength - 12);
    653. 

  653. 		if (p && ht_ielen > 0)
    654. 

  654. 			ht_cap = true;
    655. 

  655. 		prates = &pcur_bss->SupportedRates;
    656. 

  656. 		if (r8712_is_cckratesonly_included((u8 *)prates) == true) {
    657. 

  657. 			if (ht_cap == true)
    658. 

  658. 				snprintf(wrqu->name, IFNAMSIZ,
    659. 

  659. 					 "IEEE 802.11bn");
    660. 

  660. 			else
    661. 

  661. 				snprintf(wrqu->name, IFNAMSIZ,
    662. 

  662. 					 "IEEE 802.11b");
    663. 

  663. 		} else if ((r8712_is_cckrates_included((u8 *)prates)) == true) {
    664. 

  664. 			if (ht_cap == true)
    665. 

  665. 				snprintf(wrqu->name, IFNAMSIZ,
    666. 

  666. 					 "IEEE 802.11bgn");
    667. 

  667. 			else
    668. 

  668. 				snprintf(wrqu->name, IFNAMSIZ,
    669. 

  669. 					 "IEEE 802.11bg");
    670. 

  670. 		} else {
    671. 

  671. 			if (ht_cap == true)
    672. 

  672. 				snprintf(wrqu->name, IFNAMSIZ,
    673. 

  673. 					 "IEEE 802.11gn");
    674. 

  674. 			else
    675. 

  675. 				snprintf(wrqu->name, IFNAMSIZ,
    676. 

  676. 					 "IEEE 802.11g");
    677. 

  677. 		}
    678. 

  678. 	} else
    679. 

  679. 		snprintf(wrqu->name, IFNAMSIZ, "unassociated");
    680. 

  680. 	return 0;
    681. 

  681. }
    682. 

  682. 

  683. static const long frequency_list[] = {
    684. 

  684. 	2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462,
    685. 

  685. 	2467, 2472, 2484, 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
    686. 

  686. 	5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210,
    687. 

  687. 	5220, 5230, 5240, 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560,
    688. 

  688. 	5580, 5600, 5620, 5640, 5660, 5680, 5700, 5745, 5765, 5785, 5805,
    689. 

  689. 	5825
    690. 

  690. };
    691. 

  691. 

  692. static int r8711_wx_set_freq(struct net_device *dev,
    693. 

  693. 			     struct iw_request_info *info,
    694. 

  694. 			     union iwreq_data *wrqu, char *extra)
    695. 

  695. {
    696. 

  696. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    697. 

  697. 	struct iw_freq *fwrq = &wrqu->freq;
    698. 

  698. 	int rc = 0;
    699. 

  699. 

  700. /* If setting by frequency, convert to a channel */
    701. 

  701. 	if ((fwrq->e == 1) &&
    702. 

  702. 	  (fwrq->m >= (int) 2.412e8) &&
    703. 

  703. 	  (fwrq->m <= (int) 2.487e8)) {
    704. 

  704. 		int f = fwrq->m / 100000;
    705. 

  705. 		int c = 0;
    706. 

  706. 		while ((c < 14) && (f != frequency_list[c]))
    707. 

  707. 			c++;
    708. 

  708. 		fwrq->e = 0;
    709. 

  709. 		fwrq->m = c + 1;
    710. 

  710. 	}
    711. 

  711. 	/* Setting by channel number */
    712. 

  712. 	if ((fwrq->m > 14) || (fwrq->e > 0))
    713. 

  713. 		rc = -EOPNOTSUPP;
    714. 

  714. 	else {
    715. 

  715. 		int channel = fwrq->m;
    716. 

  716. 		if ((channel < 1) || (channel > 14))
    717. 

  717. 			rc = -EINVAL;
    718. 

  718. 		else {
    719. 

  719. 			/* Yes ! We can set it !!! */
    720. 

  720. 			padapter->registrypriv.channel = channel;
    721. 

  721. 		}
    722. 

  722. 	}
    723. 

  723. 	return rc;
    724. 

  724. }
    725. 

  725. 

  726. static int r8711_wx_get_freq(struct net_device *dev,
    727. 

  727. 			     struct iw_request_info *info,
    728. 

  728. 			     union iwreq_data *wrqu, char *extra)
    729. 

  729. {
    730. 

  730. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    731. 

  731. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    732. 

  732. 	struct ndis_wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
    733. 

  733. 

  734. 	if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
    735. 

  735. 		wrqu->freq.m = ieee80211_wlan_frequencies[
    736. 

  736. 			       pcur_bss->Configuration.DSConfig-1] * 100000;
    737. 

  737. 		wrqu->freq.e = 1;
    738. 

  738. 		wrqu->freq.i = pcur_bss->Configuration.DSConfig;
    739. 

  739. 	} else
    740. 

  740. 		return -1;
    741. 

  741. 	return 0;
    742. 

  742. }
    743. 

  743. 

  744. static int r8711_wx_set_mode(struct net_device *dev,
    745. 

  745. 			     struct iw_request_info *a,
    746. 

  746. 			     union iwreq_data *wrqu, char *b)
    747. 

  747. {
    748. 

  748. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    749. 

  749. 	enum NDIS_802_11_NETWORK_INFRASTRUCTURE networkType;
    750. 

  750. 

  751. 	switch (wrqu->mode) {
    752. 

  752. 	case IW_MODE_AUTO:
    753. 

  753. 		networkType = Ndis802_11AutoUnknown;
    754. 

  754. 		break;
    755. 

  755. 	case IW_MODE_ADHOC:
    756. 

  756. 		networkType = Ndis802_11IBSS;
    757. 

  757. 		break;
    758. 

  758. 	case IW_MODE_MASTER:
    759. 

  759. 		networkType = Ndis802_11APMode;
    760. 

  760. 		break;
    761. 

  761. 	case IW_MODE_INFRA:
    762. 

  762. 		networkType = Ndis802_11Infrastructure;
    763. 

  763. 		break;
    764. 

  764. 	default:
    765. 

  765. 		return -EINVAL;
    766. 

  766. 	}
    767. 

  767. 	if (Ndis802_11APMode == networkType)
    768. 

  768. 		r8712_setopmode_cmd(padapter, networkType);
    769. 

  769. 	else
    770. 

  770. 		r8712_setopmode_cmd(padapter, Ndis802_11AutoUnknown);
    771. 

  771. 	if (!r8712_set_802_11_infrastructure_mode(padapter, networkType))
    772. 

  772. 		return -1;
    773. 

  773. 	return 0;
    774. 

  774. }
    775. 

  775. 

  776. static int r8711_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
    777. 

  777. 			     union iwreq_data *wrqu, char *b)
    778. 

  778. {
    779. 

  779. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    780. 

  780. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    781. 

  781. 

  782. 	if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true)
    783. 

  783. 		wrqu->mode = IW_MODE_INFRA;
    784. 

  784. 	else if (check_fwstate(pmlmepriv,
    785. 

  785. 		 WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE) == true)
    786. 

  786. 		wrqu->mode = IW_MODE_ADHOC;
    787. 

  787. 	else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
    788. 

  788. 		wrqu->mode = IW_MODE_MASTER;
    789. 

  789. 	else
    790. 

  790. 		wrqu->mode = IW_MODE_AUTO;
    791. 

  791. 	return 0;
    792. 

  792. }
    793. 

  793. 

  794. static int r871x_wx_set_pmkid(struct net_device *dev,
    795. 

  795. 			     struct iw_request_info *a,
    796. 

  796. 			     union iwreq_data *wrqu, char *extra)
    797. 

  797. {
    798. 

  798. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    799. 

  799. 	struct security_priv *psecuritypriv = &padapter->securitypriv;
    800. 

  800. 	struct iw_pmksa *pPMK = (struct iw_pmksa *) extra;
    801. 

  801. 	u8 strZeroMacAddress[ETH_ALEN] = {0x00};
    802. 

  802. 	u8 strIssueBssid[ETH_ALEN] = {0x00};
    803. 

  803. 	u8 j, blInserted = false;
    804. 

  804. 	int intReturn = false;
    805. 

  805. 

  806. /*
    807. 

  807. 	There are the BSSID information in the bssid.sa_data array.
    808. 

  808. 	If cmd is IW_PMKSA_FLUSH, it means the wpa_suppplicant wants to clear
    809. 

  809. 	 all the PMKID information. If cmd is IW_PMKSA_ADD, it means the
    810. 

  810. 	  wpa_supplicant wants to add a PMKID/BSSID to driver.
    811. 

  811. 	If cmd is IW_PMKSA_REMOVE, it means the wpa_supplicant wants to
    812. 

  812. 	  remove a PMKID/BSSID from driver.
    813. 

  813. */
    814. 

  814. 	if (pPMK == NULL)
    815. 

  815. 		return -EINVAL;
    816. 

  816. 	memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN);
    817. 

  817. 	switch (pPMK->cmd) {
    818. 

  818. 	case IW_PMKSA_ADD:
    819. 

  819. 		if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN))
    820. 

  820. 			return intReturn;
    821. 

  821. 		else
    822. 

  822. 			intReturn = true;
    823. 

  823. 		blInserted = false;
    824. 

  824. 		/* overwrite PMKID */
    825. 

  825. 		for (j = 0 ; j < NUM_PMKID_CACHE; j++) {
    826. 

  826. 			if (!memcmp(psecuritypriv->PMKIDList[j].Bssid,
    827. 

  827. 			    strIssueBssid, ETH_ALEN)) {
    828. 

  828. 				/* BSSID is matched, the same AP => rewrite
    829. 

  829. 				 * with new PMKID. */
    830. 

  830. 				printk(KERN_INFO "r8712u: r871x_wx_set_pmkid:"
    831. 

  831. 				    " BSSID exists in the PMKList.\n");
    832. 

  832. 				memcpy(psecuritypriv->PMKIDList[j].PMKID,
    833. 

  833. 					pPMK->pmkid, IW_PMKID_LEN);
    834. 

  834. 				psecuritypriv->PMKIDList[j].bUsed = true;
    835. 

  835. 				psecuritypriv->PMKIDIndex = j + 1;
    836. 

  836. 				blInserted = true;
    837. 

  837. 				break;
    838. 

  838. 			}
    839. 

  839. 		}
    840. 

  840. 		if (!blInserted) {
    841. 

  841. 			/* Find a new entry */
    842. 

  842. 			printk(KERN_INFO "r8712u: r871x_wx_set_pmkid: Use the"
    843. 

  843. 			    " new entry index = %d for this PMKID.\n",
    844. 

  844. 			    psecuritypriv->PMKIDIndex);
    845. 

  845. 			memcpy(psecuritypriv->PMKIDList[psecuritypriv->
    846. 

  846. 				PMKIDIndex].Bssid, strIssueBssid, ETH_ALEN);
    847. 

  847. 			memcpy(psecuritypriv->PMKIDList[psecuritypriv->
    848. 

  848. 				PMKIDIndex].PMKID, pPMK->pmkid, IW_PMKID_LEN);
    849. 

  849. 			psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].
    850. 

  850. 				bUsed = true;
    851. 

  851. 			psecuritypriv->PMKIDIndex++ ;
    852. 

  852. 			if (psecuritypriv->PMKIDIndex == NUM_PMKID_CACHE)
    853. 

  853. 				psecuritypriv->PMKIDIndex = 0;
    854. 

  854. 		}
    855. 

  855. 		break;
    856. 

  856. 	case IW_PMKSA_REMOVE:
    857. 

  857. 		intReturn = true;
    858. 

  858. 		for (j = 0; j < NUM_PMKID_CACHE; j++) {
    859. 

  859. 			if (!memcmp(psecuritypriv->PMKIDList[j].Bssid,
    860. 

  860. 			    strIssueBssid, ETH_ALEN)) {
    861. 

  861. 				/* BSSID is matched, the same AP => Remove
    862. 

  862. 				 * this PMKID information and reset it. */
    863. 

  863. 				memset(psecuritypriv->PMKIDList[j].Bssid,
    864. 

  864. 					0x00, ETH_ALEN);
    865. 

  865. 				psecuritypriv->PMKIDList[j].bUsed = false;
    866. 

  866. 				break;
    867. 

  867. 			}
    868. 

  868. 		}
    869. 

  869. 		break;
    870. 

  870. 	case IW_PMKSA_FLUSH:
    871. 

  871. 		memset(psecuritypriv->PMKIDList, 0,
    872. 

  872. 			sizeof(struct RT_PMKID_LIST) * NUM_PMKID_CACHE);
    873. 

  873. 		psecuritypriv->PMKIDIndex = 0;
    874. 

  874. 		intReturn = true;
    875. 

  875. 		break;
    876. 

  876. 	default:
    877. 

  877. 		printk(KERN_INFO "r8712u: r871x_wx_set_pmkid: "
    878. 

  878. 		       "unknown Command\n");
    879. 

  879. 		intReturn = false;
    880. 

  880. 		break;
    881. 

  881. 	}
    882. 

  882. 	return intReturn;
    883. 

  883. }
    884. 

  884. 

  885. static int r8711_wx_get_sens(struct net_device *dev,
    886. 

  886. 			     struct iw_request_info *info,
    887. 

  887. 			     union iwreq_data *wrqu, char *extra)
    888. 

  888. {
    889. 

  889. 	wrqu->sens.value = 0;
    890. 

  890. 	wrqu->sens.fixed = 0;	/* no auto select */
    891. 

  891. 	wrqu->sens.disabled = 1;
    892. 

  892. 	return 0;
    893. 

  893. }
    894. 

  894. 

  895. static int r8711_wx_get_range(struct net_device *dev,
    896. 

  896. 				struct iw_request_info *info,
    897. 

  897. 				union iwreq_data *wrqu, char *extra)
    898. 

  898. {
    899. 

  899. 	struct iw_range *range = (struct iw_range *)extra;
    900. 

  900. 	u16 val;
    901. 

  901. 	int i;
    902. 

  902. 

  903. 	wrqu->data.length = sizeof(*range);
    904. 

  904. 	memset(range, 0, sizeof(*range));
    905. 

  905. 	/* Let's try to keep this struct in the same order as in
    906. 

  906. 	 * linux/include/wireless.h
    907. 

  907. 	 */
    908. 

  908. 

  909. 	/* TODO: See what values we can set, and remove the ones we can't
    910. 

  910. 	 * set, or fill them with some default data.
    911. 

  911. 	 */
    912. 

  912. 	/* ~5 Mb/s real (802.11b) */
    913. 

  913. 	range->throughput = 5 * 1000 * 1000;
    914. 

  914. 	/* TODO: 8711 sensitivity ? */
    915. 

  915. 	/* signal level threshold range */
    916. 

  916. 	/* percent values between 0 and 100. */
    917. 

  917. 	range->max_qual.qual = 100;
    918. 

  918. 	range->max_qual.level = 100;
    919. 

  919. 	range->max_qual.noise = 100;
    920. 

  920. 	range->max_qual.updated = 7; /* Updated all three */
    921. 

  921. 	range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
    922. 

  922. 	/* TODO: Find real 'good' to 'bad' threshol value for RSSI */
    923. 

  923. 	range->avg_qual.level = 20 + -98;
    924. 

  924. 	range->avg_qual.noise = 0;
    925. 

  925. 	range->avg_qual.updated = 7; /* Updated all three */
    926. 

  926. 	range->num_bitrates = RATE_COUNT;
    927. 

  927. 	for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++)
    928. 

  928. 		range->bitrate[i] = rtl8180_rates[i];
    929. 

  929. 	range->min_frag = MIN_FRAG_THRESHOLD;
    930. 

  930. 	range->max_frag = MAX_FRAG_THRESHOLD;
    931. 

  931. 	range->pm_capa = 0;
    932. 

  932. 	range->we_version_compiled = WIRELESS_EXT;
    933. 

  933. 	range->we_version_source = 16;
    934. 

  934. 	range->num_channels = 14;
    935. 

  935. 	for (i = 0, val = 0; i < 14; i++) {
    936. 

  936. 		/* Include only legal frequencies for some countries */
    937. 

  937. 		range->freq[val].i = i + 1;
    938. 

  938. 		range->freq[val].m = ieee80211_wlan_frequencies[i] * 100000;
    939. 

  939. 		range->freq[val].e = 1;
    940. 

  940. 		val++;
    941. 

  941. 		if (val == IW_MAX_FREQUENCIES)
    942. 

  942. 			break;
    943. 

  943. 	}
    944. 

  944. 	range->num_frequency = val;
    945. 

  945. 	range->enc_capa = IW_ENC_CAPA_WPA |
    946. 

  946. 			  IW_ENC_CAPA_WPA2 |
    947. 

  947. 			  IW_ENC_CAPA_CIPHER_TKIP |
    948. 

  948. 			  IW_ENC_CAPA_CIPHER_CCMP;
    949. 

  949. 	return 0;
    950. 

  950. }
    951. 

  951. 

  952. static int r871x_wx_set_priv(struct net_device *dev,
    953. 

  953. 				struct iw_request_info *info,
    954. 

  954. 				union iwreq_data *awrq,
    955. 

  955. 				char *extra)
    956. 

  956. {
    957. 

  957. 	int ret = 0, len = 0;
    958. 

  958. 	char *ext;
    959. 

  959. 	struct iw_point *dwrq = (struct iw_point *)awrq;
    960. 

  960. 

  961. 	len = dwrq->length;
    962. 

  962. 	ext = _malloc(len);
    963. 

  963. 	if (!ext)
    964. 

  964. 		return -ENOMEM;
    965. 

  965. 	if (copy_from_user(ext, dwrq->pointer, len)) {
    966. 

  966. 		kfree(ext);
    967. 

  967. 		return -EFAULT;
    968. 

  968. 	}
    969. 

  969. 	kfree(ext);
    970. 

  970. 	return ret;
    971. 

  971. }
    972. 

  972. 

  973. /* set bssid flow
    974. 

  974.  * s1. set_802_11_infrastructure_mode()
    975. 

  975.  * s2. set_802_11_authentication_mode()
    976. 

  976.  * s3. set_802_11_encryption_mode()
    977. 

  977.  * s4. set_802_11_bssid()
    978. 

  978.  */
    979. 

  979. static int r8711_wx_set_wap(struct net_device *dev,
    980. 

  980. 			 struct iw_request_info *info,
    981. 

  981. 			 union iwreq_data *awrq,
    982. 

  982. 			 char *extra)
    983. 

  983. {
    984. 

  984. 	int ret = -EINPROGRESS;
    985. 

  985. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    986. 

  986. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    987. 

  987. 	struct  __queue *queue = &pmlmepriv->scanned_queue;
    988. 

  988. 	struct sockaddr *temp = (struct sockaddr *)awrq;
    989. 

  989. 	unsigned long irqL;
    990. 

  990. 	struct list_head *phead;
    991. 

  991. 	u8 *dst_bssid;
    992. 

  992. 	struct wlan_network *pnetwork = NULL;
    993. 

  993. 	enum NDIS_802_11_AUTHENTICATION_MODE	authmode;
    994. 

  994. 

  995. 	if (padapter->bup == false)
    996. 

  996. 		return -1;
    997. 

  997. 	if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
    998. 

  998. 		return -1;
    999. 

  999. 	if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true)
    1000. 

  1000. 		return ret;
    1001. 

  1001. 	if (temp->sa_family != ARPHRD_ETHER)
    1002. 

  1002. 		return -EINVAL;
    1003. 

  1003. 	authmode = padapter->securitypriv.ndisauthtype;
    1004. 

  1004. 	spin_lock_irqsave(&queue->lock, irqL);
    1005. 

  1005. 	phead = get_list_head(queue);
    1006. 

  1006. 	pmlmepriv->pscanned = get_next(phead);
    1007. 

  1007. 	while (1) {
    1008. 

  1008. 		if (end_of_queue_search(phead, pmlmepriv->pscanned) == true)
    1009. 

  1009. 			break;
    1010. 

  1010. 		pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned,
    1011. 

  1011. 			   struct wlan_network, list);
    1012. 

  1012. 		pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
    1013. 

  1013. 		dst_bssid = pnetwork->network.MacAddress;
    1014. 

  1014. 		if (!memcmp(dst_bssid, temp->sa_data, ETH_ALEN)) {
    1015. 

  1015. 			if (r8712_set_802_11_infrastructure_mode(padapter,
    1016. 

  1016. 			    pnetwork->network.InfrastructureMode) == false)
    1017. 

  1017. 				ret = -1;
    1018. 

  1018. 			break;
    1019. 

  1019. 		}
    1020. 

  1020. 	}
    1021. 

  1021. 	spin_unlock_irqrestore(&queue->lock, irqL);
    1022. 

  1022. 	if (!ret) {
    1023. 

  1023. 		if (!r8712_set_802_11_authentication_mode(padapter, authmode))
    1024. 

  1024. 			ret = -1;
    1025. 

  1025. 		else {
    1026. 

  1026. 			if (!r8712_set_802_11_bssid(padapter, temp->sa_data))
    1027. 

  1027. 				ret = -1;
    1028. 

  1028. 		}
    1029. 

  1029. 	}
    1030. 

  1030. 	return ret;
    1031. 

  1031. }
    1032. 

  1032. 

  1033. static int r8711_wx_get_wap(struct net_device *dev,
    1034. 

  1034. 				struct iw_request_info *info,
    1035. 

  1035. 				union iwreq_data *wrqu, char *extra)
    1036. 

  1036. {
    1037. 

  1037. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1038. 

  1038. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1039. 

  1039. 	struct ndis_wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
    1040. 

  1040. 

  1041. 	wrqu->ap_addr.sa_family = ARPHRD_ETHER;
    1042. 

  1042. 	memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
    1043. 

  1043. 	if (check_fwstate(pmlmepriv, _FW_LINKED |
    1044. 

  1044. 	    WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE)) {
    1045. 

  1045. 		memcpy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress, ETH_ALEN);
    1046. 

  1046. 	}
    1047. 

  1047. 	return 0;
    1048. 

  1048. }
    1049. 

  1049. 

  1050. static int r871x_wx_set_mlme(struct net_device *dev,
    1051. 

  1051. 			     struct iw_request_info *info,
    1052. 

  1052. 			     union iwreq_data *wrqu, char *extra)
    1053. 

  1053. {
    1054. 

  1054. 	int ret = 0;
    1055. 

  1055. 	u16 reason;
    1056. 

  1056. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1057. 

  1057. 	struct iw_mlme *mlme = (struct iw_mlme *) extra;
    1058. 

  1058. 

  1059. 	if (mlme == NULL)
    1060. 

  1060. 		return -1;
    1061. 

  1061. 	reason = cpu_to_le16(mlme->reason_code);
    1062. 

  1062. 	switch (mlme->cmd) {
    1063. 

  1063. 	case IW_MLME_DEAUTH:
    1064. 

  1064. 		if (!r8712_set_802_11_disassociate(padapter))
    1065. 

  1065. 			ret = -1;
    1066. 

  1066. 		break;
    1067. 

  1067. 	case IW_MLME_DISASSOC:
    1068. 

  1068. 		if (!r8712_set_802_11_disassociate(padapter))
    1069. 

  1069. 			ret = -1;
    1070. 

  1070. 		break;
    1071. 

  1071. 	default:
    1072. 

  1072. 		return -EOPNOTSUPP;
    1073. 

  1073. 	}
    1074. 

  1074. 	return ret;
    1075. 

  1075. }
    1076. 

  1076. 

  1077. static int r8711_wx_set_scan(struct net_device *dev,
    1078. 

  1078. 			struct iw_request_info *a,
    1079. 

  1079. 			union iwreq_data *wrqu, char *extra)
    1080. 

  1080. {
    1081. 

  1081. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1082. 

  1082. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1083. 

  1083. 	u8 status = true;
    1084. 

  1084. 

  1085. 	if (padapter->bDriverStopped == true) {
    1086. 

  1086. 		printk(KERN_WARNING "r8712u: in r8711_wx_set_scan: "
    1087. 

  1087. 		    "bDriverStopped=%d\n", padapter->bDriverStopped);
    1088. 

  1088. 		return -1;
    1089. 

  1089. 	}
    1090. 

  1090. 	if (padapter->bup == false)
    1091. 

  1091. 		return -1;
    1092. 

  1092. 	if (padapter->hw_init_completed == false)
    1093. 

  1093. 		return -1;
    1094. 

  1094. 	if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) ||
    1095. 

  1095. 	    (pmlmepriv->sitesurveyctrl.traffic_busy == true))
    1096. 

  1096. 		return 0;
    1097. 

  1097. 	if (wrqu->data.length == sizeof(struct iw_scan_req)) {
    1098. 

  1098. 		struct iw_scan_req *req = (struct iw_scan_req *)extra;
    1099. 

  1099. 		if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
    1100. 

  1100. 			struct ndis_802_11_ssid ssid;
    1101. 

  1101. 			unsigned long irqL;
    1102. 

  1102. 			u32 len = (u32) min((u8)req->essid_len,
    1103. 

  1103. 				  (u8)IW_ESSID_MAX_SIZE);
    1104. 

  1104. 			memset((unsigned char *)&ssid, 0,
    1105. 

  1105. 				 sizeof(struct ndis_802_11_ssid));
    1106. 

  1106. 			memcpy(ssid.Ssid, req->essid, len);
    1107. 

  1107. 			ssid.SsidLength = len;
    1108. 

  1108. 			spin_lock_irqsave(&pmlmepriv->lock, irqL);
    1109. 

  1109. 			if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY |
    1110. 

  1110. 			     _FW_UNDER_LINKING)) ||
    1111. 

  1111. 			    (pmlmepriv->sitesurveyctrl.traffic_busy == true)) {
    1112. 

  1112. 				if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
    1113. 

  1113. 					status = false;
    1114. 

  1114. 			} else
    1115. 

  1115. 				status = r8712_sitesurvey_cmd(padapter, &ssid);
    1116. 

  1116. 			spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
    1117. 

  1117. 		}
    1118. 

  1118. 	} else
    1119. 

  1119. 		status = r8712_set_802_11_bssid_list_scan(padapter);
    1120. 

  1120. 	if (status == false)
    1121. 

  1121. 		return -1;
    1122. 

  1122. 	return 0;
    1123. 

  1123. }
    1124. 

  1124. 

  1125. static int r8711_wx_get_scan(struct net_device *dev,
    1126. 

  1126. 				struct iw_request_info *a,
    1127. 

  1127. 				union iwreq_data *wrqu, char *extra)
    1128. 

  1128. {
    1129. 

  1129. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1130. 

  1130. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1131. 

  1131. 	struct  __queue *queue = &pmlmepriv->scanned_queue;
    1132. 

  1132. 	struct wlan_network *pnetwork = NULL;
    1133. 

  1133. 	unsigned long irqL;
    1134. 

  1134. 	struct list_head *plist, *phead;
    1135. 

  1135. 	char *ev = extra;
    1136. 

  1136. 	char *stop = ev + wrqu->data.length;
    1137. 

  1137. 	u32 ret = 0, cnt = 0;
    1138. 

  1138. 

  1139. 	if (padapter->bDriverStopped)
    1140. 

  1140. 		return -EINVAL;
    1141. 

  1141. 	while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) {
    1142. 

  1142. 		msleep(30);
    1143. 

  1143. 		cnt++;
    1144. 

  1144. 		if (cnt > 1000)
    1145. 

  1145. 			break;
    1146. 

  1146. 	}
    1147. 

  1147. 	spin_lock_irqsave(&queue->lock, irqL);
    1148. 

  1148. 	phead = get_list_head(queue);
    1149. 

  1149. 	plist = get_next(phead);
    1150. 

  1150. 	while (1) {
    1151. 

  1151. 		if (end_of_queue_search(phead, plist) == true)
    1152. 

  1152. 			break;
    1153. 

  1153. 		if ((stop - ev) < SCAN_ITEM_SIZE) {
    1154. 

  1154. 			ret = -E2BIG;
    1155. 

  1155. 			break;
    1156. 

  1156. 		}
    1157. 

  1157. 		pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
    1158. 

  1158. 		ev = translate_scan(padapter, a, pnetwork, ev, stop);
    1159. 

  1159. 		plist = get_next(plist);
    1160. 

  1160. 	}
    1161. 

  1161. 	spin_unlock_irqrestore(&queue->lock, irqL);
    1162. 

  1162. 	wrqu->data.length = ev - extra;
    1163. 

  1163. 	wrqu->data.flags = 0;
    1164. 

  1164. 	return ret;
    1165. 

  1165. }
    1166. 

  1166. 

  1167. /* set ssid flow
    1168. 

  1168.  * s1. set_802_11_infrastructure_mode()
    1169. 

  1169.  * s2. set_802_11_authenticaion_mode()
    1170. 

  1170.  * s3. set_802_11_encryption_mode()
    1171. 

  1171.  * s4. set_802_11_ssid()
    1172. 

  1172.  */
    1173. 

  1173. static int r8711_wx_set_essid(struct net_device *dev,
    1174. 

  1174. 				struct iw_request_info *a,
    1175. 

  1175. 				union iwreq_data *wrqu, char *extra)
    1176. 

  1176. {
    1177. 

  1177. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1178. 

  1178. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1179. 

  1179. 	struct  __queue *queue = &pmlmepriv->scanned_queue;
    1180. 

  1180. 	struct wlan_network *pnetwork = NULL;
    1181. 

  1181. 	enum NDIS_802_11_AUTHENTICATION_MODE	authmode;
    1182. 

  1182. 	struct ndis_802_11_ssid ndis_ssid;
    1183. 

  1183. 	u8 *dst_ssid, *src_ssid;
    1184. 

  1184. 	struct list_head *phead;
    1185. 

  1185. 	u32 len;
    1186. 

  1186. 

  1187. 	if (padapter->bup == false)
    1188. 

  1188. 		return -1;
    1189. 

  1189. 	if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
    1190. 

  1190. 		return -1;
    1191. 

  1191. 	if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
    1192. 

  1192. 		return 0;
    1193. 

  1193. 	if (wrqu->essid.length > IW_ESSID_MAX_SIZE)
    1194. 

  1194. 		return -E2BIG;
    1195. 

  1195. 	authmode = padapter->securitypriv.ndisauthtype;
    1196. 

  1196. 	if (wrqu->essid.flags && wrqu->essid.length) {
    1197. 

  1197. 		len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ?
    1198. 

  1198. 		       wrqu->essid.length : IW_ESSID_MAX_SIZE;
    1199. 

  1199. 		memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
    1200. 

  1200. 		ndis_ssid.SsidLength = len;
    1201. 

  1201. 		memcpy(ndis_ssid.Ssid, extra, len);
    1202. 

  1202. 		src_ssid = ndis_ssid.Ssid;
    1203. 

  1203. 		phead = get_list_head(queue);
    1204. 

  1204. 		pmlmepriv->pscanned = get_next(phead);
    1205. 

  1205. 		while (1) {
    1206. 

  1206. 			if (end_of_queue_search(phead, pmlmepriv->pscanned))
    1207. 

  1207. 				break;
    1208. 

  1208. 			pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned,
    1209. 

  1209. 				   struct wlan_network, list);
    1210. 

  1210. 			pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
    1211. 

  1211. 			dst_ssid = pnetwork->network.Ssid.Ssid;
    1212. 

  1212. 			if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength))
    1213. 

  1213. 			    && (pnetwork->network.Ssid.SsidLength ==
    1214. 

  1214. 			     ndis_ssid.SsidLength)) {
    1215. 

  1215. 				if (!r8712_set_802_11_infrastructure_mode(
    1216. 

  1216. 				     padapter,
    1217. 

  1217. 				     pnetwork->network.InfrastructureMode))
    1218. 

  1218. 					return -1;
    1219. 

  1219. 				break;
    1220. 

  1220. 			}
    1221. 

  1221. 		}
    1222. 

  1222. 		r8712_set_802_11_authentication_mode(padapter, authmode);
    1223. 

  1223. 		r8712_set_802_11_ssid(padapter, &ndis_ssid);
    1224. 

  1224. 	}
    1225. 

  1225. 	return -EINPROGRESS;
    1226. 

  1226. }
    1227. 

  1227. 

  1228. static int r8711_wx_get_essid(struct net_device *dev,
    1229. 

  1229. 				struct iw_request_info *a,
    1230. 

  1230. 				union iwreq_data *wrqu, char *extra)
    1231. 

  1231. {
    1232. 

  1232. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1233. 

  1233. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1234. 

  1234. 	struct ndis_wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
    1235. 

  1235. 	u32 len, ret = 0;
    1236. 

  1236. 

  1237. 	if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE)) {
    1238. 

  1238. 		len = pcur_bss->Ssid.SsidLength;
    1239. 

  1239. 		wrqu->essid.length = len;
    1240. 

  1240. 		memcpy(extra, pcur_bss->Ssid.Ssid, len);
    1241. 

  1241. 		wrqu->essid.flags = 1;
    1242. 

  1242. 	} else
    1243. 

  1243. 		ret = -1;
    1244. 

  1244. 	return ret;
    1245. 

  1245. }
    1246. 

  1246. 

  1247. static int r8711_wx_set_rate(struct net_device *dev,
    1248. 

  1248. 				struct iw_request_info *a,
    1249. 

  1249. 				union iwreq_data *wrqu, char *extra)
    1250. 

  1250. {
    1251. 

  1251. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1252. 

  1252. 	u32 target_rate = wrqu->bitrate.value;
    1253. 

  1253. 	u32 fixed = wrqu->bitrate.fixed;
    1254. 

  1254. 	u32 ratevalue = 0;
    1255. 

  1255. 	u8 datarates[NumRates];
    1256. 

  1256. 	u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
    1257. 

  1257. 	int i, ret = 0;
    1258. 

  1258. 

  1259. 	if (target_rate == -1) {
    1260. 

  1260. 		ratevalue = 11;
    1261. 

  1261. 		goto set_rate;
    1262. 

  1262. 	}
    1263. 

  1263. 	target_rate = target_rate / 100000;
    1264. 

  1264. 	switch (target_rate) {
    1265. 

  1265. 	case 10:
    1266. 

  1266. 		ratevalue = 0;
    1267. 

  1267. 		break;
    1268. 

  1268. 	case 20:
    1269. 

  1269. 		ratevalue = 1;
    1270. 

  1270. 		break;
    1271. 

  1271. 	case 55:
    1272. 

  1272. 		ratevalue = 2;
    1273. 

  1273. 		break;
    1274. 

  1274. 	case 60:
    1275. 

  1275. 		ratevalue = 3;
    1276. 

  1276. 		break;
    1277. 

  1277. 	case 90:
    1278. 

  1278. 		ratevalue = 4;
    1279. 

  1279. 		break;
    1280. 

  1280. 	case 110:
    1281. 

  1281. 		ratevalue = 5;
    1282. 

  1282. 		break;
    1283. 

  1283. 	case 120:
    1284. 

  1284. 		ratevalue = 6;
    1285. 

  1285. 		break;
    1286. 

  1286. 	case 180:
    1287. 

  1287. 		ratevalue = 7;
    1288. 

  1288. 		break;
    1289. 

  1289. 	case 240:
    1290. 

  1290. 		ratevalue = 8;
    1291. 

  1291. 		break;
    1292. 

  1292. 	case 360:
    1293. 

  1293. 		ratevalue = 9;
    1294. 

  1294. 		break;
    1295. 

  1295. 	case 480:
    1296. 

  1296. 		ratevalue = 10;
    1297. 

  1297. 		break;
    1298. 

  1298. 	case 540:
    1299. 

  1299. 		ratevalue = 11;
    1300. 

  1300. 		break;
    1301. 

  1301. 	default:
    1302. 

  1302. 		ratevalue = 11;
    1303. 

  1303. 		break;
    1304. 

  1304. 	}
    1305. 

  1305. set_rate:
    1306. 

  1306. 	for (i = 0; i < NumRates; i++) {
    1307. 

  1307. 		if (ratevalue == mpdatarate[i]) {
    1308. 

  1308. 			datarates[i] = mpdatarate[i];
    1309. 

  1309. 			if (fixed == 0)
    1310. 

  1310. 				break;
    1311. 

  1311. 		} else
    1312. 

  1312. 			datarates[i] = 0xff;
    1313. 

  1313. 	}
    1314. 

  1314. 	if (r8712_setdatarate_cmd(padapter, datarates) != _SUCCESS)
    1315. 

  1315. 		ret = -1;
    1316. 

  1316. 	return ret;
    1317. 

  1317. }
    1318. 

  1318. 

  1319. static int r8711_wx_get_rate(struct net_device *dev,
    1320. 

  1320. 			     struct iw_request_info *info,
    1321. 

  1321. 			     union iwreq_data *wrqu, char *extra)
    1322. 

  1322. {
    1323. 

  1323. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1324. 

  1324. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1325. 

  1325. 	struct ndis_wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
    1326. 

  1326. 	struct ieee80211_ht_cap *pht_capie;
    1327. 

  1327. 	int i;
    1328. 

  1328. 	u8 *p;
    1329. 

  1329. 	u16 rate, max_rate = 0, ht_cap = false;
    1330. 

  1330. 	u32 ht_ielen = 0;
    1331. 

  1331. 	u8 bw_40MHz = 0, short_GI = 0;
    1332. 

  1332. 	u16 mcs_rate = 0;
    1333. 

  1333. 

  1334. 	i = 0;
    1335. 

  1335. 	if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE)) {
    1336. 

  1336. 		p = r8712_get_ie(&pcur_bss->IEs[12],
    1337. 

  1337. 				 _HT_CAPABILITY_IE_, &ht_ielen,
    1338. 

  1338. 		    pcur_bss->IELength - 12);
    1339. 

  1339. 		if (p && ht_ielen > 0) {
    1340. 

  1340. 			ht_cap = true;
    1341. 

  1341. 			pht_capie = (struct ieee80211_ht_cap *)(p + 2);
    1342. 

  1342. 			memcpy(&mcs_rate , pht_capie->supp_mcs_set, 2);
    1343. 

  1343. 			bw_40MHz = (pht_capie->cap_info &
    1344. 

  1344. 				    IEEE80211_HT_CAP_SUP_WIDTH) ? 1 : 0;
    1345. 

  1345. 			short_GI = (pht_capie->cap_info &
    1346. 

  1346. 				    (IEEE80211_HT_CAP_SGI_20 |
    1347. 

  1347. 				    IEEE80211_HT_CAP_SGI_40)) ? 1 : 0;
    1348. 

  1348. 		}
    1349. 

  1349. 		while ((pcur_bss->SupportedRates[i] != 0) &&
    1350. 

  1350. 			(pcur_bss->SupportedRates[i] != 0xFF)) {
    1351. 

  1351. 			rate = pcur_bss->SupportedRates[i] & 0x7F;
    1352. 

  1352. 			if (rate > max_rate)
    1353. 

  1353. 				max_rate = rate;
    1354. 

  1354. 			wrqu->bitrate.fixed = 0;	/* no auto select */
    1355. 

  1355. 			wrqu->bitrate.value = rate*500000;
    1356. 

  1356. 			i++;
    1357. 

  1357. 		}
    1358. 

  1358. 		if (ht_cap == true) {
    1359. 

  1359. 			if (mcs_rate & 0x8000) /* MCS15 */
    1360. 

  1360. 				max_rate = (bw_40MHz) ? ((short_GI) ? 300 :
    1361. 

  1361. 					    270) : ((short_GI) ? 144 : 130);
    1362. 

  1362. 			else if (mcs_rate & 0x0080) /* MCS7 */
    1363. 

  1363. 				max_rate = (bw_40MHz) ? ((short_GI) ? 150 :
    1364. 

  1364. 					    135) : ((short_GI) ? 72 : 65);
    1365. 

  1365. 			else /* default MCS7 */
    1366. 

  1366. 				max_rate = (bw_40MHz) ? ((short_GI) ? 150 :
    1367. 

  1367. 					    135) : ((short_GI) ? 72 : 65);
    1368. 

  1368. 			max_rate *= 2; /* Mbps/2 */
    1369. 

  1369. 			wrqu->bitrate.value = max_rate * 500000;
    1370. 

  1370. 		} else {
    1371. 

  1371. 			wrqu->bitrate.value = max_rate * 500000;
    1372. 

  1372. 		}
    1373. 

  1373. 	} else
    1374. 

  1374. 		return -1;
    1375. 

  1375. 	return 0;
    1376. 

  1376. }
    1377. 

  1377. 

  1378. static int r8711_wx_get_rts(struct net_device *dev,
    1379. 

  1379. 				struct iw_request_info *info,
    1380. 

  1380. 				union iwreq_data *wrqu, char *extra)
    1381. 

  1381. {
    1382. 

  1382. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1383. 

  1383. 

  1384. 	wrqu->rts.value = padapter->registrypriv.rts_thresh;
    1385. 

  1385. 	wrqu->rts.fixed = 0;	/* no auto select */
    1386. 

  1386. 	return 0;
    1387. 

  1387. }
    1388. 

  1388. 

  1389. static int r8711_wx_set_frag(struct net_device *dev,
    1390. 

  1390. 				struct iw_request_info *info,
    1391. 

  1391. 				union iwreq_data *wrqu, char *extra)
    1392. 

  1392. {
    1393. 

  1393. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1394. 

  1394. 

  1395. 	if (wrqu->frag.disabled)
    1396. 

  1396. 		padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
    1397. 

  1397. 	else {
    1398. 

  1398. 		if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
    1399. 

  1399. 		    wrqu->frag.value > MAX_FRAG_THRESHOLD)
    1400. 

  1400. 			return -EINVAL;
    1401. 

  1401. 		padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
    1402. 

  1402. 	}
    1403. 

  1403. 	return 0;
    1404. 

  1404. }
    1405. 

  1405. 

  1406. static int r8711_wx_get_frag(struct net_device *dev,
    1407. 

  1407. 				struct iw_request_info *info,
    1408. 

  1408. 				union iwreq_data *wrqu, char *extra)
    1409. 

  1409. {
    1410. 

  1410. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1411. 

  1411. 

  1412. 	wrqu->frag.value = padapter->xmitpriv.frag_len;
    1413. 

  1413. 	wrqu->frag.fixed = 0;	/* no auto select */
    1414. 

  1414. 	return 0;
    1415. 

  1415. }
    1416. 

  1416. 

  1417. static int r8711_wx_get_retry(struct net_device *dev,
    1418. 

  1418. 				struct iw_request_info *info,
    1419. 

  1419. 				union iwreq_data *wrqu, char *extra)
    1420. 

  1420. {
    1421. 

  1421. 	wrqu->retry.value = 7;
    1422. 

  1422. 	wrqu->retry.fixed = 0;	/* no auto select */
    1423. 

  1423. 	wrqu->retry.disabled = 1;
    1424. 

  1424. 	return 0;
    1425. 

  1425. }
    1426. 

  1426. 

  1427. static int r8711_wx_set_enc(struct net_device *dev,
    1428. 

  1428. 				struct iw_request_info *info,
    1429. 

  1429. 				union iwreq_data *wrqu, char *keybuf)
    1430. 

  1430. {
    1431. 

  1431. 	u32 key;
    1432. 

  1432. 	u32 keyindex_provided;
    1433. 

  1433. 	struct NDIS_802_11_WEP	 wep;
    1434. 

  1434. 	enum NDIS_802_11_AUTHENTICATION_MODE authmode;
    1435. 

  1435. 	struct iw_point *erq = &(wrqu->encoding);
    1436. 

  1436. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1437. 

  1437. 

  1438. 	key = erq->flags & IW_ENCODE_INDEX;
    1439. 

  1439. 	memset(&wep, 0, sizeof(struct NDIS_802_11_WEP));
    1440. 

  1440. 	if (erq->flags & IW_ENCODE_DISABLED) {
    1441. 

  1441. 		printk(KERN_INFO "r8712u: r8711_wx_set_enc: "
    1442. 

  1442. 		       "EncryptionDisabled\n");
    1443. 

  1443. 		padapter->securitypriv.ndisencryptstatus =
    1444. 

  1444. 				 Ndis802_11EncryptionDisabled;
    1445. 

  1445. 		padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
    1446. 

  1446. 		padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
    1447. 

  1447. 		padapter->securitypriv.AuthAlgrthm = 0; /* open system */
    1448. 

  1448. 		authmode = Ndis802_11AuthModeOpen;
    1449. 

  1449. 		padapter->securitypriv.ndisauthtype = authmode;
    1450. 

  1450. 		return 0;
    1451. 

  1451. 	}
    1452. 

  1452. 	if (key) {
    1453. 

  1453. 		if (key > WEP_KEYS)
    1454. 

  1454. 			return -EINVAL;
    1455. 

  1455. 		key--;
    1456. 

  1456. 		keyindex_provided = 1;
    1457. 

  1457. 	} else {
    1458. 

  1458. 		keyindex_provided = 0;
    1459. 

  1459. 		key = padapter->securitypriv.PrivacyKeyIndex;
    1460. 

  1460. 	}
    1461. 

  1461. 	/* set authentication mode */
    1462. 

  1462. 	if (erq->flags & IW_ENCODE_OPEN) {
    1463. 

  1463. 		printk(KERN_INFO "r8712u: r8711_wx_set_enc: "
    1464. 

  1464. 		       "IW_ENCODE_OPEN\n");
    1465. 

  1465. 		padapter->securitypriv.ndisencryptstatus =
    1466. 

  1466. 				 Ndis802_11Encryption1Enabled;
    1467. 

  1467. 		padapter->securitypriv.AuthAlgrthm = 0; /* open system */
    1468. 

  1468. 		padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
    1469. 

  1469. 		padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
    1470. 

  1470. 		authmode = Ndis802_11AuthModeOpen;
    1471. 

  1471. 		padapter->securitypriv.ndisauthtype = authmode;
    1472. 

  1472. 	} else if (erq->flags & IW_ENCODE_RESTRICTED) {
    1473. 

  1473. 		printk(KERN_INFO "r8712u: r8711_wx_set_enc: "
    1474. 

  1474. 		       "IW_ENCODE_RESTRICTED\n");
    1475. 

  1475. 		padapter->securitypriv.ndisencryptstatus =
    1476. 

  1476. 				 Ndis802_11Encryption1Enabled;
    1477. 

  1477. 		padapter->securitypriv.AuthAlgrthm = 1; /* shared system */
    1478. 

  1478. 		padapter->securitypriv.PrivacyAlgrthm = _WEP40_;
    1479. 

  1479. 		padapter->securitypriv.XGrpPrivacy = _WEP40_;
    1480. 

  1480. 		authmode = Ndis802_11AuthModeShared;
    1481. 

  1481. 		padapter->securitypriv.ndisauthtype = authmode;
    1482. 

  1482. 	} else {
    1483. 

  1483. 		padapter->securitypriv.ndisencryptstatus =
    1484. 

  1484. 				 Ndis802_11Encryption1Enabled;
    1485. 

  1485. 		padapter->securitypriv.AuthAlgrthm = 0; /* open system */
    1486. 

  1486. 		padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
    1487. 

  1487. 		padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
    1488. 

  1488. 		authmode = Ndis802_11AuthModeOpen;
    1489. 

  1489. 		padapter->securitypriv.ndisauthtype = authmode;
    1490. 

  1490. 	}
    1491. 

  1491. 	wep.KeyIndex = key;
    1492. 

  1492. 	if (erq->length > 0) {
    1493. 

  1493. 		wep.KeyLength = erq->length <= 5 ? 5 : 13;
    1494. 

  1494. 		wep.Length = wep.KeyLength +
    1495. 

  1495. 			     FIELD_OFFSET(struct NDIS_802_11_WEP, KeyMaterial);
    1496. 

  1496. 	} else {
    1497. 

  1497. 		wep.KeyLength = 0 ;
    1498. 

  1498. 		if (keyindex_provided == 1) { /* set key_id only, no given
    1499. 

  1499. 					       * KeyMaterial(erq->length==0).*/
    1500. 

  1500. 			padapter->securitypriv.PrivacyKeyIndex = key;
    1501. 

  1501. 			switch (padapter->securitypriv.DefKeylen[key]) {
    1502. 

  1502. 			case 5:
    1503. 

  1503. 				padapter->securitypriv.PrivacyAlgrthm =
    1504. 

  1504. 						 _WEP40_;
    1505. 

  1505. 				break;
    1506. 

  1506. 			case 13:
    1507. 

  1507. 				padapter->securitypriv.PrivacyAlgrthm =
    1508. 

  1508. 						 _WEP104_;
    1509. 

  1509. 				break;
    1510. 

  1510. 			default:
    1511. 

  1511. 				padapter->securitypriv.PrivacyAlgrthm =
    1512. 

  1512. 						 _NO_PRIVACY_;
    1513. 

  1513. 				break;
    1514. 

  1514. 			}
    1515. 

  1515. 			return 0;
    1516. 

  1516. 		}
    1517. 

  1517. 	}
    1518. 

  1518. 	wep.KeyIndex |= 0x80000000;	/* transmit key */
    1519. 

  1519. 	memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
    1520. 

  1520. 	if (r8712_set_802_11_add_wep(padapter, &wep) == _FAIL)
    1521. 

  1521. 		return -EOPNOTSUPP;
    1522. 

  1522. 	return 0;
    1523. 

  1523. }
    1524. 

  1524. 

  1525. static int r8711_wx_get_enc(struct net_device *dev,
    1526. 

  1526. 				struct iw_request_info *info,
    1527. 

  1527. 				union iwreq_data *wrqu, char *keybuf)
    1528. 

  1528. {
    1529. 

  1529. 	uint key, ret = 0;
    1530. 

  1530. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1531. 

  1531. 	struct iw_point *erq = &(wrqu->encoding);
    1532. 

  1532. 	struct	mlme_priv	*pmlmepriv = &(padapter->mlmepriv);
    1533. 

  1533. 

  1534. 	if (check_fwstate(pmlmepriv, _FW_LINKED) == false) {
    1535. 

  1535. 		if (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
    1536. 

  1536. 			erq->length = 0;
    1537. 

  1537. 			erq->flags |= IW_ENCODE_DISABLED;
    1538. 

  1538. 			return 0;
    1539. 

  1539. 		}
    1540. 

  1540. 	}
    1541. 

  1541. 	key = erq->flags & IW_ENCODE_INDEX;
    1542. 

  1542. 	if (key) {
    1543. 

  1543. 		if (key > WEP_KEYS)
    1544. 

  1544. 			return -EINVAL;
    1545. 

  1545. 		key--;
    1546. 

  1546. 	} else {
    1547. 

  1547. 		key = padapter->securitypriv.PrivacyKeyIndex;
    1548. 

  1548. 	}
    1549. 

  1549. 	erq->flags = key + 1;
    1550. 

  1550. 	switch (padapter->securitypriv.ndisencryptstatus) {
    1551. 

  1551. 	case Ndis802_11EncryptionNotSupported:
    1552. 

  1552. 	case Ndis802_11EncryptionDisabled:
    1553. 

  1553. 		erq->length = 0;
    1554. 

  1554. 		erq->flags |= IW_ENCODE_DISABLED;
    1555. 

  1555. 		break;
    1556. 

  1556. 	case Ndis802_11Encryption1Enabled:
    1557. 

  1557. 		erq->length = padapter->securitypriv.DefKeylen[key];
    1558. 

  1558. 		if (erq->length) {
    1559. 

  1559. 			memcpy(keybuf, padapter->securitypriv.DefKey[
    1560. 

  1560. 				key].skey, padapter->securitypriv.
    1561. 

  1561. 				DefKeylen[key]);
    1562. 

  1562. 			erq->flags |= IW_ENCODE_ENABLED;
    1563. 

  1563. 			if (padapter->securitypriv.ndisauthtype ==
    1564. 

  1564. 			    Ndis802_11AuthModeOpen)
    1565. 

  1565. 				erq->flags |= IW_ENCODE_OPEN;
    1566. 

  1566. 			else if (padapter->securitypriv.ndisauthtype ==
    1567. 

  1567. 				 Ndis802_11AuthModeShared)
    1568. 

  1568. 				erq->flags |= IW_ENCODE_RESTRICTED;
    1569. 

  1569. 		} else {
    1570. 

  1570. 			erq->length = 0;
    1571. 

  1571. 			erq->flags |= IW_ENCODE_DISABLED;
    1572. 

  1572. 		}
    1573. 

  1573. 		break;
    1574. 

  1574. 	case Ndis802_11Encryption2Enabled:
    1575. 

  1575. 	case Ndis802_11Encryption3Enabled:
    1576. 

  1576. 		erq->length = 16;
    1577. 

  1577. 		erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN |
    1578. 

  1578. 			       IW_ENCODE_NOKEY);
    1579. 

  1579. 		break;
    1580. 

  1580. 	default:
    1581. 

  1581. 		erq->length = 0;
    1582. 

  1582. 		erq->flags |= IW_ENCODE_DISABLED;
    1583. 

  1583. 		break;
    1584. 

  1584. 	}
    1585. 

  1585. 	return ret;
    1586. 

  1586. }
    1587. 

  1587. 

  1588. static int r8711_wx_get_power(struct net_device *dev,
    1589. 

  1589. 				struct iw_request_info *info,
    1590. 

  1590. 				union iwreq_data *wrqu, char *extra)
    1591. 

  1591. {
    1592. 

  1592. 	wrqu->power.value = 0;
    1593. 

  1593. 	wrqu->power.fixed = 0;	/* no auto select */
    1594. 

  1594. 	wrqu->power.disabled = 1;
    1595. 

  1595. 	return 0;
    1596. 

  1596. }
    1597. 

  1597. 

  1598. static int r871x_wx_set_gen_ie(struct net_device *dev,
    1599. 

  1599. 				struct iw_request_info *info,
    1600. 

  1600. 				union iwreq_data *wrqu, char *extra)
    1601. 

  1601. {
    1602. 

  1602. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1603. 

  1603. 

  1604. 	return r871x_set_wpa_ie(padapter, extra, wrqu->data.length);
    1605. 

  1605. }
    1606. 

  1606. 

  1607. static int r871x_wx_set_auth(struct net_device *dev,
    1608. 

  1608. 				struct iw_request_info *info,
    1609. 

  1609. 				union iwreq_data *wrqu, char *extra)
    1610. 

  1610. {
    1611. 

  1611. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1612. 

  1612. 	struct iw_param *param = (struct iw_param *)&(wrqu->param);
    1613. 

  1613. 	int paramid;
    1614. 

  1614. 	int paramval;
    1615. 

  1615. 	int ret = 0;
    1616. 

  1616. 

  1617. 	paramid = param->flags & IW_AUTH_INDEX;
    1618. 

  1618. 	paramval = param->value;
    1619. 

  1619. 	switch (paramid) {
    1620. 

  1620. 	case IW_AUTH_WPA_VERSION:
    1621. 

  1621. 		break;
    1622. 

  1622. 	case IW_AUTH_CIPHER_PAIRWISE:
    1623. 

  1623. 		break;
    1624. 

  1624. 	case IW_AUTH_CIPHER_GROUP:
    1625. 

  1625. 		break;
    1626. 

  1626. 	case IW_AUTH_KEY_MGMT:
    1627. 

  1627. 		/*
    1628. 

  1628. 		 *  ??? does not use these parameters
    1629. 

  1629. 		 */
    1630. 

  1630. 		break;
    1631. 

  1631. 	case IW_AUTH_TKIP_COUNTERMEASURES:
    1632. 

  1632. 		if (paramval) {
    1633. 

  1633. 			/* wpa_supplicant is enabling tkip countermeasure. */
    1634. 

  1634. 			padapter->securitypriv.btkip_countermeasure = true;
    1635. 

  1635. 		} else {
    1636. 

  1636. 			/* wpa_supplicant is disabling tkip countermeasure. */
    1637. 

  1637. 			padapter->securitypriv.btkip_countermeasure = false;
    1638. 

  1638. 		}
    1639. 

  1639. 		break;
    1640. 

  1640. 	case IW_AUTH_DROP_UNENCRYPTED:
    1641. 

  1641. 		/* HACK:
    1642. 

  1642. 		 *
    1643. 

  1643. 		 * wpa_supplicant calls set_wpa_enabled when the driver
    1644. 

  1644. 		 * is loaded and unloaded, regardless of if WPA is being
    1645. 

  1645. 		 * used.  No other calls are made which can be used to
    1646. 

  1646. 		 * determine if encryption will be used or not prior to
    1647. 

  1647. 		 * association being expected.  If encryption is not being
    1648. 

  1648. 		 * used, drop_unencrypted is set to false, else true -- we
    1649. 

  1649. 		 * can use this to determine if the CAP_PRIVACY_ON bit should
    1650. 

  1650. 		 * be set.
    1651. 

  1651. 		 */
    1652. 

  1652. 		if (padapter->securitypriv.ndisencryptstatus ==
    1653. 

  1653. 		    Ndis802_11Encryption1Enabled) {
    1654. 

  1654. 				/* it means init value, or using wep,
    1655. 

  1655. 				 * ndisencryptstatus =
    1656. 

  1656. 				 *	Ndis802_11Encryption1Enabled,
    1657. 

  1657. 				 * then it needn't reset it;
    1658. 

  1658. 				 */
    1659. 

  1659. 				break;
    1660. 

  1660. 		}
    1661. 

  1661. 

  1662. 		if (paramval) {
    1663. 

  1663. 			padapter->securitypriv.ndisencryptstatus =
    1664. 

  1664. 				   Ndis802_11EncryptionDisabled;
    1665. 

  1665. 			padapter->securitypriv.PrivacyAlgrthm =
    1666. 

  1666. 				  _NO_PRIVACY_;
    1667. 

  1667. 			padapter->securitypriv.XGrpPrivacy =
    1668. 

  1668. 				  _NO_PRIVACY_;
    1669. 

  1669. 			padapter->securitypriv.AuthAlgrthm = 0;
    1670. 

  1670. 			padapter->securitypriv.ndisauthtype =
    1671. 

  1671. 				  Ndis802_11AuthModeOpen;
    1672. 

  1672. 		}
    1673. 

  1673. 		break;
    1674. 

  1674. 	case IW_AUTH_80211_AUTH_ALG:
    1675. 

  1675. 		ret = wpa_set_auth_algs(dev, (u32)paramval);
    1676. 

  1676. 		break;
    1677. 

  1677. 	case IW_AUTH_WPA_ENABLED:
    1678. 

  1678. 		break;
    1679. 

  1679. 	case IW_AUTH_RX_UNENCRYPTED_EAPOL:
    1680. 

  1680. 		break;
    1681. 

  1681. 	case IW_AUTH_PRIVACY_INVOKED:
    1682. 

  1682. 		break;
    1683. 

  1683. 	default:
    1684. 

  1684. 		return -EOPNOTSUPP;
    1685. 

  1685. 	}
    1686. 

  1686. 

  1687. 	return ret;
    1688. 

  1688. }
    1689. 

  1689. 

  1690. static int r871x_wx_set_enc_ext(struct net_device *dev,
    1691. 

  1691. 			     struct iw_request_info *info,
    1692. 

  1692. 			     union iwreq_data *wrqu, char *extra)
    1693. 

  1693. {
    1694. 

  1694. 	struct iw_point *pencoding = &wrqu->encoding;
    1695. 

  1695. 	struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
    1696. 

  1696. 	struct ieee_param *param = NULL;
    1697. 

  1697. 	char *alg_name;
    1698. 

  1698. 	u32 param_len;
    1699. 

  1699. 	int ret = 0;
    1700. 

  1700. 

  1701. 	param_len = sizeof(struct ieee_param) + pext->key_len;
    1702. 

  1702. 	param = (struct ieee_param *)_malloc(param_len);
    1703. 

  1703. 	if (param == NULL)
    1704. 

  1704. 		return -1;
    1705. 

  1705. 	memset(param, 0, param_len);
    1706. 

  1706. 	param->cmd = IEEE_CMD_SET_ENCRYPTION;
    1707. 

  1707. 	memset(param->sta_addr, 0xff, ETH_ALEN);
    1708. 

  1708. 	switch (pext->alg) {
    1709. 

  1709. 	case IW_ENCODE_ALG_NONE:
    1710. 

  1710. 		alg_name = "none";
    1711. 

  1711. 		break;
    1712. 

  1712. 	case IW_ENCODE_ALG_WEP:
    1713. 

  1713. 		alg_name = "WEP";
    1714. 

  1714. 		break;
    1715. 

  1715. 	case IW_ENCODE_ALG_TKIP:
    1716. 

  1716. 		alg_name = "TKIP";
    1717. 

  1717. 		break;
    1718. 

  1718. 	case IW_ENCODE_ALG_CCMP:
    1719. 

  1719. 		alg_name = "CCMP";
    1720. 

  1720. 		break;
    1721. 

  1721. 	default:
    1722. 

  1722. 		return -1;
    1723. 

  1723. 	}
    1724. 

  1724. 	strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
    1725. 

  1725. 	if (pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
    1726. 

  1726. 		param->u.crypt.set_tx = 0;
    1727. 

  1727. 	if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
    1728. 

  1728. 		param->u.crypt.set_tx = 1;
    1729. 

  1729. 	param->u.crypt.idx = (pencoding->flags & 0x00FF) - 1;
    1730. 

  1730. 	if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
    1731. 

  1731. 		memcpy(param->u.crypt.seq, pext->rx_seq, 8);
    1732. 

  1732. 	if (pext->key_len) {
    1733. 

  1733. 		param->u.crypt.key_len = pext->key_len;
    1734. 

  1734. 		memcpy(param + 1, pext + 1, pext->key_len);
    1735. 

  1735. 	}
    1736. 

  1736. 	ret = wpa_set_encryption(dev, param, param_len);
    1737. 

  1737. 	kfree(param);
    1738. 

  1738. 	return ret;
    1739. 

  1739. }
    1740. 

  1740. 

  1741. static int r871x_wx_get_nick(struct net_device *dev,
    1742. 

  1742. 			     struct iw_request_info *info,
    1743. 

  1743. 			     union iwreq_data *wrqu, char *extra)
    1744. 

  1744. {
    1745. 

  1745. 	if (extra) {
    1746. 

  1746. 		wrqu->data.length = 8;
    1747. 

  1747. 		wrqu->data.flags = 1;
    1748. 

  1748. 		memcpy(extra, "rtl_wifi", 8);
    1749. 

  1749. 	}
    1750. 

  1750. 	return 0;
    1751. 

  1751. }
    1752. 

  1752. 

  1753. static int r8711_wx_read32(struct net_device *dev,
    1754. 

  1754. 				struct iw_request_info *info,
    1755. 

  1755. 				union iwreq_data *wrqu, char *keybuf)
    1756. 

  1756. {
    1757. 

  1757. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1758. 

  1758. 	u32 addr;
    1759. 

  1759. 	u32 data32;
    1760. 

  1760. 

  1761. 	get_user(addr, (u32 __user *)wrqu->data.pointer);
    1762. 

  1762. 	data32 = r8712_read32(padapter, addr);
    1763. 

  1763. 	put_user(data32, (u32 __user *)wrqu->data.pointer);
    1764. 

  1764. 	wrqu->data.length = (data32 & 0xffff0000) >> 16;
    1765. 

  1765. 	wrqu->data.flags = data32 & 0xffff;
    1766. 

  1766. 	get_user(addr, (u32 __user *)wrqu->data.pointer);
    1767. 

  1767. 	return 0;
    1768. 

  1768. }
    1769. 

  1769. 

  1770. static int r8711_wx_write32(struct net_device *dev,
    1771. 

  1771. 				 struct iw_request_info *info,
    1772. 

  1772. 				 union iwreq_data *wrqu, char *keybuf)
    1773. 

  1773. {
    1774. 

  1774. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1775. 

  1775. 	u32 addr;
    1776. 

  1776. 	u32 data32;
    1777. 

  1777. 

  1778. 	get_user(addr, (u32 __user *)wrqu->data.pointer);
    1779. 

  1779. 	data32 = ((u32)wrqu->data.length<<16) | (u32)wrqu->data.flags ;
    1780. 

  1780. 	r8712_write32(padapter, addr, data32);
    1781. 

  1781. 	return 0;
    1782. 

  1782. }
    1783. 

  1783. 

  1784. static int dummy(struct net_device *dev,
    1785. 

  1785. 		struct iw_request_info *a,
    1786. 

  1786. 		union iwreq_data *wrqu, char *b)
    1787. 

  1787. {
    1788. 

  1788. 	return -1;
    1789. 

  1789. }
    1790. 

  1790. 

  1791. static int r8711_drvext_hdl(struct net_device *dev,
    1792. 

  1792. 				struct iw_request_info *info,
    1793. 

  1793. 				union iwreq_data *wrqu, char *extra)
    1794. 

  1794. {
    1795. 

  1795. 	return 0;
    1796. 

  1796. }
    1797. 

  1797. 

  1798. static int r871x_mp_ioctl_hdl(struct net_device *dev,
    1799. 

  1799. 				struct iw_request_info *info,
    1800. 

  1800. 				union iwreq_data *wrqu, char *extra)
    1801. 

  1801. {
    1802. 

  1802. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1803. 

  1803. 	struct iw_point *p = &wrqu->data;
    1804. 

  1804. 	struct oid_par_priv oid_par;
    1805. 

  1805. 	struct mp_ioctl_handler *phandler;
    1806. 

  1806. 	struct mp_ioctl_param *poidparam;
    1807. 

  1807. 	unsigned long BytesRead, BytesWritten, BytesNeeded;
    1808. 

  1808. 	u8 *pparmbuf = NULL, bset;
    1809. 

  1809. 	u16 len;
    1810. 

  1810. 	uint status;
    1811. 

  1811. 	int ret = 0;
    1812. 

  1812. 

  1813. 	if ((!p->length) || (!p->pointer)) {
    1814. 

  1814. 		ret = -EINVAL;
    1815. 

  1815. 		goto _r871x_mp_ioctl_hdl_exit;
    1816. 

  1816. 	}
    1817. 

  1817. 	bset = (u8)(p->flags & 0xFFFF);
    1818. 

  1818. 	len = p->length;
    1819. 

  1819. 	pparmbuf = NULL;
    1820. 

  1820. 	pparmbuf = (u8 *)_malloc(len);
    1821. 

  1821. 	if (pparmbuf == NULL) {
    1822. 

  1822. 		ret = -ENOMEM;
    1823. 

  1823. 		goto _r871x_mp_ioctl_hdl_exit;
    1824. 

  1824. 	}
    1825. 

  1825. 	if (copy_from_user(pparmbuf, p->pointer, len)) {
    1826. 

  1826. 		ret = -EFAULT;
    1827. 

  1827. 		goto _r871x_mp_ioctl_hdl_exit;
    1828. 

  1828. 	}
    1829. 

  1829. 	poidparam = (struct mp_ioctl_param *)pparmbuf;
    1830. 

  1830. 	if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) {
    1831. 

  1831. 		ret = -EINVAL;
    1832. 

  1832. 		goto _r871x_mp_ioctl_hdl_exit;
    1833. 

  1833. 	}
    1834. 

  1834. 	phandler = mp_ioctl_hdl + poidparam->subcode;
    1835. 

  1835. 	if ((phandler->paramsize != 0) &&
    1836. 

  1836. 	    (poidparam->len < phandler->paramsize)) {
    1837. 

  1837. 		ret = -EINVAL;
    1838. 

  1838. 		goto _r871x_mp_ioctl_hdl_exit;
    1839. 

  1839. 	}
    1840. 

  1840. 	if (phandler->oid == 0 && phandler->handler)
    1841. 

  1841. 		status = phandler->handler(&oid_par);
    1842. 

  1842. 	else if (phandler->handler) {
    1843. 

  1843. 		oid_par.adapter_context = padapter;
    1844. 

  1844. 		oid_par.oid = phandler->oid;
    1845. 

  1845. 		oid_par.information_buf = poidparam->data;
    1846. 

  1846. 		oid_par.information_buf_len = poidparam->len;
    1847. 

  1847. 		oid_par.dbg = 0;
    1848. 

  1848. 		BytesWritten = 0;
    1849. 

  1849. 		BytesNeeded = 0;
    1850. 

  1850. 		if (bset) {
    1851. 

  1851. 			oid_par.bytes_rw = &BytesRead;
    1852. 

  1852. 			oid_par.bytes_needed = &BytesNeeded;
    1853. 

  1853. 			oid_par.type_of_oid = SET_OID;
    1854. 

  1854. 		} else {
    1855. 

  1855. 			oid_par.bytes_rw = &BytesWritten;
    1856. 

  1856. 			oid_par.bytes_needed = &BytesNeeded;
    1857. 

  1857. 			oid_par.type_of_oid = QUERY_OID;
    1858. 

  1858. 		}
    1859. 

  1859. 		status = phandler->handler(&oid_par);
    1860. 

  1860. 		/* todo:check status, BytesNeeded, etc. */
    1861. 

  1861. 	} else {
    1862. 

  1862. 		printk(KERN_INFO "r8712u: r871x_mp_ioctl_hdl(): err!,"
    1863. 

  1863. 		    " subcode=%d, oid=%d, handler=%p\n",
    1864. 

  1864. 		    poidparam->subcode, phandler->oid, phandler->handler);
    1865. 

  1865. 		ret = -EFAULT;
    1866. 

  1866. 		goto _r871x_mp_ioctl_hdl_exit;
    1867. 

  1867. 	}
    1868. 

  1868. 	if (bset == 0x00) { /* query info */
    1869. 

  1869. 		if (copy_to_user(p->pointer, pparmbuf, len))
    1870. 

  1870. 			ret = -EFAULT;
    1871. 

  1871. 	}
    1872. 

  1872. 	if (status) {
    1873. 

  1873. 		ret = -EFAULT;
    1874. 

  1874. 		goto _r871x_mp_ioctl_hdl_exit;
    1875. 

  1875. 	}
    1876. 

  1876. _r871x_mp_ioctl_hdl_exit:
    1877. 

  1877. 	kfree(pparmbuf);
    1878. 

  1878. 	return ret;
    1879. 

  1879. }
    1880. 

  1880. 

  1881. static int r871x_get_ap_info(struct net_device *dev,
    1882. 

  1882. 				struct iw_request_info *info,
    1883. 

  1883. 				union iwreq_data *wrqu, char *extra)
    1884. 

  1884. {
    1885. 

  1885. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1886. 

  1886. 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
    1887. 

  1887. 	struct  __queue *queue = &pmlmepriv->scanned_queue;
    1888. 

  1888. 	struct iw_point *pdata = &wrqu->data;
    1889. 

  1889. 	struct wlan_network *pnetwork = NULL;
    1890. 

  1890. 	u32 cnt = 0, wpa_ielen;
    1891. 

  1891. 	unsigned long irqL;
    1892. 

  1892. 	struct list_head *plist, *phead;
    1893. 

  1893. 	unsigned char *pbuf;
    1894. 

  1894. 	u8 bssid[ETH_ALEN];
    1895. 

  1895. 	char data[32];
    1896. 

  1896. 

  1897. 	if (padapter->bDriverStopped || (pdata == NULL))
    1898. 

  1898. 		return -EINVAL;
    1899. 

  1899. 	while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) {
    1900. 

  1900. 		msleep(30);
    1901. 

  1901. 		cnt++;
    1902. 

  1902. 		if (cnt > 100)
    1903. 

  1903. 			break;
    1904. 

  1904. 	}
    1905. 

  1905. 	pdata->flags = 0;
    1906. 

  1906. 	if (pdata->length >= 32) {
    1907. 

  1907. 		if (copy_from_user(data, pdata->pointer, 32))
    1908. 

  1908. 			return -EINVAL;
    1909. 

  1909. 	} else
    1910. 

  1910. 		 return -EINVAL;
    1911. 

  1911. 	spin_lock_irqsave(&(pmlmepriv->scanned_queue.lock), irqL);
    1912. 

  1912. 	phead = get_list_head(queue);
    1913. 

  1913. 	plist = get_next(phead);
    1914. 

  1914. 	while (1) {
    1915. 

  1915. 		if (end_of_queue_search(phead, plist) == true)
    1916. 

  1916. 			break;
    1917. 

  1917. 		pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
    1918. 

  1918. 		if (hwaddr_aton_i(data, bssid)) {
    1919. 

  1919. 			printk(KERN_INFO "r8712u: Invalid BSSID '%s'.\n",
    1920. 

  1920. 			       (u8 *)data);
    1921. 

  1921. 			spin_unlock_irqrestore(&(pmlmepriv->scanned_queue.lock),
    1922. 

  1922. 									irqL);
    1923. 

  1923. 			return -EINVAL;
    1924. 

  1924. 		}
    1925. 

  1925. 		printk(KERN_INFO "r8712u: BSSID:%pM\n", bssid);
    1926. 

  1926. 		if (!memcmp(bssid, pnetwork->network.MacAddress, ETH_ALEN)) {
    1927. 

  1927. 			/* BSSID match, then check if supporting wpa/wpa2 */
    1928. 

  1928. 			pbuf = r8712_get_wpa_ie(&pnetwork->network.IEs[12],
    1929. 

  1929. 			       &wpa_ielen, pnetwork->network.IELength-12);
    1930. 

  1930. 			if (pbuf && (wpa_ielen > 0)) {
    1931. 

  1931. 				pdata->flags = 1;
    1932. 

  1932. 				break;
    1933. 

  1933. 			}
    1934. 

  1934. 			pbuf = r8712_get_wpa2_ie(&pnetwork->network.IEs[12],
    1935. 

  1935. 			       &wpa_ielen, pnetwork->network.IELength-12);
    1936. 

  1936. 			if (pbuf && (wpa_ielen > 0)) {
    1937. 

  1937. 				pdata->flags = 2;
    1938. 

  1938. 				break;
    1939. 

  1939. 			}
    1940. 

  1940. 		}
    1941. 

  1941. 		plist = get_next(plist);
    1942. 

  1942. 	}
    1943. 

  1943. 	spin_unlock_irqrestore(&(pmlmepriv->scanned_queue.lock), irqL);
    1944. 

  1944. 	if (pdata->length >= 34) {
    1945. 

  1945. 		if (copy_to_user((u8 __user *)pdata->pointer + 32,
    1946. 

  1946. 		    (u8 *)&pdata->flags, 1))
    1947. 

  1947. 			return -EINVAL;
    1948. 

  1948. 	}
    1949. 

  1949. 	return 0;
    1950. 

  1950. }
    1951. 

  1951. 

  1952. static int r871x_set_pid(struct net_device *dev,
    1953. 

  1953. 				struct iw_request_info *info,
    1954. 

  1954. 				union iwreq_data *wrqu, char *extra)
    1955. 

  1955. {
    1956. 

  1956. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1957. 

  1957. 	struct iw_point *pdata = &wrqu->data;
    1958. 

  1958. 

  1959. 	if ((padapter->bDriverStopped) || (pdata == NULL))
    1960. 

  1960. 		return -EINVAL;
    1961. 

  1961. 	if (copy_from_user(&padapter->pid, pdata->pointer, sizeof(int)))
    1962. 

  1962. 		return -EINVAL;
    1963. 

  1963. 	return 0;
    1964. 

  1964. }
    1965. 

  1965. 

  1966. static int r871x_wps_start(struct net_device *dev,
    1967. 

  1967. 			   struct iw_request_info *info,
    1968. 

  1968. 			   union iwreq_data *wrqu, char *extra)
    1969. 

  1969. {
    1970. 

  1970. 	struct _adapter *padapter = (struct _adapter *)_netdev_priv(dev);
    1971. 

  1971. 	struct iw_point *pdata = &wrqu->data;
    1972. 

  1972. 	u32   u32wps_start = 0;
    1973. 

  1973. 

  1974. 	if (copy_from_user((void *)&u32wps_start, pdata->pointer, 4))
    1975. 

  1975. 		return -EFAULT;
    1976. 

  1976. 	if ((padapter->bDriverStopped) || (pdata == NULL))
    1977. 

  1977. 		return -EINVAL;
    1978. 

  1978. 	if (u32wps_start == 0)
    1979. 

  1979. 		u32wps_start = *extra;
    1980. 

  1980. 	if (u32wps_start == 1) /* WPS Start */
    1981. 

  1981. 		padapter->ledpriv.LedControlHandler(padapter,
    1982. 

  1982. 			   LED_CTL_START_WPS);
    1983. 

  1983. 	else if (u32wps_start == 2) /* WPS Stop because of wps success */
    1984. 

  1984. 		padapter->ledpriv.LedControlHandler(padapter,
    1985. 

  1985. 			   LED_CTL_STOP_WPS);
    1986. 

  1986. 	else if (u32wps_start == 3) /* WPS Stop because of wps fail */
    1987. 

  1987. 		padapter->ledpriv.LedControlHandler(padapter,
    1988. 

  1988. 			   LED_CTL_STOP_WPS_FAIL);
    1989. 

  1989. 	return 0;
    1990. 

  1990. }
    1991. 

  1991. 

  1992. static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
    1993. 

  1993. {
    1994. 

  1994. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    1995. 

  1995. 

  1996. 	switch (name) {
    1997. 

  1997. 	case IEEE_PARAM_WPA_ENABLED:
    1998. 

  1998. 		padapter->securitypriv.AuthAlgrthm = 2; /* 802.1x */
    1999. 

  1999. 		switch ((value)&0xff) {
    2000. 

  2000. 		case 1: /* WPA */
    2001. 

  2001. 			padapter->securitypriv.ndisauthtype =
    2002. 

  2002. 				Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
    2003. 

  2003. 			padapter->securitypriv.ndisencryptstatus =
    2004. 

  2004. 				Ndis802_11Encryption2Enabled;
    2005. 

  2005. 			break;
    2006. 

  2006. 		case 2: /* WPA2 */
    2007. 

  2007. 			padapter->securitypriv.ndisauthtype =
    2008. 

  2008. 				Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
    2009. 

  2009. 			padapter->securitypriv.ndisencryptstatus =
    2010. 

  2010. 				Ndis802_11Encryption3Enabled;
    2011. 

  2011. 			break;
    2012. 

  2012. 		}
    2013. 

  2013. 		break;
    2014. 

  2014. 	case IEEE_PARAM_TKIP_COUNTERMEASURES:
    2015. 

  2015. 		break;
    2016. 

  2016. 	case IEEE_PARAM_DROP_UNENCRYPTED:
    2017. 

  2017. 		/* HACK:
    2018. 

  2018. 		 *
    2019. 

  2019. 		 * wpa_supplicant calls set_wpa_enabled when the driver
    2020. 

  2020. 		 * is loaded and unloaded, regardless of if WPA is being
    2021. 

  2021. 		 * used.  No other calls are made which can be used to
    2022. 

  2022. 		 * determine if encryption will be used or not prior to
    2023. 

  2023. 		 * association being expected.  If encryption is not being
    2024. 

  2024. 		 * used, drop_unencrypted is set to false, else true -- we
    2025. 

  2025. 		 * can use this to determine if the CAP_PRIVACY_ON bit should
    2026. 

  2026. 		 * be set.
    2027. 

  2027. 		 */
    2028. 

  2028. 		break;
    2029. 

  2029. 	case IEEE_PARAM_PRIVACY_INVOKED:
    2030. 

  2030. 		break;
    2031. 

  2031. 	case IEEE_PARAM_AUTH_ALGS:
    2032. 

  2032. 		return wpa_set_auth_algs(dev, value);
    2033. 

  2033. 		break;
    2034. 

  2034. 	case IEEE_PARAM_IEEE_802_1X:
    2035. 

  2035. 		break;
    2036. 

  2036. 	case IEEE_PARAM_WPAX_SELECT:
    2037. 

  2037. 		/* added for WPA2 mixed mode */
    2038. 

  2038. 		break;
    2039. 

  2039. 	default:
    2040. 

  2040. 		return -EOPNOTSUPP;
    2041. 

  2041. 	}
    2042. 

  2042. 	return 0;
    2043. 

  2043. }
    2044. 

  2044. 

  2045. static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
    2046. 

  2046. {
    2047. 

  2047. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    2048. 

  2048. 

  2049. 	switch (command) {
    2050. 

  2050. 	case IEEE_MLME_STA_DEAUTH:
    2051. 

  2051. 		if (!r8712_set_802_11_disassociate(padapter))
    2052. 

  2052. 			return -1;
    2053. 

  2053. 		break;
    2054. 

  2054. 	case IEEE_MLME_STA_DISASSOC:
    2055. 

  2055. 		if (!r8712_set_802_11_disassociate(padapter))
    2056. 

  2056. 			return -1;
    2057. 

  2057. 		break;
    2058. 

  2058. 	default:
    2059. 

  2059. 		return -EOPNOTSUPP;
    2060. 

  2060. 	}
    2061. 

  2061. 	return 0;
    2062. 

  2062. }
    2063. 

  2063. 

  2064. static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
    2065. 

  2065. {
    2066. 

  2066. 	struct ieee_param *param;
    2067. 

  2067. 	int ret = 0;
    2068. 

  2068. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    2069. 

  2069. 

  2070. 	if (p->length < sizeof(struct ieee_param) || !p->pointer)
    2071. 

  2071. 		return -EINVAL;
    2072. 

  2072. 	param = (struct ieee_param *)_malloc(p->length);
    2073. 

  2073. 	if (param == NULL)
    2074. 

  2074. 		return -ENOMEM;
    2075. 

  2075. 	if (copy_from_user(param, p->pointer, p->length))
    2076. 

  2076. 		kfree((u8 *)param);
    2077. 

  2077. 		return -EFAULT;
    2078. 

  2078. 	switch (param->cmd) {
    2079. 

  2079. 	case IEEE_CMD_SET_WPA_PARAM:
    2080. 

  2080. 		ret = wpa_set_param(dev, param->u.wpa_param.name,
    2081. 

  2081. 		      param->u.wpa_param.value);
    2082. 

  2082. 		break;
    2083. 

  2083. 	case IEEE_CMD_SET_WPA_IE:
    2084. 

  2084. 		ret =  r871x_set_wpa_ie(padapter, (char *)param->u.wpa_ie.data,
    2085. 

  2085. 		       (u16)param->u.wpa_ie.len);
    2086. 

  2086. 		break;
    2087. 

  2087. 	case IEEE_CMD_SET_ENCRYPTION:
    2088. 

  2088. 		ret = wpa_set_encryption(dev, param, p->length);
    2089. 

  2089. 		break;
    2090. 

  2090. 	case IEEE_CMD_MLME:
    2091. 

  2091. 		ret = wpa_mlme(dev, param->u.mlme.command,
    2092. 

  2092. 		      param->u.mlme.reason_code);
    2093. 

  2093. 		break;
    2094. 

  2094. 	default:
    2095. 

  2095. 		ret = -EOPNOTSUPP;
    2096. 

  2096. 		break;
    2097. 

  2097. 	}
    2098. 

  2098. 	if (ret == 0 && copy_to_user(p->pointer, param, p->length))
    2099. 

  2099. 		ret = -EFAULT;
    2100. 

  2100. 	kfree((u8 *)param);
    2101. 

  2101. 	return ret;
    2102. 

  2102. }
    2103. 

  2103. 

  2104. /* based on "driver_ipw" and for hostapd */
    2105. 

  2105. int r871x_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
    2106. 

  2106. {
    2107. 

  2107. 	struct iwreq *wrq = (struct iwreq *)rq;
    2108. 

  2108. 

  2109. 	switch (cmd) {
    2110. 

  2110. 	case RTL_IOCTL_WPA_SUPPLICANT:
    2111. 

  2111. 		return wpa_supplicant_ioctl(dev, &wrq->u.data);
    2112. 

  2112. 	default:
    2113. 

  2113. 		return -EOPNOTSUPP;
    2114. 

  2114. 	}
    2115. 

  2115. 	return 0;
    2116. 

  2116. }
    2117. 

  2117. 

  2118. static iw_handler r8711_handlers[] = {
    2119. 

  2119. 	NULL,				/* SIOCSIWCOMMIT */
    2120. 

  2120. 	r8711_wx_get_name,		/* SIOCGIWNAME */
    2121. 

  2121. 	dummy,				/* SIOCSIWNWID */
    2122. 

  2122. 	dummy,				/* SIOCGIWNWID */
    2123. 

  2123. 	r8711_wx_set_freq,		/* SIOCSIWFREQ */
    2124. 

  2124. 	r8711_wx_get_freq,		/* SIOCGIWFREQ */
    2125. 

  2125. 	r8711_wx_set_mode,		/* SIOCSIWMODE */
    2126. 

  2126. 	r8711_wx_get_mode,		/* SIOCGIWMODE */
    2127. 

  2127. 	dummy,				/* SIOCSIWSENS */
    2128. 

  2128. 	r8711_wx_get_sens,		/* SIOCGIWSENS */
    2129. 

  2129. 	NULL,				/* SIOCSIWRANGE */
    2130. 

  2130. 	r8711_wx_get_range,		/* SIOCGIWRANGE */
    2131. 

  2131. 	r871x_wx_set_priv,		/* SIOCSIWPRIV */
    2132. 

  2132. 	NULL,				/* SIOCGIWPRIV */
    2133. 

  2133. 	NULL,				/* SIOCSIWSTATS */
    2134. 

  2134. 	NULL,				/* SIOCGIWSTATS */
    2135. 

  2135. 	dummy,				/* SIOCSIWSPY */
    2136. 

  2136. 	dummy,				/* SIOCGIWSPY */
    2137. 

  2137. 	NULL,				/* SIOCGIWTHRSPY */
    2138. 

  2138. 	NULL,				/* SIOCWIWTHRSPY */
    2139. 

  2139. 	r8711_wx_set_wap,		/* SIOCSIWAP */
    2140. 

  2140. 	r8711_wx_get_wap,		/* SIOCGIWAP */
    2141. 

  2141. 	r871x_wx_set_mlme,		/* request MLME operation;
    2142. 

  2142. 					 *  uses struct iw_mlme */
    2143. 

  2143. 	dummy,				/* SIOCGIWAPLIST -- deprecated */
    2144. 

  2144. 	r8711_wx_set_scan,		/* SIOCSIWSCAN */
    2145. 

  2145. 	r8711_wx_get_scan,		/* SIOCGIWSCAN */
    2146. 

  2146. 	r8711_wx_set_essid,		/* SIOCSIWESSID */
    2147. 

  2147. 	r8711_wx_get_essid,		/* SIOCGIWESSID */
    2148. 

  2148. 	dummy,				/* SIOCSIWNICKN */
    2149. 

  2149. 	r871x_wx_get_nick,		/* SIOCGIWNICKN */
    2150. 

  2150. 	NULL,				/* -- hole -- */
    2151. 

  2151. 	NULL,				/* -- hole -- */
    2152. 

  2152. 	r8711_wx_set_rate,		/* SIOCSIWRATE */
    2153. 

  2153. 	r8711_wx_get_rate,		/* SIOCGIWRATE */
    2154. 

  2154. 	dummy,				/* SIOCSIWRTS */
    2155. 

  2155. 	r8711_wx_get_rts,		/* SIOCGIWRTS */
    2156. 

  2156. 	r8711_wx_set_frag,		/* SIOCSIWFRAG */
    2157. 

  2157. 	r8711_wx_get_frag,		/* SIOCGIWFRAG */
    2158. 

  2158. 	dummy,				/* SIOCSIWTXPOW */
    2159. 

  2159. 	dummy,				/* SIOCGIWTXPOW */
    2160. 

  2160. 	dummy,				/* SIOCSIWRETRY */
    2161. 

  2161. 	r8711_wx_get_retry,		/* SIOCGIWRETRY */
    2162. 

  2162. 	r8711_wx_set_enc,		/* SIOCSIWENCODE */
    2163. 

  2163. 	r8711_wx_get_enc,		/* SIOCGIWENCODE */
    2164. 

  2164. 	dummy,				/* SIOCSIWPOWER */
    2165. 

  2165. 	r8711_wx_get_power,		/* SIOCGIWPOWER */
    2166. 

  2166. 	NULL,				/*---hole---*/
    2167. 

  2167. 	NULL,				/*---hole---*/
    2168. 

  2168. 	r871x_wx_set_gen_ie,		/* SIOCSIWGENIE */
    2169. 

  2169. 	NULL,				/* SIOCGIWGENIE */
    2170. 

  2170. 	r871x_wx_set_auth,		/* SIOCSIWAUTH */
    2171. 

  2171. 	NULL,				/* SIOCGIWAUTH */
    2172. 

  2172. 	r871x_wx_set_enc_ext,		/* SIOCSIWENCODEEXT */
    2173. 

  2173. 	NULL,				/* SIOCGIWENCODEEXT */
    2174. 

  2174. 	r871x_wx_set_pmkid,		/* SIOCSIWPMKSA */
    2175. 

  2175. 	NULL,				/*---hole---*/
    2176. 

  2176. };
    2177. 

  2177. 

  2178. static const struct iw_priv_args r8711_private_args[] = {
    2179. 

  2179. 	{
    2180. 

  2180. 		SIOCIWFIRSTPRIV + 0x0,
    2181. 

  2181. 		IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "read32"
    2182. 

  2182. 	},
    2183. 

  2183. 	{
    2184. 

  2184. 		SIOCIWFIRSTPRIV + 0x1,
    2185. 

  2185. 		IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "write32"
    2186. 

  2186. 	},
    2187. 

  2187. 	{
    2188. 

  2188. 		SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext"
    2189. 

  2189. 	},
    2190. 

  2190. 	{
    2191. 

  2191. 		SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl"
    2192. 

  2192. 	},
    2193. 

  2193. 	{
    2194. 

  2194. 		SIOCIWFIRSTPRIV + 0x4,
    2195. 

  2195. 		IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo"
    2196. 

  2196. 	},
    2197. 

  2197. 	{
    2198. 

  2198. 		SIOCIWFIRSTPRIV + 0x5,
    2199. 

  2199. 		IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "setpid"
    2200. 

  2200. 	},
    2201. 

  2201. 	{
    2202. 

  2202. 		SIOCIWFIRSTPRIV + 0x6,
    2203. 

  2203. 		IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start"
    2204. 

  2204. 	}
    2205. 

  2205. };
    2206. 

  2206. 

  2207. static iw_handler r8711_private_handler[] = {
    2208. 

  2208. 	r8711_wx_read32,
    2209. 

  2209. 	r8711_wx_write32,
    2210. 

  2210. 	r8711_drvext_hdl,
    2211. 

  2211. 	r871x_mp_ioctl_hdl,
    2212. 

  2212. 	r871x_get_ap_info, /*for MM DTV platform*/
    2213. 

  2213. 	r871x_set_pid,
    2214. 

  2214. 	 r871x_wps_start,
    2215. 

  2215. };
    2216. 

  2216. 

  2217. static struct iw_statistics *r871x_get_wireless_stats(struct net_device *dev)
    2218. 

  2218. {
    2219. 

  2219. 	struct _adapter *padapter = (struct _adapter *) _netdev_priv(dev);
    2220. 

  2220. 	struct iw_statistics *piwstats = &padapter->iwstats;
    2221. 

  2221. 	int tmp_level = 0;
    2222. 

  2222. 	int tmp_qual = 0;
    2223. 

  2223. 	int tmp_noise = 0;
    2224. 

  2224. 

  2225. 	if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) != true) {
    2226. 

  2226. 		piwstats->qual.qual = 0;
    2227. 

  2227. 		piwstats->qual.level = 0;
    2228. 

  2228. 		piwstats->qual.noise = 0;
    2229. 

  2229. 	} else {
    2230. 

  2230. 		/* show percentage, we need transfer dbm to orignal value. */
    2231. 

  2231. 		tmp_level = padapter->recvpriv.fw_rssi;
    2232. 

  2232. 		tmp_qual = padapter->recvpriv.signal;
    2233. 

  2233. 		tmp_noise = padapter->recvpriv.noise;
    2234. 

  2234. 		piwstats->qual.level = tmp_level;
    2235. 

  2235. 		piwstats->qual.qual = tmp_qual;
    2236. 

  2236. 		piwstats->qual.noise = tmp_noise;
    2237. 

  2237. 	}
    2238. 

  2238. 	piwstats->qual.updated = IW_QUAL_ALL_UPDATED;
    2239. 

  2239. 	return &padapter->iwstats;
    2240. 

  2240. }
    2241. 

  2241. 

  2242. struct iw_handler_def r871x_handlers_def = {
    2243. 

  2243. 	.standard = r8711_handlers,
    2244. 

  2244. 	.num_standard = sizeof(r8711_handlers) / sizeof(iw_handler),
    2245. 

  2245. 	.private = r8711_private_handler,
    2246. 

  2246. 	.private_args = (struct iw_priv_args *)r8711_private_args,
    2247. 

  2247. 	.num_private = sizeof(r8711_private_handler) / sizeof(iw_handler),
    2248. 

  2248. 	.num_private_args = sizeof(r8711_private_args) /
    2249. 

  2249. 			    sizeof(struct iw_priv_args),
    2250. 

  2250. 	.get_wireless_stats = r871x_get_wireless_stats,
    2251. 

  2251. };
    2252.