PageRenderTime 38ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/staging/wilc1000/host_interface.c

http://github.com/mirrors/linux-2.6
C | 4094 lines | 3306 code | 773 blank | 15 comment | 516 complexity | 36487000da69407ae6b0d036e5386c04 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0 
    

  1. #include <linux/slab.h>
    2. 

  2. #include <linux/time.h>
    3. 

  3. #include <linux/kthread.h>
    4. 

  4. #include <linux/delay.h>
    5. 

  5. #include <linux/completion.h>
    6. 

  6. #include <linux/list.h>
    7. 

  7. #include <linux/workqueue.h>
    8. 

  8. #include "host_interface.h"
    9. 

  9. #include <linux/spinlock.h>
    10. 

  10. #include <linux/errno.h>
    11. 

  11. #include "coreconfigurator.h"
    12. 

  12. #include "wilc_wlan.h"
    13. 

  13. #include "wilc_wlan_if.h"
    14. 

  14. #include <linux/etherdevice.h>
    15. 

  15. #include "wilc_wfi_netdevice.h"
    16. 

  16. 

  17. #define HOST_IF_MSG_SCAN                        0
    18. 

  18. #define HOST_IF_MSG_CONNECT                     1
    19. 

  19. #define HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO        2
    20. 

  20. #define HOST_IF_MSG_KEY                         3
    21. 

  21. #define HOST_IF_MSG_RCVD_NTWRK_INFO             4
    22. 

  22. #define HOST_IF_MSG_RCVD_SCAN_COMPLETE          5
    23. 

  23. #define HOST_IF_MSG_CFG_PARAMS                  6
    24. 

  24. #define HOST_IF_MSG_SET_CHANNEL                 7
    25. 

  25. #define HOST_IF_MSG_DISCONNECT                  8
    26. 

  26. #define HOST_IF_MSG_GET_RSSI                    9
    27. 

  27. #define HOST_IF_MSG_ADD_BEACON                  11
    28. 

  28. #define HOST_IF_MSG_DEL_BEACON                  12
    29. 

  29. #define HOST_IF_MSG_ADD_STATION                 13
    30. 

  30. #define HOST_IF_MSG_DEL_STATION                 14
    31. 

  31. #define HOST_IF_MSG_EDIT_STATION                15
    32. 

  32. #define HOST_IF_MSG_SCAN_TIMER_FIRED            16
    33. 

  33. #define HOST_IF_MSG_CONNECT_TIMER_FIRED         17
    34. 

  34. #define HOST_IF_MSG_POWER_MGMT                  18
    35. 

  35. #define HOST_IF_MSG_GET_INACTIVETIME            19
    36. 

  36. #define HOST_IF_MSG_REMAIN_ON_CHAN              20
    37. 

  37. #define HOST_IF_MSG_REGISTER_FRAME              21
    38. 

  38. #define HOST_IF_MSG_LISTEN_TIMER_FIRED          22
    39. 

  39. #define HOST_IF_MSG_SET_WFIDRV_HANDLER          24
    40. 

  40. #define HOST_IF_MSG_GET_MAC_ADDRESS             26
    41. 

  41. #define HOST_IF_MSG_SET_OPERATION_MODE          27
    42. 

  42. #define HOST_IF_MSG_SET_IPADDRESS               28
    43. 

  43. #define HOST_IF_MSG_GET_IPADDRESS               29
    44. 

  44. #define HOST_IF_MSG_GET_STATISTICS              31
    45. 

  45. #define HOST_IF_MSG_SET_MULTICAST_FILTER        32
    46. 

  46. #define HOST_IF_MSG_DEL_BA_SESSION              34
    47. 

  47. #define HOST_IF_MSG_DEL_ALL_STA                 36
    48. 

  48. #define HOST_IF_MSG_SET_TX_POWER		38
    49. 

  49. #define HOST_IF_MSG_GET_TX_POWER		39
    50. 

  50. #define HOST_IF_MSG_EXIT                        100
    51. 

  51. 

  52. #define HOST_IF_SCAN_TIMEOUT                    4000
    53. 

  53. #define HOST_IF_CONNECT_TIMEOUT                 9500
    54. 

  54. 

  55. #define BA_SESSION_DEFAULT_BUFFER_SIZE          16
    56. 

  56. #define BA_SESSION_DEFAULT_TIMEOUT              1000
    57. 

  57. #define BLOCK_ACK_REQ_SIZE                      0x14
    58. 

  58. #define FALSE_FRMWR_CHANNEL			100
    59. 

  59. 

  60. #define TCP_ACK_FILTER_LINK_SPEED_THRESH	54
    61. 

  61. #define DEFAULT_LINK_SPEED			72
    62. 

  62. 

  63. struct host_if_wpa_attr {
    64. 

  64. 	u8 *key;
    65. 

  65. 	const u8 *mac_addr;
    66. 

  66. 	u8 *seq;
    67. 

  67. 	u8 seq_len;
    68. 

  68. 	u8 index;
    69. 

  69. 	u8 key_len;
    70. 

  70. 	u8 mode;
    71. 

  71. };
    72. 

  72. 

  73. struct host_if_wep_attr {
    74. 

  74. 	u8 *key;
    75. 

  75. 	u8 key_len;
    76. 

  76. 	u8 index;
    77. 

  77. 	u8 mode;
    78. 

  78. 	enum AUTHTYPE auth_type;
    79. 

  79. };
    80. 

  80. 

  81. union host_if_key_attr {
    82. 

  82. 	struct host_if_wep_attr wep;
    83. 

  83. 	struct host_if_wpa_attr wpa;
    84. 

  84. 	struct host_if_pmkid_attr pmkid;
    85. 

  85. };
    86. 

  86. 

  87. struct key_attr {
    88. 

  88. 	enum KEY_TYPE type;
    89. 

  89. 	u8 action;
    90. 

  90. 	union host_if_key_attr attr;
    91. 

  91. };
    92. 

  92. 

  93. struct scan_attr {
    94. 

  94. 	u8 src;
    95. 

  95. 	u8 type;
    96. 

  96. 	u8 *ch_freq_list;
    97. 

  97. 	u8 ch_list_len;
    98. 

  98. 	u8 *ies;
    99. 

  99. 	size_t ies_len;
    100. 

  100. 	wilc_scan_result result;
    101. 

  101. 	void *arg;
    102. 

  102. 	struct hidden_network hidden_network;
    103. 

  103. };
    104. 

  104. 

  105. struct connect_attr {
    106. 

  106. 	u8 *bssid;
    107. 

  107. 	u8 *ssid;
    108. 

  108. 	size_t ssid_len;
    109. 

  109. 	u8 *ies;
    110. 

  110. 	size_t ies_len;
    111. 

  111. 	u8 security;
    112. 

  112. 	wilc_connect_result result;
    113. 

  113. 	void *arg;
    114. 

  114. 	enum AUTHTYPE auth_type;
    115. 

  115. 	u8 ch;
    116. 

  116. 	void *params;
    117. 

  117. };
    118. 

  118. 

  119. struct rcvd_async_info {
    120. 

  120. 	u8 *buffer;
    121. 

  121. 	u32 len;
    122. 

  122. };
    123. 

  123. 

  124. struct channel_attr {
    125. 

  125. 	u8 set_ch;
    126. 

  126. };
    127. 

  127. 

  128. struct beacon_attr {
    129. 

  129. 	u32 interval;
    130. 

  130. 	u32 dtim_period;
    131. 

  131. 	u32 head_len;
    132. 

  132. 	u8 *head;
    133. 

  133. 	u32 tail_len;
    134. 

  134. 	u8 *tail;
    135. 

  135. };
    136. 

  136. 

  137. struct set_multicast {
    138. 

  138. 	bool enabled;
    139. 

  139. 	u32 cnt;
    140. 

  140. };
    141. 

  141. 

  142. struct del_all_sta {
    143. 

  143. 	u8 del_all_sta[MAX_NUM_STA][ETH_ALEN];
    144. 

  144. 	u8 assoc_sta;
    145. 

  145. };
    146. 

  146. 

  147. struct del_sta {
    148. 

  148. 	u8 mac_addr[ETH_ALEN];
    149. 

  149. };
    150. 

  150. 

  151. struct power_mgmt_param {
    152. 

  152. 	bool enabled;
    153. 

  153. 	u32 timeout;
    154. 

  154. };
    155. 

  155. 

  156. struct set_ip_addr {
    157. 

  157. 	u8 *ip_addr;
    158. 

  158. 	u8 idx;
    159. 

  159. };
    160. 

  160. 

  161. struct sta_inactive_t {
    162. 

  162. 	u8 mac[6];
    163. 

  163. };
    164. 

  164. 

  165. struct tx_power {
    166. 

  166. 	u8 tx_pwr;
    167. 

  167. };
    168. 

  168. 

  169. union message_body {
    170. 

  170. 	struct scan_attr scan_info;
    171. 

  171. 	struct connect_attr con_info;
    172. 

  172. 	struct rcvd_net_info net_info;
    173. 

  173. 	struct rcvd_async_info async_info;
    174. 

  174. 	struct key_attr key_info;
    175. 

  175. 	struct cfg_param_attr cfg_info;
    176. 

  176. 	struct channel_attr channel_info;
    177. 

  177. 	struct beacon_attr beacon_info;
    178. 

  178. 	struct add_sta_param add_sta_info;
    179. 

  179. 	struct del_sta del_sta_info;
    180. 

  180. 	struct add_sta_param edit_sta_info;
    181. 

  181. 	struct power_mgmt_param pwr_mgmt_info;
    182. 

  182. 	struct sta_inactive_t mac_info;
    183. 

  183. 	struct set_ip_addr ip_info;
    184. 

  184. 	struct drv_handler drv;
    185. 

  185. 	struct set_multicast multicast_info;
    186. 

  186. 	struct op_mode mode;
    187. 

  187. 	struct get_mac_addr get_mac_info;
    188. 

  188. 	struct ba_session_info session_info;
    189. 

  189. 	struct remain_ch remain_on_ch;
    190. 

  190. 	struct reg_frame reg_frame;
    191. 

  191. 	char *data;
    192. 

  192. 	struct del_all_sta del_all_sta_info;
    193. 

  193. 	struct tx_power tx_power;
    194. 

  194. };
    195. 

  195. 

  196. struct host_if_msg {
    197. 

  197. 	u16 id;
    198. 

  198. 	union message_body body;
    199. 

  199. 	struct wilc_vif *vif;
    200. 

  200. 	struct work_struct work;
    201. 

  201. };
    202. 

  202. 

  203. struct join_bss_param {
    204. 

  204. 	BSSTYPE_T bss_type;
    205. 

  205. 	u8 dtim_period;
    206. 

  206. 	u16 beacon_period;
    207. 

  207. 	u16 cap_info;
    208. 

  208. 	u8 bssid[6];
    209. 

  209. 	char ssid[MAX_SSID_LEN];
    210. 

  210. 	u8 ssid_len;
    211. 

  211. 	u8 supp_rates[MAX_RATES_SUPPORTED + 1];
    212. 

  212. 	u8 ht_capable;
    213. 

  213. 	u8 wmm_cap;
    214. 

  214. 	u8 uapsd_cap;
    215. 

  215. 	bool rsn_found;
    216. 

  216. 	u8 rsn_grp_policy;
    217. 

  217. 	u8 mode_802_11i;
    218. 

  218. 	u8 rsn_pcip_policy[3];
    219. 

  219. 	u8 rsn_auth_policy[3];
    220. 

  220. 	u8 rsn_cap[2];
    221. 

  221. 	u32 tsf;
    222. 

  222. 	u8 noa_enabled;
    223. 

  223. 	u8 opp_enabled;
    224. 

  224. 	u8 ct_window;
    225. 

  225. 	u8 cnt;
    226. 

  226. 	u8 idx;
    227. 

  227. 	u8 duration[4];
    228. 

  228. 	u8 interval[4];
    229. 

  229. 	u8 start_time[4];
    230. 

  230. };
    231. 

  231. 

  232. static struct host_if_drv *terminated_handle;
    233. 

  233. bool wilc_optaining_ip;
    234. 

  234. static u8 P2P_LISTEN_STATE;
    235. 

  235. static struct workqueue_struct *hif_workqueue;
    236. 

  236. static struct completion hif_thread_comp;
    237. 

  237. static struct completion hif_driver_comp;
    238. 

  238. static struct completion hif_wait_response;
    239. 

  239. static struct mutex hif_deinit_lock;
    240. 

  240. static struct timer_list periodic_rssi;
    241. 

  241. 

  242. u8 wilc_multicast_mac_addr_list[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
    243. 

  243. 

  244. static u8 rcv_assoc_resp[MAX_ASSOC_RESP_FRAME_SIZE];
    245. 

  245. 

  246. static bool scan_while_connected;
    247. 

  247. 

  248. static s8 rssi;
    249. 

  249. static u8 set_ip[2][4];
    250. 

  250. static u8 get_ip[2][4];
    251. 

  251. static u32 inactive_time;
    252. 

  252. static u8 del_beacon;
    253. 

  253. static u32 clients_count;
    254. 

  254. 

  255. static u8 *join_req;
    256. 

  256. static u8 *info_element;
    257. 

  257. static u8 mode_11i;
    258. 

  258. static u8 auth_type;
    259. 

  259. static u32 join_req_size;
    260. 

  260. static u32 info_element_size;
    261. 

  261. static struct wilc_vif *join_req_vif;
    262. 

  262. #define REAL_JOIN_REQ 0
    263. 

  263. #define FLUSHED_JOIN_REQ 1
    264. 

  264. #define FLUSHED_BYTE_POS 79
    265. 

  265. 

  266. static void *host_int_ParseJoinBssParam(struct network_info *ptstrNetworkInfo);
    267. 

  267. static int host_int_get_ipaddress(struct wilc_vif *vif, u8 *ip_addr, u8 idx);
    268. 

  268. static s32 Handle_ScanDone(struct wilc_vif *vif, enum scan_event enuEvent);
    269. 

  269. static void host_if_work(struct work_struct *work);
    270. 

  270. 

  271. /*!
    272. 

  272.  *  @author		syounan
    273. 

  273.  *  @date		1 Sep 2010
    274. 

  274.  *  @note		copied from FLO glue implementatuion
    275. 

  275.  *  @version		1.0
    276. 

  276.  */
    277. 

  277. static int wilc_enqueue_cmd(struct host_if_msg *msg)
    278. 

  278. {
    279. 

  279. 	struct host_if_msg *new_msg;
    280. 

  280. 

  281. 	new_msg = kmemdup(msg, sizeof(*new_msg), GFP_ATOMIC);
    282. 

  282. 	if (!new_msg)
    283. 

  283. 		return -ENOMEM;
    284. 

  284. 

  285. 	INIT_WORK(&new_msg->work, host_if_work);
    286. 

  286. 	queue_work(hif_workqueue, &new_msg->work);
    287. 

  287. 	return 0;
    288. 

  288. }
    289. 

  289. 

  290. 

  291. /* The u8IfIdx starts from 0 to NUM_CONCURRENT_IFC -1, but 0 index used as
    292. 

  292.  * special purpose in wilc device, so we add 1 to the index to starts from 1.
    293. 

  293.  * As a result, the returned index will be 1 to NUM_CONCURRENT_IFC.
    294. 

  294.  */
    295. 

  295. int wilc_get_vif_idx(struct wilc_vif *vif)
    296. 

  296. {
    297. 

  297. 	return vif->idx + 1;
    298. 

  298. }
    299. 

  299. 

  300. /* We need to minus 1 from idx which is from wilc device to get real index
    301. 

  301.  * of wilc->vif[], because we add 1 when pass to wilc device in the function
    302. 

  302.  * wilc_get_vif_idx.
    303. 

  303.  * As a result, the index should be between 0 and NUM_CONCURRENT_IFC -1.
    304. 

  304.  */
    305. 

  305. static struct wilc_vif *wilc_get_vif_from_idx(struct wilc *wilc, int idx)
    306. 

  306. {
    307. 

  307. 	int index = idx - 1;
    308. 

  308. 

  309. 	if (index < 0 || index >= NUM_CONCURRENT_IFC)
    310. 

  310. 		return NULL;
    311. 

  311. 

  312. 	return wilc->vif[index];
    313. 

  313. }
    314. 

  314. 

  315. static void handle_set_channel(struct wilc_vif *vif,
    316. 

  316. 			       struct channel_attr *hif_set_ch)
    317. 

  317. {
    318. 

  318. 	int ret = 0;
    319. 

  319. 	struct wid wid;
    320. 

  320. 

  321. 	wid.id = (u16)WID_CURRENT_CHANNEL;
    322. 

  322. 	wid.type = WID_CHAR;
    323. 

  323. 	wid.val = (char *)&hif_set_ch->set_ch;
    324. 

  324. 	wid.size = sizeof(char);
    325. 

  325. 

  326. 	ret = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    327. 

  327. 				   wilc_get_vif_idx(vif));
    328. 

  328. 

  329. 	if (ret)
    330. 

  330. 		netdev_err(vif->ndev, "Failed to set channel\n");
    331. 

  331. }
    332. 

  332. 

  333. static void handle_set_wfi_drv_handler(struct wilc_vif *vif,
    334. 

  334. 				       struct drv_handler *hif_drv_handler)
    335. 

  335. {
    336. 

  336. 	int ret = 0;
    337. 

  337. 	struct wid wid;
    338. 

  338. 

  339. 	wid.id = (u16)WID_SET_DRV_HANDLER;
    340. 

  340. 	wid.type = WID_STR;
    341. 

  341. 	wid.val = (s8 *)hif_drv_handler;
    342. 

  342. 	wid.size = sizeof(*hif_drv_handler);
    343. 

  343. 

  344. 	ret = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    345. 

  345. 				   hif_drv_handler->handler);
    346. 

  346. 

  347. 	if (!hif_drv_handler->handler)
    348. 

  348. 		complete(&hif_driver_comp);
    349. 

  349. 

  350. 	if (ret)
    351. 

  351. 		netdev_err(vif->ndev, "Failed to set driver handler\n");
    352. 

  352. }
    353. 

  353. 

  354. static void handle_set_operation_mode(struct wilc_vif *vif,
    355. 

  355. 				      struct op_mode *hif_op_mode)
    356. 

  356. {
    357. 

  357. 	int ret = 0;
    358. 

  358. 	struct wid wid;
    359. 

  359. 

  360. 	wid.id = (u16)WID_SET_OPERATION_MODE;
    361. 

  361. 	wid.type = WID_INT;
    362. 

  362. 	wid.val = (s8 *)&hif_op_mode->mode;
    363. 

  363. 	wid.size = sizeof(u32);
    364. 

  364. 

  365. 	ret = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    366. 

  366. 				   wilc_get_vif_idx(vif));
    367. 

  367. 

  368. 	if ((hif_op_mode->mode) == IDLE_MODE)
    369. 

  369. 		complete(&hif_driver_comp);
    370. 

  370. 

  371. 	if (ret)
    372. 

  372. 		netdev_err(vif->ndev, "Failed to set driver handler\n");
    373. 

  373. }
    374. 

  374. 

  375. static void handle_set_ip_address(struct wilc_vif *vif, u8 *ip_addr, u8 idx)
    376. 

  376. {
    377. 

  377. 	int ret = 0;
    378. 

  378. 	struct wid wid;
    379. 

  379. 	char firmware_ip_addr[4] = {0};
    380. 

  380. 

  381. 	if (ip_addr[0] < 192)
    382. 

  382. 		ip_addr[0] = 0;
    383. 

  383. 

  384. 	memcpy(set_ip[idx], ip_addr, IP_ALEN);
    385. 

  385. 

  386. 	wid.id = (u16)WID_IP_ADDRESS;
    387. 

  387. 	wid.type = WID_STR;
    388. 

  388. 	wid.val = (u8 *)ip_addr;
    389. 

  389. 	wid.size = IP_ALEN;
    390. 

  390. 

  391. 	ret = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    392. 

  392. 				   wilc_get_vif_idx(vif));
    393. 

  393. 

  394. 	host_int_get_ipaddress(vif, firmware_ip_addr, idx);
    395. 

  395. 

  396. 	if (ret)
    397. 

  397. 		netdev_err(vif->ndev, "Failed to set IP address\n");
    398. 

  398. }
    399. 

  399. 

  400. static void handle_get_ip_address(struct wilc_vif *vif, u8 idx)
    401. 

  401. {
    402. 

  402. 	int ret = 0;
    403. 

  403. 	struct wid wid;
    404. 

  404. 

  405. 	wid.id = (u16)WID_IP_ADDRESS;
    406. 

  406. 	wid.type = WID_STR;
    407. 

  407. 	wid.val = kmalloc(IP_ALEN, GFP_KERNEL);
    408. 

  408. 	wid.size = IP_ALEN;
    409. 

  409. 

  410. 	ret = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
    411. 

  411. 				   wilc_get_vif_idx(vif));
    412. 

  412. 

  413. 	memcpy(get_ip[idx], wid.val, IP_ALEN);
    414. 

  414. 

  415. 	kfree(wid.val);
    416. 

  416. 

  417. 	if (memcmp(get_ip[idx], set_ip[idx], IP_ALEN) != 0)
    418. 

  418. 		wilc_setup_ipaddress(vif, set_ip[idx], idx);
    419. 

  419. 

  420. 	if (ret)
    421. 

  421. 		netdev_err(vif->ndev, "Failed to get IP address\n");
    422. 

  422. }
    423. 

  423. 

  424. static void handle_get_mac_address(struct wilc_vif *vif,
    425. 

  425. 				   struct get_mac_addr *get_mac_addr)
    426. 

  426. {
    427. 

  427. 	int ret = 0;
    428. 

  428. 	struct wid wid;
    429. 

  429. 

  430. 	wid.id = (u16)WID_MAC_ADDR;
    431. 

  431. 	wid.type = WID_STR;
    432. 

  432. 	wid.val = get_mac_addr->mac_addr;
    433. 

  433. 	wid.size = ETH_ALEN;
    434. 

  434. 

  435. 	ret = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
    436. 

  436. 				   wilc_get_vif_idx(vif));
    437. 

  437. 

  438. 	if (ret)
    439. 

  439. 		netdev_err(vif->ndev, "Failed to get mac address\n");
    440. 

  440. 	complete(&hif_wait_response);
    441. 

  441. }
    442. 

  442. 

  443. static void handle_cfg_param(struct wilc_vif *vif,
    444. 

  444. 			     struct cfg_param_attr *cfg_param_attr)
    445. 

  445. {
    446. 

  446. 	int ret = 0;
    447. 

  447. 	struct wid wid_list[32];
    448. 

  448. 	struct host_if_drv *hif_drv = vif->hif_drv;
    449. 

  449. 	int i = 0;
    450. 

  450. 

  451. 	mutex_lock(&hif_drv->cfg_values_lock);
    452. 

  452. 

  453. 	if (cfg_param_attr->flag & BSS_TYPE) {
    454. 

  454. 		u8 bss_type = cfg_param_attr->bss_type;
    455. 

  455. 

  456. 		if (bss_type < 6) {
    457. 

  457. 			wid_list[i].id = WID_BSS_TYPE;
    458. 

  458. 			wid_list[i].val = (s8 *)&bss_type;
    459. 

  459. 			wid_list[i].type = WID_CHAR;
    460. 

  460. 			wid_list[i].size = sizeof(char);
    461. 

  461. 			hif_drv->cfg_values.bss_type = bss_type;
    462. 

  462. 		} else {
    463. 

  463. 			netdev_err(vif->ndev, "check value 6 over\n");
    464. 

  464. 			goto unlock;
    465. 

  465. 		}
    466. 

  466. 		i++;
    467. 

  467. 	}
    468. 

  468. 	if (cfg_param_attr->flag & AUTH_TYPE) {
    469. 

  469. 		if (cfg_param_attr->auth_type == 1 ||
    470. 

  470. 		    cfg_param_attr->auth_type == 2 ||
    471. 

  471. 		    cfg_param_attr->auth_type == 5) {
    472. 

  472. 			wid_list[i].id = WID_AUTH_TYPE;
    473. 

  473. 			wid_list[i].val = (s8 *)&cfg_param_attr->auth_type;
    474. 

  474. 			wid_list[i].type = WID_CHAR;
    475. 

  475. 			wid_list[i].size = sizeof(char);
    476. 

  476. 			hif_drv->cfg_values.auth_type = (u8)cfg_param_attr->auth_type;
    477. 

  477. 		} else {
    478. 

  478. 			netdev_err(vif->ndev, "Impossible value\n");
    479. 

  479. 			goto unlock;
    480. 

  480. 		}
    481. 

  481. 		i++;
    482. 

  482. 	}
    483. 

  483. 	if (cfg_param_attr->flag & AUTHEN_TIMEOUT) {
    484. 

  484. 		if (cfg_param_attr->auth_timeout > 0 &&
    485. 

  485. 		    cfg_param_attr->auth_timeout < 65536) {
    486. 

  486. 			wid_list[i].id = WID_AUTH_TIMEOUT;
    487. 

  487. 			wid_list[i].val = (s8 *)&cfg_param_attr->auth_timeout;
    488. 

  488. 			wid_list[i].type = WID_SHORT;
    489. 

  489. 			wid_list[i].size = sizeof(u16);
    490. 

  490. 			hif_drv->cfg_values.auth_timeout = cfg_param_attr->auth_timeout;
    491. 

  491. 		} else {
    492. 

  492. 			netdev_err(vif->ndev, "Range(1 ~ 65535) over\n");
    493. 

  493. 			goto unlock;
    494. 

  494. 		}
    495. 

  495. 		i++;
    496. 

  496. 	}
    497. 

  497. 	if (cfg_param_attr->flag & POWER_MANAGEMENT) {
    498. 

  498. 		if (cfg_param_attr->power_mgmt_mode < 5) {
    499. 

  499. 			wid_list[i].id = WID_POWER_MANAGEMENT;
    500. 

  500. 			wid_list[i].val = (s8 *)&cfg_param_attr->power_mgmt_mode;
    501. 

  501. 			wid_list[i].type = WID_CHAR;
    502. 

  502. 			wid_list[i].size = sizeof(char);
    503. 

  503. 			hif_drv->cfg_values.power_mgmt_mode = (u8)cfg_param_attr->power_mgmt_mode;
    504. 

  504. 		} else {
    505. 

  505. 			netdev_err(vif->ndev, "Invalid power mode\n");
    506. 

  506. 			goto unlock;
    507. 

  507. 		}
    508. 

  508. 		i++;
    509. 

  509. 	}
    510. 

  510. 	if (cfg_param_attr->flag & RETRY_SHORT) {
    511. 

  511. 		if (cfg_param_attr->short_retry_limit > 0 &&
    512. 

  512. 		    cfg_param_attr->short_retry_limit < 256) {
    513. 

  513. 			wid_list[i].id = WID_SHORT_RETRY_LIMIT;
    514. 

  514. 			wid_list[i].val = (s8 *)&cfg_param_attr->short_retry_limit;
    515. 

  515. 			wid_list[i].type = WID_SHORT;
    516. 

  516. 			wid_list[i].size = sizeof(u16);
    517. 

  517. 			hif_drv->cfg_values.short_retry_limit = cfg_param_attr->short_retry_limit;
    518. 

  518. 		} else {
    519. 

  519. 			netdev_err(vif->ndev, "Range(1~256) over\n");
    520. 

  520. 			goto unlock;
    521. 

  521. 		}
    522. 

  522. 		i++;
    523. 

  523. 	}
    524. 

  524. 	if (cfg_param_attr->flag & RETRY_LONG) {
    525. 

  525. 		if (cfg_param_attr->long_retry_limit > 0 &&
    526. 

  526. 		    cfg_param_attr->long_retry_limit < 256) {
    527. 

  527. 			wid_list[i].id = WID_LONG_RETRY_LIMIT;
    528. 

  528. 			wid_list[i].val = (s8 *)&cfg_param_attr->long_retry_limit;
    529. 

  529. 			wid_list[i].type = WID_SHORT;
    530. 

  530. 			wid_list[i].size = sizeof(u16);
    531. 

  531. 			hif_drv->cfg_values.long_retry_limit = cfg_param_attr->long_retry_limit;
    532. 

  532. 		} else {
    533. 

  533. 			netdev_err(vif->ndev, "Range(1~256) over\n");
    534. 

  534. 			goto unlock;
    535. 

  535. 		}
    536. 

  536. 		i++;
    537. 

  537. 	}
    538. 

  538. 	if (cfg_param_attr->flag & FRAG_THRESHOLD) {
    539. 

  539. 		if (cfg_param_attr->frag_threshold > 255 &&
    540. 

  540. 		    cfg_param_attr->frag_threshold < 7937) {
    541. 

  541. 			wid_list[i].id = WID_FRAG_THRESHOLD;
    542. 

  542. 			wid_list[i].val = (s8 *)&cfg_param_attr->frag_threshold;
    543. 

  543. 			wid_list[i].type = WID_SHORT;
    544. 

  544. 			wid_list[i].size = sizeof(u16);
    545. 

  545. 			hif_drv->cfg_values.frag_threshold = cfg_param_attr->frag_threshold;
    546. 

  546. 		} else {
    547. 

  547. 			netdev_err(vif->ndev, "Threshold Range fail\n");
    548. 

  548. 			goto unlock;
    549. 

  549. 		}
    550. 

  550. 		i++;
    551. 

  551. 	}
    552. 

  552. 	if (cfg_param_attr->flag & RTS_THRESHOLD) {
    553. 

  553. 		if (cfg_param_attr->rts_threshold > 255 &&
    554. 

  554. 		    cfg_param_attr->rts_threshold < 65536) {
    555. 

  555. 			wid_list[i].id = WID_RTS_THRESHOLD;
    556. 

  556. 			wid_list[i].val = (s8 *)&cfg_param_attr->rts_threshold;
    557. 

  557. 			wid_list[i].type = WID_SHORT;
    558. 

  558. 			wid_list[i].size = sizeof(u16);
    559. 

  559. 			hif_drv->cfg_values.rts_threshold = cfg_param_attr->rts_threshold;
    560. 

  560. 		} else {
    561. 

  561. 			netdev_err(vif->ndev, "Threshold Range fail\n");
    562. 

  562. 			goto unlock;
    563. 

  563. 		}
    564. 

  564. 		i++;
    565. 

  565. 	}
    566. 

  566. 	if (cfg_param_attr->flag & PREAMBLE) {
    567. 

  567. 		if (cfg_param_attr->preamble_type < 3) {
    568. 

  568. 			wid_list[i].id = WID_PREAMBLE;
    569. 

  569. 			wid_list[i].val = (s8 *)&cfg_param_attr->preamble_type;
    570. 

  570. 			wid_list[i].type = WID_CHAR;
    571. 

  571. 			wid_list[i].size = sizeof(char);
    572. 

  572. 			hif_drv->cfg_values.preamble_type = cfg_param_attr->preamble_type;
    573. 

  573. 		} else {
    574. 

  574. 			netdev_err(vif->ndev, "Preamle Range(0~2) over\n");
    575. 

  575. 			goto unlock;
    576. 

  576. 		}
    577. 

  577. 		i++;
    578. 

  578. 	}
    579. 

  579. 	if (cfg_param_attr->flag & SHORT_SLOT_ALLOWED) {
    580. 

  580. 		if (cfg_param_attr->short_slot_allowed < 2) {
    581. 

  581. 			wid_list[i].id = WID_SHORT_SLOT_ALLOWED;
    582. 

  582. 			wid_list[i].val = (s8 *)&cfg_param_attr->short_slot_allowed;
    583. 

  583. 			wid_list[i].type = WID_CHAR;
    584. 

  584. 			wid_list[i].size = sizeof(char);
    585. 

  585. 			hif_drv->cfg_values.short_slot_allowed = (u8)cfg_param_attr->short_slot_allowed;
    586. 

  586. 		} else {
    587. 

  587. 			netdev_err(vif->ndev, "Short slot(2) over\n");
    588. 

  588. 			goto unlock;
    589. 

  589. 		}
    590. 

  590. 		i++;
    591. 

  591. 	}
    592. 

  592. 	if (cfg_param_attr->flag & TXOP_PROT_DISABLE) {
    593. 

  593. 		if (cfg_param_attr->txop_prot_disabled < 2) {
    594. 

  594. 			wid_list[i].id = WID_11N_TXOP_PROT_DISABLE;
    595. 

  595. 			wid_list[i].val = (s8 *)&cfg_param_attr->txop_prot_disabled;
    596. 

  596. 			wid_list[i].type = WID_CHAR;
    597. 

  597. 			wid_list[i].size = sizeof(char);
    598. 

  598. 			hif_drv->cfg_values.txop_prot_disabled = (u8)cfg_param_attr->txop_prot_disabled;
    599. 

  599. 		} else {
    600. 

  600. 			netdev_err(vif->ndev, "TXOP prot disable\n");
    601. 

  601. 			goto unlock;
    602. 

  602. 		}
    603. 

  603. 		i++;
    604. 

  604. 	}
    605. 

  605. 	if (cfg_param_attr->flag & BEACON_INTERVAL) {
    606. 

  606. 		if (cfg_param_attr->beacon_interval > 0 &&
    607. 

  607. 		    cfg_param_attr->beacon_interval < 65536) {
    608. 

  608. 			wid_list[i].id = WID_BEACON_INTERVAL;
    609. 

  609. 			wid_list[i].val = (s8 *)&cfg_param_attr->beacon_interval;
    610. 

  610. 			wid_list[i].type = WID_SHORT;
    611. 

  611. 			wid_list[i].size = sizeof(u16);
    612. 

  612. 			hif_drv->cfg_values.beacon_interval = cfg_param_attr->beacon_interval;
    613. 

  613. 		} else {
    614. 

  614. 			netdev_err(vif->ndev, "Beacon interval(1~65535)fail\n");
    615. 

  615. 			goto unlock;
    616. 

  616. 		}
    617. 

  617. 		i++;
    618. 

  618. 	}
    619. 

  619. 	if (cfg_param_attr->flag & DTIM_PERIOD) {
    620. 

  620. 		if (cfg_param_attr->dtim_period > 0 &&
    621. 

  621. 		    cfg_param_attr->dtim_period < 256) {
    622. 

  622. 			wid_list[i].id = WID_DTIM_PERIOD;
    623. 

  623. 			wid_list[i].val = (s8 *)&cfg_param_attr->dtim_period;
    624. 

  624. 			wid_list[i].type = WID_CHAR;
    625. 

  625. 			wid_list[i].size = sizeof(char);
    626. 

  626. 			hif_drv->cfg_values.dtim_period = cfg_param_attr->dtim_period;
    627. 

  627. 		} else {
    628. 

  628. 			netdev_err(vif->ndev, "DTIM range(1~255) fail\n");
    629. 

  629. 			goto unlock;
    630. 

  630. 		}
    631. 

  631. 		i++;
    632. 

  632. 	}
    633. 

  633. 	if (cfg_param_attr->flag & SITE_SURVEY) {
    634. 

  634. 		if (cfg_param_attr->site_survey_enabled < 3) {
    635. 

  635. 			wid_list[i].id = WID_SITE_SURVEY;
    636. 

  636. 			wid_list[i].val = (s8 *)&cfg_param_attr->site_survey_enabled;
    637. 

  637. 			wid_list[i].type = WID_CHAR;
    638. 

  638. 			wid_list[i].size = sizeof(char);
    639. 

  639. 			hif_drv->cfg_values.site_survey_enabled = (u8)cfg_param_attr->site_survey_enabled;
    640. 

  640. 		} else {
    641. 

  641. 			netdev_err(vif->ndev, "Site survey disable\n");
    642. 

  642. 			goto unlock;
    643. 

  643. 		}
    644. 

  644. 		i++;
    645. 

  645. 	}
    646. 

  646. 	if (cfg_param_attr->flag & SITE_SURVEY_SCAN_TIME) {
    647. 

  647. 		if (cfg_param_attr->site_survey_scan_time > 0 &&
    648. 

  648. 		    cfg_param_attr->site_survey_scan_time < 65536) {
    649. 

  649. 			wid_list[i].id = WID_SITE_SURVEY_SCAN_TIME;
    650. 

  650. 			wid_list[i].val = (s8 *)&cfg_param_attr->site_survey_scan_time;
    651. 

  651. 			wid_list[i].type = WID_SHORT;
    652. 

  652. 			wid_list[i].size = sizeof(u16);
    653. 

  653. 			hif_drv->cfg_values.site_survey_scan_time = cfg_param_attr->site_survey_scan_time;
    654. 

  654. 		} else {
    655. 

  655. 			netdev_err(vif->ndev, "Site scan time(1~65535) over\n");
    656. 

  656. 			goto unlock;
    657. 

  657. 		}
    658. 

  658. 		i++;
    659. 

  659. 	}
    660. 

  660. 	if (cfg_param_attr->flag & ACTIVE_SCANTIME) {
    661. 

  661. 		if (cfg_param_attr->active_scan_time > 0 &&
    662. 

  662. 		    cfg_param_attr->active_scan_time < 65536) {
    663. 

  663. 			wid_list[i].id = WID_ACTIVE_SCAN_TIME;
    664. 

  664. 			wid_list[i].val = (s8 *)&cfg_param_attr->active_scan_time;
    665. 

  665. 			wid_list[i].type = WID_SHORT;
    666. 

  666. 			wid_list[i].size = sizeof(u16);
    667. 

  667. 			hif_drv->cfg_values.active_scan_time = cfg_param_attr->active_scan_time;
    668. 

  668. 		} else {
    669. 

  669. 			netdev_err(vif->ndev, "Active time(1~65535) over\n");
    670. 

  670. 			goto unlock;
    671. 

  671. 		}
    672. 

  672. 		i++;
    673. 

  673. 	}
    674. 

  674. 	if (cfg_param_attr->flag & PASSIVE_SCANTIME) {
    675. 

  675. 		if (cfg_param_attr->passive_scan_time > 0 &&
    676. 

  676. 		    cfg_param_attr->passive_scan_time < 65536) {
    677. 

  677. 			wid_list[i].id = WID_PASSIVE_SCAN_TIME;
    678. 

  678. 			wid_list[i].val = (s8 *)&cfg_param_attr->passive_scan_time;
    679. 

  679. 			wid_list[i].type = WID_SHORT;
    680. 

  680. 			wid_list[i].size = sizeof(u16);
    681. 

  681. 			hif_drv->cfg_values.passive_scan_time = cfg_param_attr->passive_scan_time;
    682. 

  682. 		} else {
    683. 

  683. 			netdev_err(vif->ndev, "Passive time(1~65535) over\n");
    684. 

  684. 			goto unlock;
    685. 

  685. 		}
    686. 

  686. 		i++;
    687. 

  687. 	}
    688. 

  688. 	if (cfg_param_attr->flag & CURRENT_TX_RATE) {
    689. 

  689. 		enum CURRENT_TXRATE curr_tx_rate = cfg_param_attr->curr_tx_rate;
    690. 

  690. 

  691. 		if (curr_tx_rate == AUTORATE || curr_tx_rate == MBPS_1 ||
    692. 

  692. 		    curr_tx_rate == MBPS_2 || curr_tx_rate == MBPS_5_5 ||
    693. 

  693. 		    curr_tx_rate == MBPS_11 || curr_tx_rate == MBPS_6 ||
    694. 

  694. 		    curr_tx_rate == MBPS_9 || curr_tx_rate == MBPS_12 ||
    695. 

  695. 		    curr_tx_rate == MBPS_18 || curr_tx_rate == MBPS_24 ||
    696. 

  696. 		    curr_tx_rate == MBPS_36 || curr_tx_rate == MBPS_48 ||
    697. 

  697. 		    curr_tx_rate == MBPS_54) {
    698. 

  698. 			wid_list[i].id = WID_CURRENT_TX_RATE;
    699. 

  699. 			wid_list[i].val = (s8 *)&curr_tx_rate;
    700. 

  700. 			wid_list[i].type = WID_SHORT;
    701. 

  701. 			wid_list[i].size = sizeof(u16);
    702. 

  702. 			hif_drv->cfg_values.curr_tx_rate = (u8)curr_tx_rate;
    703. 

  703. 		} else {
    704. 

  704. 			netdev_err(vif->ndev, "out of TX rate\n");
    705. 

  705. 			goto unlock;
    706. 

  706. 		}
    707. 

  707. 		i++;
    708. 

  708. 	}
    709. 

  709. 

  710. 	ret = wilc_send_config_pkt(vif, SET_CFG, wid_list,
    711. 

  711. 				   i, wilc_get_vif_idx(vif));
    712. 

  712. 

  713. 	if (ret)
    714. 

  714. 		netdev_err(vif->ndev, "Error in setting CFG params\n");
    715. 

  715. 

  716. unlock:
    717. 

  717. 	mutex_unlock(&hif_drv->cfg_values_lock);
    718. 

  718. }
    719. 

  719. 

  720. static s32 handle_scan(struct wilc_vif *vif, struct scan_attr *scan_info)
    721. 

  721. {
    722. 

  722. 	s32 result = 0;
    723. 

  723. 	struct wid wid_list[5];
    724. 

  724. 	u32 index = 0;
    725. 

  725. 	u32 i;
    726. 

  726. 	u8 *buffer;
    727. 

  727. 	u8 valuesize = 0;
    728. 

  728. 	u8 *pu8HdnNtwrksWidVal = NULL;
    729. 

  729. 	struct host_if_drv *hif_drv = vif->hif_drv;
    730. 

  730. 

  731. 	hif_drv->usr_scan_req.scan_result = scan_info->result;
    732. 

  732. 	hif_drv->usr_scan_req.arg = scan_info->arg;
    733. 

  733. 

  734. 	if ((hif_drv->hif_state >= HOST_IF_SCANNING) &&
    735. 

  735. 	    (hif_drv->hif_state < HOST_IF_CONNECTED)) {
    736. 

  736. 		netdev_err(vif->ndev, "Already scan\n");
    737. 

  737. 		result = -EBUSY;
    738. 

  738. 		goto ERRORHANDLER;
    739. 

  739. 	}
    740. 

  740. 

  741. 	if (wilc_optaining_ip || wilc_connecting) {
    742. 

  742. 		netdev_err(vif->ndev, "Don't do obss scan\n");
    743. 

  743. 		result = -EBUSY;
    744. 

  744. 		goto ERRORHANDLER;
    745. 

  745. 	}
    746. 

  746. 

  747. 	hif_drv->usr_scan_req.rcvd_ch_cnt = 0;
    748. 

  748. 

  749. 	wid_list[index].id = (u16)WID_SSID_PROBE_REQ;
    750. 

  750. 	wid_list[index].type = WID_STR;
    751. 

  751. 

  752. 	for (i = 0; i < scan_info->hidden_network.n_ssids; i++)
    753. 

  753. 		valuesize += ((scan_info->hidden_network.net_info[i].ssid_len) + 1);
    754. 

  754. 	pu8HdnNtwrksWidVal = kmalloc(valuesize + 1, GFP_KERNEL);
    755. 

  755. 	wid_list[index].val = pu8HdnNtwrksWidVal;
    756. 

  756. 	if (wid_list[index].val) {
    757. 

  757. 		buffer = wid_list[index].val;
    758. 

  758. 

  759. 		*buffer++ = scan_info->hidden_network.n_ssids;
    760. 

  760. 

  761. 		for (i = 0; i < scan_info->hidden_network.n_ssids; i++) {
    762. 

  762. 			*buffer++ = scan_info->hidden_network.net_info[i].ssid_len;
    763. 

  763. 			memcpy(buffer, scan_info->hidden_network.net_info[i].ssid, scan_info->hidden_network.net_info[i].ssid_len);
    764. 

  764. 			buffer += scan_info->hidden_network.net_info[i].ssid_len;
    765. 

  765. 		}
    766. 

  766. 

  767. 		wid_list[index].size = (s32)(valuesize + 1);
    768. 

  768. 		index++;
    769. 

  769. 	}
    770. 

  770. 

  771. 	wid_list[index].id = WID_INFO_ELEMENT_PROBE;
    772. 

  772. 	wid_list[index].type = WID_BIN_DATA;
    773. 

  773. 	wid_list[index].val = scan_info->ies;
    774. 

  774. 	wid_list[index].size = scan_info->ies_len;
    775. 

  775. 	index++;
    776. 

  776. 

  777. 	wid_list[index].id = WID_SCAN_TYPE;
    778. 

  778. 	wid_list[index].type = WID_CHAR;
    779. 

  779. 	wid_list[index].size = sizeof(char);
    780. 

  780. 	wid_list[index].val = (s8 *)&scan_info->type;
    781. 

  781. 	index++;
    782. 

  782. 

  783. 	wid_list[index].id = WID_SCAN_CHANNEL_LIST;
    784. 

  784. 	wid_list[index].type = WID_BIN_DATA;
    785. 

  785. 

  786. 	if (scan_info->ch_freq_list &&
    787. 

  787. 	    scan_info->ch_list_len > 0) {
    788. 

  788. 		int i;
    789. 

  789. 

  790. 		for (i = 0; i < scan_info->ch_list_len; i++)	{
    791. 

  791. 			if (scan_info->ch_freq_list[i] > 0)
    792. 

  792. 				scan_info->ch_freq_list[i] = scan_info->ch_freq_list[i] - 1;
    793. 

  793. 		}
    794. 

  794. 	}
    795. 

  795. 

  796. 	wid_list[index].val = scan_info->ch_freq_list;
    797. 

  797. 	wid_list[index].size = scan_info->ch_list_len;
    798. 

  798. 	index++;
    799. 

  799. 

  800. 	wid_list[index].id = WID_START_SCAN_REQ;
    801. 

  801. 	wid_list[index].type = WID_CHAR;
    802. 

  802. 	wid_list[index].size = sizeof(char);
    803. 

  803. 	wid_list[index].val = (s8 *)&scan_info->src;
    804. 

  804. 	index++;
    805. 

  805. 

  806. 	if (hif_drv->hif_state == HOST_IF_CONNECTED)
    807. 

  807. 		scan_while_connected = true;
    808. 

  808. 	else if (hif_drv->hif_state == HOST_IF_IDLE)
    809. 

  809. 		scan_while_connected = false;
    810. 

  810. 

  811. 	result = wilc_send_config_pkt(vif, SET_CFG, wid_list,
    812. 

  812. 				      index,
    813. 

  813. 				      wilc_get_vif_idx(vif));
    814. 

  814. 

  815. 	if (result)
    816. 

  816. 		netdev_err(vif->ndev, "Failed to send scan parameters\n");
    817. 

  817. 

  818. ERRORHANDLER:
    819. 

  819. 	if (result) {
    820. 

  820. 		del_timer(&hif_drv->scan_timer);
    821. 

  821. 		Handle_ScanDone(vif, SCAN_EVENT_ABORTED);
    822. 

  822. 	}
    823. 

  823. 

  824. 	kfree(scan_info->ch_freq_list);
    825. 

  825. 	scan_info->ch_freq_list = NULL;
    826. 

  826. 

  827. 	kfree(scan_info->ies);
    828. 

  828. 	scan_info->ies = NULL;
    829. 

  829. 	kfree(scan_info->hidden_network.net_info);
    830. 

  830. 	scan_info->hidden_network.net_info = NULL;
    831. 

  831. 

  832. 	kfree(pu8HdnNtwrksWidVal);
    833. 

  833. 

  834. 	return result;
    835. 

  835. }
    836. 

  836. 

  837. static s32 Handle_ScanDone(struct wilc_vif *vif,
    838. 

  838. 			   enum scan_event enuEvent)
    839. 

  839. {
    840. 

  840. 	s32 result = 0;
    841. 

  841. 	u8 u8abort_running_scan;
    842. 

  842. 	struct wid wid;
    843. 

  843. 	struct host_if_drv *hif_drv = vif->hif_drv;
    844. 

  844. 

  845. 	if (enuEvent == SCAN_EVENT_ABORTED) {
    846. 

  846. 		u8abort_running_scan = 1;
    847. 

  847. 		wid.id = (u16)WID_ABORT_RUNNING_SCAN;
    848. 

  848. 		wid.type = WID_CHAR;
    849. 

  849. 		wid.val = (s8 *)&u8abort_running_scan;
    850. 

  850. 		wid.size = sizeof(char);
    851. 

  851. 

  852. 		result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    853. 

  853. 					      wilc_get_vif_idx(vif));
    854. 

  854. 

  855. 		if (result) {
    856. 

  856. 			netdev_err(vif->ndev, "Failed to set abort running\n");
    857. 

  857. 			result = -EFAULT;
    858. 

  858. 		}
    859. 

  859. 	}
    860. 

  860. 

  861. 	if (!hif_drv) {
    862. 

  862. 		netdev_err(vif->ndev, "Driver handler is NULL\n");
    863. 

  863. 		return result;
    864. 

  864. 	}
    865. 

  865. 

  866. 	if (hif_drv->usr_scan_req.scan_result) {
    867. 

  867. 		hif_drv->usr_scan_req.scan_result(enuEvent, NULL,
    868. 

  868. 						  hif_drv->usr_scan_req.arg, NULL);
    869. 

  869. 		hif_drv->usr_scan_req.scan_result = NULL;
    870. 

  870. 	}
    871. 

  871. 

  872. 	return result;
    873. 

  873. }
    874. 

  874. 

  875. u8 wilc_connected_ssid[6] = {0};
    876. 

  876. static s32 Handle_Connect(struct wilc_vif *vif,
    877. 

  877. 			  struct connect_attr *pstrHostIFconnectAttr)
    878. 

  878. {
    879. 

  879. 	s32 result = 0;
    880. 

  880. 	struct wid strWIDList[8];
    881. 

  881. 	u32 u32WidsCount = 0, dummyval = 0;
    882. 

  882. 	u8 *pu8CurrByte = NULL;
    883. 

  883. 	struct join_bss_param *ptstrJoinBssParam;
    884. 

  884. 	struct host_if_drv *hif_drv = vif->hif_drv;
    885. 

  885. 

  886. 	if (memcmp(pstrHostIFconnectAttr->bssid, wilc_connected_ssid, ETH_ALEN) == 0) {
    887. 

  887. 		result = 0;
    888. 

  888. 		netdev_err(vif->ndev, "Discard connect request\n");
    889. 

  889. 		return result;
    890. 

  890. 	}
    891. 

  891. 

  892. 	ptstrJoinBssParam = pstrHostIFconnectAttr->params;
    893. 

  893. 	if (!ptstrJoinBssParam) {
    894. 

  894. 		netdev_err(vif->ndev, "Required BSSID not found\n");
    895. 

  895. 		result = -ENOENT;
    896. 

  896. 		goto ERRORHANDLER;
    897. 

  897. 	}
    898. 

  898. 

  899. 	if (pstrHostIFconnectAttr->bssid) {
    900. 

  900. 		hif_drv->usr_conn_req.bssid = kmalloc(6, GFP_KERNEL);
    901. 

  901. 		memcpy(hif_drv->usr_conn_req.bssid, pstrHostIFconnectAttr->bssid, 6);
    902. 

  902. 	}
    903. 

  903. 

  904. 	hif_drv->usr_conn_req.ssid_len = pstrHostIFconnectAttr->ssid_len;
    905. 

  905. 	if (pstrHostIFconnectAttr->ssid) {
    906. 

  906. 		hif_drv->usr_conn_req.ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL);
    907. 

  907. 		memcpy(hif_drv->usr_conn_req.ssid,
    908. 

  908. 		       pstrHostIFconnectAttr->ssid,
    909. 

  909. 		       pstrHostIFconnectAttr->ssid_len);
    910. 

  910. 		hif_drv->usr_conn_req.ssid[pstrHostIFconnectAttr->ssid_len] = '\0';
    911. 

  911. 	}
    912. 

  912. 

  913. 	hif_drv->usr_conn_req.ies_len = pstrHostIFconnectAttr->ies_len;
    914. 

  914. 	if (pstrHostIFconnectAttr->ies) {
    915. 

  915. 		hif_drv->usr_conn_req.ies = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
    916. 

  916. 		memcpy(hif_drv->usr_conn_req.ies,
    917. 

  917. 		       pstrHostIFconnectAttr->ies,
    918. 

  918. 		       pstrHostIFconnectAttr->ies_len);
    919. 

  919. 	}
    920. 

  920. 

  921. 	hif_drv->usr_conn_req.security = pstrHostIFconnectAttr->security;
    922. 

  922. 	hif_drv->usr_conn_req.auth_type = pstrHostIFconnectAttr->auth_type;
    923. 

  923. 	hif_drv->usr_conn_req.conn_result = pstrHostIFconnectAttr->result;
    924. 

  924. 	hif_drv->usr_conn_req.arg = pstrHostIFconnectAttr->arg;
    925. 

  925. 

  926. 	strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
    927. 

  927. 	strWIDList[u32WidsCount].type = WID_INT;
    928. 

  928. 	strWIDList[u32WidsCount].size = sizeof(u32);
    929. 

  929. 	strWIDList[u32WidsCount].val = (s8 *)(&(dummyval));
    930. 

  930. 	u32WidsCount++;
    931. 

  931. 

  932. 	strWIDList[u32WidsCount].id = WID_RECEIVED_FRAGMENT_COUNT;
    933. 

  933. 	strWIDList[u32WidsCount].type = WID_INT;
    934. 

  934. 	strWIDList[u32WidsCount].size = sizeof(u32);
    935. 

  935. 	strWIDList[u32WidsCount].val = (s8 *)(&(dummyval));
    936. 

  936. 	u32WidsCount++;
    937. 

  937. 

  938. 	strWIDList[u32WidsCount].id = WID_FAILED_COUNT;
    939. 

  939. 	strWIDList[u32WidsCount].type = WID_INT;
    940. 

  940. 	strWIDList[u32WidsCount].size = sizeof(u32);
    941. 

  941. 	strWIDList[u32WidsCount].val = (s8 *)(&(dummyval));
    942. 

  942. 	u32WidsCount++;
    943. 

  943. 

  944. 	{
    945. 

  945. 		strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE;
    946. 

  946. 		strWIDList[u32WidsCount].type = WID_BIN_DATA;
    947. 

  947. 		strWIDList[u32WidsCount].val = hif_drv->usr_conn_req.ies;
    948. 

  948. 		strWIDList[u32WidsCount].size = hif_drv->usr_conn_req.ies_len;
    949. 

  949. 		u32WidsCount++;
    950. 

  950. 

  951. 		if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
    952. 

  952. 			info_element_size = hif_drv->usr_conn_req.ies_len;
    953. 

  953. 			info_element = kmalloc(info_element_size, GFP_KERNEL);
    954. 

  954. 			memcpy(info_element, hif_drv->usr_conn_req.ies,
    955. 

  955. 			       info_element_size);
    956. 

  956. 		}
    957. 

  957. 	}
    958. 

  958. 	strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
    959. 

  959. 	strWIDList[u32WidsCount].type = WID_CHAR;
    960. 

  960. 	strWIDList[u32WidsCount].size = sizeof(char);
    961. 

  961. 	strWIDList[u32WidsCount].val = (s8 *)&hif_drv->usr_conn_req.security;
    962. 

  962. 	u32WidsCount++;
    963. 

  963. 

  964. 	if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
    965. 

  965. 		mode_11i = hif_drv->usr_conn_req.security;
    966. 

  966. 

  967. 	strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
    968. 

  968. 	strWIDList[u32WidsCount].type = WID_CHAR;
    969. 

  969. 	strWIDList[u32WidsCount].size = sizeof(char);
    970. 

  970. 	strWIDList[u32WidsCount].val = (s8 *)&hif_drv->usr_conn_req.auth_type;
    971. 

  971. 	u32WidsCount++;
    972. 

  972. 

  973. 	if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
    974. 

  974. 		auth_type = (u8)hif_drv->usr_conn_req.auth_type;
    975. 

  975. 

  976. 	strWIDList[u32WidsCount].id = (u16)WID_JOIN_REQ_EXTENDED;
    977. 

  977. 	strWIDList[u32WidsCount].type = WID_STR;
    978. 

  978. 	strWIDList[u32WidsCount].size = 112;
    979. 

  979. 	strWIDList[u32WidsCount].val = kmalloc(strWIDList[u32WidsCount].size, GFP_KERNEL);
    980. 

  980. 

  981. 	if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
    982. 

  982. 		join_req_size = strWIDList[u32WidsCount].size;
    983. 

  983. 		join_req = kmalloc(join_req_size, GFP_KERNEL);
    984. 

  984. 	}
    985. 

  985. 	if (!strWIDList[u32WidsCount].val) {
    986. 

  986. 		result = -EFAULT;
    987. 

  987. 		goto ERRORHANDLER;
    988. 

  988. 	}
    989. 

  989. 

  990. 	pu8CurrByte = strWIDList[u32WidsCount].val;
    991. 

  991. 

  992. 	if (pstrHostIFconnectAttr->ssid) {
    993. 

  993. 		memcpy(pu8CurrByte, pstrHostIFconnectAttr->ssid, pstrHostIFconnectAttr->ssid_len);
    994. 

  994. 		pu8CurrByte[pstrHostIFconnectAttr->ssid_len] = '\0';
    995. 

  995. 	}
    996. 

  996. 	pu8CurrByte += MAX_SSID_LEN;
    997. 

  997. 	*(pu8CurrByte++) = INFRASTRUCTURE;
    998. 

  998. 

  999. 	if ((pstrHostIFconnectAttr->ch >= 1) && (pstrHostIFconnectAttr->ch <= 14)) {
    1000. 

  1000. 		*(pu8CurrByte++) = pstrHostIFconnectAttr->ch;
    1001. 

  1001. 	} else {
    1002. 

  1002. 		netdev_err(vif->ndev, "Channel out of range\n");
    1003. 

  1003. 		*(pu8CurrByte++) = 0xFF;
    1004. 

  1004. 	}
    1005. 

  1005. 	*(pu8CurrByte++)  = (ptstrJoinBssParam->cap_info) & 0xFF;
    1006. 

  1006. 	*(pu8CurrByte++)  = ((ptstrJoinBssParam->cap_info) >> 8) & 0xFF;
    1007. 

  1007. 

  1008. 	if (pstrHostIFconnectAttr->bssid)
    1009. 

  1009. 		memcpy(pu8CurrByte, pstrHostIFconnectAttr->bssid, 6);
    1010. 

  1010. 	pu8CurrByte += 6;
    1011. 

  1011. 

  1012. 	if (pstrHostIFconnectAttr->bssid)
    1013. 

  1013. 		memcpy(pu8CurrByte, pstrHostIFconnectAttr->bssid, 6);
    1014. 

  1014. 	pu8CurrByte += 6;
    1015. 

  1015. 

  1016. 	*(pu8CurrByte++)  = (ptstrJoinBssParam->beacon_period) & 0xFF;
    1017. 

  1017. 	*(pu8CurrByte++)  = ((ptstrJoinBssParam->beacon_period) >> 8) & 0xFF;
    1018. 

  1018. 	*(pu8CurrByte++)  =  ptstrJoinBssParam->dtim_period;
    1019. 

  1019. 

  1020. 	memcpy(pu8CurrByte, ptstrJoinBssParam->supp_rates, MAX_RATES_SUPPORTED + 1);
    1021. 

  1021. 	pu8CurrByte += (MAX_RATES_SUPPORTED + 1);
    1022. 

  1022. 

  1023. 	*(pu8CurrByte++)  =  ptstrJoinBssParam->wmm_cap;
    1024. 

  1024. 	*(pu8CurrByte++)  = ptstrJoinBssParam->uapsd_cap;
    1025. 

  1025. 

  1026. 	*(pu8CurrByte++)  = ptstrJoinBssParam->ht_capable;
    1027. 

  1027. 	hif_drv->usr_conn_req.ht_capable = ptstrJoinBssParam->ht_capable;
    1028. 

  1028. 

  1029. 	*(pu8CurrByte++)  =  ptstrJoinBssParam->rsn_found;
    1030. 

  1030. 	*(pu8CurrByte++)  =  ptstrJoinBssParam->rsn_grp_policy;
    1031. 

  1031. 	*(pu8CurrByte++) =  ptstrJoinBssParam->mode_802_11i;
    1032. 

  1032. 

  1033. 	memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_pcip_policy, sizeof(ptstrJoinBssParam->rsn_pcip_policy));
    1034. 

  1034. 	pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_pcip_policy);
    1035. 

  1035. 

  1036. 	memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_auth_policy, sizeof(ptstrJoinBssParam->rsn_auth_policy));
    1037. 

  1037. 	pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_auth_policy);
    1038. 

  1038. 

  1039. 	memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_cap, sizeof(ptstrJoinBssParam->rsn_cap));
    1040. 

  1040. 	pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_cap);
    1041. 

  1041. 

  1042. 	*(pu8CurrByte++) = REAL_JOIN_REQ;
    1043. 

  1043. 	*(pu8CurrByte++) = ptstrJoinBssParam->noa_enabled;
    1044. 

  1044. 

  1045. 	if (ptstrJoinBssParam->noa_enabled) {
    1046. 

  1046. 		*(pu8CurrByte++) = (ptstrJoinBssParam->tsf) & 0xFF;
    1047. 

  1047. 		*(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 8) & 0xFF;
    1048. 

  1048. 		*(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 16) & 0xFF;
    1049. 

  1049. 		*(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 24) & 0xFF;
    1050. 

  1050. 

  1051. 		*(pu8CurrByte++) = ptstrJoinBssParam->opp_enabled;
    1052. 

  1052. 		*(pu8CurrByte++) = ptstrJoinBssParam->idx;
    1053. 

  1053. 

  1054. 		if (ptstrJoinBssParam->opp_enabled)
    1055. 

  1055. 			*(pu8CurrByte++) = ptstrJoinBssParam->ct_window;
    1056. 

  1056. 

  1057. 		*(pu8CurrByte++) = ptstrJoinBssParam->cnt;
    1058. 

  1058. 

  1059. 		memcpy(pu8CurrByte, ptstrJoinBssParam->duration, sizeof(ptstrJoinBssParam->duration));
    1060. 

  1060. 		pu8CurrByte += sizeof(ptstrJoinBssParam->duration);
    1061. 

  1061. 

  1062. 		memcpy(pu8CurrByte, ptstrJoinBssParam->interval, sizeof(ptstrJoinBssParam->interval));
    1063. 

  1063. 		pu8CurrByte += sizeof(ptstrJoinBssParam->interval);
    1064. 

  1064. 

  1065. 		memcpy(pu8CurrByte, ptstrJoinBssParam->start_time, sizeof(ptstrJoinBssParam->start_time));
    1066. 

  1066. 		pu8CurrByte += sizeof(ptstrJoinBssParam->start_time);
    1067. 

  1067. 	}
    1068. 

  1068. 

  1069. 	pu8CurrByte = strWIDList[u32WidsCount].val;
    1070. 

  1070. 	u32WidsCount++;
    1071. 

  1071. 

  1072. 	if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
    1073. 

  1073. 		memcpy(join_req, pu8CurrByte, join_req_size);
    1074. 

  1074. 		join_req_vif = vif;
    1075. 

  1075. 	}
    1076. 

  1076. 

  1077. 	if (pstrHostIFconnectAttr->bssid)
    1078. 

  1078. 		memcpy(wilc_connected_ssid,
    1079. 

  1079. 		       pstrHostIFconnectAttr->bssid, ETH_ALEN);
    1080. 

  1080. 

  1081. 	result = wilc_send_config_pkt(vif, SET_CFG, strWIDList,
    1082. 

  1082. 				      u32WidsCount,
    1083. 

  1083. 				      wilc_get_vif_idx(vif));
    1084. 

  1084. 	if (result) {
    1085. 

  1085. 		netdev_err(vif->ndev, "failed to send config packet\n");
    1086. 

  1086. 		result = -EFAULT;
    1087. 

  1087. 		goto ERRORHANDLER;
    1088. 

  1088. 	} else {
    1089. 

  1089. 		hif_drv->hif_state = HOST_IF_WAITING_CONN_RESP;
    1090. 

  1090. 	}
    1091. 

  1091. 

  1092. ERRORHANDLER:
    1093. 

  1093. 	if (result) {
    1094. 

  1094. 		struct connect_info strConnectInfo;
    1095. 

  1095. 

  1096. 		del_timer(&hif_drv->connect_timer);
    1097. 

  1097. 

  1098. 		memset(&strConnectInfo, 0, sizeof(struct connect_info));
    1099. 

  1099. 

  1100. 		if (pstrHostIFconnectAttr->result) {
    1101. 

  1101. 			if (pstrHostIFconnectAttr->bssid)
    1102. 

  1102. 				memcpy(strConnectInfo.bssid, pstrHostIFconnectAttr->bssid, 6);
    1103. 

  1103. 

  1104. 			if (pstrHostIFconnectAttr->ies) {
    1105. 

  1105. 				strConnectInfo.req_ies_len = pstrHostIFconnectAttr->ies_len;
    1106. 

  1106. 				strConnectInfo.req_ies = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
    1107. 

  1107. 				memcpy(strConnectInfo.req_ies,
    1108. 

  1108. 				       pstrHostIFconnectAttr->ies,
    1109. 

  1109. 				       pstrHostIFconnectAttr->ies_len);
    1110. 

  1110. 			}
    1111. 

  1111. 

  1112. 			pstrHostIFconnectAttr->result(CONN_DISCONN_EVENT_CONN_RESP,
    1113. 

  1113. 							       &strConnectInfo,
    1114. 

  1114. 							       MAC_DISCONNECTED,
    1115. 

  1115. 							       NULL,
    1116. 

  1116. 							       pstrHostIFconnectAttr->arg);
    1117. 

  1117. 			hif_drv->hif_state = HOST_IF_IDLE;
    1118. 

  1118. 			kfree(strConnectInfo.req_ies);
    1119. 

  1119. 			strConnectInfo.req_ies = NULL;
    1120. 

  1120. 

  1121. 		} else {
    1122. 

  1122. 			netdev_err(vif->ndev, "Connect callback is NULL\n");
    1123. 

  1123. 		}
    1124. 

  1124. 	}
    1125. 

  1125. 

  1126. 	kfree(pstrHostIFconnectAttr->bssid);
    1127. 

  1127. 	pstrHostIFconnectAttr->bssid = NULL;
    1128. 

  1128. 

  1129. 	kfree(pstrHostIFconnectAttr->ssid);
    1130. 

  1130. 	pstrHostIFconnectAttr->ssid = NULL;
    1131. 

  1131. 

  1132. 	kfree(pstrHostIFconnectAttr->ies);
    1133. 

  1133. 	pstrHostIFconnectAttr->ies = NULL;
    1134. 

  1134. 

  1135. 	kfree(pu8CurrByte);
    1136. 

  1136. 	return result;
    1137. 

  1137. }
    1138. 

  1138. 

  1139. static s32 Handle_ConnectTimeout(struct wilc_vif *vif)
    1140. 

  1140. {
    1141. 

  1141. 	s32 result = 0;
    1142. 

  1142. 	struct connect_info strConnectInfo;
    1143. 

  1143. 	struct wid wid;
    1144. 

  1144. 	u16 u16DummyReasonCode = 0;
    1145. 

  1145. 	struct host_if_drv *hif_drv = vif->hif_drv;
    1146. 

  1146. 

  1147. 	if (!hif_drv) {
    1148. 

  1148. 		netdev_err(vif->ndev, "Driver handler is NULL\n");
    1149. 

  1149. 		return result;
    1150. 

  1150. 	}
    1151. 

  1151. 

  1152. 	hif_drv->hif_state = HOST_IF_IDLE;
    1153. 

  1153. 

  1154. 	scan_while_connected = false;
    1155. 

  1155. 

  1156. 	memset(&strConnectInfo, 0, sizeof(struct connect_info));
    1157. 

  1157. 

  1158. 	if (hif_drv->usr_conn_req.conn_result) {
    1159. 

  1159. 		if (hif_drv->usr_conn_req.bssid) {
    1160. 

  1160. 			memcpy(strConnectInfo.bssid,
    1161. 

  1161. 			       hif_drv->usr_conn_req.bssid, 6);
    1162. 

  1162. 		}
    1163. 

  1163. 

  1164. 		if (hif_drv->usr_conn_req.ies) {
    1165. 

  1165. 			strConnectInfo.req_ies_len = hif_drv->usr_conn_req.ies_len;
    1166. 

  1166. 			strConnectInfo.req_ies = kmalloc(hif_drv->usr_conn_req.ies_len, GFP_KERNEL);
    1167. 

  1167. 			memcpy(strConnectInfo.req_ies,
    1168. 

  1168. 			       hif_drv->usr_conn_req.ies,
    1169. 

  1169. 			       hif_drv->usr_conn_req.ies_len);
    1170. 

  1170. 		}
    1171. 

  1171. 

  1172. 		hif_drv->usr_conn_req.conn_result(CONN_DISCONN_EVENT_CONN_RESP,
    1173. 

  1173. 						  &strConnectInfo,
    1174. 

  1174. 						  MAC_DISCONNECTED,
    1175. 

  1175. 						  NULL,
    1176. 

  1176. 						  hif_drv->usr_conn_req.arg);
    1177. 

  1177. 

  1178. 		kfree(strConnectInfo.req_ies);
    1179. 

  1179. 		strConnectInfo.req_ies = NULL;
    1180. 

  1180. 	} else {
    1181. 

  1181. 		netdev_err(vif->ndev, "Connect callback is NULL\n");
    1182. 

  1182. 	}
    1183. 

  1183. 

  1184. 	wid.id = (u16)WID_DISCONNECT;
    1185. 

  1185. 	wid.type = WID_CHAR;
    1186. 

  1186. 	wid.val = (s8 *)&u16DummyReasonCode;
    1187. 

  1187. 	wid.size = sizeof(char);
    1188. 

  1188. 

  1189. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    1190. 

  1190. 				      wilc_get_vif_idx(vif));
    1191. 

  1191. 	if (result)
    1192. 

  1192. 		netdev_err(vif->ndev, "Failed to send dissconect\n");
    1193. 

  1193. 

  1194. 	hif_drv->usr_conn_req.ssid_len = 0;
    1195. 

  1195. 	kfree(hif_drv->usr_conn_req.ssid);
    1196. 

  1196. 	hif_drv->usr_conn_req.ssid = NULL;
    1197. 

  1197. 	kfree(hif_drv->usr_conn_req.bssid);
    1198. 

  1198. 	hif_drv->usr_conn_req.bssid = NULL;
    1199. 

  1199. 	hif_drv->usr_conn_req.ies_len = 0;
    1200. 

  1200. 	kfree(hif_drv->usr_conn_req.ies);
    1201. 

  1201. 	hif_drv->usr_conn_req.ies = NULL;
    1202. 

  1202. 

  1203. 	eth_zero_addr(wilc_connected_ssid);
    1204. 

  1204. 

  1205. 	if (join_req && join_req_vif == vif) {
    1206. 

  1206. 		kfree(join_req);
    1207. 

  1207. 		join_req = NULL;
    1208. 

  1208. 	}
    1209. 

  1209. 

  1210. 	if (info_element && join_req_vif == vif) {
    1211. 

  1211. 		kfree(info_element);
    1212. 

  1212. 		info_element = NULL;
    1213. 

  1213. 	}
    1214. 

  1214. 

  1215. 	return result;
    1216. 

  1216. }
    1217. 

  1217. 

  1218. static s32 Handle_RcvdNtwrkInfo(struct wilc_vif *vif,
    1219. 

  1219. 				struct rcvd_net_info *pstrRcvdNetworkInfo)
    1220. 

  1220. {
    1221. 

  1221. 	u32 i;
    1222. 

  1222. 	bool bNewNtwrkFound;
    1223. 

  1223. 	s32 result = 0;
    1224. 

  1224. 	struct network_info *pstrNetworkInfo = NULL;
    1225. 

  1225. 	void *pJoinParams = NULL;
    1226. 

  1226. 	struct host_if_drv *hif_drv = vif->hif_drv;
    1227. 

  1227. 

  1228. 	bNewNtwrkFound = true;
    1229. 

  1229. 

  1230. 	if (hif_drv->usr_scan_req.scan_result) {
    1231. 

  1231. 		wilc_parse_network_info(pstrRcvdNetworkInfo->buffer, &pstrNetworkInfo);
    1232. 

  1232. 		if ((!pstrNetworkInfo) ||
    1233. 

  1233. 		    (!hif_drv->usr_scan_req.scan_result)) {
    1234. 

  1234. 			netdev_err(vif->ndev, "driver is null\n");
    1235. 

  1235. 			result = -EINVAL;
    1236. 

  1236. 			goto done;
    1237. 

  1237. 		}
    1238. 

  1238. 

  1239. 		for (i = 0; i < hif_drv->usr_scan_req.rcvd_ch_cnt; i++) {
    1240. 

  1240. 			if (memcmp(hif_drv->usr_scan_req.net_info[i].bssid,
    1241. 

  1241. 				   pstrNetworkInfo->bssid, 6) == 0) {
    1242. 

  1242. 				if (pstrNetworkInfo->rssi <= hif_drv->usr_scan_req.net_info[i].rssi) {
    1243. 

  1243. 					goto done;
    1244. 

  1244. 				} else {
    1245. 

  1245. 					hif_drv->usr_scan_req.net_info[i].rssi = pstrNetworkInfo->rssi;
    1246. 

  1246. 					bNewNtwrkFound = false;
    1247. 

  1247. 					break;
    1248. 

  1248. 				}
    1249. 

  1249. 			}
    1250. 

  1250. 		}
    1251. 

  1251. 

  1252. 		if (bNewNtwrkFound) {
    1253. 

  1253. 			if (hif_drv->usr_scan_req.rcvd_ch_cnt < MAX_NUM_SCANNED_NETWORKS) {
    1254. 

  1254. 				hif_drv->usr_scan_req.net_info[hif_drv->usr_scan_req.rcvd_ch_cnt].rssi = pstrNetworkInfo->rssi;
    1255. 

  1255. 

  1256. 				memcpy(hif_drv->usr_scan_req.net_info[hif_drv->usr_scan_req.rcvd_ch_cnt].bssid,
    1257. 

  1257. 				       pstrNetworkInfo->bssid, 6);
    1258. 

  1258. 

  1259. 				hif_drv->usr_scan_req.rcvd_ch_cnt++;
    1260. 

  1260. 

  1261. 				pstrNetworkInfo->new_network = true;
    1262. 

  1262. 				pJoinParams = host_int_ParseJoinBssParam(pstrNetworkInfo);
    1263. 

  1263. 

  1264. 				hif_drv->usr_scan_req.scan_result(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
    1265. 

  1265. 								  hif_drv->usr_scan_req.arg,
    1266. 

  1266. 								  pJoinParams);
    1267. 

  1267. 			}
    1268. 

  1268. 		} else {
    1269. 

  1269. 			pstrNetworkInfo->new_network = false;
    1270. 

  1270. 			hif_drv->usr_scan_req.scan_result(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
    1271. 

  1271. 							  hif_drv->usr_scan_req.arg, NULL);
    1272. 

  1272. 		}
    1273. 

  1273. 	}
    1274. 

  1274. 

  1275. done:
    1276. 

  1276. 	kfree(pstrRcvdNetworkInfo->buffer);
    1277. 

  1277. 	pstrRcvdNetworkInfo->buffer = NULL;
    1278. 

  1278. 

  1279. 	if (pstrNetworkInfo) {
    1280. 

  1280. 		kfree(pstrNetworkInfo->ies);
    1281. 

  1281. 		kfree(pstrNetworkInfo);
    1282. 

  1282. 	}
    1283. 

  1283. 

  1284. 	return result;
    1285. 

  1285. }
    1286. 

  1286. 

  1287. static s32 host_int_get_assoc_res_info(struct wilc_vif *vif,
    1288. 

  1288. 				       u8 *pu8AssocRespInfo,
    1289. 

  1289. 				       u32 u32MaxAssocRespInfoLen,
    1290. 

  1290. 				       u32 *pu32RcvdAssocRespInfoLen);
    1291. 

  1291. 

  1292. static s32 Handle_RcvdGnrlAsyncInfo(struct wilc_vif *vif,
    1293. 

  1293. 				    struct rcvd_async_info *pstrRcvdGnrlAsyncInfo)
    1294. 

  1294. {
    1295. 

  1295. 	s32 result = 0;
    1296. 

  1296. 	u8 u8MsgType = 0;
    1297. 

  1297. 	u8 u8MsgID = 0;
    1298. 

  1298. 	u16 u16MsgLen = 0;
    1299. 

  1299. 	u16 u16WidID = (u16)WID_NIL;
    1300. 

  1300. 	u8 u8WidLen  = 0;
    1301. 

  1301. 	u8 u8MacStatus;
    1302. 

  1302. 	u8 u8MacStatusReasonCode;
    1303. 

  1303. 	u8 u8MacStatusAdditionalInfo;
    1304. 

  1304. 	struct connect_info strConnectInfo;
    1305. 

  1305. 	struct disconnect_info strDisconnectNotifInfo;
    1306. 

  1306. 	s32 s32Err = 0;
    1307. 

  1307. 	struct host_if_drv *hif_drv = vif->hif_drv;
    1308. 

  1308. 

  1309. 	if (!hif_drv) {
    1310. 

  1310. 		netdev_err(vif->ndev, "Driver handler is NULL\n");
    1311. 

  1311. 		return -ENODEV;
    1312. 

  1312. 	}
    1313. 

  1313. 

  1314. 	if ((hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) ||
    1315. 

  1315. 	    (hif_drv->hif_state == HOST_IF_CONNECTED) ||
    1316. 

  1316. 	    hif_drv->usr_scan_req.scan_result) {
    1317. 

  1317. 		if (!pstrRcvdGnrlAsyncInfo->buffer ||
    1318. 

  1318. 		    !hif_drv->usr_conn_req.conn_result) {
    1319. 

  1319. 			netdev_err(vif->ndev, "driver is null\n");
    1320. 

  1320. 			return -EINVAL;
    1321. 

  1321. 		}
    1322. 

  1322. 

  1323. 		u8MsgType = pstrRcvdGnrlAsyncInfo->buffer[0];
    1324. 

  1324. 

  1325. 		if ('I' != u8MsgType) {
    1326. 

  1326. 			netdev_err(vif->ndev, "Received Message incorrect.\n");
    1327. 

  1327. 			return -EFAULT;
    1328. 

  1328. 		}
    1329. 

  1329. 

  1330. 		u8MsgID = pstrRcvdGnrlAsyncInfo->buffer[1];
    1331. 

  1331. 		u16MsgLen = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->buffer[2], pstrRcvdGnrlAsyncInfo->buffer[3]);
    1332. 

  1332. 		u16WidID = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->buffer[4], pstrRcvdGnrlAsyncInfo->buffer[5]);
    1333. 

  1333. 		u8WidLen = pstrRcvdGnrlAsyncInfo->buffer[6];
    1334. 

  1334. 		u8MacStatus  = pstrRcvdGnrlAsyncInfo->buffer[7];
    1335. 

  1335. 		u8MacStatusReasonCode = pstrRcvdGnrlAsyncInfo->buffer[8];
    1336. 

  1336. 		u8MacStatusAdditionalInfo = pstrRcvdGnrlAsyncInfo->buffer[9];
    1337. 

  1337. 		if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) {
    1338. 

  1338. 			u32 u32RcvdAssocRespInfoLen = 0;
    1339. 

  1339. 			struct connect_resp_info *pstrConnectRespInfo = NULL;
    1340. 

  1340. 

  1341. 			memset(&strConnectInfo, 0, sizeof(struct connect_info));
    1342. 

  1342. 

  1343. 			if (u8MacStatus == MAC_CONNECTED) {
    1344. 

  1344. 				memset(rcv_assoc_resp, 0, MAX_ASSOC_RESP_FRAME_SIZE);
    1345. 

  1345. 

  1346. 				host_int_get_assoc_res_info(vif,
    1347. 

  1347. 							    rcv_assoc_resp,
    1348. 

  1348. 							    MAX_ASSOC_RESP_FRAME_SIZE,
    1349. 

  1349. 							    &u32RcvdAssocRespInfoLen);
    1350. 

  1350. 

  1351. 				if (u32RcvdAssocRespInfoLen != 0) {
    1352. 

  1352. 					s32Err = wilc_parse_assoc_resp_info(rcv_assoc_resp, u32RcvdAssocRespInfoLen,
    1353. 

  1353. 								    &pstrConnectRespInfo);
    1354. 

  1354. 					if (s32Err) {
    1355. 

  1355. 						netdev_err(vif->ndev, "wilc_parse_assoc_resp_info() returned error %d\n", s32Err);
    1356. 

  1356. 					} else {
    1357. 

  1357. 						strConnectInfo.status = pstrConnectRespInfo->status;
    1358. 

  1358. 

  1359. 						if (strConnectInfo.status == SUCCESSFUL_STATUSCODE) {
    1360. 

  1360. 							if (pstrConnectRespInfo->ies) {
    1361. 

  1361. 								strConnectInfo.resp_ies_len = pstrConnectRespInfo->ies_len;
    1362. 

  1362. 								strConnectInfo.resp_ies = kmalloc(pstrConnectRespInfo->ies_len, GFP_KERNEL);
    1363. 

  1363. 								memcpy(strConnectInfo.resp_ies, pstrConnectRespInfo->ies,
    1364. 

  1364. 								       pstrConnectRespInfo->ies_len);
    1365. 

  1365. 							}
    1366. 

  1366. 						}
    1367. 

  1367. 

  1368. 						if (pstrConnectRespInfo) {
    1369. 

  1369. 							kfree(pstrConnectRespInfo->ies);
    1370. 

  1370. 							kfree(pstrConnectRespInfo);
    1371. 

  1371. 						}
    1372. 

  1372. 					}
    1373. 

  1373. 				}
    1374. 

  1374. 			}
    1375. 

  1375. 

  1376. 			if ((u8MacStatus == MAC_CONNECTED) &&
    1377. 

  1377. 			    (strConnectInfo.status != SUCCESSFUL_STATUSCODE))	{
    1378. 

  1378. 				netdev_err(vif->ndev, "Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE\n");
    1379. 

  1379. 				eth_zero_addr(wilc_connected_ssid);
    1380. 

  1380. 			} else if (u8MacStatus == MAC_DISCONNECTED)    {
    1381. 

  1381. 				netdev_err(vif->ndev, "Received MAC status is MAC_DISCONNECTED\n");
    1382. 

  1382. 				eth_zero_addr(wilc_connected_ssid);
    1383. 

  1383. 			}
    1384. 

  1384. 

  1385. 			if (hif_drv->usr_conn_req.bssid) {
    1386. 

  1386. 				memcpy(strConnectInfo.bssid, hif_drv->usr_conn_req.bssid, 6);
    1387. 

  1387. 

  1388. 				if ((u8MacStatus == MAC_CONNECTED) &&
    1389. 

  1389. 				    (strConnectInfo.status == SUCCESSFUL_STATUSCODE))	{
    1390. 

  1390. 					memcpy(hif_drv->assoc_bssid,
    1391. 

  1391. 					       hif_drv->usr_conn_req.bssid, ETH_ALEN);
    1392. 

  1392. 				}
    1393. 

  1393. 			}
    1394. 

  1394. 

  1395. 			if (hif_drv->usr_conn_req.ies) {
    1396. 

  1396. 				strConnectInfo.req_ies_len = hif_drv->usr_conn_req.ies_len;
    1397. 

  1397. 				strConnectInfo.req_ies = kmalloc(hif_drv->usr_conn_req.ies_len, GFP_KERNEL);
    1398. 

  1398. 				memcpy(strConnectInfo.req_ies,
    1399. 

  1399. 				       hif_drv->usr_conn_req.ies,
    1400. 

  1400. 				       hif_drv->usr_conn_req.ies_len);
    1401. 

  1401. 			}
    1402. 

  1402. 

  1403. 			del_timer(&hif_drv->connect_timer);
    1404. 

  1404. 			hif_drv->usr_conn_req.conn_result(CONN_DISCONN_EVENT_CONN_RESP,
    1405. 

  1405. 							  &strConnectInfo,
    1406. 

  1406. 							  u8MacStatus,
    1407. 

  1407. 							  NULL,
    1408. 

  1408. 							  hif_drv->usr_conn_req.arg);
    1409. 

  1409. 

  1410. 			if ((u8MacStatus == MAC_CONNECTED) &&
    1411. 

  1411. 			    (strConnectInfo.status == SUCCESSFUL_STATUSCODE))	{
    1412. 

  1412. 				wilc_set_power_mgmt(vif, 0, 0);
    1413. 

  1413. 

  1414. 				hif_drv->hif_state = HOST_IF_CONNECTED;
    1415. 

  1415. 

  1416. 				wilc_optaining_ip = true;
    1417. 

  1417. 				mod_timer(&wilc_during_ip_timer,
    1418. 

  1418. 					  jiffies + msecs_to_jiffies(10000));
    1419. 

  1419. 			} else {
    1420. 

  1420. 				hif_drv->hif_state = HOST_IF_IDLE;
    1421. 

  1421. 				scan_while_connected = false;
    1422. 

  1422. 			}
    1423. 

  1423. 

  1424. 			kfree(strConnectInfo.resp_ies);
    1425. 

  1425. 			strConnectInfo.resp_ies = NULL;
    1426. 

  1426. 

  1427. 			kfree(strConnectInfo.req_ies);
    1428. 

  1428. 			strConnectInfo.req_ies = NULL;
    1429. 

  1429. 			hif_drv->usr_conn_req.ssid_len = 0;
    1430. 

  1430. 			kfree(hif_drv->usr_conn_req.ssid);
    1431. 

  1431. 			hif_drv->usr_conn_req.ssid = NULL;
    1432. 

  1432. 			kfree(hif_drv->usr_conn_req.bssid);
    1433. 

  1433. 			hif_drv->usr_conn_req.bssid = NULL;
    1434. 

  1434. 			hif_drv->usr_conn_req.ies_len = 0;
    1435. 

  1435. 			kfree(hif_drv->usr_conn_req.ies);
    1436. 

  1436. 			hif_drv->usr_conn_req.ies = NULL;
    1437. 

  1437. 		} else if ((u8MacStatus == MAC_DISCONNECTED) &&
    1438. 

  1438. 			   (hif_drv->hif_state == HOST_IF_CONNECTED)) {
    1439. 

  1439. 			memset(&strDisconnectNotifInfo, 0, sizeof(struct disconnect_info));
    1440. 

  1440. 

  1441. 			if (hif_drv->usr_scan_req.scan_result) {
    1442. 

  1442. 				del_timer(&hif_drv->scan_timer);
    1443. 

  1443. 				Handle_ScanDone(vif, SCAN_EVENT_ABORTED);
    1444. 

  1444. 			}
    1445. 

  1445. 

  1446. 			strDisconnectNotifInfo.reason = 0;
    1447. 

  1447. 			strDisconnectNotifInfo.ie = NULL;
    1448. 

  1448. 			strDisconnectNotifInfo.ie_len = 0;
    1449. 

  1449. 

  1450. 			if (hif_drv->usr_conn_req.conn_result) {
    1451. 

  1451. 				wilc_optaining_ip = false;
    1452. 

  1452. 				wilc_set_power_mgmt(vif, 0, 0);
    1453. 

  1453. 

  1454. 				hif_drv->usr_conn_req.conn_result(CONN_DISCONN_EVENT_DISCONN_NOTIF,
    1455. 

  1455. 								  NULL,
    1456. 

  1456. 								  0,
    1457. 

  1457. 								  &strDisconnectNotifInfo,
    1458. 

  1458. 								  hif_drv->usr_conn_req.arg);
    1459. 

  1459. 			} else {
    1460. 

  1460. 				netdev_err(vif->ndev, "Connect result NULL\n");
    1461. 

  1461. 			}
    1462. 

  1462. 

  1463. 			eth_zero_addr(hif_drv->assoc_bssid);
    1464. 

  1464. 

  1465. 			hif_drv->usr_conn_req.ssid_len = 0;
    1466. 

  1466. 			kfree(hif_drv->usr_conn_req.ssid);
    1467. 

  1467. 			hif_drv->usr_conn_req.ssid = NULL;
    1468. 

  1468. 			kfree(hif_drv->usr_conn_req.bssid);
    1469. 

  1469. 			hif_drv->usr_conn_req.bssid = NULL;
    1470. 

  1470. 			hif_drv->usr_conn_req.ies_len = 0;
    1471. 

  1471. 			kfree(hif_drv->usr_conn_req.ies);
    1472. 

  1472. 			hif_drv->usr_conn_req.ies = NULL;
    1473. 

  1473. 

  1474. 			if (join_req && join_req_vif == vif) {
    1475. 

  1475. 				kfree(join_req);
    1476. 

  1476. 				join_req = NULL;
    1477. 

  1477. 			}
    1478. 

  1478. 

  1479. 			if (info_element && join_req_vif == vif) {
    1480. 

  1480. 				kfree(info_element);
    1481. 

  1481. 				info_element = NULL;
    1482. 

  1482. 			}
    1483. 

  1483. 

  1484. 			hif_drv->hif_state = HOST_IF_IDLE;
    1485. 

  1485. 			scan_while_connected = false;
    1486. 

  1486. 

  1487. 		} else if ((u8MacStatus == MAC_DISCONNECTED) &&
    1488. 

  1488. 			   (hif_drv->usr_scan_req.scan_result)) {
    1489. 

  1489. 			del_timer(&hif_drv->scan_timer);
    1490. 

  1490. 			if (hif_drv->usr_scan_req.scan_result)
    1491. 

  1491. 				Handle_ScanDone(vif, SCAN_EVENT_ABORTED);
    1492. 

  1492. 		}
    1493. 

  1493. 	}
    1494. 

  1494. 

  1495. 	kfree(pstrRcvdGnrlAsyncInfo->buffer);
    1496. 

  1496. 	pstrRcvdGnrlAsyncInfo->buffer = NULL;
    1497. 

  1497. 

  1498. 	return result;
    1499. 

  1499. }
    1500. 

  1500. 

  1501. static int Handle_Key(struct wilc_vif *vif,
    1502. 

  1502. 		      struct key_attr *pstrHostIFkeyAttr)
    1503. 

  1503. {
    1504. 

  1504. 	s32 result = 0;
    1505. 

  1505. 	struct wid wid;
    1506. 

  1506. 	struct wid strWIDList[5];
    1507. 

  1507. 	u8 i;
    1508. 

  1508. 	u8 *pu8keybuf;
    1509. 

  1509. 	s8 s8idxarray[1];
    1510. 

  1510. 	s8 ret = 0;
    1511. 

  1511. 	struct host_if_drv *hif_drv = vif->hif_drv;
    1512. 

  1512. 

  1513. 	switch (pstrHostIFkeyAttr->type) {
    1514. 

  1514. 	case WEP:
    1515. 

  1515. 

  1516. 		if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
    1517. 

  1517. 			strWIDList[0].id = (u16)WID_11I_MODE;
    1518. 

  1518. 			strWIDList[0].type = WID_CHAR;
    1519. 

  1519. 			strWIDList[0].size = sizeof(char);
    1520. 

  1520. 			strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.mode;
    1521. 

  1521. 

  1522. 			strWIDList[1].id = WID_AUTH_TYPE;
    1523. 

  1523. 			strWIDList[1].type = WID_CHAR;
    1524. 

  1524. 			strWIDList[1].size = sizeof(char);
    1525. 

  1525. 			strWIDList[1].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.auth_type;
    1526. 

  1526. 

  1527. 			pu8keybuf = kmalloc(pstrHostIFkeyAttr->attr.wep.key_len + 2,
    1528. 

  1528. 					    GFP_KERNEL);
    1529. 

  1529. 			if (!pu8keybuf)
    1530. 

  1530. 				return -ENOMEM;
    1531. 

  1531. 

  1532. 			pu8keybuf[0] = pstrHostIFkeyAttr->attr.wep.index;
    1533. 

  1533. 			pu8keybuf[1] = pstrHostIFkeyAttr->attr.wep.key_len;
    1534. 

  1534. 

  1535. 			memcpy(&pu8keybuf[2], pstrHostIFkeyAttr->attr.wep.key,
    1536. 

  1536. 			       pstrHostIFkeyAttr->attr.wep.key_len);
    1537. 

  1537. 

  1538. 			kfree(pstrHostIFkeyAttr->attr.wep.key);
    1539. 

  1539. 

  1540. 			strWIDList[2].id = (u16)WID_WEP_KEY_VALUE;
    1541. 

  1541. 			strWIDList[2].type = WID_STR;
    1542. 

  1542. 			strWIDList[2].size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
    1543. 

  1543. 			strWIDList[2].val = (s8 *)pu8keybuf;
    1544. 

  1544. 

  1545. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1546. 

  1546. 						      strWIDList, 3,
    1547. 

  1547. 						      wilc_get_vif_idx(vif));
    1548. 

  1548. 			kfree(pu8keybuf);
    1549. 

  1549. 		} else if (pstrHostIFkeyAttr->action & ADDKEY) {
    1550. 

  1550. 			pu8keybuf = kmalloc(pstrHostIFkeyAttr->attr.wep.key_len + 2, GFP_KERNEL);
    1551. 

  1551. 			if (!pu8keybuf)
    1552. 

  1552. 				return -ENOMEM;
    1553. 

  1553. 			pu8keybuf[0] = pstrHostIFkeyAttr->attr.wep.index;
    1554. 

  1554. 			memcpy(pu8keybuf + 1, &pstrHostIFkeyAttr->attr.wep.key_len, 1);
    1555. 

  1555. 			memcpy(pu8keybuf + 2, pstrHostIFkeyAttr->attr.wep.key,
    1556. 

  1556. 			       pstrHostIFkeyAttr->attr.wep.key_len);
    1557. 

  1557. 			kfree(pstrHostIFkeyAttr->attr.wep.key);
    1558. 

  1558. 

  1559. 			wid.id = (u16)WID_ADD_WEP_KEY;
    1560. 

  1560. 			wid.type = WID_STR;
    1561. 

  1561. 			wid.val = (s8 *)pu8keybuf;
    1562. 

  1562. 			wid.size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
    1563. 

  1563. 

  1564. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1565. 

  1565. 						      &wid, 1,
    1566. 

  1566. 						      wilc_get_vif_idx(vif));
    1567. 

  1567. 			kfree(pu8keybuf);
    1568. 

  1568. 		} else if (pstrHostIFkeyAttr->action & REMOVEKEY) {
    1569. 

  1569. 			wid.id = (u16)WID_REMOVE_WEP_KEY;
    1570. 

  1570. 			wid.type = WID_STR;
    1571. 

  1571. 

  1572. 			s8idxarray[0] = (s8)pstrHostIFkeyAttr->attr.wep.index;
    1573. 

  1573. 			wid.val = s8idxarray;
    1574. 

  1574. 			wid.size = 1;
    1575. 

  1575. 

  1576. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1577. 

  1577. 						      &wid, 1,
    1578. 

  1578. 						      wilc_get_vif_idx(vif));
    1579. 

  1579. 		} else if (pstrHostIFkeyAttr->action & DEFAULTKEY) {
    1580. 

  1580. 			wid.id = (u16)WID_KEY_ID;
    1581. 

  1581. 			wid.type = WID_CHAR;
    1582. 

  1582. 			wid.val = (s8 *)&pstrHostIFkeyAttr->attr.wep.index;
    1583. 

  1583. 			wid.size = sizeof(char);
    1584. 

  1584. 

  1585. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1586. 

  1586. 						      &wid, 1,
    1587. 

  1587. 						      wilc_get_vif_idx(vif));
    1588. 

  1588. 		}
    1589. 

  1589. 		complete(&hif_drv->comp_test_key_block);
    1590. 

  1590. 		break;
    1591. 

  1591. 

  1592. 	case WPA_RX_GTK:
    1593. 

  1593. 		if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
    1594. 

  1594. 			pu8keybuf = kzalloc(RX_MIC_KEY_MSG_LEN, GFP_KERNEL);
    1595. 

  1595. 			if (!pu8keybuf) {
    1596. 

  1596. 				ret = -ENOMEM;
    1597. 

  1597. 				goto _WPARxGtk_end_case_;
    1598. 

  1598. 			}
    1599. 

  1599. 

  1600. 			if (pstrHostIFkeyAttr->attr.wpa.seq)
    1601. 

  1601. 				memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->attr.wpa.seq, 8);
    1602. 

  1602. 

  1603. 			memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
    1604. 

  1604. 			memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
    1605. 

  1605. 			memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
    1606. 

  1606. 			       pstrHostIFkeyAttr->attr.wpa.key_len);
    1607. 

  1607. 

  1608. 			strWIDList[0].id = (u16)WID_11I_MODE;
    1609. 

  1609. 			strWIDList[0].type = WID_CHAR;
    1610. 

  1610. 			strWIDList[0].size = sizeof(char);
    1611. 

  1611. 			strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wpa.mode;
    1612. 

  1612. 

  1613. 			strWIDList[1].id = (u16)WID_ADD_RX_GTK;
    1614. 

  1614. 			strWIDList[1].type = WID_STR;
    1615. 

  1615. 			strWIDList[1].val = (s8 *)pu8keybuf;
    1616. 

  1616. 			strWIDList[1].size = RX_MIC_KEY_MSG_LEN;
    1617. 

  1617. 

  1618. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1619. 

  1619. 						      strWIDList, 2,
    1620. 

  1620. 						      wilc_get_vif_idx(vif));
    1621. 

  1621. 

  1622. 			kfree(pu8keybuf);
    1623. 

  1623. 			complete(&hif_drv->comp_test_key_block);
    1624. 

  1624. 		} else if (pstrHostIFkeyAttr->action & ADDKEY) {
    1625. 

  1625. 			pu8keybuf = kzalloc(RX_MIC_KEY_MSG_LEN, GFP_KERNEL);
    1626. 

  1626. 			if (!pu8keybuf) {
    1627. 

  1627. 				ret = -ENOMEM;
    1628. 

  1628. 				goto _WPARxGtk_end_case_;
    1629. 

  1629. 			}
    1630. 

  1630. 

  1631. 			if (hif_drv->hif_state == HOST_IF_CONNECTED)
    1632. 

  1632. 				memcpy(pu8keybuf, hif_drv->assoc_bssid, ETH_ALEN);
    1633. 

  1633. 			else
    1634. 

  1634. 				netdev_err(vif->ndev, "Couldn't handle\n");
    1635. 

  1635. 

  1636. 			memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->attr.wpa.seq, 8);
    1637. 

  1637. 			memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
    1638. 

  1638. 			memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
    1639. 

  1639. 			memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
    1640. 

  1640. 			       pstrHostIFkeyAttr->attr.wpa.key_len);
    1641. 

  1641. 

  1642. 			wid.id = (u16)WID_ADD_RX_GTK;
    1643. 

  1643. 			wid.type = WID_STR;
    1644. 

  1644. 			wid.val = (s8 *)pu8keybuf;
    1645. 

  1645. 			wid.size = RX_MIC_KEY_MSG_LEN;
    1646. 

  1646. 

  1647. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1648. 

  1648. 						      &wid, 1,
    1649. 

  1649. 						      wilc_get_vif_idx(vif));
    1650. 

  1650. 

  1651. 			kfree(pu8keybuf);
    1652. 

  1652. 			complete(&hif_drv->comp_test_key_block);
    1653. 

  1653. 		}
    1654. 

  1654. _WPARxGtk_end_case_:
    1655. 

  1655. 		kfree(pstrHostIFkeyAttr->attr.wpa.key);
    1656. 

  1656. 		kfree(pstrHostIFkeyAttr->attr.wpa.seq);
    1657. 

  1657. 		if (ret)
    1658. 

  1658. 			return ret;
    1659. 

  1659. 

  1660. 		break;
    1661. 

  1661. 

  1662. 	case WPA_PTK:
    1663. 

  1663. 		if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
    1664. 

  1664. 			pu8keybuf = kmalloc(PTK_KEY_MSG_LEN + 1, GFP_KERNEL);
    1665. 

  1665. 			if (!pu8keybuf) {
    1666. 

  1666. 				ret = -ENOMEM;
    1667. 

  1667. 				goto _WPAPtk_end_case_;
    1668. 

  1668. 			}
    1669. 

  1669. 

  1670. 			memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
    1671. 

  1671. 			memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->attr.wpa.index, 1);
    1672. 

  1672. 			memcpy(pu8keybuf + 7, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
    1673. 

  1673. 			memcpy(pu8keybuf + 8, pstrHostIFkeyAttr->attr.wpa.key,
    1674. 

  1674. 			       pstrHostIFkeyAttr->attr.wpa.key_len);
    1675. 

  1675. 

  1676. 			strWIDList[0].id = (u16)WID_11I_MODE;
    1677. 

  1677. 			strWIDList[0].type = WID_CHAR;
    1678. 

  1678. 			strWIDList[0].size = sizeof(char);
    1679. 

  1679. 			strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wpa.mode;
    1680. 

  1680. 

  1681. 			strWIDList[1].id = (u16)WID_ADD_PTK;
    1682. 

  1682. 			strWIDList[1].type = WID_STR;
    1683. 

  1683. 			strWIDList[1].val = (s8 *)pu8keybuf;
    1684. 

  1684. 			strWIDList[1].size = PTK_KEY_MSG_LEN + 1;
    1685. 

  1685. 

  1686. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1687. 

  1687. 						      strWIDList, 2,
    1688. 

  1688. 						      wilc_get_vif_idx(vif));
    1689. 

  1689. 			kfree(pu8keybuf);
    1690. 

  1690. 			complete(&hif_drv->comp_test_key_block);
    1691. 

  1691. 		} else if (pstrHostIFkeyAttr->action & ADDKEY) {
    1692. 

  1692. 			pu8keybuf = kmalloc(PTK_KEY_MSG_LEN, GFP_KERNEL);
    1693. 

  1693. 			if (!pu8keybuf) {
    1694. 

  1694. 				netdev_err(vif->ndev, "No buffer send PTK\n");
    1695. 

  1695. 				ret = -ENOMEM;
    1696. 

  1696. 				goto _WPAPtk_end_case_;
    1697. 

  1697. 			}
    1698. 

  1698. 

  1699. 			memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
    1700. 

  1700. 			memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
    1701. 

  1701. 			memcpy(pu8keybuf + 7, pstrHostIFkeyAttr->attr.wpa.key,
    1702. 

  1702. 			       pstrHostIFkeyAttr->attr.wpa.key_len);
    1703. 

  1703. 

  1704. 			wid.id = (u16)WID_ADD_PTK;
    1705. 

  1705. 			wid.type = WID_STR;
    1706. 

  1706. 			wid.val = (s8 *)pu8keybuf;
    1707. 

  1707. 			wid.size = PTK_KEY_MSG_LEN;
    1708. 

  1708. 

  1709. 			result = wilc_send_config_pkt(vif, SET_CFG,
    1710. 

  1710. 						      &wid, 1,
    1711. 

  1711. 						      wilc_get_vif_idx(vif));
    1712. 

  1712. 			kfree(pu8keybuf);
    1713. 

  1713. 			complete(&hif_drv->comp_test_key_block);
    1714. 

  1714. 		}
    1715. 

  1715. 

  1716. _WPAPtk_end_case_:
    1717. 

  1717. 		kfree(pstrHostIFkeyAttr->attr.wpa.key);
    1718. 

  1718. 		if (ret)
    1719. 

  1719. 			return ret;
    1720. 

  1720. 

  1721. 		break;
    1722. 

  1722. 

  1723. 	case PMKSA:
    1724. 

  1724. 		pu8keybuf = kmalloc((pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1, GFP_KERNEL);
    1725. 

  1725. 		if (!pu8keybuf) {
    1726. 

  1726. 			netdev_err(vif->ndev, "No buffer to send PMKSA Key\n");
    1727. 

  1727. 			return -ENOMEM;
    1728. 

  1728. 		}
    1729. 

  1729. 

  1730. 		pu8keybuf[0] = pstrHostIFkeyAttr->attr.pmkid.numpmkid;
    1731. 

  1731. 

  1732. 		for (i = 0; i < pstrHostIFkeyAttr->attr.pmkid.numpmkid; i++) {
    1733. 

  1733. 			memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + 1), pstrHostIFkeyAttr->attr.pmkid.pmkidlist[i].bssid, ETH_ALEN);
    1734. 

  1734. 			memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + ETH_ALEN + 1), pstrHostIFkeyAttr->attr.pmkid.pmkidlist[i].pmkid, PMKID_LEN);
    1735. 

  1735. 		}
    1736. 

  1736. 

  1737. 		wid.id = (u16)WID_PMKID_INFO;
    1738. 

  1738. 		wid.type = WID_STR;
    1739. 

  1739. 		wid.val = (s8 *)pu8keybuf;
    1740. 

  1740. 		wid.size = (pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1;
    1741. 

  1741. 

  1742. 		result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    1743. 

  1743. 					      wilc_get_vif_idx(vif));
    1744. 

  1744. 

  1745. 		kfree(pu8keybuf);
    1746. 

  1746. 		break;
    1747. 

  1747. 	}
    1748. 

  1748. 

  1749. 	if (result)
    1750. 

  1750. 		netdev_err(vif->ndev, "Failed to send key config packet\n");
    1751. 

  1751. 

  1752. 	return result;
    1753. 

  1753. }
    1754. 

  1754. 

  1755. static void Handle_Disconnect(struct wilc_vif *vif)
    1756. 

  1756. {
    1757. 

  1757. 	struct wid wid;
    1758. 

  1758. 	struct host_if_drv *hif_drv = vif->hif_drv;
    1759. 

  1759. 

  1760. 	s32 result = 0;
    1761. 

  1761. 	u16 u16DummyReasonCode = 0;
    1762. 

  1762. 

  1763. 	wid.id = (u16)WID_DISCONNECT;
    1764. 

  1764. 	wid.type = WID_CHAR;
    1765. 

  1765. 	wid.val = (s8 *)&u16DummyReasonCode;
    1766. 

  1766. 	wid.size = sizeof(char);
    1767. 

  1767. 

  1768. 	wilc_optaining_ip = false;
    1769. 

  1769. 	wilc_set_power_mgmt(vif, 0, 0);
    1770. 

  1770. 

  1771. 	eth_zero_addr(wilc_connected_ssid);
    1772. 

  1772. 

  1773. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    1774. 

  1774. 				      wilc_get_vif_idx(vif));
    1775. 

  1775. 

  1776. 	if (result) {
    1777. 

  1777. 		netdev_err(vif->ndev, "Failed to send dissconect\n");
    1778. 

  1778. 	} else {
    1779. 

  1779. 		struct disconnect_info strDisconnectNotifInfo;
    1780. 

  1780. 

  1781. 		memset(&strDisconnectNotifInfo, 0, sizeof(struct disconnect_info));
    1782. 

  1782. 

  1783. 		strDisconnectNotifInfo.reason = 0;
    1784. 

  1784. 		strDisconnectNotifInfo.ie = NULL;
    1785. 

  1785. 		strDisconnectNotifInfo.ie_len = 0;
    1786. 

  1786. 

  1787. 		if (hif_drv->usr_scan_req.scan_result) {
    1788. 

  1788. 			del_timer(&hif_drv->scan_timer);
    1789. 

  1789. 			hif_drv->usr_scan_req.scan_result(SCAN_EVENT_ABORTED,
    1790. 

  1790. 							  NULL,
    1791. 

  1791. 							  hif_drv->usr_scan_req.arg,
    1792. 

  1792. 							  NULL);
    1793. 

  1793. 			hif_drv->usr_scan_req.scan_result = NULL;
    1794. 

  1794. 		}
    1795. 

  1795. 

  1796. 		if (hif_drv->usr_conn_req.conn_result) {
    1797. 

  1797. 			if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP)
    1798. 

  1798. 				del_timer(&hif_drv->connect_timer);
    1799. 

  1799. 

  1800. 			hif_drv->usr_conn_req.conn_result(CONN_DISCONN_EVENT_DISCONN_NOTIF,
    1801. 

  1801. 							  NULL,
    1802. 

  1802. 							  0,
    1803. 

  1803. 							  &strDisconnectNotifInfo,
    1804. 

  1804. 							  hif_drv->usr_conn_req.arg);
    1805. 

  1805. 		} else {
    1806. 

  1806. 			netdev_err(vif->ndev, "conn_result = NULL\n");
    1807. 

  1807. 		}
    1808. 

  1808. 

  1809. 		scan_while_connected = false;
    1810. 

  1810. 

  1811. 		hif_drv->hif_state = HOST_IF_IDLE;
    1812. 

  1812. 

  1813. 		eth_zero_addr(hif_drv->assoc_bssid);
    1814. 

  1814. 

  1815. 		hif_drv->usr_conn_req.ssid_len = 0;
    1816. 

  1816. 		kfree(hif_drv->usr_conn_req.ssid);
    1817. 

  1817. 		hif_drv->usr_conn_req.ssid = NULL;
    1818. 

  1818. 		kfree(hif_drv->usr_conn_req.bssid);
    1819. 

  1819. 		hif_drv->usr_conn_req.bssid = NULL;
    1820. 

  1820. 		hif_drv->usr_conn_req.ies_len = 0;
    1821. 

  1821. 		kfree(hif_drv->usr_conn_req.ies);
    1822. 

  1822. 		hif_drv->usr_conn_req.ies = NULL;
    1823. 

  1823. 

  1824. 		if (join_req && join_req_vif == vif) {
    1825. 

  1825. 			kfree(join_req);
    1826. 

  1826. 			join_req = NULL;
    1827. 

  1827. 		}
    1828. 

  1828. 

  1829. 		if (info_element && join_req_vif == vif) {
    1830. 

  1830. 			kfree(info_element);
    1831. 

  1831. 			info_element = NULL;
    1832. 

  1832. 		}
    1833. 

  1833. 	}
    1834. 

  1834. 

  1835. 	complete(&hif_drv->comp_test_disconn_block);
    1836. 

  1836. }
    1837. 

  1837. 

  1838. void wilc_resolve_disconnect_aberration(struct wilc_vif *vif)
    1839. 

  1839. {
    1840. 

  1840. 	if (!vif->hif_drv)
    1841. 

  1841. 		return;
    1842. 

  1842. 	if ((vif->hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) ||
    1843. 

  1843. 	    (vif->hif_drv->hif_state == HOST_IF_CONNECTING))
    1844. 

  1844. 		wilc_disconnect(vif, 1);
    1845. 

  1845. }
    1846. 

  1846. 

  1847. static void Handle_GetRssi(struct wilc_vif *vif)
    1848. 

  1848. {
    1849. 

  1849. 	s32 result = 0;
    1850. 

  1850. 	struct wid wid;
    1851. 

  1851. 

  1852. 	wid.id = (u16)WID_RSSI;
    1853. 

  1853. 	wid.type = WID_CHAR;
    1854. 

  1854. 	wid.val = &rssi;
    1855. 

  1855. 	wid.size = sizeof(char);
    1856. 

  1856. 

  1857. 	result = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
    1858. 

  1858. 				      wilc_get_vif_idx(vif));
    1859. 

  1859. 	if (result) {
    1860. 

  1860. 		netdev_err(vif->ndev, "Failed to get RSSI value\n");
    1861. 

  1861. 		result = -EFAULT;
    1862. 

  1862. 	}
    1863. 

  1863. 

  1864. 	complete(&vif->hif_drv->comp_get_rssi);
    1865. 

  1865. }
    1866. 

  1866. 

  1867. static s32 Handle_GetStatistics(struct wilc_vif *vif,
    1868. 

  1868. 				struct rf_info *pstrStatistics)
    1869. 

  1869. {
    1870. 

  1870. 	struct wid strWIDList[5];
    1871. 

  1871. 	u32 u32WidsCount = 0, result = 0;
    1872. 

  1872. 

  1873. 	strWIDList[u32WidsCount].id = WID_LINKSPEED;
    1874. 

  1874. 	strWIDList[u32WidsCount].type = WID_CHAR;
    1875. 

  1875. 	strWIDList[u32WidsCount].size = sizeof(char);
    1876. 

  1876. 	strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->link_speed;
    1877. 

  1877. 	u32WidsCount++;
    1878. 

  1878. 

  1879. 	strWIDList[u32WidsCount].id = WID_RSSI;
    1880. 

  1880. 	strWIDList[u32WidsCount].type = WID_CHAR;
    1881. 

  1881. 	strWIDList[u32WidsCount].size = sizeof(char);
    1882. 

  1882. 	strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->rssi;
    1883. 

  1883. 	u32WidsCount++;
    1884. 

  1884. 

  1885. 	strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
    1886. 

  1886. 	strWIDList[u32WidsCount].type = WID_INT;
    1887. 

  1887. 	strWIDList[u32WidsCount].size = sizeof(u32);
    1888. 

  1888. 	strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->tx_cnt;
    1889. 

  1889. 	u32WidsCount++;
    1890. 

  1890. 

  1891. 	strWIDList[u32WidsCount].id = WID_RECEIVED_FRAGMENT_COUNT;
    1892. 

  1892. 	strWIDList[u32WidsCount].type = WID_INT;
    1893. 

  1893. 	strWIDList[u32WidsCount].size = sizeof(u32);
    1894. 

  1894. 	strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->rx_cnt;
    1895. 

  1895. 	u32WidsCount++;
    1896. 

  1896. 

  1897. 	strWIDList[u32WidsCount].id = WID_FAILED_COUNT;
    1898. 

  1898. 	strWIDList[u32WidsCount].type = WID_INT;
    1899. 

  1899. 	strWIDList[u32WidsCount].size = sizeof(u32);
    1900. 

  1900. 	strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->tx_fail_cnt;
    1901. 

  1901. 	u32WidsCount++;
    1902. 

  1902. 

  1903. 	result = wilc_send_config_pkt(vif, GET_CFG, strWIDList,
    1904. 

  1904. 				      u32WidsCount,
    1905. 

  1905. 				      wilc_get_vif_idx(vif));
    1906. 

  1906. 

  1907. 	if (result)
    1908. 

  1908. 		netdev_err(vif->ndev, "Failed to send scan parameters\n");
    1909. 

  1909. 

  1910. 	if (pstrStatistics->link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH &&
    1911. 

  1911. 	    pstrStatistics->link_speed != DEFAULT_LINK_SPEED)
    1912. 

  1912. 		wilc_enable_tcp_ack_filter(true);
    1913. 

  1913. 	else if (pstrStatistics->link_speed != DEFAULT_LINK_SPEED)
    1914. 

  1914. 		wilc_enable_tcp_ack_filter(false);
    1915. 

  1915. 

  1916. 	if (pstrStatistics != &vif->wilc->dummy_statistics)
    1917. 

  1917. 		complete(&hif_wait_response);
    1918. 

  1918. 	return 0;
    1919. 

  1919. }
    1920. 

  1920. 

  1921. static s32 Handle_Get_InActiveTime(struct wilc_vif *vif,
    1922. 

  1922. 				   struct sta_inactive_t *strHostIfStaInactiveT)
    1923. 

  1923. {
    1924. 

  1924. 	s32 result = 0;
    1925. 

  1925. 	u8 *stamac;
    1926. 

  1926. 	struct wid wid;
    1927. 

  1927. 	struct host_if_drv *hif_drv = vif->hif_drv;
    1928. 

  1928. 

  1929. 	wid.id = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
    1930. 

  1930. 	wid.type = WID_STR;
    1931. 

  1931. 	wid.size = ETH_ALEN;
    1932. 

  1932. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    1933. 

  1933. 

  1934. 	stamac = wid.val;
    1935. 

  1935. 	memcpy(stamac, strHostIfStaInactiveT->mac, ETH_ALEN);
    1936. 

  1936. 

  1937. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    1938. 

  1938. 				      wilc_get_vif_idx(vif));
    1939. 

  1939. 

  1940. 	if (result) {
    1941. 

  1941. 		netdev_err(vif->ndev, "Failed to SET incative time\n");
    1942. 

  1942. 		return -EFAULT;
    1943. 

  1943. 	}
    1944. 

  1944. 

  1945. 	wid.id = (u16)WID_GET_INACTIVE_TIME;
    1946. 

  1946. 	wid.type = WID_INT;
    1947. 

  1947. 	wid.val = (s8 *)&inactive_time;
    1948. 

  1948. 	wid.size = sizeof(u32);
    1949. 

  1949. 

  1950. 	result = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
    1951. 

  1951. 				      wilc_get_vif_idx(vif));
    1952. 

  1952. 

  1953. 	if (result) {
    1954. 

  1954. 		netdev_err(vif->ndev, "Failed to get incative time\n");
    1955. 

  1955. 		return -EFAULT;
    1956. 

  1956. 	}
    1957. 

  1957. 

  1958. 	complete(&hif_drv->comp_inactive_time);
    1959. 

  1959. 

  1960. 	return result;
    1961. 

  1961. }
    1962. 

  1962. 

  1963. static void Handle_AddBeacon(struct wilc_vif *vif,
    1964. 

  1964. 			     struct beacon_attr *pstrSetBeaconParam)
    1965. 

  1965. {
    1966. 

  1966. 	s32 result = 0;
    1967. 

  1967. 	struct wid wid;
    1968. 

  1968. 	u8 *pu8CurrByte;
    1969. 

  1969. 

  1970. 	wid.id = (u16)WID_ADD_BEACON;
    1971. 

  1971. 	wid.type = WID_BIN;
    1972. 

  1972. 	wid.size = pstrSetBeaconParam->head_len + pstrSetBeaconParam->tail_len + 16;
    1973. 

  1973. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    1974. 

  1974. 	if (!wid.val)
    1975. 

  1975. 		goto ERRORHANDLER;
    1976. 

  1976. 

  1977. 	pu8CurrByte = wid.val;
    1978. 

  1978. 	*pu8CurrByte++ = (pstrSetBeaconParam->interval & 0xFF);
    1979. 

  1979. 	*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 8) & 0xFF);
    1980. 

  1980. 	*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 16) & 0xFF);
    1981. 

  1981. 	*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 24) & 0xFF);
    1982. 

  1982. 

  1983. 	*pu8CurrByte++ = (pstrSetBeaconParam->dtim_period & 0xFF);
    1984. 

  1984. 	*pu8CurrByte++ = ((pstrSetBeaconParam->dtim_period >> 8) & 0xFF);
    1985. 

  1985. 	*pu8CurrByte++ = ((pstrSetBeaconParam->dtim_period >> 16) & 0xFF);
    1986. 

  1986. 	*pu8CurrByte++ = ((pstrSetBeaconParam->dtim_period >> 24) & 0xFF);
    1987. 

  1987. 

  1988. 	*pu8CurrByte++ = (pstrSetBeaconParam->head_len & 0xFF);
    1989. 

  1989. 	*pu8CurrByte++ = ((pstrSetBeaconParam->head_len >> 8) & 0xFF);
    1990. 

  1990. 	*pu8CurrByte++ = ((pstrSetBeaconParam->head_len >> 16) & 0xFF);
    1991. 

  1991. 	*pu8CurrByte++ = ((pstrSetBeaconParam->head_len >> 24) & 0xFF);
    1992. 

  1992. 

  1993. 	memcpy(pu8CurrByte, pstrSetBeaconParam->head, pstrSetBeaconParam->head_len);
    1994. 

  1994. 	pu8CurrByte += pstrSetBeaconParam->head_len;
    1995. 

  1995. 

  1996. 	*pu8CurrByte++ = (pstrSetBeaconParam->tail_len & 0xFF);
    1997. 

  1997. 	*pu8CurrByte++ = ((pstrSetBeaconParam->tail_len >> 8) & 0xFF);
    1998. 

  1998. 	*pu8CurrByte++ = ((pstrSetBeaconParam->tail_len >> 16) & 0xFF);
    1999. 

  1999. 	*pu8CurrByte++ = ((pstrSetBeaconParam->tail_len >> 24) & 0xFF);
    2000. 

  2000. 

  2001. 	if (pstrSetBeaconParam->tail)
    2002. 

  2002. 		memcpy(pu8CurrByte, pstrSetBeaconParam->tail, pstrSetBeaconParam->tail_len);
    2003. 

  2003. 	pu8CurrByte += pstrSetBeaconParam->tail_len;
    2004. 

  2004. 

  2005. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2006. 

  2006. 				      wilc_get_vif_idx(vif));
    2007. 

  2007. 	if (result)
    2008. 

  2008. 		netdev_err(vif->ndev, "Failed to send add beacon\n");
    2009. 

  2009. 

  2010. ERRORHANDLER:
    2011. 

  2011. 	kfree(wid.val);
    2012. 

  2012. 	kfree(pstrSetBeaconParam->head);
    2013. 

  2013. 	kfree(pstrSetBeaconParam->tail);
    2014. 

  2014. }
    2015. 

  2015. 

  2016. static void Handle_DelBeacon(struct wilc_vif *vif)
    2017. 

  2017. {
    2018. 

  2018. 	s32 result = 0;
    2019. 

  2019. 	struct wid wid;
    2020. 

  2020. 	u8 *pu8CurrByte;
    2021. 

  2021. 

  2022. 	wid.id = (u16)WID_DEL_BEACON;
    2023. 

  2023. 	wid.type = WID_CHAR;
    2024. 

  2024. 	wid.size = sizeof(char);
    2025. 

  2025. 	wid.val = &del_beacon;
    2026. 

  2026. 

  2027. 	if (!wid.val)
    2028. 

  2028. 		return;
    2029. 

  2029. 

  2030. 	pu8CurrByte = wid.val;
    2031. 

  2031. 

  2032. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2033. 

  2033. 				      wilc_get_vif_idx(vif));
    2034. 

  2034. 	if (result)
    2035. 

  2035. 		netdev_err(vif->ndev, "Failed to send delete beacon\n");
    2036. 

  2036. }
    2037. 

  2037. 

  2038. static u32 WILC_HostIf_PackStaParam(u8 *pu8Buffer,
    2039. 

  2039. 				    struct add_sta_param *pstrStationParam)
    2040. 

  2040. {
    2041. 

  2041. 	u8 *pu8CurrByte;
    2042. 

  2042. 

  2043. 	pu8CurrByte = pu8Buffer;
    2044. 

  2044. 

  2045. 	memcpy(pu8CurrByte, pstrStationParam->bssid, ETH_ALEN);
    2046. 

  2046. 	pu8CurrByte +=  ETH_ALEN;
    2047. 

  2047. 

  2048. 	*pu8CurrByte++ = pstrStationParam->aid & 0xFF;
    2049. 

  2049. 	*pu8CurrByte++ = (pstrStationParam->aid >> 8) & 0xFF;
    2050. 

  2050. 

  2051. 	*pu8CurrByte++ = pstrStationParam->rates_len;
    2052. 

  2052. 	if (pstrStationParam->rates_len > 0)
    2053. 

  2053. 		memcpy(pu8CurrByte, pstrStationParam->rates,
    2054. 

  2054. 		       pstrStationParam->rates_len);
    2055. 

  2055. 	pu8CurrByte += pstrStationParam->rates_len;
    2056. 

  2056. 

  2057. 	*pu8CurrByte++ = pstrStationParam->ht_supported;
    2058. 

  2058. 	*pu8CurrByte++ = pstrStationParam->ht_capa_info & 0xFF;
    2059. 

  2059. 	*pu8CurrByte++ = (pstrStationParam->ht_capa_info >> 8) & 0xFF;
    2060. 

  2060. 

  2061. 	*pu8CurrByte++ = pstrStationParam->ht_ampdu_params;
    2062. 

  2062. 	memcpy(pu8CurrByte, pstrStationParam->ht_supp_mcs_set,
    2063. 

  2063. 	       WILC_SUPP_MCS_SET_SIZE);
    2064. 

  2064. 	pu8CurrByte += WILC_SUPP_MCS_SET_SIZE;
    2065. 

  2065. 

  2066. 	*pu8CurrByte++ = pstrStationParam->ht_ext_params & 0xFF;
    2067. 

  2067. 	*pu8CurrByte++ = (pstrStationParam->ht_ext_params >> 8) & 0xFF;
    2068. 

  2068. 

  2069. 	*pu8CurrByte++ = pstrStationParam->ht_tx_bf_cap & 0xFF;
    2070. 

  2070. 	*pu8CurrByte++ = (pstrStationParam->ht_tx_bf_cap >> 8) & 0xFF;
    2071. 

  2071. 	*pu8CurrByte++ = (pstrStationParam->ht_tx_bf_cap >> 16) & 0xFF;
    2072. 

  2072. 	*pu8CurrByte++ = (pstrStationParam->ht_tx_bf_cap >> 24) & 0xFF;
    2073. 

  2073. 

  2074. 	*pu8CurrByte++ = pstrStationParam->ht_ante_sel;
    2075. 

  2075. 

  2076. 	*pu8CurrByte++ = pstrStationParam->flags_mask & 0xFF;
    2077. 

  2077. 	*pu8CurrByte++ = (pstrStationParam->flags_mask >> 8) & 0xFF;
    2078. 

  2078. 

  2079. 	*pu8CurrByte++ = pstrStationParam->flags_set & 0xFF;
    2080. 

  2080. 	*pu8CurrByte++ = (pstrStationParam->flags_set >> 8) & 0xFF;
    2081. 

  2081. 

  2082. 	return pu8CurrByte - pu8Buffer;
    2083. 

  2083. }
    2084. 

  2084. 

  2085. static void Handle_AddStation(struct wilc_vif *vif,
    2086. 

  2086. 			      struct add_sta_param *pstrStationParam)
    2087. 

  2087. {
    2088. 

  2088. 	s32 result = 0;
    2089. 

  2089. 	struct wid wid;
    2090. 

  2090. 	u8 *pu8CurrByte;
    2091. 

  2091. 

  2092. 	wid.id = (u16)WID_ADD_STA;
    2093. 

  2093. 	wid.type = WID_BIN;
    2094. 

  2094. 	wid.size = WILC_ADD_STA_LENGTH + pstrStationParam->rates_len;
    2095. 

  2095. 

  2096. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    2097. 

  2097. 	if (!wid.val)
    2098. 

  2098. 		goto ERRORHANDLER;
    2099. 

  2099. 

  2100. 	pu8CurrByte = wid.val;
    2101. 

  2101. 	pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
    2102. 

  2102. 

  2103. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2104. 

  2104. 				      wilc_get_vif_idx(vif));
    2105. 

  2105. 	if (result != 0)
    2106. 

  2106. 		netdev_err(vif->ndev, "Failed to send add station\n");
    2107. 

  2107. 

  2108. ERRORHANDLER:
    2109. 

  2109. 	kfree(pstrStationParam->rates);
    2110. 

  2110. 	kfree(wid.val);
    2111. 

  2111. }
    2112. 

  2112. 

  2113. static void Handle_DelAllSta(struct wilc_vif *vif,
    2114. 

  2114. 			     struct del_all_sta *pstrDelAllStaParam)
    2115. 

  2115. {
    2116. 

  2116. 	s32 result = 0;
    2117. 

  2117. 	struct wid wid;
    2118. 

  2118. 	u8 *pu8CurrByte;
    2119. 

  2119. 	u8 i;
    2120. 

  2120. 	u8 au8Zero_Buff[6] = {0};
    2121. 

  2121. 

  2122. 	wid.id = (u16)WID_DEL_ALL_STA;
    2123. 

  2123. 	wid.type = WID_STR;
    2124. 

  2124. 	wid.size = (pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1;
    2125. 

  2125. 

  2126. 	wid.val = kmalloc((pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1, GFP_KERNEL);
    2127. 

  2127. 	if (!wid.val)
    2128. 

  2128. 		goto ERRORHANDLER;
    2129. 

  2129. 

  2130. 	pu8CurrByte = wid.val;
    2131. 

  2131. 

  2132. 	*(pu8CurrByte++) = pstrDelAllStaParam->assoc_sta;
    2133. 

  2133. 

  2134. 	for (i = 0; i < MAX_NUM_STA; i++) {
    2135. 

  2135. 		if (memcmp(pstrDelAllStaParam->del_all_sta[i], au8Zero_Buff, ETH_ALEN))
    2136. 

  2136. 			memcpy(pu8CurrByte, pstrDelAllStaParam->del_all_sta[i], ETH_ALEN);
    2137. 

  2137. 		else
    2138. 

  2138. 			continue;
    2139. 

  2139. 

  2140. 		pu8CurrByte += ETH_ALEN;
    2141. 

  2141. 	}
    2142. 

  2142. 

  2143. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2144. 

  2144. 				      wilc_get_vif_idx(vif));
    2145. 

  2145. 	if (result)
    2146. 

  2146. 		netdev_err(vif->ndev, "Failed to send add station\n");
    2147. 

  2147. 

  2148. ERRORHANDLER:
    2149. 

  2149. 	kfree(wid.val);
    2150. 

  2150. 

  2151. 	complete(&hif_wait_response);
    2152. 

  2152. }
    2153. 

  2153. 

  2154. static void Handle_DelStation(struct wilc_vif *vif,
    2155. 

  2155. 			      struct del_sta *pstrDelStaParam)
    2156. 

  2156. {
    2157. 

  2157. 	s32 result = 0;
    2158. 

  2158. 	struct wid wid;
    2159. 

  2159. 	u8 *pu8CurrByte;
    2160. 

  2160. 

  2161. 	wid.id = (u16)WID_REMOVE_STA;
    2162. 

  2162. 	wid.type = WID_BIN;
    2163. 

  2163. 	wid.size = ETH_ALEN;
    2164. 

  2164. 

  2165. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    2166. 

  2166. 	if (!wid.val)
    2167. 

  2167. 		goto ERRORHANDLER;
    2168. 

  2168. 

  2169. 	pu8CurrByte = wid.val;
    2170. 

  2170. 

  2171. 	memcpy(pu8CurrByte, pstrDelStaParam->mac_addr, ETH_ALEN);
    2172. 

  2172. 

  2173. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2174. 

  2174. 				      wilc_get_vif_idx(vif));
    2175. 

  2175. 	if (result)
    2176. 

  2176. 		netdev_err(vif->ndev, "Failed to send add station\n");
    2177. 

  2177. 

  2178. ERRORHANDLER:
    2179. 

  2179. 	kfree(wid.val);
    2180. 

  2180. }
    2181. 

  2181. 

  2182. static void Handle_EditStation(struct wilc_vif *vif,
    2183. 

  2183. 			       struct add_sta_param *pstrStationParam)
    2184. 

  2184. {
    2185. 

  2185. 	s32 result = 0;
    2186. 

  2186. 	struct wid wid;
    2187. 

  2187. 	u8 *pu8CurrByte;
    2188. 

  2188. 

  2189. 	wid.id = (u16)WID_EDIT_STA;
    2190. 

  2190. 	wid.type = WID_BIN;
    2191. 

  2191. 	wid.size = WILC_ADD_STA_LENGTH + pstrStationParam->rates_len;
    2192. 

  2192. 

  2193. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    2194. 

  2194. 	if (!wid.val)
    2195. 

  2195. 		goto ERRORHANDLER;
    2196. 

  2196. 

  2197. 	pu8CurrByte = wid.val;
    2198. 

  2198. 	pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
    2199. 

  2199. 

  2200. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2201. 

  2201. 				      wilc_get_vif_idx(vif));
    2202. 

  2202. 	if (result)
    2203. 

  2203. 		netdev_err(vif->ndev, "Failed to send edit station\n");
    2204. 

  2204. 

  2205. ERRORHANDLER:
    2206. 

  2206. 	kfree(pstrStationParam->rates);
    2207. 

  2207. 	kfree(wid.val);
    2208. 

  2208. }
    2209. 

  2209. 

  2210. static int Handle_RemainOnChan(struct wilc_vif *vif,
    2211. 

  2211. 			       struct remain_ch *pstrHostIfRemainOnChan)
    2212. 

  2212. {
    2213. 

  2213. 	s32 result = 0;
    2214. 

  2214. 	u8 u8remain_on_chan_flag;
    2215. 

  2215. 	struct wid wid;
    2216. 

  2216. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2217. 

  2217. 

  2218. 	if (!hif_drv->remain_on_ch_pending) {
    2219. 

  2219. 		hif_drv->remain_on_ch.arg = pstrHostIfRemainOnChan->arg;
    2220. 

  2220. 		hif_drv->remain_on_ch.expired = pstrHostIfRemainOnChan->expired;
    2221. 

  2221. 		hif_drv->remain_on_ch.ready = pstrHostIfRemainOnChan->ready;
    2222. 

  2222. 		hif_drv->remain_on_ch.ch = pstrHostIfRemainOnChan->ch;
    2223. 

  2223. 		hif_drv->remain_on_ch.id = pstrHostIfRemainOnChan->id;
    2224. 

  2224. 	} else {
    2225. 

  2225. 		pstrHostIfRemainOnChan->ch = hif_drv->remain_on_ch.ch;
    2226. 

  2226. 	}
    2227. 

  2227. 

  2228. 	if (hif_drv->usr_scan_req.scan_result) {
    2229. 

  2229. 		hif_drv->remain_on_ch_pending = 1;
    2230. 

  2230. 		result = -EBUSY;
    2231. 

  2231. 		goto ERRORHANDLER;
    2232. 

  2232. 	}
    2233. 

  2233. 	if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) {
    2234. 

  2234. 		result = -EBUSY;
    2235. 

  2235. 		goto ERRORHANDLER;
    2236. 

  2236. 	}
    2237. 

  2237. 

  2238. 	if (wilc_optaining_ip || wilc_connecting) {
    2239. 

  2239. 		result = -EBUSY;
    2240. 

  2240. 		goto ERRORHANDLER;
    2241. 

  2241. 	}
    2242. 

  2242. 

  2243. 	u8remain_on_chan_flag = true;
    2244. 

  2244. 	wid.id = (u16)WID_REMAIN_ON_CHAN;
    2245. 

  2245. 	wid.type = WID_STR;
    2246. 

  2246. 	wid.size = 2;
    2247. 

  2247. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    2248. 

  2248. 	if (!wid.val) {
    2249. 

  2249. 		result = -ENOMEM;
    2250. 

  2250. 		goto ERRORHANDLER;
    2251. 

  2251. 	}
    2252. 

  2252. 

  2253. 	wid.val[0] = u8remain_on_chan_flag;
    2254. 

  2254. 	wid.val[1] = (s8)pstrHostIfRemainOnChan->ch;
    2255. 

  2255. 

  2256. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2257. 

  2257. 				      wilc_get_vif_idx(vif));
    2258. 

  2258. 	if (result != 0)
    2259. 

  2259. 		netdev_err(vif->ndev, "Failed to set remain on channel\n");
    2260. 

  2260. 

  2261. ERRORHANDLER:
    2262. 

  2262. 	{
    2263. 

  2263. 		P2P_LISTEN_STATE = 1;
    2264. 

  2264. 		hif_drv->remain_on_ch_timer.data = (unsigned long)vif;
    2265. 

  2265. 		mod_timer(&hif_drv->remain_on_ch_timer,
    2266. 

  2266. 			  jiffies +
    2267. 

  2267. 			  msecs_to_jiffies(pstrHostIfRemainOnChan->duration));
    2268. 

  2268. 

  2269. 		if (hif_drv->remain_on_ch.ready)
    2270. 

  2270. 			hif_drv->remain_on_ch.ready(hif_drv->remain_on_ch.arg);
    2271. 

  2271. 

  2272. 		if (hif_drv->remain_on_ch_pending)
    2273. 

  2273. 			hif_drv->remain_on_ch_pending = 0;
    2274. 

  2274. 	}
    2275. 

  2275. 

  2276. 	return result;
    2277. 

  2277. }
    2278. 

  2278. 

  2279. static int Handle_RegisterFrame(struct wilc_vif *vif,
    2280. 

  2280. 				struct reg_frame *pstrHostIfRegisterFrame)
    2281. 

  2281. {
    2282. 

  2282. 	s32 result = 0;
    2283. 

  2283. 	struct wid wid;
    2284. 

  2284. 	u8 *pu8CurrByte;
    2285. 

  2285. 

  2286. 	wid.id = (u16)WID_REGISTER_FRAME;
    2287. 

  2287. 	wid.type = WID_STR;
    2288. 

  2288. 	wid.val = kmalloc(sizeof(u16) + 2, GFP_KERNEL);
    2289. 

  2289. 	if (!wid.val)
    2290. 

  2290. 		return -ENOMEM;
    2291. 

  2291. 

  2292. 	pu8CurrByte = wid.val;
    2293. 

  2293. 

  2294. 	*pu8CurrByte++ = pstrHostIfRegisterFrame->reg;
    2295. 

  2295. 	*pu8CurrByte++ = pstrHostIfRegisterFrame->reg_id;
    2296. 

  2296. 	memcpy(pu8CurrByte, &pstrHostIfRegisterFrame->frame_type, sizeof(u16));
    2297. 

  2297. 

  2298. 	wid.size = sizeof(u16) + 2;
    2299. 

  2299. 

  2300. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2301. 

  2301. 				      wilc_get_vif_idx(vif));
    2302. 

  2302. 	if (result) {
    2303. 

  2303. 		netdev_err(vif->ndev, "Failed to frame register\n");
    2304. 

  2304. 		result = -EINVAL;
    2305. 

  2305. 	}
    2306. 

  2306. 

  2307. 	return result;
    2308. 

  2308. }
    2309. 

  2309. 

  2310. static u32 Handle_ListenStateExpired(struct wilc_vif *vif,
    2311. 

  2311. 				     struct remain_ch *pstrHostIfRemainOnChan)
    2312. 

  2312. {
    2313. 

  2313. 	u8 u8remain_on_chan_flag;
    2314. 

  2314. 	struct wid wid;
    2315. 

  2315. 	s32 result = 0;
    2316. 

  2316. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2317. 

  2317. 

  2318. 	if (P2P_LISTEN_STATE) {
    2319. 

  2319. 		u8remain_on_chan_flag = false;
    2320. 

  2320. 		wid.id = (u16)WID_REMAIN_ON_CHAN;
    2321. 

  2321. 		wid.type = WID_STR;
    2322. 

  2322. 		wid.size = 2;
    2323. 

  2323. 		wid.val = kmalloc(wid.size, GFP_KERNEL);
    2324. 

  2324. 

  2325. 		if (!wid.val) {
    2326. 

  2326. 			netdev_err(vif->ndev, "Failed to allocate memory\n");
    2327. 

  2327. 			return -ENOMEM;
    2328. 

  2328. 		}
    2329. 

  2329. 

  2330. 		wid.val[0] = u8remain_on_chan_flag;
    2331. 

  2331. 		wid.val[1] = FALSE_FRMWR_CHANNEL;
    2332. 

  2332. 

  2333. 		result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2334. 

  2334. 					      wilc_get_vif_idx(vif));
    2335. 

  2335. 		if (result != 0) {
    2336. 

  2336. 			netdev_err(vif->ndev, "Failed to set remain channel\n");
    2337. 

  2337. 			goto _done_;
    2338. 

  2338. 		}
    2339. 

  2339. 

  2340. 		if (hif_drv->remain_on_ch.expired) {
    2341. 

  2341. 			hif_drv->remain_on_ch.expired(hif_drv->remain_on_ch.arg,
    2342. 

  2342. 						      pstrHostIfRemainOnChan->id);
    2343. 

  2343. 		}
    2344. 

  2344. 		P2P_LISTEN_STATE = 0;
    2345. 

  2345. 	} else {
    2346. 

  2346. 		netdev_dbg(vif->ndev, "Not in listen state\n");
    2347. 

  2347. 		result = -EFAULT;
    2348. 

  2348. 	}
    2349. 

  2349. 

  2350. _done_:
    2351. 

  2351. 	return result;
    2352. 

  2352. }
    2353. 

  2353. 

  2354. static void ListenTimerCB(unsigned long arg)
    2355. 

  2355. {
    2356. 

  2356. 	s32 result = 0;
    2357. 

  2357. 	struct host_if_msg msg;
    2358. 

  2358. 	struct wilc_vif *vif = (struct wilc_vif *)arg;
    2359. 

  2359. 

  2360. 	del_timer(&vif->hif_drv->remain_on_ch_timer);
    2361. 

  2361. 

  2362. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2363. 

  2363. 	msg.id = HOST_IF_MSG_LISTEN_TIMER_FIRED;
    2364. 

  2364. 	msg.vif = vif;
    2365. 

  2365. 	msg.body.remain_on_ch.id = vif->hif_drv->remain_on_ch.id;
    2366. 

  2366. 

  2367. 	result = wilc_enqueue_cmd(&msg);
    2368. 

  2368. 	if (result)
    2369. 

  2369. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    2370. 

  2370. }
    2371. 

  2371. 

  2372. static void Handle_PowerManagement(struct wilc_vif *vif,
    2373. 

  2373. 				   struct power_mgmt_param *strPowerMgmtParam)
    2374. 

  2374. {
    2375. 

  2375. 	s32 result = 0;
    2376. 

  2376. 	struct wid wid;
    2377. 

  2377. 	s8 s8PowerMode;
    2378. 

  2378. 

  2379. 	wid.id = (u16)WID_POWER_MANAGEMENT;
    2380. 

  2380. 

  2381. 	if (strPowerMgmtParam->enabled)
    2382. 

  2382. 		s8PowerMode = MIN_FAST_PS;
    2383. 

  2383. 	else
    2384. 

  2384. 		s8PowerMode = NO_POWERSAVE;
    2385. 

  2385. 

  2386. 	wid.val = &s8PowerMode;
    2387. 

  2387. 	wid.size = sizeof(char);
    2388. 

  2388. 

  2389. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2390. 

  2390. 				      wilc_get_vif_idx(vif));
    2391. 

  2391. 	if (result)
    2392. 

  2392. 		netdev_err(vif->ndev, "Failed to send power management\n");
    2393. 

  2393. }
    2394. 

  2394. 

  2395. static void Handle_SetMulticastFilter(struct wilc_vif *vif,
    2396. 

  2396. 				      struct set_multicast *strHostIfSetMulti)
    2397. 

  2397. {
    2398. 

  2398. 	s32 result = 0;
    2399. 

  2399. 	struct wid wid;
    2400. 

  2400. 	u8 *pu8CurrByte;
    2401. 

  2401. 

  2402. 	wid.id = (u16)WID_SETUP_MULTICAST_FILTER;
    2403. 

  2403. 	wid.type = WID_BIN;
    2404. 

  2404. 	wid.size = sizeof(struct set_multicast) + ((strHostIfSetMulti->cnt) * ETH_ALEN);
    2405. 

  2405. 	wid.val = kmalloc(wid.size, GFP_KERNEL);
    2406. 

  2406. 	if (!wid.val)
    2407. 

  2407. 		goto ERRORHANDLER;
    2408. 

  2408. 

  2409. 	pu8CurrByte = wid.val;
    2410. 

  2410. 	*pu8CurrByte++ = (strHostIfSetMulti->enabled & 0xFF);
    2411. 

  2411. 	*pu8CurrByte++ = 0;
    2412. 

  2412. 	*pu8CurrByte++ = 0;
    2413. 

  2413. 	*pu8CurrByte++ = 0;
    2414. 

  2414. 

  2415. 	*pu8CurrByte++ = (strHostIfSetMulti->cnt & 0xFF);
    2416. 

  2416. 	*pu8CurrByte++ = ((strHostIfSetMulti->cnt >> 8) & 0xFF);
    2417. 

  2417. 	*pu8CurrByte++ = ((strHostIfSetMulti->cnt >> 16) & 0xFF);
    2418. 

  2418. 	*pu8CurrByte++ = ((strHostIfSetMulti->cnt >> 24) & 0xFF);
    2419. 

  2419. 

  2420. 	if ((strHostIfSetMulti->cnt) > 0)
    2421. 

  2421. 		memcpy(pu8CurrByte, wilc_multicast_mac_addr_list,
    2422. 

  2422. 		       ((strHostIfSetMulti->cnt) * ETH_ALEN));
    2423. 

  2423. 

  2424. 	result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2425. 

  2425. 				      wilc_get_vif_idx(vif));
    2426. 

  2426. 	if (result)
    2427. 

  2427. 		netdev_err(vif->ndev, "Failed to send setup multicast\n");
    2428. 

  2428. 

  2429. ERRORHANDLER:
    2430. 

  2430. 	kfree(wid.val);
    2431. 

  2431. }
    2432. 

  2432. 

  2433. static void handle_set_tx_pwr(struct wilc_vif *vif, u8 tx_pwr)
    2434. 

  2434. {
    2435. 

  2435. 	int ret;
    2436. 

  2436. 	struct wid wid;
    2437. 

  2437. 

  2438. 	wid.id = (u16)WID_TX_POWER;
    2439. 

  2439. 	wid.type = WID_CHAR;
    2440. 

  2440. 	wid.val = &tx_pwr;
    2441. 

  2441. 	wid.size = sizeof(char);
    2442. 

  2442. 

  2443. 	ret = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
    2444. 

  2444. 				   wilc_get_vif_idx(vif));
    2445. 

  2445. 	if (ret)
    2446. 

  2446. 		netdev_err(vif->ndev, "Failed to set TX PWR\n");
    2447. 

  2447. }
    2448. 

  2448. 

  2449. static void handle_get_tx_pwr(struct wilc_vif *vif, u8 *tx_pwr)
    2450. 

  2450. {
    2451. 

  2451. 	int ret = 0;
    2452. 

  2452. 	struct wid wid;
    2453. 

  2453. 

  2454. 	wid.id = (u16)WID_TX_POWER;
    2455. 

  2455. 	wid.type = WID_CHAR;
    2456. 

  2456. 	wid.val = (s8 *)tx_pwr;
    2457. 

  2457. 	wid.size = sizeof(char);
    2458. 

  2458. 

  2459. 	ret = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
    2460. 

  2460. 				   wilc_get_vif_idx(vif));
    2461. 

  2461. 	if (ret)
    2462. 

  2462. 		netdev_err(vif->ndev, "Failed to get TX PWR\n");
    2463. 

  2463. 

  2464. 	complete(&hif_wait_response);
    2465. 

  2465. }
    2466. 

  2466. 

  2467. static void host_if_work(struct work_struct *work)
    2468. 

  2468. {
    2469. 

  2469. 	struct host_if_msg *msg;
    2470. 

  2470. 	struct wilc *wilc;
    2471. 

  2471. 

  2472. 	msg = container_of(work, struct host_if_msg, work);
    2473. 

  2473. 	wilc = msg->vif->wilc;
    2474. 

  2474. 

  2475. 	if (msg->id == HOST_IF_MSG_CONNECT &&
    2476. 

  2476. 	    msg->vif->hif_drv->usr_scan_req.scan_result) {
    2477. 

  2477. 		wilc_enqueue_cmd(msg);
    2478. 

  2478. 		usleep_range(2 * 1000, 2 * 1000);
    2479. 

  2479. 		goto free_msg;
    2480. 

  2480. 	}
    2481. 

  2481. 	switch (msg->id) {
    2482. 

  2482. 	case HOST_IF_MSG_SCAN:
    2483. 

  2483. 		handle_scan(msg->vif, &msg->body.scan_info);
    2484. 

  2484. 		break;
    2485. 

  2485. 

  2486. 	case HOST_IF_MSG_CONNECT:
    2487. 

  2487. 		Handle_Connect(msg->vif, &msg->body.con_info);
    2488. 

  2488. 		break;
    2489. 

  2489. 

  2490. 	case HOST_IF_MSG_RCVD_NTWRK_INFO:
    2491. 

  2491. 		Handle_RcvdNtwrkInfo(msg->vif, &msg->body.net_info);
    2492. 

  2492. 		break;
    2493. 

  2493. 

  2494. 	case HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO:
    2495. 

  2495. 		Handle_RcvdGnrlAsyncInfo(msg->vif,
    2496. 

  2496. 					 &msg->body.async_info);
    2497. 

  2497. 		break;
    2498. 

  2498. 

  2499. 	case HOST_IF_MSG_KEY:
    2500. 

  2500. 		Handle_Key(msg->vif, &msg->body.key_info);
    2501. 

  2501. 		break;
    2502. 

  2502. 

  2503. 	case HOST_IF_MSG_CFG_PARAMS:
    2504. 

  2504. 		handle_cfg_param(msg->vif, &msg->body.cfg_info);
    2505. 

  2505. 		break;
    2506. 

  2506. 

  2507. 	case HOST_IF_MSG_SET_CHANNEL:
    2508. 

  2508. 		handle_set_channel(msg->vif, &msg->body.channel_info);
    2509. 

  2509. 		break;
    2510. 

  2510. 

  2511. 	case HOST_IF_MSG_DISCONNECT:
    2512. 

  2512. 		Handle_Disconnect(msg->vif);
    2513. 

  2513. 		break;
    2514. 

  2514. 

  2515. 	case HOST_IF_MSG_RCVD_SCAN_COMPLETE:
    2516. 

  2516. 		del_timer(&msg->vif->hif_drv->scan_timer);
    2517. 

  2517. 

  2518. 		if (!wilc_wlan_get_num_conn_ifcs(wilc))
    2519. 

  2519. 			wilc_chip_sleep_manually(wilc);
    2520. 

  2520. 

  2521. 		Handle_ScanDone(msg->vif, SCAN_EVENT_DONE);
    2522. 

  2522. 

  2523. 		if (msg->vif->hif_drv->remain_on_ch_pending)
    2524. 

  2524. 			Handle_RemainOnChan(msg->vif,
    2525. 

  2525. 					    &msg->body.remain_on_ch);
    2526. 

  2526. 

  2527. 		break;
    2528. 

  2528. 

  2529. 	case HOST_IF_MSG_GET_RSSI:
    2530. 

  2530. 		Handle_GetRssi(msg->vif);
    2531. 

  2531. 		break;
    2532. 

  2532. 

  2533. 	case HOST_IF_MSG_GET_STATISTICS:
    2534. 

  2534. 		Handle_GetStatistics(msg->vif,
    2535. 

  2535. 				     (struct rf_info *)msg->body.data);
    2536. 

  2536. 		break;
    2537. 

  2537. 

  2538. 	case HOST_IF_MSG_ADD_BEACON:
    2539. 

  2539. 		Handle_AddBeacon(msg->vif, &msg->body.beacon_info);
    2540. 

  2540. 		break;
    2541. 

  2541. 

  2542. 	case HOST_IF_MSG_DEL_BEACON:
    2543. 

  2543. 		Handle_DelBeacon(msg->vif);
    2544. 

  2544. 		break;
    2545. 

  2545. 

  2546. 	case HOST_IF_MSG_ADD_STATION:
    2547. 

  2547. 		Handle_AddStation(msg->vif, &msg->body.add_sta_info);
    2548. 

  2548. 		break;
    2549. 

  2549. 

  2550. 	case HOST_IF_MSG_DEL_STATION:
    2551. 

  2551. 		Handle_DelStation(msg->vif, &msg->body.del_sta_info);
    2552. 

  2552. 		break;
    2553. 

  2553. 

  2554. 	case HOST_IF_MSG_EDIT_STATION:
    2555. 

  2555. 		Handle_EditStation(msg->vif, &msg->body.edit_sta_info);
    2556. 

  2556. 		break;
    2557. 

  2557. 

  2558. 	case HOST_IF_MSG_GET_INACTIVETIME:
    2559. 

  2559. 		Handle_Get_InActiveTime(msg->vif, &msg->body.mac_info);
    2560. 

  2560. 		break;
    2561. 

  2561. 

  2562. 	case HOST_IF_MSG_SCAN_TIMER_FIRED:
    2563. 

  2563. 		Handle_ScanDone(msg->vif, SCAN_EVENT_ABORTED);
    2564. 

  2564. 		break;
    2565. 

  2565. 

  2566. 	case HOST_IF_MSG_CONNECT_TIMER_FIRED:
    2567. 

  2567. 		Handle_ConnectTimeout(msg->vif);
    2568. 

  2568. 		break;
    2569. 

  2569. 

  2570. 	case HOST_IF_MSG_POWER_MGMT:
    2571. 

  2571. 		Handle_PowerManagement(msg->vif,
    2572. 

  2572. 				       &msg->body.pwr_mgmt_info);
    2573. 

  2573. 		break;
    2574. 

  2574. 

  2575. 	case HOST_IF_MSG_SET_WFIDRV_HANDLER:
    2576. 

  2576. 		handle_set_wfi_drv_handler(msg->vif, &msg->body.drv);
    2577. 

  2577. 		break;
    2578. 

  2578. 

  2579. 	case HOST_IF_MSG_SET_OPERATION_MODE:
    2580. 

  2580. 		handle_set_operation_mode(msg->vif, &msg->body.mode);
    2581. 

  2581. 		break;
    2582. 

  2582. 

  2583. 	case HOST_IF_MSG_SET_IPADDRESS:
    2584. 

  2584. 		handle_set_ip_address(msg->vif,
    2585. 

  2585. 				      msg->body.ip_info.ip_addr,
    2586. 

  2586. 				      msg->body.ip_info.idx);
    2587. 

  2587. 		break;
    2588. 

  2588. 

  2589. 	case HOST_IF_MSG_GET_IPADDRESS:
    2590. 

  2590. 		handle_get_ip_address(msg->vif, msg->body.ip_info.idx);
    2591. 

  2591. 		break;
    2592. 

  2592. 

  2593. 	case HOST_IF_MSG_GET_MAC_ADDRESS:
    2594. 

  2594. 		handle_get_mac_address(msg->vif,
    2595. 

  2595. 				       &msg->body.get_mac_info);
    2596. 

  2596. 		break;
    2597. 

  2597. 

  2598. 	case HOST_IF_MSG_REMAIN_ON_CHAN:
    2599. 

  2599. 		Handle_RemainOnChan(msg->vif, &msg->body.remain_on_ch);
    2600. 

  2600. 		break;
    2601. 

  2601. 

  2602. 	case HOST_IF_MSG_REGISTER_FRAME:
    2603. 

  2603. 		Handle_RegisterFrame(msg->vif, &msg->body.reg_frame);
    2604. 

  2604. 		break;
    2605. 

  2605. 

  2606. 	case HOST_IF_MSG_LISTEN_TIMER_FIRED:
    2607. 

  2607. 		Handle_ListenStateExpired(msg->vif, &msg->body.remain_on_ch);
    2608. 

  2608. 		break;
    2609. 

  2609. 

  2610. 	case HOST_IF_MSG_SET_MULTICAST_FILTER:
    2611. 

  2611. 		Handle_SetMulticastFilter(msg->vif, &msg->body.multicast_info);
    2612. 

  2612. 		break;
    2613. 

  2613. 

  2614. 	case HOST_IF_MSG_DEL_ALL_STA:
    2615. 

  2615. 		Handle_DelAllSta(msg->vif, &msg->body.del_all_sta_info);
    2616. 

  2616. 		break;
    2617. 

  2617. 

  2618. 	case HOST_IF_MSG_SET_TX_POWER:
    2619. 

  2619. 		handle_set_tx_pwr(msg->vif, msg->body.tx_power.tx_pwr);
    2620. 

  2620. 		break;
    2621. 

  2621. 

  2622. 	case HOST_IF_MSG_GET_TX_POWER:
    2623. 

  2623. 		handle_get_tx_pwr(msg->vif, &msg->body.tx_power.tx_pwr);
    2624. 

  2624. 		break;
    2625. 

  2625. 	default:
    2626. 

  2626. 		netdev_err(msg->vif->ndev, "[Host Interface] undefined\n");
    2627. 

  2627. 		break;
    2628. 

  2628. 	}
    2629. 

  2629. free_msg:
    2630. 

  2630. 	kfree(msg);
    2631. 

  2631. 	complete(&hif_thread_comp);
    2632. 

  2632. }
    2633. 

  2633. 

  2634. static void TimerCB_Scan(unsigned long arg)
    2635. 

  2635. {
    2636. 

  2636. 	struct wilc_vif *vif = (struct wilc_vif *)arg;
    2637. 

  2637. 	struct host_if_msg msg;
    2638. 

  2638. 

  2639. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2640. 

  2640. 	msg.vif = vif;
    2641. 

  2641. 	msg.id = HOST_IF_MSG_SCAN_TIMER_FIRED;
    2642. 

  2642. 

  2643. 	wilc_enqueue_cmd(&msg);
    2644. 

  2644. }
    2645. 

  2645. 

  2646. static void TimerCB_Connect(unsigned long arg)
    2647. 

  2647. {
    2648. 

  2648. 	struct wilc_vif *vif = (struct wilc_vif *)arg;
    2649. 

  2649. 	struct host_if_msg msg;
    2650. 

  2650. 

  2651. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2652. 

  2652. 	msg.vif = vif;
    2653. 

  2653. 	msg.id = HOST_IF_MSG_CONNECT_TIMER_FIRED;
    2654. 

  2654. 

  2655. 	wilc_enqueue_cmd(&msg);
    2656. 

  2656. }
    2657. 

  2657. 

  2658. s32 wilc_remove_key(struct host_if_drv *hif_drv, const u8 *pu8StaAddress)
    2659. 

  2659. {
    2660. 

  2660. 	struct wid wid;
    2661. 

  2661. 

  2662. 	wid.id = (u16)WID_REMOVE_KEY;
    2663. 

  2663. 	wid.type = WID_STR;
    2664. 

  2664. 	wid.val = (s8 *)pu8StaAddress;
    2665. 

  2665. 	wid.size = 6;
    2666. 

  2666. 

  2667. 	return 0;
    2668. 

  2668. }
    2669. 

  2669. 

  2670. int wilc_remove_wep_key(struct wilc_vif *vif, u8 index)
    2671. 

  2671. {
    2672. 

  2672. 	int result = 0;
    2673. 

  2673. 	struct host_if_msg msg;
    2674. 

  2674. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2675. 

  2675. 

  2676. 	if (!hif_drv) {
    2677. 

  2677. 		result = -EFAULT;
    2678. 

  2678. 		netdev_err(vif->ndev, "Failed to send setup multicast\n");
    2679. 

  2679. 		return result;
    2680. 

  2680. 	}
    2681. 

  2681. 

  2682. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2683. 

  2683. 

  2684. 	msg.id = HOST_IF_MSG_KEY;
    2685. 

  2685. 	msg.body.key_info.type = WEP;
    2686. 

  2686. 	msg.body.key_info.action = REMOVEKEY;
    2687. 

  2687. 	msg.vif = vif;
    2688. 

  2688. 	msg.body.key_info.attr.wep.index = index;
    2689. 

  2689. 

  2690. 	result = wilc_enqueue_cmd(&msg);
    2691. 

  2691. 	if (result)
    2692. 

  2692. 		netdev_err(vif->ndev, "Request to remove WEP key\n");
    2693. 

  2693. 	else
    2694. 

  2694. 		wait_for_completion(&hif_drv->comp_test_key_block);
    2695. 

  2695. 

  2696. 	return result;
    2697. 

  2697. }
    2698. 

  2698. 

  2699. int wilc_set_wep_default_keyid(struct wilc_vif *vif, u8 index)
    2700. 

  2700. {
    2701. 

  2701. 	int result = 0;
    2702. 

  2702. 	struct host_if_msg msg;
    2703. 

  2703. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2704. 

  2704. 

  2705. 	if (!hif_drv) {
    2706. 

  2706. 		result = -EFAULT;
    2707. 

  2707. 		netdev_err(vif->ndev, "driver is null\n");
    2708. 

  2708. 		return result;
    2709. 

  2709. 	}
    2710. 

  2710. 

  2711. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2712. 

  2712. 

  2713. 	msg.id = HOST_IF_MSG_KEY;
    2714. 

  2714. 	msg.body.key_info.type = WEP;
    2715. 

  2715. 	msg.body.key_info.action = DEFAULTKEY;
    2716. 

  2716. 	msg.vif = vif;
    2717. 

  2717. 	msg.body.key_info.attr.wep.index = index;
    2718. 

  2718. 

  2719. 	result = wilc_enqueue_cmd(&msg);
    2720. 

  2720. 	if (result)
    2721. 

  2721. 		netdev_err(vif->ndev, "Default key index\n");
    2722. 

  2722. 	else
    2723. 

  2723. 		wait_for_completion(&hif_drv->comp_test_key_block);
    2724. 

  2724. 

  2725. 	return result;
    2726. 

  2726. }
    2727. 

  2727. 

  2728. int wilc_add_wep_key_bss_sta(struct wilc_vif *vif, const u8 *key, u8 len,
    2729. 

  2729. 			     u8 index)
    2730. 

  2730. {
    2731. 

  2731. 	int result = 0;
    2732. 

  2732. 	struct host_if_msg msg;
    2733. 

  2733. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2734. 

  2734. 

  2735. 	if (!hif_drv) {
    2736. 

  2736. 		netdev_err(vif->ndev, "driver is null\n");
    2737. 

  2737. 		return -EFAULT;
    2738. 

  2738. 	}
    2739. 

  2739. 

  2740. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2741. 

  2741. 

  2742. 	msg.id = HOST_IF_MSG_KEY;
    2743. 

  2743. 	msg.body.key_info.type = WEP;
    2744. 

  2744. 	msg.body.key_info.action = ADDKEY;
    2745. 

  2745. 	msg.vif = vif;
    2746. 

  2746. 	msg.body.key_info.attr.wep.key = kmemdup(key, len, GFP_KERNEL);
    2747. 

  2747. 	if (!msg.body.key_info.attr.wep.key)
    2748. 

  2748. 		return -ENOMEM;
    2749. 

  2749. 

  2750. 	msg.body.key_info.attr.wep.key_len = len;
    2751. 

  2751. 	msg.body.key_info.attr.wep.index = index;
    2752. 

  2752. 

  2753. 	result = wilc_enqueue_cmd(&msg);
    2754. 

  2754. 	if (result)
    2755. 

  2755. 		netdev_err(vif->ndev, "STA - WEP Key\n");
    2756. 

  2756. 	wait_for_completion(&hif_drv->comp_test_key_block);
    2757. 

  2757. 

  2758. 	return result;
    2759. 

  2759. }
    2760. 

  2760. 

  2761. int wilc_add_wep_key_bss_ap(struct wilc_vif *vif, const u8 *key, u8 len,
    2762. 

  2762. 			    u8 index, u8 mode, enum AUTHTYPE auth_type)
    2763. 

  2763. {
    2764. 

  2764. 	int result = 0;
    2765. 

  2765. 	struct host_if_msg msg;
    2766. 

  2766. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2767. 

  2767. 

  2768. 	if (!hif_drv) {
    2769. 

  2769. 		netdev_err(vif->ndev, "driver is null\n");
    2770. 

  2770. 		return -EFAULT;
    2771. 

  2771. 	}
    2772. 

  2772. 

  2773. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2774. 

  2774. 

  2775. 	msg.id = HOST_IF_MSG_KEY;
    2776. 

  2776. 	msg.body.key_info.type = WEP;
    2777. 

  2777. 	msg.body.key_info.action = ADDKEY_AP;
    2778. 

  2778. 	msg.vif = vif;
    2779. 

  2779. 	msg.body.key_info.attr.wep.key = kmemdup(key, len, GFP_KERNEL);
    2780. 

  2780. 	if (!msg.body.key_info.attr.wep.key)
    2781. 

  2781. 		return -ENOMEM;
    2782. 

  2782. 

  2783. 	msg.body.key_info.attr.wep.key_len = len;
    2784. 

  2784. 	msg.body.key_info.attr.wep.index = index;
    2785. 

  2785. 	msg.body.key_info.attr.wep.mode = mode;
    2786. 

  2786. 	msg.body.key_info.attr.wep.auth_type = auth_type;
    2787. 

  2787. 

  2788. 	result = wilc_enqueue_cmd(&msg);
    2789. 

  2789. 

  2790. 	if (result)
    2791. 

  2791. 		netdev_err(vif->ndev, "AP - WEP Key\n");
    2792. 

  2792. 	else
    2793. 

  2793. 		wait_for_completion(&hif_drv->comp_test_key_block);
    2794. 

  2794. 

  2795. 	return result;
    2796. 

  2796. }
    2797. 

  2797. 

  2798. int wilc_add_ptk(struct wilc_vif *vif, const u8 *ptk, u8 ptk_key_len,
    2799. 

  2799. 		 const u8 *mac_addr, const u8 *rx_mic, const u8 *tx_mic,
    2800. 

  2800. 		 u8 mode, u8 cipher_mode, u8 index)
    2801. 

  2801. {
    2802. 

  2802. 	int result = 0;
    2803. 

  2803. 	struct host_if_msg msg;
    2804. 

  2804. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2805. 

  2805. 	u8 key_len = ptk_key_len;
    2806. 

  2806. 

  2807. 	if (!hif_drv) {
    2808. 

  2808. 		netdev_err(vif->ndev, "driver is null\n");
    2809. 

  2809. 		return -EFAULT;
    2810. 

  2810. 	}
    2811. 

  2811. 

  2812. 	if (rx_mic)
    2813. 

  2813. 		key_len += RX_MIC_KEY_LEN;
    2814. 

  2814. 

  2815. 	if (tx_mic)
    2816. 

  2816. 		key_len += TX_MIC_KEY_LEN;
    2817. 

  2817. 

  2818. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2819. 

  2819. 

  2820. 	msg.id = HOST_IF_MSG_KEY;
    2821. 

  2821. 	msg.body.key_info.type = WPA_PTK;
    2822. 

  2822. 	if (mode == AP_MODE) {
    2823. 

  2823. 		msg.body.key_info.action = ADDKEY_AP;
    2824. 

  2824. 		msg.body.key_info.attr.wpa.index = index;
    2825. 

  2825. 	}
    2826. 

  2826. 	if (mode == STATION_MODE)
    2827. 

  2827. 		msg.body.key_info.action = ADDKEY;
    2828. 

  2828. 

  2829. 	msg.body.key_info.attr.wpa.key = kmemdup(ptk, ptk_key_len, GFP_KERNEL);
    2830. 

  2830. 	if (!msg.body.key_info.attr.wpa.key)
    2831. 

  2831. 		return -ENOMEM;
    2832. 

  2832. 

  2833. 	if (rx_mic)
    2834. 

  2834. 		memcpy(msg.body.key_info.attr.wpa.key + 16, rx_mic, RX_MIC_KEY_LEN);
    2835. 

  2835. 

  2836. 	if (tx_mic)
    2837. 

  2837. 		memcpy(msg.body.key_info.attr.wpa.key + 24, tx_mic, TX_MIC_KEY_LEN);
    2838. 

  2838. 

  2839. 	msg.body.key_info.attr.wpa.key_len = key_len;
    2840. 

  2840. 	msg.body.key_info.attr.wpa.mac_addr = mac_addr;
    2841. 

  2841. 	msg.body.key_info.attr.wpa.mode = cipher_mode;
    2842. 

  2842. 	msg.vif = vif;
    2843. 

  2843. 

  2844. 	result = wilc_enqueue_cmd(&msg);
    2845. 

  2845. 

  2846. 	if (result)
    2847. 

  2847. 		netdev_err(vif->ndev, "PTK Key\n");
    2848. 

  2848. 	else
    2849. 

  2849. 		wait_for_completion(&hif_drv->comp_test_key_block);
    2850. 

  2850. 

  2851. 	return result;
    2852. 

  2852. }
    2853. 

  2853. 

  2854. int wilc_add_rx_gtk(struct wilc_vif *vif, const u8 *rx_gtk, u8 gtk_key_len,
    2855. 

  2855. 		    u8 index, u32 key_rsc_len, const u8 *key_rsc,
    2856. 

  2856. 		    const u8 *rx_mic, const u8 *tx_mic, u8 mode,
    2857. 

  2857. 		    u8 cipher_mode)
    2858. 

  2858. {
    2859. 

  2859. 	int result = 0;
    2860. 

  2860. 	struct host_if_msg msg;
    2861. 

  2861. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2862. 

  2862. 	u8 key_len = gtk_key_len;
    2863. 

  2863. 

  2864. 	if (!hif_drv) {
    2865. 

  2865. 		netdev_err(vif->ndev, "driver is null\n");
    2866. 

  2866. 		return -EFAULT;
    2867. 

  2867. 	}
    2868. 

  2868. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2869. 

  2869. 

  2870. 	if (rx_mic)
    2871. 

  2871. 		key_len += RX_MIC_KEY_LEN;
    2872. 

  2872. 

  2873. 	if (tx_mic)
    2874. 

  2874. 		key_len += TX_MIC_KEY_LEN;
    2875. 

  2875. 

  2876. 	if (key_rsc) {
    2877. 

  2877. 		msg.body.key_info.attr.wpa.seq = kmemdup(key_rsc,
    2878. 

  2878. 							 key_rsc_len,
    2879. 

  2879. 							 GFP_KERNEL);
    2880. 

  2880. 		if (!msg.body.key_info.attr.wpa.seq)
    2881. 

  2881. 			return -ENOMEM;
    2882. 

  2882. 	}
    2883. 

  2883. 

  2884. 	msg.id = HOST_IF_MSG_KEY;
    2885. 

  2885. 	msg.body.key_info.type = WPA_RX_GTK;
    2886. 

  2886. 	msg.vif = vif;
    2887. 

  2887. 

  2888. 	if (mode == AP_MODE) {
    2889. 

  2889. 		msg.body.key_info.action = ADDKEY_AP;
    2890. 

  2890. 		msg.body.key_info.attr.wpa.mode = cipher_mode;
    2891. 

  2891. 	}
    2892. 

  2892. 	if (mode == STATION_MODE)
    2893. 

  2893. 		msg.body.key_info.action = ADDKEY;
    2894. 

  2894. 

  2895. 	msg.body.key_info.attr.wpa.key = kmemdup(rx_gtk,
    2896. 

  2896. 						 key_len,
    2897. 

  2897. 						 GFP_KERNEL);
    2898. 

  2898. 	if (!msg.body.key_info.attr.wpa.key)
    2899. 

  2899. 		return -ENOMEM;
    2900. 

  2900. 

  2901. 	if (rx_mic)
    2902. 

  2902. 		memcpy(msg.body.key_info.attr.wpa.key + 16, rx_mic,
    2903. 

  2903. 		       RX_MIC_KEY_LEN);
    2904. 

  2904. 

  2905. 	if (tx_mic)
    2906. 

  2906. 		memcpy(msg.body.key_info.attr.wpa.key + 24, tx_mic,
    2907. 

  2907. 		       TX_MIC_KEY_LEN);
    2908. 

  2908. 

  2909. 	msg.body.key_info.attr.wpa.index = index;
    2910. 

  2910. 	msg.body.key_info.attr.wpa.key_len = key_len;
    2911. 

  2911. 	msg.body.key_info.attr.wpa.seq_len = key_rsc_len;
    2912. 

  2912. 

  2913. 	result = wilc_enqueue_cmd(&msg);
    2914. 

  2914. 	if (result)
    2915. 

  2915. 		netdev_err(vif->ndev, "RX GTK\n");
    2916. 

  2916. 	else
    2917. 

  2917. 		wait_for_completion(&hif_drv->comp_test_key_block);
    2918. 

  2918. 

  2919. 	return result;
    2920. 

  2920. }
    2921. 

  2921. 

  2922. int wilc_set_pmkid_info(struct wilc_vif *vif,
    2923. 

  2923. 			struct host_if_pmkid_attr *pmkid)
    2924. 

  2924. {
    2925. 

  2925. 	int result = 0;
    2926. 

  2926. 	struct host_if_msg msg;
    2927. 

  2927. 	int i;
    2928. 

  2928. 

  2929. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2930. 

  2930. 

  2931. 	msg.id = HOST_IF_MSG_KEY;
    2932. 

  2932. 	msg.body.key_info.type = PMKSA;
    2933. 

  2933. 	msg.body.key_info.action = ADDKEY;
    2934. 

  2934. 	msg.vif = vif;
    2935. 

  2935. 

  2936. 	for (i = 0; i < pmkid->numpmkid; i++) {
    2937. 

  2937. 		memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].bssid,
    2938. 

  2938. 		       &pmkid->pmkidlist[i].bssid, ETH_ALEN);
    2939. 

  2939. 		memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].pmkid,
    2940. 

  2940. 		       &pmkid->pmkidlist[i].pmkid, PMKID_LEN);
    2941. 

  2941. 	}
    2942. 

  2942. 

  2943. 	result = wilc_enqueue_cmd(&msg);
    2944. 

  2944. 	if (result)
    2945. 

  2945. 		netdev_err(vif->ndev, "PMKID Info\n");
    2946. 

  2946. 

  2947. 	return result;
    2948. 

  2948. }
    2949. 

  2949. 

  2950. int wilc_get_mac_address(struct wilc_vif *vif, u8 *mac_addr)
    2951. 

  2951. {
    2952. 

  2952. 	int result = 0;
    2953. 

  2953. 	struct host_if_msg msg;
    2954. 

  2954. 

  2955. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2956. 

  2956. 

  2957. 	msg.id = HOST_IF_MSG_GET_MAC_ADDRESS;
    2958. 

  2958. 	msg.body.get_mac_info.mac_addr = mac_addr;
    2959. 

  2959. 	msg.vif = vif;
    2960. 

  2960. 

  2961. 	result = wilc_enqueue_cmd(&msg);
    2962. 

  2962. 	if (result) {
    2963. 

  2963. 		netdev_err(vif->ndev, "Failed to send get mac address\n");
    2964. 

  2964. 		return -EFAULT;
    2965. 

  2965. 	}
    2966. 

  2966. 

  2967. 	wait_for_completion(&hif_wait_response);
    2968. 

  2968. 	return result;
    2969. 

  2969. }
    2970. 

  2970. 

  2971. int wilc_set_join_req(struct wilc_vif *vif, u8 *bssid, const u8 *ssid,
    2972. 

  2972. 		      size_t ssid_len, const u8 *ies, size_t ies_len,
    2973. 

  2973. 		      wilc_connect_result connect_result, void *user_arg,
    2974. 

  2974. 		      u8 security, enum AUTHTYPE auth_type,
    2975. 

  2975. 		      u8 channel, void *join_params)
    2976. 

  2976. {
    2977. 

  2977. 	int result = 0;
    2978. 

  2978. 	struct host_if_msg msg;
    2979. 

  2979. 	struct host_if_drv *hif_drv = vif->hif_drv;
    2980. 

  2980. 

  2981. 	if (!hif_drv || !connect_result) {
    2982. 

  2982. 		netdev_err(vif->ndev, "Driver is null\n");
    2983. 

  2983. 		return -EFAULT;
    2984. 

  2984. 	}
    2985. 

  2985. 

  2986. 	if (!join_params) {
    2987. 

  2987. 		netdev_err(vif->ndev, "Unable to Join - JoinParams is NULL\n");
    2988. 

  2988. 		return -EFAULT;
    2989. 

  2989. 	}
    2990. 

  2990. 

  2991. 	memset(&msg, 0, sizeof(struct host_if_msg));
    2992. 

  2992. 

  2993. 	msg.id = HOST_IF_MSG_CONNECT;
    2994. 

  2994. 

  2995. 	msg.body.con_info.security = security;
    2996. 

  2996. 	msg.body.con_info.auth_type = auth_type;
    2997. 

  2997. 	msg.body.con_info.ch = channel;
    2998. 

  2998. 	msg.body.con_info.result = connect_result;
    2999. 

  2999. 	msg.body.con_info.arg = user_arg;
    3000. 

  3000. 	msg.body.con_info.params = join_params;
    3001. 

  3001. 	msg.vif = vif;
    3002. 

  3002. 

  3003. 	if (bssid) {
    3004. 

  3004. 		msg.body.con_info.bssid = kmemdup(bssid, 6, GFP_KERNEL);
    3005. 

  3005. 		if (!msg.body.con_info.bssid)
    3006. 

  3006. 			return -ENOMEM;
    3007. 

  3007. 	}
    3008. 

  3008. 

  3009. 	if (ssid) {
    3010. 

  3010. 		msg.body.con_info.ssid_len = ssid_len;
    3011. 

  3011. 		msg.body.con_info.ssid = kmemdup(ssid, ssid_len, GFP_KERNEL);
    3012. 

  3012. 		if (!msg.body.con_info.ssid)
    3013. 

  3013. 			return -ENOMEM;
    3014. 

  3014. 	}
    3015. 

  3015. 

  3016. 	if (ies) {
    3017. 

  3017. 		msg.body.con_info.ies_len = ies_len;
    3018. 

  3018. 		msg.body.con_info.ies = kmemdup(ies, ies_len, GFP_KERNEL);
    3019. 

  3019. 		if (!msg.body.con_info.ies)
    3020. 

  3020. 			return -ENOMEM;
    3021. 

  3021. 	}
    3022. 

  3022. 	if (hif_drv->hif_state < HOST_IF_CONNECTING)
    3023. 

  3023. 		hif_drv->hif_state = HOST_IF_CONNECTING;
    3024. 

  3024. 

  3025. 	result = wilc_enqueue_cmd(&msg);
    3026. 

  3026. 	if (result) {
    3027. 

  3027. 		netdev_err(vif->ndev, "send message: Set join request\n");
    3028. 

  3028. 		return -EFAULT;
    3029. 

  3029. 	}
    3030. 

  3030. 

  3031. 	hif_drv->connect_timer.data = (unsigned long)vif;
    3032. 

  3032. 	mod_timer(&hif_drv->connect_timer,
    3033. 

  3033. 		  jiffies + msecs_to_jiffies(HOST_IF_CONNECT_TIMEOUT));
    3034. 

  3034. 

  3035. 	return result;
    3036. 

  3036. }
    3037. 

  3037. 

  3038. int wilc_disconnect(struct wilc_vif *vif, u16 reason_code)
    3039. 

  3039. {
    3040. 

  3040. 	int result = 0;
    3041. 

  3041. 	struct host_if_msg msg;
    3042. 

  3042. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3043. 

  3043. 

  3044. 	if (!hif_drv) {
    3045. 

  3045. 		netdev_err(vif->ndev, "Driver is null\n");
    3046. 

  3046. 		return -EFAULT;
    3047. 

  3047. 	}
    3048. 

  3048. 

  3049. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3050. 

  3050. 

  3051. 	msg.id = HOST_IF_MSG_DISCONNECT;
    3052. 

  3052. 	msg.vif = vif;
    3053. 

  3053. 

  3054. 	result = wilc_enqueue_cmd(&msg);
    3055. 

  3055. 	if (result)
    3056. 

  3056. 		netdev_err(vif->ndev, "Failed to send message: disconnect\n");
    3057. 

  3057. 	else
    3058. 

  3058. 		wait_for_completion(&hif_drv->comp_test_disconn_block);
    3059. 

  3059. 

  3060. 	return result;
    3061. 

  3061. }
    3062. 

  3062. 

  3063. static s32 host_int_get_assoc_res_info(struct wilc_vif *vif,
    3064. 

  3064. 				       u8 *pu8AssocRespInfo,
    3065. 

  3065. 				       u32 u32MaxAssocRespInfoLen,
    3066. 

  3066. 				       u32 *pu32RcvdAssocRespInfoLen)
    3067. 

  3067. {
    3068. 

  3068. 	s32 result = 0;
    3069. 

  3069. 	struct wid wid;
    3070. 

  3070. 

  3071. 	wid.id = (u16)WID_ASSOC_RES_INFO;
    3072. 

  3072. 	wid.type = WID_STR;
    3073. 

  3073. 	wid.val = pu8AssocRespInfo;
    3074. 

  3074. 	wid.size = u32MaxAssocRespInfoLen;
    3075. 

  3075. 

  3076. 	result = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
    3077. 

  3077. 				      wilc_get_vif_idx(vif));
    3078. 

  3078. 	if (result) {
    3079. 

  3079. 		*pu32RcvdAssocRespInfoLen = 0;
    3080. 

  3080. 		netdev_err(vif->ndev, "Failed to send association response\n");
    3081. 

  3081. 		return -EINVAL;
    3082. 

  3082. 	}
    3083. 

  3083. 

  3084. 	*pu32RcvdAssocRespInfoLen = wid.size;
    3085. 

  3085. 	return result;
    3086. 

  3086. }
    3087. 

  3087. 

  3088. int wilc_set_mac_chnl_num(struct wilc_vif *vif, u8 channel)
    3089. 

  3089. {
    3090. 

  3090. 	int result;
    3091. 

  3091. 	struct host_if_msg msg;
    3092. 

  3092. 

  3093. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3094. 

  3094. 	msg.id = HOST_IF_MSG_SET_CHANNEL;
    3095. 

  3095. 	msg.body.channel_info.set_ch = channel;
    3096. 

  3096. 	msg.vif = vif;
    3097. 

  3097. 

  3098. 	result = wilc_enqueue_cmd(&msg);
    3099. 

  3099. 	if (result) {
    3100. 

  3100. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3101. 

  3101. 		return -EINVAL;
    3102. 

  3102. 	}
    3103. 

  3103. 

  3104. 	return 0;
    3105. 

  3105. }
    3106. 

  3106. 

  3107. int wilc_set_wfi_drv_handler(struct wilc_vif *vif, int index, u8 mac_idx)
    3108. 

  3108. {
    3109. 

  3109. 	int result = 0;
    3110. 

  3110. 	struct host_if_msg msg;
    3111. 

  3111. 

  3112. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3113. 

  3113. 	msg.id = HOST_IF_MSG_SET_WFIDRV_HANDLER;
    3114. 

  3114. 	msg.body.drv.handler = index;
    3115. 

  3115. 	msg.body.drv.mac_idx = mac_idx;
    3116. 

  3116. 	msg.vif = vif;
    3117. 

  3117. 

  3118. 	result = wilc_enqueue_cmd(&msg);
    3119. 

  3119. 	if (result) {
    3120. 

  3120. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3121. 

  3121. 		result = -EINVAL;
    3122. 

  3122. 	}
    3123. 

  3123. 

  3124. 	return result;
    3125. 

  3125. }
    3126. 

  3126. 

  3127. int wilc_set_operation_mode(struct wilc_vif *vif, u32 mode)
    3128. 

  3128. {
    3129. 

  3129. 	int result = 0;
    3130. 

  3130. 	struct host_if_msg msg;
    3131. 

  3131. 

  3132. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3133. 

  3133. 	msg.id = HOST_IF_MSG_SET_OPERATION_MODE;
    3134. 

  3134. 	msg.body.mode.mode = mode;
    3135. 

  3135. 	msg.vif = vif;
    3136. 

  3136. 

  3137. 	result = wilc_enqueue_cmd(&msg);
    3138. 

  3138. 	if (result) {
    3139. 

  3139. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3140. 

  3140. 		result = -EINVAL;
    3141. 

  3141. 	}
    3142. 

  3142. 

  3143. 	return result;
    3144. 

  3144. }
    3145. 

  3145. 

  3146. s32 wilc_get_inactive_time(struct wilc_vif *vif, const u8 *mac,
    3147. 

  3147. 			   u32 *pu32InactiveTime)
    3148. 

  3148. {
    3149. 

  3149. 	s32 result = 0;
    3150. 

  3150. 	struct host_if_msg msg;
    3151. 

  3151. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3152. 

  3152. 

  3153. 	if (!hif_drv) {
    3154. 

  3154. 		netdev_err(vif->ndev, "driver is null\n");
    3155. 

  3155. 		return -EFAULT;
    3156. 

  3156. 	}
    3157. 

  3157. 

  3158. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3159. 

  3159. 	memcpy(msg.body.mac_info.mac, mac, ETH_ALEN);
    3160. 

  3160. 

  3161. 	msg.id = HOST_IF_MSG_GET_INACTIVETIME;
    3162. 

  3162. 	msg.vif = vif;
    3163. 

  3163. 

  3164. 	result = wilc_enqueue_cmd(&msg);
    3165. 

  3165. 	if (result)
    3166. 

  3166. 		netdev_err(vif->ndev, "Failed to send get host ch param\n");
    3167. 

  3167. 	else
    3168. 

  3168. 		wait_for_completion(&hif_drv->comp_inactive_time);
    3169. 

  3169. 

  3170. 	*pu32InactiveTime = inactive_time;
    3171. 

  3171. 

  3172. 	return result;
    3173. 

  3173. }
    3174. 

  3174. 

  3175. int wilc_get_rssi(struct wilc_vif *vif, s8 *rssi_level)
    3176. 

  3176. {
    3177. 

  3177. 	int result = 0;
    3178. 

  3178. 	struct host_if_msg msg;
    3179. 

  3179. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3180. 

  3180. 

  3181. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3182. 

  3182. 	msg.id = HOST_IF_MSG_GET_RSSI;
    3183. 

  3183. 	msg.vif = vif;
    3184. 

  3184. 

  3185. 	result = wilc_enqueue_cmd(&msg);
    3186. 

  3186. 	if (result) {
    3187. 

  3187. 		netdev_err(vif->ndev, "Failed to send get host ch param\n");
    3188. 

  3188. 		return -EFAULT;
    3189. 

  3189. 	}
    3190. 

  3190. 

  3191. 	wait_for_completion(&hif_drv->comp_get_rssi);
    3192. 

  3192. 

  3193. 	if (!rssi_level) {
    3194. 

  3194. 		netdev_err(vif->ndev, "RSS pointer value is null\n");
    3195. 

  3195. 		return -EFAULT;
    3196. 

  3196. 	}
    3197. 

  3197. 

  3198. 	*rssi_level = rssi;
    3199. 

  3199. 

  3200. 	return result;
    3201. 

  3201. }
    3202. 

  3202. 

  3203. int wilc_get_statistics(struct wilc_vif *vif, struct rf_info *stats)
    3204. 

  3204. {
    3205. 

  3205. 	int result = 0;
    3206. 

  3206. 	struct host_if_msg msg;
    3207. 

  3207. 

  3208. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3209. 

  3209. 	msg.id = HOST_IF_MSG_GET_STATISTICS;
    3210. 

  3210. 	msg.body.data = (char *)stats;
    3211. 

  3211. 	msg.vif = vif;
    3212. 

  3212. 

  3213. 	result = wilc_enqueue_cmd(&msg);
    3214. 

  3214. 	if (result) {
    3215. 

  3215. 		netdev_err(vif->ndev, "Failed to send get host channel\n");
    3216. 

  3216. 		return -EFAULT;
    3217. 

  3217. 	}
    3218. 

  3218. 

  3219. 	if (stats != &vif->wilc->dummy_statistics)
    3220. 

  3220. 		wait_for_completion(&hif_wait_response);
    3221. 

  3221. 	return result;
    3222. 

  3222. }
    3223. 

  3223. 

  3224. int wilc_scan(struct wilc_vif *vif, u8 scan_source, u8 scan_type,
    3225. 

  3225. 	      u8 *ch_freq_list, u8 ch_list_len, const u8 *ies,
    3226. 

  3226. 	      size_t ies_len, wilc_scan_result scan_result, void *user_arg,
    3227. 

  3227. 	      struct hidden_network *hidden_network)
    3228. 

  3228. {
    3229. 

  3229. 	int result = 0;
    3230. 

  3230. 	struct host_if_msg msg;
    3231. 

  3231. 	struct scan_attr *scan_info = &msg.body.scan_info;
    3232. 

  3232. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3233. 

  3233. 

  3234. 	if (!hif_drv || !scan_result) {
    3235. 

  3235. 		netdev_err(vif->ndev, "hif_drv or scan_result = NULL\n");
    3236. 

  3236. 		return -EFAULT;
    3237. 

  3237. 	}
    3238. 

  3238. 

  3239. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3240. 

  3240. 

  3241. 	msg.id = HOST_IF_MSG_SCAN;
    3242. 

  3242. 

  3243. 	if (hidden_network) {
    3244. 

  3244. 		scan_info->hidden_network.net_info = hidden_network->net_info;
    3245. 

  3245. 		scan_info->hidden_network.n_ssids = hidden_network->n_ssids;
    3246. 

  3246. 	}
    3247. 

  3247. 

  3248. 	msg.vif = vif;
    3249. 

  3249. 	scan_info->src = scan_source;
    3250. 

  3250. 	scan_info->type = scan_type;
    3251. 

  3251. 	scan_info->result = scan_result;
    3252. 

  3252. 	scan_info->arg = user_arg;
    3253. 

  3253. 

  3254. 	scan_info->ch_list_len = ch_list_len;
    3255. 

  3255. 	scan_info->ch_freq_list = kmemdup(ch_freq_list,
    3256. 

  3256. 					  ch_list_len,
    3257. 

  3257. 					  GFP_KERNEL);
    3258. 

  3258. 	if (!scan_info->ch_freq_list)
    3259. 

  3259. 		return -ENOMEM;
    3260. 

  3260. 

  3261. 	scan_info->ies_len = ies_len;
    3262. 

  3262. 	scan_info->ies = kmemdup(ies, ies_len, GFP_KERNEL);
    3263. 

  3263. 	if (!scan_info->ies)
    3264. 

  3264. 		return -ENOMEM;
    3265. 

  3265. 

  3266. 	result = wilc_enqueue_cmd(&msg);
    3267. 

  3267. 	if (result) {
    3268. 

  3268. 		netdev_err(vif->ndev, "Error in sending message queue\n");
    3269. 

  3269. 		return -EINVAL;
    3270. 

  3270. 	}
    3271. 

  3271. 

  3272. 	hif_drv->scan_timer.data = (unsigned long)vif;
    3273. 

  3273. 	mod_timer(&hif_drv->scan_timer,
    3274. 

  3274. 		  jiffies + msecs_to_jiffies(HOST_IF_SCAN_TIMEOUT));
    3275. 

  3275. 

  3276. 	return result;
    3277. 

  3277. }
    3278. 

  3278. 

  3279. int wilc_hif_set_cfg(struct wilc_vif *vif,
    3280. 

  3280. 		     struct cfg_param_attr *cfg_param)
    3281. 

  3281. {
    3282. 

  3282. 	int result = 0;
    3283. 

  3283. 	struct host_if_msg msg;
    3284. 

  3284. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3285. 

  3285. 

  3286. 	if (!hif_drv) {
    3287. 

  3287. 		netdev_err(vif->ndev, "hif_drv NULL\n");
    3288. 

  3288. 		return -EFAULT;
    3289. 

  3289. 	}
    3290. 

  3290. 

  3291. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3292. 

  3292. 	msg.id = HOST_IF_MSG_CFG_PARAMS;
    3293. 

  3293. 	msg.body.cfg_info = *cfg_param;
    3294. 

  3294. 	msg.vif = vif;
    3295. 

  3295. 

  3296. 	result = wilc_enqueue_cmd(&msg);
    3297. 

  3297. 

  3298. 	return result;
    3299. 

  3299. }
    3300. 

  3300. 

  3301. static void GetPeriodicRSSI(unsigned long arg)
    3302. 

  3302. {
    3303. 

  3303. 	struct wilc_vif *vif = (struct wilc_vif *)arg;
    3304. 

  3304. 

  3305. 	if (!vif->hif_drv) {
    3306. 

  3306. 		netdev_err(vif->ndev, "Driver handler is NULL\n");
    3307. 

  3307. 		return;
    3308. 

  3308. 	}
    3309. 

  3309. 

  3310. 	if (vif->hif_drv->hif_state == HOST_IF_CONNECTED)
    3311. 

  3311. 		wilc_get_statistics(vif, &vif->wilc->dummy_statistics);
    3312. 

  3312. 

  3313. 	periodic_rssi.data = (unsigned long)vif;
    3314. 

  3314. 	mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
    3315. 

  3315. }
    3316. 

  3316. 

  3317. int wilc_init(struct net_device *dev, struct host_if_drv **hif_drv_handler)
    3318. 

  3318. {
    3319. 

  3319. 	int result = 0;
    3320. 

  3320. 	struct host_if_drv *hif_drv;
    3321. 

  3321. 	struct wilc_vif *vif;
    3322. 

  3322. 	struct wilc *wilc;
    3323. 

  3323. 	int i;
    3324. 

  3324. 

  3325. 	vif = netdev_priv(dev);
    3326. 

  3326. 	wilc = vif->wilc;
    3327. 

  3327. 

  3328. 	scan_while_connected = false;
    3329. 

  3329. 

  3330. 	init_completion(&hif_wait_response);
    3331. 

  3331. 

  3332. 	hif_drv  = kzalloc(sizeof(struct host_if_drv), GFP_KERNEL);
    3333. 

  3333. 	if (!hif_drv) {
    3334. 

  3334. 		result = -ENOMEM;
    3335. 

  3335. 		goto _fail_;
    3336. 

  3336. 	}
    3337. 

  3337. 	*hif_drv_handler = hif_drv;
    3338. 

  3338. 	for (i = 0; i < wilc->vif_num; i++)
    3339. 

  3339. 		if (dev == wilc->vif[i]->ndev) {
    3340. 

  3340. 			wilc->vif[i]->hif_drv = hif_drv;
    3341. 

  3341. 			break;
    3342. 

  3342. 		}
    3343. 

  3343. 

  3344. 	wilc_optaining_ip = false;
    3345. 

  3345. 

  3346. 	if (clients_count == 0)	{
    3347. 

  3347. 		init_completion(&hif_thread_comp);
    3348. 

  3348. 		init_completion(&hif_driver_comp);
    3349. 

  3349. 		mutex_init(&hif_deinit_lock);
    3350. 

  3350. 	}
    3351. 

  3351. 

  3352. 	init_completion(&hif_drv->comp_test_key_block);
    3353. 

  3353. 	init_completion(&hif_drv->comp_test_disconn_block);
    3354. 

  3354. 	init_completion(&hif_drv->comp_get_rssi);
    3355. 

  3355. 	init_completion(&hif_drv->comp_inactive_time);
    3356. 

  3356. 

  3357. 	if (clients_count == 0)	{
    3358. 

  3358. 		if (result < 0) {
    3359. 

  3359. 			netdev_err(vif->ndev, "Failed to creat MQ\n");
    3360. 

  3360. 			goto _fail_;
    3361. 

  3361. 		}
    3362. 

  3362. 		hif_workqueue = create_singlethread_workqueue("WILC_wq");
    3363. 

  3363. 		if (!hif_workqueue) {
    3364. 

  3364. 			netdev_err(vif->ndev, "Failed to create workqueue\n");
    3365. 

  3365. 			result = -ENOMEM;
    3366. 

  3366. 			goto _fail_mq_;
    3367. 

  3367. 		}
    3368. 

  3368. 

  3369. 		setup_timer(&periodic_rssi, GetPeriodicRSSI,
    3370. 

  3370. 			    (unsigned long)vif);
    3371. 

  3371. 		mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
    3372. 

  3372. 	}
    3373. 

  3373. 

  3374. 	setup_timer(&hif_drv->scan_timer, TimerCB_Scan, 0);
    3375. 

  3375. 	setup_timer(&hif_drv->connect_timer, TimerCB_Connect, 0);
    3376. 

  3376. 	setup_timer(&hif_drv->remain_on_ch_timer, ListenTimerCB, 0);
    3377. 

  3377. 

  3378. 	mutex_init(&hif_drv->cfg_values_lock);
    3379. 

  3379. 	mutex_lock(&hif_drv->cfg_values_lock);
    3380. 

  3380. 

  3381. 	hif_drv->hif_state = HOST_IF_IDLE;
    3382. 

  3382. 	hif_drv->cfg_values.site_survey_enabled = SITE_SURVEY_OFF;
    3383. 

  3383. 	hif_drv->cfg_values.scan_source = DEFAULT_SCAN;
    3384. 

  3384. 	hif_drv->cfg_values.active_scan_time = ACTIVE_SCAN_TIME;
    3385. 

  3385. 	hif_drv->cfg_values.passive_scan_time = PASSIVE_SCAN_TIME;
    3386. 

  3386. 	hif_drv->cfg_values.curr_tx_rate = AUTORATE;
    3387. 

  3387. 

  3388. 	hif_drv->p2p_timeout = 0;
    3389. 

  3389. 

  3390. 	mutex_unlock(&hif_drv->cfg_values_lock);
    3391. 

  3391. 

  3392. 	clients_count++;
    3393. 

  3393. 

  3394. _fail_mq_:
    3395. 

  3395. 	destroy_workqueue(hif_workqueue);
    3396. 

  3396. _fail_:
    3397. 

  3397. 	return result;
    3398. 

  3398. }
    3399. 

  3399. 

  3400. int wilc_deinit(struct wilc_vif *vif)
    3401. 

  3401. {
    3402. 

  3402. 	int result = 0;
    3403. 

  3403. 	struct host_if_msg msg;
    3404. 

  3404. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3405. 

  3405. 

  3406. 	if (!hif_drv)	{
    3407. 

  3407. 		netdev_err(vif->ndev, "hif_drv = NULL\n");
    3408. 

  3408. 		return -EFAULT;
    3409. 

  3409. 	}
    3410. 

  3410. 

  3411. 	mutex_lock(&hif_deinit_lock);
    3412. 

  3412. 

  3413. 	terminated_handle = hif_drv;
    3414. 

  3414. 

  3415. 	del_timer_sync(&hif_drv->scan_timer);
    3416. 

  3416. 	del_timer_sync(&hif_drv->connect_timer);
    3417. 

  3417. 	del_timer_sync(&periodic_rssi);
    3418. 

  3418. 	del_timer_sync(&hif_drv->remain_on_ch_timer);
    3419. 

  3419. 

  3420. 	wilc_set_wfi_drv_handler(vif, 0, 0);
    3421. 

  3421. 	wait_for_completion(&hif_driver_comp);
    3422. 

  3422. 

  3423. 	if (hif_drv->usr_scan_req.scan_result) {
    3424. 

  3424. 		hif_drv->usr_scan_req.scan_result(SCAN_EVENT_ABORTED, NULL,
    3425. 

  3425. 						  hif_drv->usr_scan_req.arg, NULL);
    3426. 

  3426. 		hif_drv->usr_scan_req.scan_result = NULL;
    3427. 

  3427. 	}
    3428. 

  3428. 

  3429. 	hif_drv->hif_state = HOST_IF_IDLE;
    3430. 

  3430. 

  3431. 	scan_while_connected = false;
    3432. 

  3432. 

  3433. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3434. 

  3434. 

  3435. 	if (clients_count == 1)	{
    3436. 

  3436. 		msg.id = HOST_IF_MSG_EXIT;
    3437. 

  3437. 		msg.vif = vif;
    3438. 

  3438. 

  3439. 		result = wilc_enqueue_cmd(&msg);
    3440. 

  3440. 		if (result != 0)
    3441. 

  3441. 			netdev_err(vif->ndev, "deinit : Error(%d)\n", result);
    3442. 

  3442. 		else
    3443. 

  3443. 			wait_for_completion(&hif_thread_comp);
    3444. 

  3444. 

  3445. 		destroy_workqueue(hif_workqueue);
    3446. 

  3446. 	}
    3447. 

  3447. 

  3448. 	kfree(hif_drv);
    3449. 

  3449. 

  3450. 	clients_count--;
    3451. 

  3451. 	terminated_handle = NULL;
    3452. 

  3452. 	mutex_unlock(&hif_deinit_lock);
    3453. 

  3453. 	return result;
    3454. 

  3454. }
    3455. 

  3455. 

  3456. void wilc_network_info_received(struct wilc *wilc, u8 *pu8Buffer,
    3457. 

  3457. 				u32 u32Length)
    3458. 

  3458. {
    3459. 

  3459. 	s32 result = 0;
    3460. 

  3460. 	struct host_if_msg msg;
    3461. 

  3461. 	int id;
    3462. 

  3462. 	struct host_if_drv *hif_drv = NULL;
    3463. 

  3463. 	struct wilc_vif *vif;
    3464. 

  3464. 

  3465. 	id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
    3466. 

  3466. 	vif = wilc_get_vif_from_idx(wilc, id);
    3467. 

  3467. 	if (!vif)
    3468. 

  3468. 		return;
    3469. 

  3469. 	hif_drv = vif->hif_drv;
    3470. 

  3470. 

  3471. 	if (!hif_drv || hif_drv == terminated_handle)	{
    3472. 

  3472. 		netdev_err(vif->ndev, "driver not init[%p]\n", hif_drv);
    3473. 

  3473. 		return;
    3474. 

  3474. 	}
    3475. 

  3475. 

  3476. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3477. 

  3477. 

  3478. 	msg.id = HOST_IF_MSG_RCVD_NTWRK_INFO;
    3479. 

  3479. 	msg.vif = vif;
    3480. 

  3480. 

  3481. 	msg.body.net_info.len = u32Length;
    3482. 

  3482. 	msg.body.net_info.buffer = kmalloc(u32Length, GFP_KERNEL);
    3483. 

  3483. 	memcpy(msg.body.net_info.buffer, pu8Buffer, u32Length);
    3484. 

  3484. 

  3485. 	result = wilc_enqueue_cmd(&msg);
    3486. 

  3486. 	if (result)
    3487. 

  3487. 		netdev_err(vif->ndev, "message parameters (%d)\n", result);
    3488. 

  3488. }
    3489. 

  3489. 

  3490. void wilc_gnrl_async_info_received(struct wilc *wilc, u8 *pu8Buffer,
    3491. 

  3491. 				   u32 u32Length)
    3492. 

  3492. {
    3493. 

  3493. 	s32 result = 0;
    3494. 

  3494. 	struct host_if_msg msg;
    3495. 

  3495. 	int id;
    3496. 

  3496. 	struct host_if_drv *hif_drv = NULL;
    3497. 

  3497. 	struct wilc_vif *vif;
    3498. 

  3498. 

  3499. 	mutex_lock(&hif_deinit_lock);
    3500. 

  3500. 

  3501. 	id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
    3502. 

  3502. 	vif = wilc_get_vif_from_idx(wilc, id);
    3503. 

  3503. 	if (!vif) {
    3504. 

  3504. 		mutex_unlock(&hif_deinit_lock);
    3505. 

  3505. 		return;
    3506. 

  3506. 	}
    3507. 

  3507. 

  3508. 	hif_drv = vif->hif_drv;
    3509. 

  3509. 

  3510. 	if (!hif_drv || hif_drv == terminated_handle) {
    3511. 

  3511. 		mutex_unlock(&hif_deinit_lock);
    3512. 

  3512. 		return;
    3513. 

  3513. 	}
    3514. 

  3514. 

  3515. 	if (!hif_drv->usr_conn_req.conn_result) {
    3516. 

  3516. 		netdev_err(vif->ndev, "there is no current Connect Request\n");
    3517. 

  3517. 		mutex_unlock(&hif_deinit_lock);
    3518. 

  3518. 		return;
    3519. 

  3519. 	}
    3520. 

  3520. 

  3521. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3522. 

  3522. 

  3523. 	msg.id = HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO;
    3524. 

  3524. 	msg.vif = vif;
    3525. 

  3525. 

  3526. 	msg.body.async_info.len = u32Length;
    3527. 

  3527. 	msg.body.async_info.buffer = kmalloc(u32Length, GFP_KERNEL);
    3528. 

  3528. 	memcpy(msg.body.async_info.buffer, pu8Buffer, u32Length);
    3529. 

  3529. 

  3530. 	result = wilc_enqueue_cmd(&msg);
    3531. 

  3531. 	if (result)
    3532. 

  3532. 		netdev_err(vif->ndev, "synchronous info (%d)\n", result);
    3533. 

  3533. 

  3534. 	mutex_unlock(&hif_deinit_lock);
    3535. 

  3535. }
    3536. 

  3536. 

  3537. void wilc_scan_complete_received(struct wilc *wilc, u8 *pu8Buffer,
    3538. 

  3538. 				 u32 u32Length)
    3539. 

  3539. {
    3540. 

  3540. 	s32 result = 0;
    3541. 

  3541. 	struct host_if_msg msg;
    3542. 

  3542. 	int id;
    3543. 

  3543. 	struct host_if_drv *hif_drv = NULL;
    3544. 

  3544. 	struct wilc_vif *vif;
    3545. 

  3545. 

  3546. 	id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
    3547. 

  3547. 	vif = wilc_get_vif_from_idx(wilc, id);
    3548. 

  3548. 	if (!vif)
    3549. 

  3549. 		return;
    3550. 

  3550. 	hif_drv = vif->hif_drv;
    3551. 

  3551. 

  3552. 	if (!hif_drv || hif_drv == terminated_handle)
    3553. 

  3553. 		return;
    3554. 

  3554. 

  3555. 	if (hif_drv->usr_scan_req.scan_result) {
    3556. 

  3556. 		memset(&msg, 0, sizeof(struct host_if_msg));
    3557. 

  3557. 

  3558. 		msg.id = HOST_IF_MSG_RCVD_SCAN_COMPLETE;
    3559. 

  3559. 		msg.vif = vif;
    3560. 

  3560. 

  3561. 		result = wilc_enqueue_cmd(&msg);
    3562. 

  3562. 		if (result)
    3563. 

  3563. 			netdev_err(vif->ndev, "complete param (%d)\n", result);
    3564. 

  3564. 	}
    3565. 

  3565. }
    3566. 

  3566. 

  3567. int wilc_remain_on_channel(struct wilc_vif *vif, u32 session_id,
    3568. 

  3568. 			   u32 duration, u16 chan,
    3569. 

  3569. 			   wilc_remain_on_chan_expired expired,
    3570. 

  3570. 			   wilc_remain_on_chan_ready ready,
    3571. 

  3571. 			   void *user_arg)
    3572. 

  3572. {
    3573. 

  3573. 	int result = 0;
    3574. 

  3574. 	struct host_if_msg msg;
    3575. 

  3575. 

  3576. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3577. 

  3577. 

  3578. 	msg.id = HOST_IF_MSG_REMAIN_ON_CHAN;
    3579. 

  3579. 	msg.body.remain_on_ch.ch = chan;
    3580. 

  3580. 	msg.body.remain_on_ch.expired = expired;
    3581. 

  3581. 	msg.body.remain_on_ch.ready = ready;
    3582. 

  3582. 	msg.body.remain_on_ch.arg = user_arg;
    3583. 

  3583. 	msg.body.remain_on_ch.duration = duration;
    3584. 

  3584. 	msg.body.remain_on_ch.id = session_id;
    3585. 

  3585. 	msg.vif = vif;
    3586. 

  3586. 

  3587. 	result = wilc_enqueue_cmd(&msg);
    3588. 

  3588. 	if (result)
    3589. 

  3589. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3590. 

  3590. 

  3591. 	return result;
    3592. 

  3592. }
    3593. 

  3593. 

  3594. int wilc_listen_state_expired(struct wilc_vif *vif, u32 session_id)
    3595. 

  3595. {
    3596. 

  3596. 	int result = 0;
    3597. 

  3597. 	struct host_if_msg msg;
    3598. 

  3598. 	struct host_if_drv *hif_drv = vif->hif_drv;
    3599. 

  3599. 

  3600. 	if (!hif_drv) {
    3601. 

  3601. 		netdev_err(vif->ndev, "driver is null\n");
    3602. 

  3602. 		return -EFAULT;
    3603. 

  3603. 	}
    3604. 

  3604. 

  3605. 	del_timer(&hif_drv->remain_on_ch_timer);
    3606. 

  3606. 

  3607. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3608. 

  3608. 	msg.id = HOST_IF_MSG_LISTEN_TIMER_FIRED;
    3609. 

  3609. 	msg.vif = vif;
    3610. 

  3610. 	msg.body.remain_on_ch.id = session_id;
    3611. 

  3611. 

  3612. 	result = wilc_enqueue_cmd(&msg);
    3613. 

  3613. 	if (result)
    3614. 

  3614. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3615. 

  3615. 

  3616. 	return result;
    3617. 

  3617. }
    3618. 

  3618. 

  3619. int wilc_frame_register(struct wilc_vif *vif, u16 frame_type, bool reg)
    3620. 

  3620. {
    3621. 

  3621. 	int result = 0;
    3622. 

  3622. 	struct host_if_msg msg;
    3623. 

  3623. 

  3624. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3625. 

  3625. 

  3626. 	msg.id = HOST_IF_MSG_REGISTER_FRAME;
    3627. 

  3627. 	switch (frame_type) {
    3628. 

  3628. 	case ACTION:
    3629. 

  3629. 		msg.body.reg_frame.reg_id = ACTION_FRM_IDX;
    3630. 

  3630. 		break;
    3631. 

  3631. 

  3632. 	case PROBE_REQ:
    3633. 

  3633. 		msg.body.reg_frame.reg_id = PROBE_REQ_IDX;
    3634. 

  3634. 		break;
    3635. 

  3635. 

  3636. 	default:
    3637. 

  3637. 		break;
    3638. 

  3638. 	}
    3639. 

  3639. 	msg.body.reg_frame.frame_type = frame_type;
    3640. 

  3640. 	msg.body.reg_frame.reg = reg;
    3641. 

  3641. 	msg.vif = vif;
    3642. 

  3642. 

  3643. 	result = wilc_enqueue_cmd(&msg);
    3644. 

  3644. 	if (result)
    3645. 

  3645. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3646. 

  3646. 

  3647. 	return result;
    3648. 

  3648. }
    3649. 

  3649. 

  3650. int wilc_add_beacon(struct wilc_vif *vif, u32 interval, u32 dtim_period,
    3651. 

  3651. 		    u32 head_len, u8 *head, u32 tail_len, u8 *tail)
    3652. 

  3652. {
    3653. 

  3653. 	int result = 0;
    3654. 

  3654. 	struct host_if_msg msg;
    3655. 

  3655. 	struct beacon_attr *beacon_info = &msg.body.beacon_info;
    3656. 

  3656. 

  3657. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3658. 

  3658. 

  3659. 	msg.id = HOST_IF_MSG_ADD_BEACON;
    3660. 

  3660. 	msg.vif = vif;
    3661. 

  3661. 	beacon_info->interval = interval;
    3662. 

  3662. 	beacon_info->dtim_period = dtim_period;
    3663. 

  3663. 	beacon_info->head_len = head_len;
    3664. 

  3664. 	beacon_info->head = kmemdup(head, head_len, GFP_KERNEL);
    3665. 

  3665. 	if (!beacon_info->head) {
    3666. 

  3666. 		result = -ENOMEM;
    3667. 

  3667. 		goto ERRORHANDLER;
    3668. 

  3668. 	}
    3669. 

  3669. 	beacon_info->tail_len = tail_len;
    3670. 

  3670. 

  3671. 	if (tail_len > 0) {
    3672. 

  3672. 		beacon_info->tail = kmemdup(tail, tail_len, GFP_KERNEL);
    3673. 

  3673. 		if (!beacon_info->tail) {
    3674. 

  3674. 			result = -ENOMEM;
    3675. 

  3675. 			goto ERRORHANDLER;
    3676. 

  3676. 		}
    3677. 

  3677. 	} else {
    3678. 

  3678. 		beacon_info->tail = NULL;
    3679. 

  3679. 	}
    3680. 

  3680. 

  3681. 	result = wilc_enqueue_cmd(&msg);
    3682. 

  3682. 	if (result)
    3683. 

  3683. 		netdev_err(vif->ndev, "wilc mq send fail\n");
    3684. 

  3684. 

  3685. ERRORHANDLER:
    3686. 

  3686. 	if (result) {
    3687. 

  3687. 		kfree(beacon_info->head);
    3688. 

  3688. 

  3689. 		kfree(beacon_info->tail);
    3690. 

  3690. 	}
    3691. 

  3691. 

  3692. 	return result;
    3693. 

  3693. }
    3694. 

  3694. 

  3695. int wilc_del_beacon(struct wilc_vif *vif)
    3696. 

  3696. {
    3697. 

  3697. 	int result = 0;
    3698. 

  3698. 	struct host_if_msg msg;
    3699. 

  3699. 

  3700. 	msg.id = HOST_IF_MSG_DEL_BEACON;
    3701. 

  3701. 	msg.vif = vif;
    3702. 

  3702. 

  3703. 	result = wilc_enqueue_cmd(&msg);
    3704. 

  3704. 	if (result)
    3705. 

  3705. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3706. 

  3706. 

  3707. 	return result;
    3708. 

  3708. }
    3709. 

  3709. 

  3710. int wilc_add_station(struct wilc_vif *vif, struct add_sta_param *sta_param)
    3711. 

  3711. {
    3712. 

  3712. 	int result = 0;
    3713. 

  3713. 	struct host_if_msg msg;
    3714. 

  3714. 	struct add_sta_param *add_sta_info = &msg.body.add_sta_info;
    3715. 

  3715. 

  3716. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3717. 

  3717. 

  3718. 	msg.id = HOST_IF_MSG_ADD_STATION;
    3719. 

  3719. 	msg.vif = vif;
    3720. 

  3720. 

  3721. 	memcpy(add_sta_info, sta_param, sizeof(struct add_sta_param));
    3722. 

  3722. 	if (add_sta_info->rates_len > 0) {
    3723. 

  3723. 		add_sta_info->rates = kmemdup(sta_param->rates,
    3724. 

  3724. 				      add_sta_info->rates_len,
    3725. 

  3725. 				      GFP_KERNEL);
    3726. 

  3726. 		if (!add_sta_info->rates)
    3727. 

  3727. 			return -ENOMEM;
    3728. 

  3728. 	}
    3729. 

  3729. 

  3730. 	result = wilc_enqueue_cmd(&msg);
    3731. 

  3731. 	if (result)
    3732. 

  3732. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3733. 

  3733. 	return result;
    3734. 

  3734. }
    3735. 

  3735. 

  3736. int wilc_del_station(struct wilc_vif *vif, const u8 *mac_addr)
    3737. 

  3737. {
    3738. 

  3738. 	int result = 0;
    3739. 

  3739. 	struct host_if_msg msg;
    3740. 

  3740. 	struct del_sta *del_sta_info = &msg.body.del_sta_info;
    3741. 

  3741. 

  3742. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3743. 

  3743. 

  3744. 	msg.id = HOST_IF_MSG_DEL_STATION;
    3745. 

  3745. 	msg.vif = vif;
    3746. 

  3746. 

  3747. 	if (!mac_addr)
    3748. 

  3748. 		eth_broadcast_addr(del_sta_info->mac_addr);
    3749. 

  3749. 	else
    3750. 

  3750. 		memcpy(del_sta_info->mac_addr, mac_addr, ETH_ALEN);
    3751. 

  3751. 

  3752. 	result = wilc_enqueue_cmd(&msg);
    3753. 

  3753. 	if (result)
    3754. 

  3754. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3755. 

  3755. 	return result;
    3756. 

  3756. }
    3757. 

  3757. 

  3758. int wilc_del_allstation(struct wilc_vif *vif, u8 mac_addr[][ETH_ALEN])
    3759. 

  3759. {
    3760. 

  3760. 	int result = 0;
    3761. 

  3761. 	struct host_if_msg msg;
    3762. 

  3762. 	struct del_all_sta *del_all_sta_info = &msg.body.del_all_sta_info;
    3763. 

  3763. 	u8 zero_addr[ETH_ALEN] = {0};
    3764. 

  3764. 	int i;
    3765. 

  3765. 	u8 assoc_sta = 0;
    3766. 

  3766. 

  3767. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3768. 

  3768. 

  3769. 	msg.id = HOST_IF_MSG_DEL_ALL_STA;
    3770. 

  3770. 	msg.vif = vif;
    3771. 

  3771. 

  3772. 	for (i = 0; i < MAX_NUM_STA; i++) {
    3773. 

  3773. 		if (memcmp(mac_addr[i], zero_addr, ETH_ALEN)) {
    3774. 

  3774. 			memcpy(del_all_sta_info->del_all_sta[i], mac_addr[i], ETH_ALEN);
    3775. 

  3775. 			assoc_sta++;
    3776. 

  3776. 		}
    3777. 

  3777. 	}
    3778. 

  3778. 	if (!assoc_sta)
    3779. 

  3779. 		return result;
    3780. 

  3780. 

  3781. 	del_all_sta_info->assoc_sta = assoc_sta;
    3782. 

  3782. 	result = wilc_enqueue_cmd(&msg);
    3783. 

  3783. 

  3784. 	if (result)
    3785. 

  3785. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3786. 

  3786. 	else
    3787. 

  3787. 		wait_for_completion(&hif_wait_response);
    3788. 

  3788. 

  3789. 	return result;
    3790. 

  3790. }
    3791. 

  3791. 

  3792. int wilc_edit_station(struct wilc_vif *vif,
    3793. 

  3793. 		      struct add_sta_param *sta_param)
    3794. 

  3794. {
    3795. 

  3795. 	int result = 0;
    3796. 

  3796. 	struct host_if_msg msg;
    3797. 

  3797. 	struct add_sta_param *add_sta_info = &msg.body.add_sta_info;
    3798. 

  3798. 

  3799. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3800. 

  3800. 

  3801. 	msg.id = HOST_IF_MSG_EDIT_STATION;
    3802. 

  3802. 	msg.vif = vif;
    3803. 

  3803. 

  3804. 	memcpy(add_sta_info, sta_param, sizeof(struct add_sta_param));
    3805. 

  3805. 	if (add_sta_info->rates_len > 0) {
    3806. 

  3806. 		add_sta_info->rates = kmemdup(sta_param->rates,
    3807. 

  3807. 					      add_sta_info->rates_len,
    3808. 

  3808. 					      GFP_KERNEL);
    3809. 

  3809. 		if (!add_sta_info->rates)
    3810. 

  3810. 			return -ENOMEM;
    3811. 

  3811. 	}
    3812. 

  3812. 

  3813. 	result = wilc_enqueue_cmd(&msg);
    3814. 

  3814. 	if (result)
    3815. 

  3815. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3816. 

  3816. 

  3817. 	return result;
    3818. 

  3818. }
    3819. 

  3819. 

  3820. int wilc_set_power_mgmt(struct wilc_vif *vif, bool enabled, u32 timeout)
    3821. 

  3821. {
    3822. 

  3822. 	int result = 0;
    3823. 

  3823. 	struct host_if_msg msg;
    3824. 

  3824. 	struct power_mgmt_param *pwr_mgmt_info = &msg.body.pwr_mgmt_info;
    3825. 

  3825. 

  3826. 	if (wilc_wlan_get_num_conn_ifcs(vif->wilc) == 2 && enabled)
    3827. 

  3827. 		return 0;
    3828. 

  3828. 

  3829. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3830. 

  3830. 

  3831. 	msg.id = HOST_IF_MSG_POWER_MGMT;
    3832. 

  3832. 	msg.vif = vif;
    3833. 

  3833. 

  3834. 	pwr_mgmt_info->enabled = enabled;
    3835. 

  3835. 	pwr_mgmt_info->timeout = timeout;
    3836. 

  3836. 

  3837. 	result = wilc_enqueue_cmd(&msg);
    3838. 

  3838. 	if (result)
    3839. 

  3839. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3840. 

  3840. 	return result;
    3841. 

  3841. }
    3842. 

  3842. 

  3843. int wilc_setup_multicast_filter(struct wilc_vif *vif, bool enabled,
    3844. 

  3844. 				u32 count)
    3845. 

  3845. {
    3846. 

  3846. 	int result = 0;
    3847. 

  3847. 	struct host_if_msg msg;
    3848. 

  3848. 	struct set_multicast *multicast_filter_param = &msg.body.multicast_info;
    3849. 

  3849. 

  3850. 	memset(&msg, 0, sizeof(struct host_if_msg));
    3851. 

  3851. 

  3852. 	msg.id = HOST_IF_MSG_SET_MULTICAST_FILTER;
    3853. 

  3853. 	msg.vif = vif;
    3854. 

  3854. 

  3855. 	multicast_filter_param->enabled = enabled;
    3856. 

  3856. 	multicast_filter_param->cnt = count;
    3857. 

  3857. 

  3858. 	result = wilc_enqueue_cmd(&msg);
    3859. 

  3859. 	if (result)
    3860. 

  3860. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    3861. 

  3861. 	return result;
    3862. 

  3862. }
    3863. 

  3863. 

  3864. static void *host_int_ParseJoinBssParam(struct network_info *ptstrNetworkInfo)
    3865. 

  3865. {
    3866. 

  3866. 	struct join_bss_param *pNewJoinBssParam = NULL;
    3867. 

  3867. 	u8 *pu8IEs;
    3868. 

  3868. 	u16 u16IEsLen;
    3869. 

  3869. 	u16 index = 0;
    3870. 

  3870. 	u8 suppRatesNo = 0;
    3871. 

  3871. 	u8 extSuppRatesNo;
    3872. 

  3872. 	u16 jumpOffset;
    3873. 

  3873. 	u8 pcipherCount;
    3874. 

  3874. 	u8 authCount;
    3875. 

  3875. 	u8 pcipherTotalCount = 0;
    3876. 

  3876. 	u8 authTotalCount = 0;
    3877. 

  3877. 	u8 i, j;
    3878. 

  3878. 

  3879. 	pu8IEs = ptstrNetworkInfo->ies;
    3880. 

  3880. 	u16IEsLen = ptstrNetworkInfo->ies_len;
    3881. 

  3881. 

  3882. 	pNewJoinBssParam = kzalloc(sizeof(struct join_bss_param), GFP_KERNEL);
    3883. 

  3883. 	if (pNewJoinBssParam) {
    3884. 

  3884. 		pNewJoinBssParam->dtim_period = ptstrNetworkInfo->dtim_period;
    3885. 

  3885. 		pNewJoinBssParam->beacon_period = ptstrNetworkInfo->beacon_period;
    3886. 

  3886. 		pNewJoinBssParam->cap_info = ptstrNetworkInfo->cap_info;
    3887. 

  3887. 		memcpy(pNewJoinBssParam->bssid, ptstrNetworkInfo->bssid, 6);
    3888. 

  3888. 		memcpy((u8 *)pNewJoinBssParam->ssid, ptstrNetworkInfo->ssid,
    3889. 

  3889. 		       ptstrNetworkInfo->ssid_len + 1);
    3890. 

  3890. 		pNewJoinBssParam->ssid_len = ptstrNetworkInfo->ssid_len;
    3891. 

  3891. 		memset(pNewJoinBssParam->rsn_pcip_policy, 0xFF, 3);
    3892. 

  3892. 		memset(pNewJoinBssParam->rsn_auth_policy, 0xFF, 3);
    3893. 

  3893. 

  3894. 		while (index < u16IEsLen) {
    3895. 

  3895. 			if (pu8IEs[index] == SUPP_RATES_IE) {
    3896. 

  3896. 				suppRatesNo = pu8IEs[index + 1];
    3897. 

  3897. 				pNewJoinBssParam->supp_rates[0] = suppRatesNo;
    3898. 

  3898. 				index += 2;
    3899. 

  3899. 

  3900. 				for (i = 0; i < suppRatesNo; i++)
    3901. 

  3901. 					pNewJoinBssParam->supp_rates[i + 1] = pu8IEs[index + i];
    3902. 

  3902. 

  3903. 				index += suppRatesNo;
    3904. 

  3904. 				continue;
    3905. 

  3905. 			} else if (pu8IEs[index] == EXT_SUPP_RATES_IE) {
    3906. 

  3906. 				extSuppRatesNo = pu8IEs[index + 1];
    3907. 

  3907. 				if (extSuppRatesNo > (MAX_RATES_SUPPORTED - suppRatesNo))
    3908. 

  3908. 					pNewJoinBssParam->supp_rates[0] = MAX_RATES_SUPPORTED;
    3909. 

  3909. 				else
    3910. 

  3910. 					pNewJoinBssParam->supp_rates[0] += extSuppRatesNo;
    3911. 

  3911. 				index += 2;
    3912. 

  3912. 				for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++)
    3913. 

  3913. 					pNewJoinBssParam->supp_rates[suppRatesNo + i + 1] = pu8IEs[index + i];
    3914. 

  3914. 

  3915. 				index += extSuppRatesNo;
    3916. 

  3916. 				continue;
    3917. 

  3917. 			} else if (pu8IEs[index] == HT_CAPABILITY_IE) {
    3918. 

  3918. 				pNewJoinBssParam->ht_capable = true;
    3919. 

  3919. 				index += pu8IEs[index + 1] + 2;
    3920. 

  3920. 				continue;
    3921. 

  3921. 			} else if ((pu8IEs[index] == WMM_IE) &&
    3922. 

  3922. 				   (pu8IEs[index + 2] == 0x00) && (pu8IEs[index + 3] == 0x50) &&
    3923. 

  3923. 				   (pu8IEs[index + 4] == 0xF2) &&
    3924. 

  3924. 				   (pu8IEs[index + 5] == 0x02) &&
    3925. 

  3925. 				   ((pu8IEs[index + 6] == 0x00) || (pu8IEs[index + 6] == 0x01)) &&
    3926. 

  3926. 				   (pu8IEs[index + 7] == 0x01)) {
    3927. 

  3927. 				pNewJoinBssParam->wmm_cap = true;
    3928. 

  3928. 

  3929. 				if (pu8IEs[index + 8] & BIT(7))
    3930. 

  3930. 					pNewJoinBssParam->uapsd_cap = true;
    3931. 

  3931. 				index += pu8IEs[index + 1] + 2;
    3932. 

  3932. 				continue;
    3933. 

  3933. 			} else if ((pu8IEs[index] == P2P_IE) &&
    3934. 

  3934. 				 (pu8IEs[index + 2] == 0x50) && (pu8IEs[index + 3] == 0x6f) &&
    3935. 

  3935. 				 (pu8IEs[index + 4] == 0x9a) &&
    3936. 

  3936. 				 (pu8IEs[index + 5] == 0x09) && (pu8IEs[index + 6] == 0x0c)) {
    3937. 

  3937. 				u16 u16P2P_count;
    3938. 

  3938. 

  3939. 				pNewJoinBssParam->tsf = ptstrNetworkInfo->tsf_lo;
    3940. 

  3940. 				pNewJoinBssParam->noa_enabled = 1;
    3941. 

  3941. 				pNewJoinBssParam->idx = pu8IEs[index + 9];
    3942. 

  3942. 

  3943. 				if (pu8IEs[index + 10] & BIT(7)) {
    3944. 

  3944. 					pNewJoinBssParam->opp_enabled = 1;
    3945. 

  3945. 					pNewJoinBssParam->ct_window = pu8IEs[index + 10];
    3946. 

  3946. 				} else {
    3947. 

  3947. 					pNewJoinBssParam->opp_enabled = 0;
    3948. 

  3948. 				}
    3949. 

  3949. 

  3950. 				pNewJoinBssParam->cnt = pu8IEs[index + 11];
    3951. 

  3951. 				u16P2P_count = index + 12;
    3952. 

  3952. 

  3953. 				memcpy(pNewJoinBssParam->duration, pu8IEs + u16P2P_count, 4);
    3954. 

  3954. 				u16P2P_count += 4;
    3955. 

  3955. 

  3956. 				memcpy(pNewJoinBssParam->interval, pu8IEs + u16P2P_count, 4);
    3957. 

  3957. 				u16P2P_count += 4;
    3958. 

  3958. 

  3959. 				memcpy(pNewJoinBssParam->start_time, pu8IEs + u16P2P_count, 4);
    3960. 

  3960. 

  3961. 				index += pu8IEs[index + 1] + 2;
    3962. 

  3962. 				continue;
    3963. 

  3963. 

  3964. 			} else if ((pu8IEs[index] == RSN_IE) ||
    3965. 

  3965. 				 ((pu8IEs[index] == WPA_IE) && (pu8IEs[index + 2] == 0x00) &&
    3966. 

  3966. 				  (pu8IEs[index + 3] == 0x50) && (pu8IEs[index + 4] == 0xF2) &&
    3967. 

  3967. 				  (pu8IEs[index + 5] == 0x01)))	{
    3968. 

  3968. 				u16 rsnIndex = index;
    3969. 

  3969. 

  3970. 				if (pu8IEs[rsnIndex] == RSN_IE)	{
    3971. 

  3971. 					pNewJoinBssParam->mode_802_11i = 2;
    3972. 

  3972. 				} else {
    3973. 

  3973. 					if (pNewJoinBssParam->mode_802_11i == 0)
    3974. 

  3974. 						pNewJoinBssParam->mode_802_11i = 1;
    3975. 

  3975. 					rsnIndex += 4;
    3976. 

  3976. 				}
    3977. 

  3977. 

  3978. 				rsnIndex += 7;
    3979. 

  3979. 				pNewJoinBssParam->rsn_grp_policy = pu8IEs[rsnIndex];
    3980. 

  3980. 				rsnIndex++;
    3981. 

  3981. 				jumpOffset = pu8IEs[rsnIndex] * 4;
    3982. 

  3982. 				pcipherCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
    3983. 

  3983. 				rsnIndex += 2;
    3984. 

  3984. 

  3985. 				for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++)
    3986. 

  3986. 					pNewJoinBssParam->rsn_pcip_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
    3987. 

  3987. 

  3988. 				pcipherTotalCount += pcipherCount;
    3989. 

  3989. 				rsnIndex += jumpOffset;
    3990. 

  3990. 

  3991. 				jumpOffset = pu8IEs[rsnIndex] * 4;
    3992. 

  3992. 

  3993. 				authCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
    3994. 

  3994. 				rsnIndex += 2;
    3995. 

  3995. 

  3996. 				for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++)
    3997. 

  3997. 					pNewJoinBssParam->rsn_auth_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
    3998. 

  3998. 

  3999. 				authTotalCount += authCount;
    4000. 

  4000. 				rsnIndex += jumpOffset;
    4001. 

  4001. 

  4002. 				if (pu8IEs[index] == RSN_IE) {
    4003. 

  4003. 					pNewJoinBssParam->rsn_cap[0] = pu8IEs[rsnIndex];
    4004. 

  4004. 					pNewJoinBssParam->rsn_cap[1] = pu8IEs[rsnIndex + 1];
    4005. 

  4005. 					rsnIndex += 2;
    4006. 

  4006. 				}
    4007. 

  4007. 				pNewJoinBssParam->rsn_found = true;
    4008. 

  4008. 				index += pu8IEs[index + 1] + 2;
    4009. 

  4009. 				continue;
    4010. 

  4010. 			} else
    4011. 

  4011. 				index += pu8IEs[index + 1] + 2;
    4012. 

  4012. 		}
    4013. 

  4013. 	}
    4014. 

  4014. 

  4015. 	return (void *)pNewJoinBssParam;
    4016. 

  4016. }
    4017. 

  4017. 

  4018. int wilc_setup_ipaddress(struct wilc_vif *vif, u8 *ip_addr, u8 idx)
    4019. 

  4019. {
    4020. 

  4020. 	int result = 0;
    4021. 

  4021. 	struct host_if_msg msg;
    4022. 

  4022. 

  4023. 	memset(&msg, 0, sizeof(struct host_if_msg));
    4024. 

  4024. 

  4025. 	msg.id = HOST_IF_MSG_SET_IPADDRESS;
    4026. 

  4026. 

  4027. 	msg.body.ip_info.ip_addr = ip_addr;
    4028. 

  4028. 	msg.vif = vif;
    4029. 

  4029. 	msg.body.ip_info.idx = idx;
    4030. 

  4030. 

  4031. 	result = wilc_enqueue_cmd(&msg);
    4032. 

  4032. 	if (result)
    4033. 

  4033. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    4034. 

  4034. 

  4035. 	return result;
    4036. 

  4036. }
    4037. 

  4037. 

  4038. static int host_int_get_ipaddress(struct wilc_vif *vif, u8 *ip_addr, u8 idx)
    4039. 

  4039. {
    4040. 

  4040. 	int result = 0;
    4041. 

  4041. 	struct host_if_msg msg;
    4042. 

  4042. 

  4043. 	memset(&msg, 0, sizeof(struct host_if_msg));
    4044. 

  4044. 

  4045. 	msg.id = HOST_IF_MSG_GET_IPADDRESS;
    4046. 

  4046. 

  4047. 	msg.body.ip_info.ip_addr = ip_addr;
    4048. 

  4048. 	msg.vif = vif;
    4049. 

  4049. 	msg.body.ip_info.idx = idx;
    4050. 

  4050. 

  4051. 	result = wilc_enqueue_cmd(&msg);
    4052. 

  4052. 	if (result)
    4053. 

  4053. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    4054. 

  4054. 

  4055. 	return result;
    4056. 

  4056. }
    4057. 

  4057. 

  4058. int wilc_set_tx_power(struct wilc_vif *vif, u8 tx_power)
    4059. 

  4059. {
    4060. 

  4060. 	int ret = 0;
    4061. 

  4061. 	struct host_if_msg msg;
    4062. 

  4062. 

  4063. 	memset(&msg, 0, sizeof(struct host_if_msg));
    4064. 

  4064. 

  4065. 	msg.id = HOST_IF_MSG_SET_TX_POWER;
    4066. 

  4066. 	msg.body.tx_power.tx_pwr = tx_power;
    4067. 

  4067. 	msg.vif = vif;
    4068. 

  4068. 

  4069. 	ret = wilc_enqueue_cmd(&msg);
    4070. 

  4070. 	if (ret)
    4071. 

  4071. 		netdev_err(vif->ndev, "wilc_mq_send fail\n");
    4072. 

  4072. 

  4073. 	return ret;
    4074. 

  4074. }
    4075. 

  4075. 

  4076. int wilc_get_tx_power(struct wilc_vif *vif, u8 *tx_power)
    4077. 

  4077. {
    4078. 

  4078. 	int ret = 0;
    4079. 

  4079. 	struct host_if_msg msg;
    4080. 

  4080. 

  4081. 	memset(&msg, 0, sizeof(struct host_if_msg));
    4082. 

  4082. 

  4083. 	msg.id = HOST_IF_MSG_GET_TX_POWER;
    4084. 

  4084. 	msg.vif = vif;
    4085. 

  4085. 

  4086. 	ret = wilc_enqueue_cmd(&msg);
    4087. 

  4087. 	if (ret)
    4088. 

  4088. 		netdev_err(vif->ndev, "Failed to get TX PWR\n");
    4089. 

  4089. 

  4090. 	wait_for_completion(&hif_wait_response);
    4091. 

  4091. 	*tx_power = msg.body.tx_power.tx_pwr;
    4092. 

  4092. 

  4093. 	return ret;
    4094. 

  4094. }
    4095. 

  4095.