projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: wilc1000: periodic_rssi can be static
[deliverable/linux.git] / drivers / staging / wilc1000 / host_interface.c
CommitLineData
e215a871
CL		 1#include <linux/slab.h>
2#include <linux/time.h>
3#include <linux/kthread.h>
4#include <linux/delay.h>
c5c77ba1 5#include "host_interface.h"
c5c77ba1 6#include "coreconfigurator.h"
5366012d 7#include "wilc_wlan_if.h"
f23eb98b 8#include "wilc_msgqueue.h"
281dd5ac 9#include <linux/etherdevice.h>
c5c77ba1 10
63d03e47 11extern u8 connecting;
c5c77ba1 12
da711eb6 13extern struct timer_list hDuringIpTimer;
c5c77ba1 14
63d03e47 15extern u8 g_wilc_initialized;
c5c77ba1 16
9eac3a15
CL		 17#define HOST_IF_MSG_SCAN 0
18#define HOST_IF_MSG_CONNECT 1
19#define HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO 2
20#define HOST_IF_MSG_KEY 3
21#define HOST_IF_MSG_RCVD_NTWRK_INFO 4
22#define HOST_IF_MSG_RCVD_SCAN_COMPLETE 5
23#define HOST_IF_MSG_CFG_PARAMS 6
24#define HOST_IF_MSG_SET_CHANNEL 7
25#define HOST_IF_MSG_DISCONNECT 8
26#define HOST_IF_MSG_GET_RSSI 9
27#define HOST_IF_MSG_GET_CHNL 10
28#define HOST_IF_MSG_ADD_BEACON 11
29#define HOST_IF_MSG_DEL_BEACON 12
30#define HOST_IF_MSG_ADD_STATION 13
31#define HOST_IF_MSG_DEL_STATION 14
32#define HOST_IF_MSG_EDIT_STATION 15
33#define HOST_IF_MSG_SCAN_TIMER_FIRED 16
34#define HOST_IF_MSG_CONNECT_TIMER_FIRED 17
35#define HOST_IF_MSG_POWER_MGMT 18
36#define HOST_IF_MSG_GET_INACTIVETIME 19
37#define HOST_IF_MSG_REMAIN_ON_CHAN 20
38#define HOST_IF_MSG_REGISTER_FRAME 21
39#define HOST_IF_MSG_LISTEN_TIMER_FIRED 22
40#define HOST_IF_MSG_GET_LINKSPEED 23
41#define HOST_IF_MSG_SET_WFIDRV_HANDLER 24
42#define HOST_IF_MSG_SET_MAC_ADDRESS 25
43#define HOST_IF_MSG_GET_MAC_ADDRESS 26
44#define HOST_IF_MSG_SET_OPERATION_MODE 27
45#define HOST_IF_MSG_SET_IPADDRESS 28
46#define HOST_IF_MSG_GET_IPADDRESS 29
47#define HOST_IF_MSG_FLUSH_CONNECT 30
48#define HOST_IF_MSG_GET_STATISTICS 31
49#define HOST_IF_MSG_SET_MULTICAST_FILTER 32
50#define HOST_IF_MSG_ADD_BA_SESSION 33
51#define HOST_IF_MSG_DEL_BA_SESSION 34
52#define HOST_IF_MSG_Q_IDLE 35
53#define HOST_IF_MSG_DEL_ALL_STA 36
54#define HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS 34
55#define HOST_IF_MSG_EXIT 100
d85f5326 56
e54d5b75
CL		 57#define HOST_IF_SCAN_TIMEOUT 4000
58#define HOST_IF_CONNECT_TIMEOUT 9500
c5c77ba1 59
e54d5b75
CL		 60#define BA_SESSION_DEFAULT_BUFFER_SIZE 16
61#define BA_SESSION_DEFAULT_TIMEOUT 1000
62#define BLOCK_ACK_REQ_SIZE 0x14
c5c77ba1 63
361ff841 64struct cfg_param_attr {
221371e5 65 struct cfg_param_val cfg_attr_info;
361ff841 66};
c5c77ba1 67
4372d3d3 68struct host_if_wpa_attr {
124968fc 69 u8 *key;
248080aa 70 const u8 *mac_addr;
0e74c009 71 u8 *seq;
dacc594d 72 u8 seq_len;
e2dfbac5 73 u8 index;
6acf2919 74 u8 key_len;
7b2ebb28 75 u8 mode;
4372d3d3 76};
c5c77ba1 77
c276c44a 78struct host_if_wep_attr {
e5538d34 79 u8 *key;
d520e355 80 u8 key_len;
259b3aa6 81 u8 index;
b5eaff12 82 u8 mode;
7fa252e7 83 enum AUTHTYPE auth_type;
c276c44a 84};
c5c77ba1 85
40cc2c90 86union host_if_key_attr {
2ed7a2fb 87 struct host_if_wep_attr wep;
e3501a4d 88 struct host_if_wpa_attr wpa;
610e3868 89 struct host_if_pmkid_attr pmkid;
40cc2c90 90};
c5c77ba1 91
c98387a5 92struct key_attr {
8e9f427a 93 enum KEY_TYPE type;
0d17e382 94 u8 action;
73b2e381 95 union host_if_key_attr attr;
c98387a5 96};
c5c77ba1 97
c476feb8 98struct scan_attr {
42568898 99 u8 src;
1e276c88 100 u8 type;
82eeb0ad 101 u8 *ch_freq_list;
f97bd9ca 102 u8 ch_list_len;
d6f19aa5 103 u8 *ies;
7b1f76cd 104 size_t ies_len;
c17c6da6 105 wilc_scan_result result;
5f2b50c8 106 void *arg;
629b9ca0 107 struct hidden_network hidden_network;
c476feb8 108};
c5c77ba1 109
120ae593 110struct connect_attr {
9254db07 111 u8 *bssid;
f7bbd9cf 112 u8 *ssid;
8b3c9fa6 113 size_t ssid_len;
2ea158c4 114 u8 *ies;
b59d5c5b 115 size_t ies_len;
a64fd677 116 u8 security;
6abcc11d 117 wilc_connect_result result;
8f38db89 118 void *arg;
61b4fd02 119 enum AUTHTYPE auth_type;
0d1527e6 120 u8 ch;
f2bed2ca 121 void *params;
120ae593 122};
c5c77ba1 123
f23a9eab 124struct rcvd_async_info {
33722ac7 125 u8 *buffer;
f94f4889 126 u32 len;
f23a9eab 127};
c5c77ba1 128
94bdfe42 129struct channel_attr {
730ee059 130 u8 set_ch;
326b323d 131};
c5c77ba1 132
7f33fecd 133struct beacon_attr {
12262dda 134 u32 interval;
e76ab770 135 u32 dtim_period;
51c66185 136 u32 head_len;
8ce528b9 137 u8 *head;
030c57e2 138 u32 tail_len;
7dbcb6d3 139 u8 *tail;
902362b1 140};
c5c77ba1 141
641210ac 142struct set_multicast {
bae636eb 143 bool enabled;
adab2f71 144 u32 cnt;
641210ac 145};
c5c77ba1 146
b4e644e4 147struct del_all_sta {
e51b9216 148 u8 del_all_sta[MAX_NUM_STA][ETH_ALEN];
8ba1803f 149 u8 assoc_sta;
b4e644e4 150};
c5c77ba1 151
fb93a1e1 152struct del_sta {
e4839d39 153 u8 mac_addr[ETH_ALEN];
fb93a1e1 154};
c5c77ba1 155
5a008f1c 156struct power_mgmt_param {
33c70c1b 157 bool enabled;
937918ff 158 u32 timeout;
5a008f1c 159};
c5c77ba1 160
15191eaf 161struct set_ip_addr {
78675be5 162 u8 *ip_addr;
63d03e47 163 u8 idx;
15191eaf 164};
c5c77ba1 165
3d1eac04 166struct sta_inactive_t {
63d03e47 167 u8 mac[6];
3d1eac04 168};
ae4dfa57 169
dfc7663b 170union message_body {
4528bdb5 171 struct scan_attr scan_info;
3f501971 172 struct connect_attr con_info;
02d19460 173 struct rcvd_net_info net_info;
66add622 174 struct rcvd_async_info async_info;
18990bfe 175 struct key_attr key_info;
a2340c36 176 struct cfg_param_attr cfg_info;
ffd6dbc8 177 struct channel_attr channel_info;
a98491e5 178 struct beacon_attr beacon_info;
ca8f47f8 179 struct add_sta_param add_sta_info;
889c25be 180 struct del_sta del_sta_info;
4a930962 181 struct add_sta_param edit_sta_info;
49e1f81b 182 struct power_mgmt_param pwr_mgmt_info;
66bac7f2 183 struct sta_inactive_t mac_info;
fb2d65ed 184 struct set_ip_addr ip_info;
5e4377e6 185 struct drv_handler drv;
a079cf4d 186 struct set_multicast multicast_info;
00c4630e 187 struct op_mode mode;
15326e28 188 struct set_mac_addr set_mac_info;
a5848695 189 struct get_mac_addr get_mac_info;
c833b474 190 struct ba_session_info session_info;
070d365c 191 struct remain_ch remain_on_ch;
5c4008db 192 struct reg_frame reg_frame;
e60831e9 193 char *data;
b0c1e80e 194 struct del_all_sta del_all_sta_info;
dfc7663b 195};
c5c77ba1 196
3a8c41b5 197struct host_if_msg {
ae4dfa57
LK		 198 u16 id;
199 union message_body body;
2482a79f 200 struct host_if_drv *drv;
3a8c41b5 201};
c5c77ba1 202
e0a12217 203struct join_bss_param {
c5c77ba1 204 BSSTYPE_T bss_type;
63d03e47 205 u8 dtim_period;
d85f5326
CL		 206 u16 beacon_period;
207 u16 cap_info;
63d03e47 208 u8 au8bssid[6];
576917ad 209 char ssid[MAX_SSID_LEN];
619d27b8 210 u8 ssid_len;
63d03e47
GKH		 211 u8 supp_rates[MAX_RATES_SUPPORTED + 1];
212 u8 ht_capable;
213 u8 wmm_cap;
214 u8 uapsd_cap;
72ed4dc7 215 bool rsn_found;
63d03e47
GKH		 216 u8 rsn_grp_policy;
217 u8 mode_802_11i;
218 u8 rsn_pcip_policy[3];
219 u8 rsn_auth_policy[3];
220 u8 rsn_cap[2];
4e4467fd 221 u32 tsf;
7a8d51d7 222 u8 noa_enabled;
d72b33ca 223 u8 opp_enabled;
99b66945 224 u8 ct_window;
c21047ed 225 u8 cnt;
cc179008 226 u8 idx;
109e6cab 227 u8 duration[4];
1d8b76b3 228 u8 interval[4];
63d03e47 229 u8 au8StartTime[4];
e0a12217 230};
c5c77ba1 231
441dc609
LK		 232static struct host_if_drv *wfidrv_list[NUM_CONCURRENT_IFC + 1];
233struct host_if_drv *terminated_handle;
f2fc9f6e 234bool g_obtainingIP;
63d03e47 235u8 P2P_LISTEN_STATE;
c2115d8e 236static struct task_struct *hif_thread_handler;
cb067dcf 237static WILC_MsgQueueHandle hif_msg_q;
834e0cb0 238static struct semaphore hif_sema_thread;
413f930e 239static struct semaphore hif_sema_driver;
2d25af87 240static struct semaphore hif_sema_wait_response;
17225002 241static struct semaphore hif_sema_deinit;
24aadb8b 242static struct timer_list periodic_rssi;
c5c77ba1 243
63d03e47 244u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
c5c77ba1 245
63d03e47 246static u8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE];
c5c77ba1 247
f2fc9f6e 248bool gbScanWhileConnected;
c5c77ba1 249
ca356ada
CL		 250static s8 gs8Rssi;
251static s8 gs8lnkspd;
63d03e47
GKH		 252static u8 gu8Chnl;
253static u8 gs8SetIP[2][4];
254static u8 gs8GetIP[2][4];
4e4467fd 255static u32 gu32InactiveTime;
63d03e47 256static u8 gu8DelBcn;
4e4467fd 257static u32 gu32WidConnRstHack;
c5c77ba1 258
63d03e47
GKH		 259u8 *gu8FlushedJoinReq;
260u8 *gu8FlushedInfoElemAsoc;
261u8 gu8Flushed11iMode;
262u8 gu8FlushedAuthType;
4e4467fd
CL		 263u32 gu32FlushedJoinReqSize;
264u32 gu32FlushedInfoElemAsocSize;
441dc609 265struct host_if_drv *gu8FlushedJoinReqDrvHandler;
c5c77ba1
JK		 266#define REAL_JOIN_REQ 0
267#define FLUSHED_JOIN_REQ 1
ae4dfa57 268#define FLUSHED_BYTE_POS 79
c5c77ba1 269
c5c77ba1 270static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo);
c5c77ba1 271
4e4467fd 272extern void chip_sleep_manually(u32 u32SleepTime);
c5c77ba1
JK		 273extern int linux_wlan_get_num_conn_ifcs(void);
274
441dc609 275static int add_handler_in_list(struct host_if_drv *handler)
d42ab083
JK		 276{
277 int i;
278
279 for (i = 1; i < ARRAY_SIZE(wfidrv_list); i++) {
280 if (!wfidrv_list[i]) {
281 wfidrv_list[i] = handler;
282 return 0;
283 }
284 }
285
286 return -ENOBUFS;
287}
288
441dc609 289static int remove_handler_in_list(struct host_if_drv *handler)
d42ab083
JK		 290{
291 int i;
292
293 for (i = 1; i < ARRAY_SIZE(wfidrv_list); i++) {
294 if (wfidrv_list[i] == handler) {
295 wfidrv_list[i] = NULL;
296 return 0;
297 }
298 }
299
300 return -EINVAL;
301}
302
441dc609 303static int get_id_from_handler(struct host_if_drv *handler)
d42ab083
JK		 304{
305 int i;
306
307 if (!handler)
308 return 0;
309
310 for (i = 1; i < ARRAY_SIZE(wfidrv_list); i++) {
311 if (wfidrv_list[i] == handler)
312 return i;
313 }
314
315 return 0;
316}
317
441dc609 318static struct host_if_drv *get_handler_from_id(int id)
d42ab083 319{
6ae9ac0b 320 if (id <= 0 || id >= ARRAY_SIZE(wfidrv_list))
d42ab083
JK		 321 return NULL;
322 return wfidrv_list[id];
323}
324
a4ab1ade 325static s32 Handle_SetChannel(struct host_if_drv *hif_drv,
94bdfe42 326 struct channel_attr *pstrHostIFSetChan)
c5c77ba1
JK		 327{
328
e6e12661 329 s32 s32Error = 0;
e9e0c260 330 struct wid strWID;
c5c77ba1 331
daaf16ba 332 strWID.id = (u16)WID_CURRENT_CHANNEL;
416d8321 333 strWID.type = WID_CHAR;
730ee059 334 strWID.val = (char *)&(pstrHostIFSetChan->set_ch);
2fd3e443 335 strWID.size = sizeof(char);
c5c77ba1
JK		 336
337 PRINT_D(HOSTINF_DBG, "Setting channel\n");
ae4dfa57 338
03362286 339 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 340 get_id_from_handler(hif_drv));
c5c77ba1
JK		 341 if (s32Error) {
342 PRINT_ER("Failed to set channel\n");
24db713f 343 return -EINVAL;
c5c77ba1
JK		 344 }
345
346 return s32Error;
347}
ae4dfa57 348
a4ab1ade 349static s32 Handle_SetWfiDrvHandler(struct host_if_drv *hif_drv,
127f9d94 350 struct drv_handler *pstrHostIfSetDrvHandler)
c5c77ba1
JK		 351{
352
e6e12661 353 s32 s32Error = 0;
e9e0c260 354 struct wid strWID;
c5c77ba1 355
daaf16ba 356 strWID.id = (u16)WID_SET_DRV_HANDLER;
416d8321 357 strWID.type = WID_INT;
900bb4a6 358 strWID.val = (s8 *)&(pstrHostIfSetDrvHandler->u32Address);
2fd3e443 359 strWID.size = sizeof(u32);
c5c77ba1 360
03362286 361 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
cf32c3c4 362 pstrHostIfSetDrvHandler->u32Address);
c5c77ba1 363
a4ab1ade 364 if (!hif_drv)
27ff2168 365 up(&hif_sema_driver);
c5c77ba1
JK		 366
367 if (s32Error) {
368 PRINT_ER("Failed to set driver handler\n");
24db713f 369 return -EINVAL;
c5c77ba1
JK		 370 }
371
372 return s32Error;
373}
374
a4ab1ade 375static s32 Handle_SetOperationMode(struct host_if_drv *hif_drv,
801bee52 376 struct op_mode *pstrHostIfSetOperationMode)
c5c77ba1
JK		 377{
378
e6e12661 379 s32 s32Error = 0;
e9e0c260 380 struct wid strWID;
c5c77ba1 381
daaf16ba 382 strWID.id = (u16)WID_SET_OPERATION_MODE;
416d8321 383 strWID.type = WID_INT;
900bb4a6 384 strWID.val = (s8 *)&(pstrHostIfSetOperationMode->u32Mode);
2fd3e443 385 strWID.size = sizeof(u32);
c5c77ba1 386
03362286 387 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 388 get_id_from_handler(hif_drv));
c5c77ba1
JK		 389
390
c590b9a4 391 if ((pstrHostIfSetOperationMode->u32Mode) == IDLE_MODE)
27ff2168 392 up(&hif_sema_driver);
c5c77ba1
JK		 393
394 if (s32Error) {
395 PRINT_ER("Failed to set driver handler\n");
24db713f 396 return -EINVAL;
c5c77ba1
JK		 397 }
398
399 return s32Error;
400}
401
a4ab1ade 402s32 Handle_set_IPAddress(struct host_if_drv *hif_drv, u8 *pu8IPAddr, u8 idx)
c5c77ba1
JK		 403{
404
e6e12661 405 s32 s32Error = 0;
e9e0c260 406 struct wid strWID;
c5c77ba1 407 char firmwareIPAddress[4] = {0};
c5c77ba1
JK		 408
409 if (pu8IPAddr[0] < 192)
410 pu8IPAddr[0] = 0;
411
b3a02832 412 PRINT_INFO(HOSTINF_DBG, "Indx = %d, Handling set IP = %pI4\n", idx, pu8IPAddr);
c5c77ba1 413
d00d2ba3 414 memcpy(gs8SetIP[idx], pu8IPAddr, IP_ALEN);
c5c77ba1 415
daaf16ba 416 strWID.id = (u16)WID_IP_ADDRESS;
416d8321 417 strWID.type = WID_STR;
900bb4a6 418 strWID.val = (u8 *)pu8IPAddr;
2fd3e443 419 strWID.size = IP_ALEN;
c5c77ba1 420
03362286 421 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 422 get_id_from_handler(hif_drv));
c5c77ba1
JK		 423
424
a4ab1ade 425 host_int_get_ipaddress(hif_drv, firmwareIPAddress, idx);
c5c77ba1
JK		 426
427 if (s32Error) {
24db713f
LK		 428 PRINT_ER("Failed to set IP address\n");
429 return -EINVAL;
c5c77ba1
JK		 430 }
431
24db713f 432 PRINT_INFO(HOSTINF_DBG, "IP address set\n");
c5c77ba1
JK		 433
434 return s32Error;
435}
436
a4ab1ade 437s32 Handle_get_IPAddress(struct host_if_drv *hif_drv, u8 *pu8IPAddr, u8 idx)
c5c77ba1
JK		 438{
439
e6e12661 440 s32 s32Error = 0;
e9e0c260 441 struct wid strWID;
c5c77ba1 442
daaf16ba 443 strWID.id = (u16)WID_IP_ADDRESS;
416d8321 444 strWID.type = WID_STR;
900bb4a6 445 strWID.val = kmalloc(IP_ALEN, GFP_KERNEL);
2fd3e443 446 strWID.size = IP_ALEN;
c5c77ba1 447
03362286 448 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 449 get_id_from_handler(hif_drv));
c5c77ba1 450
900bb4a6 451 PRINT_INFO(HOSTINF_DBG, "%pI4\n", strWID.val);
c5c77ba1 452
900bb4a6 453 memcpy(gs8GetIP[idx], strWID.val, IP_ALEN);
c5c77ba1 454
900bb4a6 455 kfree(strWID.val);
c5c77ba1 456
1a646e7e 457 if (memcmp(gs8GetIP[idx], gs8SetIP[idx], IP_ALEN) != 0)
a4ab1ade 458 host_int_setup_ipaddress(hif_drv, gs8SetIP[idx], idx);
c5c77ba1 459
e6e12661 460 if (s32Error != 0) {
c5c77ba1 461 PRINT_ER("Failed to get IP address\n");
24db713f 462 return -EINVAL;
c5c77ba1
JK		 463 }
464
24db713f
LK		 465 PRINT_INFO(HOSTINF_DBG, "IP address retrieved:: u8IfIdx = %d\n", idx);
466 PRINT_INFO(HOSTINF_DBG, "%pI4\n", gs8GetIP[idx]);
467 PRINT_INFO(HOSTINF_DBG, "\n");
c5c77ba1
JK		 468
469 return s32Error;
470}
471
a4ab1ade 472static s32 Handle_SetMacAddress(struct host_if_drv *hif_drv,
b7611a87 473 struct set_mac_addr *pstrHostIfSetMacAddress)
c5c77ba1
JK		 474{
475
e6e12661 476 s32 s32Error = 0;
e9e0c260 477 struct wid strWID;
f3052587 478 u8 *mac_buf = kmalloc(ETH_ALEN, GFP_KERNEL);
78c87591 479
c5c77ba1
JK		 480 if (mac_buf == NULL) {
481 PRINT_ER("No buffer to send mac address\n");
e6e12661 482 return -EFAULT;
c5c77ba1 483 }
d00d2ba3 484 memcpy(mac_buf, pstrHostIfSetMacAddress->u8MacAddress, ETH_ALEN);
c5c77ba1 485
daaf16ba 486 strWID.id = (u16)WID_MAC_ADDR;
416d8321 487 strWID.type = WID_STR;
900bb4a6 488 strWID.val = mac_buf;
2fd3e443 489 strWID.size = ETH_ALEN;
900bb4a6 490 PRINT_D(GENERIC_DBG, "mac addr = :%pM\n", strWID.val);
ae4dfa57 491
03362286 492 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 493 get_id_from_handler(hif_drv));
c5c77ba1
JK		 494 if (s32Error) {
495 PRINT_ER("Failed to set mac address\n");
24db713f 496 s32Error = -EFAULT;
c5c77ba1
JK		 497 }
498
49188af2 499 kfree(mac_buf);
c5c77ba1
JK		 500 return s32Error;
501}
502
a4ab1ade 503static s32 Handle_GetMacAddress(struct host_if_drv *hif_drv,
fcd27c5f 504 struct get_mac_addr *pstrHostIfGetMacAddress)
c5c77ba1
JK		 505{
506
e6e12661 507 s32 s32Error = 0;
e9e0c260 508 struct wid strWID;
c5c77ba1 509
daaf16ba 510 strWID.id = (u16)WID_MAC_ADDR;
416d8321 511 strWID.type = WID_STR;
900bb4a6 512 strWID.val = pstrHostIfGetMacAddress->u8MacAddress;
2fd3e443 513 strWID.size = ETH_ALEN;
c5c77ba1 514
03362286 515 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 516 get_id_from_handler(hif_drv));
c5c77ba1
JK		 517 if (s32Error) {
518 PRINT_ER("Failed to get mac address\n");
24db713f 519 s32Error = -EFAULT;
c5c77ba1 520 }
2d25af87 521 up(&hif_sema_wait_response);
c5c77ba1
JK		 522
523 return s32Error;
524}
525
a4ab1ade 526static s32 Handle_CfgParam(struct host_if_drv *hif_drv,
361ff841 527 struct cfg_param_attr *strHostIFCfgParamAttr)
c5c77ba1 528{
e6e12661 529 s32 s32Error = 0;
e9e0c260 530 struct wid strWIDList[32];
63d03e47 531 u8 u8WidCnt = 0;
c5c77ba1 532
a4ab1ade 533 down(&hif_drv->gtOsCfgValuesSem);
c5c77ba1
JK		 534
535
536 PRINT_D(HOSTINF_DBG, "Setting CFG params\n");
537
87c05b28 538 if (strHostIFCfgParamAttr->cfg_attr_info.flag & BSS_TYPE) {
221371e5 539 if (strHostIFCfgParamAttr->cfg_attr_info.bss_type < 6) {
daaf16ba 540 strWIDList[u8WidCnt].id = WID_BSS_TYPE;
221371e5 541 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.bss_type;
416d8321 542 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 543 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 544 hif_drv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->cfg_attr_info.bss_type;
c5c77ba1 545 } else {
24db713f
LK		 546 PRINT_ER("check value 6 over\n");
547 s32Error = -EINVAL;
548 goto ERRORHANDLER;
c5c77ba1
JK		 549 }
550 u8WidCnt++;
551 }
87c05b28 552 if (strHostIFCfgParamAttr->cfg_attr_info.flag & AUTH_TYPE) {
221371e5 553 if ((strHostIFCfgParamAttr->cfg_attr_info.auth_type) == 1 || (strHostIFCfgParamAttr->cfg_attr_info.auth_type) == 2 || (strHostIFCfgParamAttr->cfg_attr_info.auth_type) == 5) {
daaf16ba 554 strWIDList[u8WidCnt].id = WID_AUTH_TYPE;
221371e5 555 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.auth_type;
416d8321 556 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 557 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 558 hif_drv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->cfg_attr_info.auth_type;
c5c77ba1 559 } else {
24db713f
LK		 560 PRINT_ER("Impossible value \n");
561 s32Error = -EINVAL;
562 goto ERRORHANDLER;
c5c77ba1
JK		 563 }
564 u8WidCnt++;
565 }
87c05b28 566 if (strHostIFCfgParamAttr->cfg_attr_info.flag & AUTHEN_TIMEOUT) {
221371e5 567 if (strHostIFCfgParamAttr->cfg_attr_info.auth_timeout > 0 && strHostIFCfgParamAttr->cfg_attr_info.auth_timeout < 65536) {
daaf16ba 568 strWIDList[u8WidCnt].id = WID_AUTH_TIMEOUT;
221371e5 569 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.auth_timeout;
416d8321 570 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 571 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 572 hif_drv->strCfgValues.auth_timeout = strHostIFCfgParamAttr->cfg_attr_info.auth_timeout;
c5c77ba1 573 } else {
24db713f
LK		 574 PRINT_ER("Range(1 ~ 65535) over\n");
575 s32Error = -EINVAL;
576 goto ERRORHANDLER;
c5c77ba1
JK		 577 }
578 u8WidCnt++;
579 }
87c05b28 580 if (strHostIFCfgParamAttr->cfg_attr_info.flag & POWER_MANAGEMENT) {
221371e5 581 if (strHostIFCfgParamAttr->cfg_attr_info.power_mgmt_mode < 5) {
daaf16ba 582 strWIDList[u8WidCnt].id = WID_POWER_MANAGEMENT;
221371e5 583 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.power_mgmt_mode;
416d8321 584 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 585 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 586 hif_drv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->cfg_attr_info.power_mgmt_mode;
c5c77ba1 587 } else {
24db713f
LK		 588 PRINT_ER("Invalide power mode\n");
589 s32Error = -EINVAL;
590 goto ERRORHANDLER;
c5c77ba1
JK		 591 }
592 u8WidCnt++;
593 }
87c05b28 594 if (strHostIFCfgParamAttr->cfg_attr_info.flag & RETRY_SHORT) {
221371e5 595 if ((strHostIFCfgParamAttr->cfg_attr_info.short_retry_limit > 0) && (strHostIFCfgParamAttr->cfg_attr_info.short_retry_limit < 256)) {
daaf16ba 596 strWIDList[u8WidCnt].id = WID_SHORT_RETRY_LIMIT;
221371e5 597 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.short_retry_limit;
416d8321 598 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 599 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 600 hif_drv->strCfgValues.short_retry_limit = strHostIFCfgParamAttr->cfg_attr_info.short_retry_limit;
c5c77ba1 601 } else {
24db713f
LK		 602 PRINT_ER("Range(1~256) over\n");
603 s32Error = -EINVAL;
604 goto ERRORHANDLER;
c5c77ba1
JK		 605 }
606 u8WidCnt++;
607 }
87c05b28 608 if (strHostIFCfgParamAttr->cfg_attr_info.flag & RETRY_LONG) {
221371e5 609 if ((strHostIFCfgParamAttr->cfg_attr_info.long_retry_limit > 0) && (strHostIFCfgParamAttr->cfg_attr_info.long_retry_limit < 256)) {
daaf16ba 610 strWIDList[u8WidCnt].id = WID_LONG_RETRY_LIMIT;
221371e5 611 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.long_retry_limit;
c5c77ba1 612
416d8321 613 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 614 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 615 hif_drv->strCfgValues.long_retry_limit = strHostIFCfgParamAttr->cfg_attr_info.long_retry_limit;
c5c77ba1 616 } else {
24db713f
LK		 617 PRINT_ER("Range(1~256) over\n");
618 s32Error = -EINVAL;
619 goto ERRORHANDLER;
c5c77ba1
JK		 620 }
621 u8WidCnt++;
622 }
87c05b28 623 if (strHostIFCfgParamAttr->cfg_attr_info.flag & FRAG_THRESHOLD) {
c5c77ba1 624
221371e5 625 if (strHostIFCfgParamAttr->cfg_attr_info.frag_threshold > 255 && strHostIFCfgParamAttr->cfg_attr_info.frag_threshold < 7937) {
daaf16ba 626 strWIDList[u8WidCnt].id = WID_FRAG_THRESHOLD;
221371e5 627 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.frag_threshold;
416d8321 628 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 629 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 630 hif_drv->strCfgValues.frag_threshold = strHostIFCfgParamAttr->cfg_attr_info.frag_threshold;
c5c77ba1 631 } else {
24db713f
LK		 632 PRINT_ER("Threshold Range fail\n");
633 s32Error = -EINVAL;
634 goto ERRORHANDLER;
c5c77ba1
JK		 635 }
636 u8WidCnt++;
637 }
87c05b28 638 if (strHostIFCfgParamAttr->cfg_attr_info.flag & RTS_THRESHOLD) {
221371e5 639 if (strHostIFCfgParamAttr->cfg_attr_info.rts_threshold > 255 && strHostIFCfgParamAttr->cfg_attr_info.rts_threshold < 65536) {
daaf16ba 640 strWIDList[u8WidCnt].id = WID_RTS_THRESHOLD;
221371e5 641 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.rts_threshold;
416d8321 642 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 643 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 644 hif_drv->strCfgValues.rts_threshold = strHostIFCfgParamAttr->cfg_attr_info.rts_threshold;
c5c77ba1 645 } else {
24db713f
LK		 646 PRINT_ER("Threshold Range fail\n");
647 s32Error = -EINVAL;
648 goto ERRORHANDLER;
c5c77ba1
JK		 649 }
650 u8WidCnt++;
651 }
87c05b28 652 if (strHostIFCfgParamAttr->cfg_attr_info.flag & PREAMBLE) {
221371e5 653 if (strHostIFCfgParamAttr->cfg_attr_info.preamble_type < 3) {
daaf16ba 654 strWIDList[u8WidCnt].id = WID_PREAMBLE;
221371e5 655 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.preamble_type;
416d8321 656 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 657 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 658 hif_drv->strCfgValues.preamble_type = strHostIFCfgParamAttr->cfg_attr_info.preamble_type;
c5c77ba1 659 } else {
24db713f
LK		 660 PRINT_ER("Preamle Range(0~2) over\n");
661 s32Error = -EINVAL;
662 goto ERRORHANDLER;
c5c77ba1
JK		 663 }
664 u8WidCnt++;
665 }
87c05b28 666 if (strHostIFCfgParamAttr->cfg_attr_info.flag & SHORT_SLOT_ALLOWED) {
221371e5 667 if (strHostIFCfgParamAttr->cfg_attr_info.short_slot_allowed < 2) {
daaf16ba 668 strWIDList[u8WidCnt].id = WID_SHORT_SLOT_ALLOWED;
221371e5 669 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.short_slot_allowed;
416d8321 670 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 671 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 672 hif_drv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->cfg_attr_info.short_slot_allowed;
c5c77ba1 673 } else {
24db713f
LK		 674 PRINT_ER("Short slot(2) over\n");
675 s32Error = -EINVAL;
676 goto ERRORHANDLER;
c5c77ba1
JK		 677 }
678 u8WidCnt++;
679 }
87c05b28 680 if (strHostIFCfgParamAttr->cfg_attr_info.flag & TXOP_PROT_DISABLE) {
221371e5 681 if (strHostIFCfgParamAttr->cfg_attr_info.txop_prot_disabled < 2) {
daaf16ba 682 strWIDList[u8WidCnt].id = WID_11N_TXOP_PROT_DISABLE;
221371e5 683 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.txop_prot_disabled;
416d8321 684 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 685 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 686 hif_drv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->cfg_attr_info.txop_prot_disabled;
c5c77ba1 687 } else {
24db713f
LK		 688 PRINT_ER("TXOP prot disable\n");
689 s32Error = -EINVAL;
690 goto ERRORHANDLER;
c5c77ba1
JK		 691 }
692 u8WidCnt++;
693 }
87c05b28 694 if (strHostIFCfgParamAttr->cfg_attr_info.flag & BEACON_INTERVAL) {
221371e5 695 if (strHostIFCfgParamAttr->cfg_attr_info.beacon_interval > 0 && strHostIFCfgParamAttr->cfg_attr_info.beacon_interval < 65536) {
daaf16ba 696 strWIDList[u8WidCnt].id = WID_BEACON_INTERVAL;
221371e5 697 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.beacon_interval;
416d8321 698 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 699 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 700 hif_drv->strCfgValues.beacon_interval = strHostIFCfgParamAttr->cfg_attr_info.beacon_interval;
c5c77ba1 701 } else {
24db713f
LK		 702 PRINT_ER("Beacon interval(1~65535) fail\n");
703 s32Error = -EINVAL;
704 goto ERRORHANDLER;
c5c77ba1
JK		 705 }
706 u8WidCnt++;
707 }
87c05b28 708 if (strHostIFCfgParamAttr->cfg_attr_info.flag & DTIM_PERIOD) {
221371e5 709 if (strHostIFCfgParamAttr->cfg_attr_info.dtim_period > 0 && strHostIFCfgParamAttr->cfg_attr_info.dtim_period < 256) {
daaf16ba 710 strWIDList[u8WidCnt].id = WID_DTIM_PERIOD;
221371e5 711 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.dtim_period;
416d8321 712 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 713 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 714 hif_drv->strCfgValues.dtim_period = strHostIFCfgParamAttr->cfg_attr_info.dtim_period;
c5c77ba1 715 } else {
24db713f
LK		 716 PRINT_ER("DTIM range(1~255) fail\n");
717 s32Error = -EINVAL;
718 goto ERRORHANDLER;
c5c77ba1
JK		 719 }
720 u8WidCnt++;
721 }
87c05b28 722 if (strHostIFCfgParamAttr->cfg_attr_info.flag & SITE_SURVEY) {
221371e5 723 if (strHostIFCfgParamAttr->cfg_attr_info.site_survey_enabled < 3) {
daaf16ba 724 strWIDList[u8WidCnt].id = WID_SITE_SURVEY;
221371e5 725 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.site_survey_enabled;
416d8321 726 strWIDList[u8WidCnt].type = WID_CHAR;
2fd3e443 727 strWIDList[u8WidCnt].size = sizeof(char);
221371e5 728 hif_drv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->cfg_attr_info.site_survey_enabled;
c5c77ba1 729 } else {
24db713f
LK		 730 PRINT_ER("Site survey disable\n");
731 s32Error = -EINVAL;
732 goto ERRORHANDLER;
c5c77ba1
JK		 733 }
734 u8WidCnt++;
735 }
87c05b28 736 if (strHostIFCfgParamAttr->cfg_attr_info.flag & SITE_SURVEY_SCAN_TIME) {
221371e5 737 if (strHostIFCfgParamAttr->cfg_attr_info.site_survey_scan_time > 0 && strHostIFCfgParamAttr->cfg_attr_info.site_survey_scan_time < 65536) {
daaf16ba 738 strWIDList[u8WidCnt].id = WID_SITE_SURVEY_SCAN_TIME;
221371e5 739 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.site_survey_scan_time;
416d8321 740 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 741 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 742 hif_drv->strCfgValues.site_survey_scan_time = strHostIFCfgParamAttr->cfg_attr_info.site_survey_scan_time;
c5c77ba1 743 } else {
24db713f
LK		 744 PRINT_ER("Site survey scan time(1~65535) over\n");
745 s32Error = -EINVAL;
746 goto ERRORHANDLER;
c5c77ba1
JK		 747 }
748 u8WidCnt++;
749 }
87c05b28 750 if (strHostIFCfgParamAttr->cfg_attr_info.flag & ACTIVE_SCANTIME) {
221371e5 751 if (strHostIFCfgParamAttr->cfg_attr_info.active_scan_time > 0 && strHostIFCfgParamAttr->cfg_attr_info.active_scan_time < 65536) {
daaf16ba 752 strWIDList[u8WidCnt].id = WID_ACTIVE_SCAN_TIME;
221371e5 753 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.active_scan_time;
416d8321 754 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 755 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 756 hif_drv->strCfgValues.active_scan_time = strHostIFCfgParamAttr->cfg_attr_info.active_scan_time;
c5c77ba1 757 } else {
24db713f
LK		 758 PRINT_ER("Active scan time(1~65535) over\n");
759 s32Error = -EINVAL;
760 goto ERRORHANDLER;
c5c77ba1
JK		 761 }
762 u8WidCnt++;
763 }
87c05b28 764 if (strHostIFCfgParamAttr->cfg_attr_info.flag & PASSIVE_SCANTIME) {
221371e5 765 if (strHostIFCfgParamAttr->cfg_attr_info.passive_scan_time > 0 && strHostIFCfgParamAttr->cfg_attr_info.passive_scan_time < 65536) {
daaf16ba 766 strWIDList[u8WidCnt].id = WID_PASSIVE_SCAN_TIME;
221371e5 767 strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.passive_scan_time;
416d8321 768 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 769 strWIDList[u8WidCnt].size = sizeof(u16);
221371e5 770 hif_drv->strCfgValues.passive_scan_time = strHostIFCfgParamAttr->cfg_attr_info.passive_scan_time;
c5c77ba1 771 } else {
24db713f
LK		 772 PRINT_ER("Passive scan time(1~65535) over\n");
773 s32Error = -EINVAL;
774 goto ERRORHANDLER;
c5c77ba1
JK		 775 }
776 u8WidCnt++;
777 }
87c05b28 778 if (strHostIFCfgParamAttr->cfg_attr_info.flag & CURRENT_TX_RATE) {
221371e5 779 enum CURRENT_TXRATE curr_tx_rate = strHostIFCfgParamAttr->cfg_attr_info.curr_tx_rate;
c5c77ba1
JK		 780 if (curr_tx_rate == AUTORATE || curr_tx_rate == MBPS_1
781 || curr_tx_rate == MBPS_2 || curr_tx_rate == MBPS_5_5
782 || curr_tx_rate == MBPS_11 || curr_tx_rate == MBPS_6
783 || curr_tx_rate == MBPS_9 || curr_tx_rate == MBPS_12
784 || curr_tx_rate == MBPS_18 || curr_tx_rate == MBPS_24
785 || curr_tx_rate == MBPS_36 || curr_tx_rate == MBPS_48 || curr_tx_rate == MBPS_54) {
daaf16ba 786 strWIDList[u8WidCnt].id = WID_CURRENT_TX_RATE;
900bb4a6 787 strWIDList[u8WidCnt].val = (s8 *)&curr_tx_rate;
416d8321 788 strWIDList[u8WidCnt].type = WID_SHORT;
2fd3e443 789 strWIDList[u8WidCnt].size = sizeof(u16);
a4ab1ade 790 hif_drv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate;
c5c77ba1 791 } else {
24db713f
LK		 792 PRINT_ER("out of TX rate\n");
793 s32Error = -EINVAL;
794 goto ERRORHANDLER;
c5c77ba1
JK		 795 }
796 u8WidCnt++;
797 }
03362286 798 s32Error = send_config_pkt(SET_CFG, strWIDList, u8WidCnt,
a4ab1ade 799 get_id_from_handler(hif_drv));
c5c77ba1 800
2b9d5b48 801 if (s32Error)
c5c77ba1
JK		 802 PRINT_ER("Error in setting CFG params\n");
803
24db713f 804ERRORHANDLER:
a4ab1ade 805 up(&hif_drv->gtOsCfgValuesSem);
c5c77ba1
JK		 806 return s32Error;
807}
808
fb4ec9ca 809static s32 Handle_wait_msg_q_empty(void)
c5c77ba1 810{
c5c77ba1 811 g_wilc_initialized = 0;
2d25af87 812 up(&hif_sema_wait_response);
b68d820b 813 return 0;
c5c77ba1
JK		 814}
815
a4ab1ade 816static s32 Handle_Scan(struct host_if_drv *hif_drv,
c476feb8 817 struct scan_attr *pstrHostIFscanAttr)
c5c77ba1 818{
e6e12661 819 s32 s32Error = 0;
e9e0c260 820 struct wid strWIDList[5];
4e4467fd
CL		 821 u32 u32WidsCount = 0;
822 u32 i;
63d03e47
GKH		 823 u8 *pu8Buffer;
824 u8 valuesize = 0;
825 u8 *pu8HdnNtwrksWidVal = NULL;
c5c77ba1
JK		 826
827 PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
a4ab1ade 828 PRINT_D(HOSTINF_DBG, "Scanning: In [%d] state\n", hif_drv->enuHostIFstate);
c5c77ba1 829
c17c6da6 830 hif_drv->strWILC_UsrScanReq.pfUserScanResult = pstrHostIFscanAttr->result;
5f2b50c8 831 hif_drv->strWILC_UsrScanReq.u32UserScanPvoid = pstrHostIFscanAttr->arg;
c5c77ba1 832
a4ab1ade 833 if ((hif_drv->enuHostIFstate >= HOST_IF_SCANNING) && (hif_drv->enuHostIFstate < HOST_IF_CONNECTED)) {
a4ab1ade 834 PRINT_D(GENERIC_DBG, "Don't scan we are already in [%d] state\n", hif_drv->enuHostIFstate);
24db713f
LK		 835 PRINT_ER("Already scan\n");
836 s32Error = -EBUSY;
837 goto ERRORHANDLER;
c5c77ba1
JK		 838 }
839
c5c77ba1
JK		 840 if (g_obtainingIP || connecting) {
841 PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
24db713f
LK		 842 PRINT_ER("Don't do obss scan\n");
843 s32Error = -EBUSY;
844 goto ERRORHANDLER;
c5c77ba1 845 }
c5c77ba1
JK		 846
847 PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
848
849
a4ab1ade 850 hif_drv->strWILC_UsrScanReq.u32RcvdChCount = 0;
c5c77ba1 851
daaf16ba 852 strWIDList[u32WidsCount].id = (u16)WID_SSID_PROBE_REQ;
416d8321 853 strWIDList[u32WidsCount].type = WID_STR;
c5c77ba1 854
629b9ca0
LK		 855 for (i = 0; i < pstrHostIFscanAttr->hidden_network.u8ssidnum; i++)
856 valuesize += ((pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen) + 1);
f3052587 857 pu8HdnNtwrksWidVal = kmalloc(valuesize + 1, GFP_KERNEL);
900bb4a6
LK		 858 strWIDList[u32WidsCount].val = pu8HdnNtwrksWidVal;
859 if (strWIDList[u32WidsCount].val != NULL) {
860 pu8Buffer = strWIDList[u32WidsCount].val;
c5c77ba1 861
629b9ca0 862 *pu8Buffer++ = pstrHostIFscanAttr->hidden_network.u8ssidnum;
c5c77ba1 863
629b9ca0 864 PRINT_D(HOSTINF_DBG, "In Handle_ProbeRequest number of ssid %d\n", pstrHostIFscanAttr->hidden_network.u8ssidnum);
c5c77ba1 865
629b9ca0
LK		 866 for (i = 0; i < pstrHostIFscanAttr->hidden_network.u8ssidnum; i++) {
867 *pu8Buffer++ = pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen;
868 memcpy(pu8Buffer, pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].pu8ssid, pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen);
869 pu8Buffer += pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen;
c5c77ba1
JK		 870 }
871
872
873
2fd3e443 874 strWIDList[u32WidsCount].size = (s32)(valuesize + 1);
c5c77ba1
JK		 875 u32WidsCount++;
876 }
877
c5c77ba1 878 {
daaf16ba 879 strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_PROBE;
416d8321 880 strWIDList[u32WidsCount].type = WID_BIN_DATA;
d6f19aa5 881 strWIDList[u32WidsCount].val = pstrHostIFscanAttr->ies;
7b1f76cd 882 strWIDList[u32WidsCount].size = pstrHostIFscanAttr->ies_len;
c5c77ba1
JK		 883 u32WidsCount++;
884 }
885
daaf16ba 886 strWIDList[u32WidsCount].id = WID_SCAN_TYPE;
416d8321 887 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 888 strWIDList[u32WidsCount].size = sizeof(char);
1e276c88 889 strWIDList[u32WidsCount].val = (s8 *)(&(pstrHostIFscanAttr->type));
c5c77ba1
JK		 890 u32WidsCount++;
891
daaf16ba 892 strWIDList[u32WidsCount].id = WID_SCAN_CHANNEL_LIST;
416d8321 893 strWIDList[u32WidsCount].type = WID_BIN_DATA;
c5c77ba1 894
f97bd9ca 895 if (pstrHostIFscanAttr->ch_freq_list != NULL && pstrHostIFscanAttr->ch_list_len > 0) {
c5c77ba1
JK		 896 int i;
897
f97bd9ca 898 for (i = 0; i < pstrHostIFscanAttr->ch_list_len; i++) {
82eeb0ad
LK		 899 if (pstrHostIFscanAttr->ch_freq_list[i] > 0)
900 pstrHostIFscanAttr->ch_freq_list[i] = pstrHostIFscanAttr->ch_freq_list[i] - 1;
c5c77ba1
JK		 901 }
902 }
903
82eeb0ad 904 strWIDList[u32WidsCount].val = pstrHostIFscanAttr->ch_freq_list;
f97bd9ca 905 strWIDList[u32WidsCount].size = pstrHostIFscanAttr->ch_list_len;
c5c77ba1
JK		 906 u32WidsCount++;
907
daaf16ba 908 strWIDList[u32WidsCount].id = WID_START_SCAN_REQ;
416d8321 909 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 910 strWIDList[u32WidsCount].size = sizeof(char);
42568898 911 strWIDList[u32WidsCount].val = (s8 *)(&(pstrHostIFscanAttr->src));
c5c77ba1
JK		 912 u32WidsCount++;
913
a4ab1ade 914 if (hif_drv->enuHostIFstate == HOST_IF_CONNECTED)
72ed4dc7 915 gbScanWhileConnected = true;
a4ab1ade 916 else if (hif_drv->enuHostIFstate == HOST_IF_IDLE)
72ed4dc7 917 gbScanWhileConnected = false;
c5c77ba1 918
03362286 919 s32Error = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
a4ab1ade 920 get_id_from_handler(hif_drv));
c5c77ba1 921
24db713f 922 if (s32Error)
c5c77ba1 923 PRINT_ER("Failed to send scan paramters config packet\n");
24db713f 924 else
c5c77ba1 925 PRINT_D(HOSTINF_DBG, "Successfully sent SCAN params config packet\n");
c5c77ba1 926
24db713f
LK		 927ERRORHANDLER:
928 if (s32Error) {
a4ab1ade 929 del_timer(&hif_drv->hScanTimer);
a4ab1ade 930 Handle_ScanDone(hif_drv, SCAN_EVENT_ABORTED);
c5c77ba1
JK		 931 }
932
95f840fb
SB		 933 kfree(pstrHostIFscanAttr->ch_freq_list);
934 pstrHostIFscanAttr->ch_freq_list = NULL;
c5c77ba1 935
95f840fb
SB		 936 kfree(pstrHostIFscanAttr->ies);
937 pstrHostIFscanAttr->ies = NULL;
938 kfree(pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo);
939 pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo = NULL;
c5c77ba1 940
95f840fb 941 kfree(pu8HdnNtwrksWidVal);
c5c77ba1
JK		 942
943 return s32Error;
944}
945
a4ab1ade
TC		 946static s32 Handle_ScanDone(struct host_if_drv *hif_drv,
947 enum scan_event enuEvent)
c5c77ba1 948{
e6e12661 949 s32 s32Error = 0;
63d03e47 950 u8 u8abort_running_scan;
e9e0c260 951 struct wid strWID;
c5c77ba1
JK		 952
953
954 PRINT_D(HOSTINF_DBG, "in Handle_ScanDone()\n");
955
c5c77ba1
JK		 956 if (enuEvent == SCAN_EVENT_ABORTED) {
957 PRINT_D(GENERIC_DBG, "Abort running scan\n");
958 u8abort_running_scan = 1;
daaf16ba 959 strWID.id = (u16)WID_ABORT_RUNNING_SCAN;
416d8321 960 strWID.type = WID_CHAR;
900bb4a6 961 strWID.val = (s8 *)&u8abort_running_scan;
2fd3e443 962 strWID.size = sizeof(char);
c5c77ba1 963
03362286 964 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 965 get_id_from_handler(hif_drv));
24db713f 966 if (s32Error) {
c5c77ba1 967 PRINT_ER("Failed to set abort running scan\n");
24db713f 968 s32Error = -EFAULT;
c5c77ba1
JK		 969 }
970 }
971
a4ab1ade 972 if (!hif_drv) {
c5c77ba1
JK		 973 PRINT_ER("Driver handler is NULL\n");
974 return s32Error;
975 }
976
a4ab1ade
TC		 977 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
978 hif_drv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, NULL,
979 hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
a4ab1ade 980 hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
c5c77ba1
JK		 981 }
982
983 return s32Error;
984}
985
63d03e47 986u8 u8ConnectedSSID[6] = {0};
a4ab1ade 987static s32 Handle_Connect(struct host_if_drv *hif_drv,
120ae593 988 struct connect_attr *pstrHostIFconnectAttr)
c5c77ba1 989{
e6e12661 990 s32 s32Error = 0;
e9e0c260 991 struct wid strWIDList[8];
4e4467fd 992 u32 u32WidsCount = 0, dummyval = 0;
63d03e47 993 u8 *pu8CurrByte = NULL;
e0a12217 994 struct join_bss_param *ptstrJoinBssParam;
c5c77ba1
JK		 995
996 PRINT_D(GENERIC_DBG, "Handling connect request\n");
997
9254db07 998 if (memcmp(pstrHostIFconnectAttr->bssid, u8ConnectedSSID, ETH_ALEN) == 0) {
c5c77ba1 999
e6e12661 1000 s32Error = 0;
c5c77ba1
JK		 1001 PRINT_ER("Trying to connect to an already connected AP, Discard connect request\n");
1002 return s32Error;
1003 }
1004
1005 PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n");
1006
f2bed2ca 1007 ptstrJoinBssParam = (struct join_bss_param *)pstrHostIFconnectAttr->params;
c5c77ba1
JK		 1008 if (ptstrJoinBssParam == NULL) {
1009 PRINT_ER("Required BSSID not found\n");
24db713f
LK		 1010 s32Error = -ENOENT;
1011 goto ERRORHANDLER;
c5c77ba1 1012 }
c5c77ba1 1013
9254db07 1014 if (pstrHostIFconnectAttr->bssid != NULL) {
a4ab1ade 1015 hif_drv->strWILC_UsrConnReq.pu8bssid = kmalloc(6, GFP_KERNEL);
9254db07 1016 memcpy(hif_drv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->bssid, 6);
c5c77ba1
JK		 1017 }
1018
8b3c9fa6 1019 hif_drv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssid_len;
f7bbd9cf 1020 if (pstrHostIFconnectAttr->ssid != NULL) {
8b3c9fa6 1021 hif_drv->strWILC_UsrConnReq.pu8ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL);
f7bbd9cf 1022 memcpy(hif_drv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->ssid,
8b3c9fa6
LK		 1023 pstrHostIFconnectAttr->ssid_len);
1024 hif_drv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssid_len] = '\0';
c5c77ba1
JK		 1025 }
1026
b59d5c5b 1027 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->ies_len;
2ea158c4 1028 if (pstrHostIFconnectAttr->ies != NULL) {
b59d5c5b 1029 hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
2ea158c4 1030 memcpy(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->ies,
b59d5c5b 1031 pstrHostIFconnectAttr->ies_len);
c5c77ba1
JK		 1032 }
1033
a64fd677 1034 hif_drv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->security;
61b4fd02 1035 hif_drv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->auth_type;
6abcc11d 1036 hif_drv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->result;
8f38db89 1037 hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->arg;
c5c77ba1 1038
daaf16ba 1039 strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
416d8321 1040 strWIDList[u32WidsCount].type = WID_INT;
2fd3e443 1041 strWIDList[u32WidsCount].size = sizeof(u32);
900bb4a6 1042 strWIDList[u32WidsCount].val = (s8 *)(&(dummyval));
c5c77ba1
JK		 1043 u32WidsCount++;
1044
daaf16ba 1045 strWIDList[u32WidsCount].id = WID_RECEIVED_FRAGMENT_COUNT;
416d8321 1046 strWIDList[u32WidsCount].type = WID_INT;
2fd3e443 1047 strWIDList[u32WidsCount].size = sizeof(u32);
900bb4a6 1048 strWIDList[u32WidsCount].val = (s8 *)(&(dummyval));
c5c77ba1
JK		 1049 u32WidsCount++;
1050
daaf16ba 1051 strWIDList[u32WidsCount].id = WID_FAILED_COUNT;
416d8321 1052 strWIDList[u32WidsCount].type = WID_INT;
2fd3e443 1053 strWIDList[u32WidsCount].size = sizeof(u32);
900bb4a6 1054 strWIDList[u32WidsCount].val = (s8 *)(&(dummyval));
c5c77ba1
JK		 1055 u32WidsCount++;
1056
c5c77ba1 1057 {
daaf16ba 1058 strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE;
416d8321 1059 strWIDList[u32WidsCount].type = WID_BIN_DATA;
a4ab1ade
TC		 1060 strWIDList[u32WidsCount].val = hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs;
1061 strWIDList[u32WidsCount].size = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
c5c77ba1
JK		 1062 u32WidsCount++;
1063
f7bbd9cf 1064 if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
c5c77ba1 1065
a4ab1ade 1066 gu32FlushedInfoElemAsocSize = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
f3052587 1067 gu8FlushedInfoElemAsoc = kmalloc(gu32FlushedInfoElemAsocSize, GFP_KERNEL);
a4ab1ade 1068 memcpy(gu8FlushedInfoElemAsoc, hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
c5c77ba1
JK		 1069 gu32FlushedInfoElemAsocSize);
1070 }
1071 }
daaf16ba 1072 strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
416d8321 1073 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 1074 strWIDList[u32WidsCount].size = sizeof(char);
a4ab1ade 1075 strWIDList[u32WidsCount].val = (s8 *)(&(hif_drv->strWILC_UsrConnReq.u8security));
c5c77ba1
JK		 1076 u32WidsCount++;
1077
f7bbd9cf 1078 if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
a4ab1ade 1079 gu8Flushed11iMode = hif_drv->strWILC_UsrConnReq.u8security;
c5c77ba1 1080
a4ab1ade 1081 PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->strWILC_UsrConnReq.u8security);
c5c77ba1
JK		 1082
1083
daaf16ba 1084 strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
416d8321 1085 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 1086 strWIDList[u32WidsCount].size = sizeof(char);
a4ab1ade 1087 strWIDList[u32WidsCount].val = (s8 *)(&hif_drv->strWILC_UsrConnReq.tenuAuth_type);
c5c77ba1
JK		 1088 u32WidsCount++;
1089
f7bbd9cf 1090 if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
a4ab1ade 1091 gu8FlushedAuthType = (u8)hif_drv->strWILC_UsrConnReq.tenuAuth_type;
c5c77ba1 1092
a4ab1ade 1093 PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", hif_drv->strWILC_UsrConnReq.tenuAuth_type);
c5c77ba1 1094 PRINT_D(HOSTINF_DBG, "Connecting to network of SSID %s on channel %d\n",
0d1527e6 1095 hif_drv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->ch);
c5c77ba1 1096
daaf16ba 1097 strWIDList[u32WidsCount].id = (u16)WID_JOIN_REQ_EXTENDED;
416d8321 1098 strWIDList[u32WidsCount].type = WID_STR;
ae4dfa57 1099 strWIDList[u32WidsCount].size = 112;
900bb4a6 1100 strWIDList[u32WidsCount].val = kmalloc(strWIDList[u32WidsCount].size, GFP_KERNEL);
c5c77ba1 1101
f7bbd9cf 1102 if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
2fd3e443 1103 gu32FlushedJoinReqSize = strWIDList[u32WidsCount].size;
f3052587 1104 gu8FlushedJoinReq = kmalloc(gu32FlushedJoinReqSize, GFP_KERNEL);
c5c77ba1 1105 }
900bb4a6 1106 if (strWIDList[u32WidsCount].val == NULL) {
24db713f
LK		 1107 s32Error = -EFAULT;
1108 goto ERRORHANDLER;
1109 }
c5c77ba1 1110
900bb4a6 1111 pu8CurrByte = strWIDList[u32WidsCount].val;
c5c77ba1
JK		 1112
1113
f7bbd9cf 1114 if (pstrHostIFconnectAttr->ssid != NULL) {
8b3c9fa6
LK		 1115 memcpy(pu8CurrByte, pstrHostIFconnectAttr->ssid, pstrHostIFconnectAttr->ssid_len);
1116 pu8CurrByte[pstrHostIFconnectAttr->ssid_len] = '\0';
c5c77ba1
JK		 1117 }
1118 pu8CurrByte += MAX_SSID_LEN;
c5c77ba1 1119 *(pu8CurrByte++) = INFRASTRUCTURE;
ae4dfa57 1120
0d1527e6
LK		 1121 if ((pstrHostIFconnectAttr->ch >= 1) && (pstrHostIFconnectAttr->ch <= 14)) {
1122 *(pu8CurrByte++) = pstrHostIFconnectAttr->ch;
c5c77ba1
JK		 1123 } else {
1124 PRINT_ER("Channel out of range\n");
1125 *(pu8CurrByte++) = 0xFF;
1126 }
c5c77ba1
JK		 1127 *(pu8CurrByte++) = (ptstrJoinBssParam->cap_info) & 0xFF;
1128 *(pu8CurrByte++) = ((ptstrJoinBssParam->cap_info) >> 8) & 0xFF;
1129 PRINT_D(HOSTINF_DBG, "* Cap Info %0x*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8)));
1130
9254db07
LK		 1131 if (pstrHostIFconnectAttr->bssid != NULL)
1132 memcpy(pu8CurrByte, pstrHostIFconnectAttr->bssid, 6);
c5c77ba1
JK		 1133 pu8CurrByte += 6;
1134
c5c77ba1
JK		 1135 *(pu8CurrByte++) = (ptstrJoinBssParam->beacon_period) & 0xFF;
1136 *(pu8CurrByte++) = ((ptstrJoinBssParam->beacon_period) >> 8) & 0xFF;
1137 PRINT_D(HOSTINF_DBG, "* Beacon Period %d*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8)));
c5c77ba1
JK		 1138 *(pu8CurrByte++) = ptstrJoinBssParam->dtim_period;
1139 PRINT_D(HOSTINF_DBG, "* DTIM Period %d*\n", (*(pu8CurrByte - 1)));
ae4dfa57 1140
d00d2ba3 1141 memcpy(pu8CurrByte, ptstrJoinBssParam->supp_rates, MAX_RATES_SUPPORTED + 1);
c5c77ba1
JK		 1142 pu8CurrByte += (MAX_RATES_SUPPORTED + 1);
1143
c5c77ba1
JK		 1144 *(pu8CurrByte++) = ptstrJoinBssParam->wmm_cap;
1145 PRINT_D(HOSTINF_DBG, "* wmm cap%d*\n", (*(pu8CurrByte - 1)));
c5c77ba1
JK		 1146 *(pu8CurrByte++) = ptstrJoinBssParam->uapsd_cap;
1147
c5c77ba1 1148 *(pu8CurrByte++) = ptstrJoinBssParam->ht_capable;
a4ab1ade 1149 hif_drv->strWILC_UsrConnReq.IsHTCapable = ptstrJoinBssParam->ht_capable;
c5c77ba1 1150
c5c77ba1
JK		 1151 *(pu8CurrByte++) = ptstrJoinBssParam->rsn_found;
1152 PRINT_D(HOSTINF_DBG, "* rsn found %d*\n", *(pu8CurrByte - 1));
c5c77ba1
JK		 1153 *(pu8CurrByte++) = ptstrJoinBssParam->rsn_grp_policy;
1154 PRINT_D(HOSTINF_DBG, "* rsn group policy %0x*\n", (*(pu8CurrByte - 1)));
c5c77ba1
JK		 1155 *(pu8CurrByte++) = ptstrJoinBssParam->mode_802_11i;
1156 PRINT_D(HOSTINF_DBG, "* mode_802_11i %d*\n", (*(pu8CurrByte - 1)));
ae4dfa57 1157
d00d2ba3 1158 memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_pcip_policy, sizeof(ptstrJoinBssParam->rsn_pcip_policy));
c5c77ba1
JK		 1159 pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_pcip_policy);
1160
d00d2ba3 1161 memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_auth_policy, sizeof(ptstrJoinBssParam->rsn_auth_policy));
c5c77ba1
JK		 1162 pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_auth_policy);
1163
d00d2ba3 1164 memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_cap, sizeof(ptstrJoinBssParam->rsn_cap));
c5c77ba1
JK		 1165 pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_cap);
1166
c5c77ba1 1167 *(pu8CurrByte++) = REAL_JOIN_REQ;
7a8d51d7 1168 *(pu8CurrByte++) = ptstrJoinBssParam->noa_enabled;
c5c77ba1 1169
7a8d51d7 1170 if (ptstrJoinBssParam->noa_enabled) {
c5c77ba1
JK		 1171 PRINT_D(HOSTINF_DBG, "NOA present\n");
1172
1173 *(pu8CurrByte++) = (ptstrJoinBssParam->tsf) & 0xFF;
1174 *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 8) & 0xFF;
1175 *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 16) & 0xFF;
1176 *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 24) & 0xFF;
1177
d72b33ca 1178 *(pu8CurrByte++) = ptstrJoinBssParam->opp_enabled;
cc179008 1179 *(pu8CurrByte++) = ptstrJoinBssParam->idx;
c5c77ba1 1180
d72b33ca 1181 if (ptstrJoinBssParam->opp_enabled)
99b66945 1182 *(pu8CurrByte++) = ptstrJoinBssParam->ct_window;
c5c77ba1 1183
c21047ed 1184 *(pu8CurrByte++) = ptstrJoinBssParam->cnt;
c5c77ba1 1185
109e6cab
LK		 1186 memcpy(pu8CurrByte, ptstrJoinBssParam->duration, sizeof(ptstrJoinBssParam->duration));
1187 pu8CurrByte += sizeof(ptstrJoinBssParam->duration);
c5c77ba1 1188
1d8b76b3
LK		 1189 memcpy(pu8CurrByte, ptstrJoinBssParam->interval, sizeof(ptstrJoinBssParam->interval));
1190 pu8CurrByte += sizeof(ptstrJoinBssParam->interval);
c5c77ba1 1191
d00d2ba3 1192 memcpy(pu8CurrByte, ptstrJoinBssParam->au8StartTime, sizeof(ptstrJoinBssParam->au8StartTime));
c5c77ba1
JK		 1193
1194 pu8CurrByte += sizeof(ptstrJoinBssParam->au8StartTime);
1195
1196 } else
1197 PRINT_D(HOSTINF_DBG, "NOA not present\n");
c5c77ba1 1198
900bb4a6 1199 pu8CurrByte = strWIDList[u32WidsCount].val;
c5c77ba1 1200 u32WidsCount++;
c5c77ba1 1201 gu32WidConnRstHack = 0;
c5c77ba1 1202
f7bbd9cf 1203 if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
c5c77ba1 1204 memcpy(gu8FlushedJoinReq, pu8CurrByte, gu32FlushedJoinReqSize);
a4ab1ade 1205 gu8FlushedJoinReqDrvHandler = hif_drv;
c5c77ba1
JK		 1206 }
1207
1208 PRINT_D(GENERIC_DBG, "send HOST_IF_WAITING_CONN_RESP\n");
1209
9254db07
LK		 1210 if (pstrHostIFconnectAttr->bssid != NULL) {
1211 memcpy(u8ConnectedSSID, pstrHostIFconnectAttr->bssid, ETH_ALEN);
c5c77ba1 1212
9254db07 1213 PRINT_D(GENERIC_DBG, "save Bssid = %pM\n", pstrHostIFconnectAttr->bssid);
310a28fd 1214 PRINT_D(GENERIC_DBG, "save bssid = %pM\n", u8ConnectedSSID);
c5c77ba1
JK		 1215 }
1216
03362286 1217 s32Error = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
a4ab1ade 1218 get_id_from_handler(hif_drv));
c5c77ba1 1219 if (s32Error) {
24db713f
LK		 1220 PRINT_ER("failed to send config packet\n");
1221 s32Error = -EFAULT;
1222 goto ERRORHANDLER;
c5c77ba1
JK		 1223 } else {
1224 PRINT_D(GENERIC_DBG, "set HOST_IF_WAITING_CONN_RESP\n");
a4ab1ade 1225 hif_drv->enuHostIFstate = HOST_IF_WAITING_CONN_RESP;
c5c77ba1 1226 }
c5c77ba1 1227
24db713f
LK		 1228ERRORHANDLER:
1229 if (s32Error) {
c5c77ba1
JK		 1230 tstrConnectInfo strConnectInfo;
1231
a4ab1ade 1232 del_timer(&hif_drv->hConnectTimer);
c5c77ba1
JK		 1233
1234 PRINT_D(HOSTINF_DBG, "could not start connecting to the required network\n");
1235
2cc46837 1236 memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
c5c77ba1 1237
6abcc11d 1238 if (pstrHostIFconnectAttr->result != NULL) {
9254db07
LK		 1239 if (pstrHostIFconnectAttr->bssid != NULL)
1240 memcpy(strConnectInfo.au8bssid, pstrHostIFconnectAttr->bssid, 6);
c5c77ba1 1241
2ea158c4 1242 if (pstrHostIFconnectAttr->ies != NULL) {
b59d5c5b
LK		 1243 strConnectInfo.ReqIEsLen = pstrHostIFconnectAttr->ies_len;
1244 strConnectInfo.pu8ReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
d00d2ba3 1245 memcpy(strConnectInfo.pu8ReqIEs,
2ea158c4 1246 pstrHostIFconnectAttr->ies,
b59d5c5b 1247 pstrHostIFconnectAttr->ies_len);
c5c77ba1
JK		 1248 }
1249
6abcc11d 1250 pstrHostIFconnectAttr->result(CONN_DISCONN_EVENT_CONN_RESP,
c5c77ba1
JK		 1251 &strConnectInfo,
1252 MAC_DISCONNECTED,
1253 NULL,
8f38db89 1254 pstrHostIFconnectAttr->arg);
a4ab1ade 1255 hif_drv->enuHostIFstate = HOST_IF_IDLE;
95f840fb
SB		 1256 kfree(strConnectInfo.pu8ReqIEs);
1257 strConnectInfo.pu8ReqIEs = NULL;
c5c77ba1
JK		 1258
1259 } else {
03b2d5e7 1260 PRINT_ER("Connect callback function pointer is NULL\n");
c5c77ba1
JK		 1261 }
1262 }
1263
1264 PRINT_D(HOSTINF_DBG, "Deallocating connection parameters\n");
95f840fb
SB		 1265 kfree(pstrHostIFconnectAttr->bssid);
1266 pstrHostIFconnectAttr->bssid = NULL;
c5c77ba1 1267
95f840fb
SB		 1268 kfree(pstrHostIFconnectAttr->ssid);
1269 pstrHostIFconnectAttr->ssid = NULL;
c5c77ba1 1270
95f840fb
SB		 1271 kfree(pstrHostIFconnectAttr->ies);
1272 pstrHostIFconnectAttr->ies = NULL;
c5c77ba1 1273
95f840fb 1274 kfree(pu8CurrByte);
c5c77ba1
JK		 1275 return s32Error;
1276}
1277
a4ab1ade 1278static s32 Handle_FlushConnect(struct host_if_drv *hif_drv)
c5c77ba1 1279{
e6e12661 1280 s32 s32Error = 0;
e9e0c260 1281 struct wid strWIDList[5];
4e4467fd 1282 u32 u32WidsCount = 0;
63d03e47 1283 u8 *pu8CurrByte = NULL;
c5c77ba1 1284
daaf16ba 1285 strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE;
416d8321 1286 strWIDList[u32WidsCount].type = WID_BIN_DATA;
900bb4a6 1287 strWIDList[u32WidsCount].val = gu8FlushedInfoElemAsoc;
2fd3e443 1288 strWIDList[u32WidsCount].size = gu32FlushedInfoElemAsocSize;
c5c77ba1
JK		 1289 u32WidsCount++;
1290
daaf16ba 1291 strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
416d8321 1292 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 1293 strWIDList[u32WidsCount].size = sizeof(char);
900bb4a6 1294 strWIDList[u32WidsCount].val = (s8 *)(&(gu8Flushed11iMode));
c5c77ba1
JK		 1295 u32WidsCount++;
1296
1297
1298
daaf16ba 1299 strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
416d8321 1300 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 1301 strWIDList[u32WidsCount].size = sizeof(char);
900bb4a6 1302 strWIDList[u32WidsCount].val = (s8 *)(&gu8FlushedAuthType);
c5c77ba1
JK		 1303 u32WidsCount++;
1304
daaf16ba 1305 strWIDList[u32WidsCount].id = (u16)WID_JOIN_REQ_EXTENDED;
416d8321 1306 strWIDList[u32WidsCount].type = WID_STR;
2fd3e443 1307 strWIDList[u32WidsCount].size = gu32FlushedJoinReqSize;
900bb4a6
LK		 1308 strWIDList[u32WidsCount].val = (s8 *)gu8FlushedJoinReq;
1309 pu8CurrByte = strWIDList[u32WidsCount].val;
c5c77ba1
JK		 1310
1311 pu8CurrByte += FLUSHED_BYTE_POS;
1312 *(pu8CurrByte) = FLUSHED_JOIN_REQ;
1313
1314 u32WidsCount++;
1315
03362286 1316 s32Error = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
cf32c3c4 1317 get_id_from_handler(gu8FlushedJoinReqDrvHandler));
c5c77ba1 1318 if (s32Error) {
24db713f
LK		 1319 PRINT_ER("failed to send config packet\n");
1320 s32Error = -EINVAL;
c5c77ba1
JK		 1321 }
1322
1323 return s32Error;
1324}
1325
a4ab1ade 1326static s32 Handle_ConnectTimeout(struct host_if_drv *hif_drv)
c5c77ba1 1327{
e6e12661 1328 s32 s32Error = 0;
c5c77ba1 1329 tstrConnectInfo strConnectInfo;
e9e0c260 1330 struct wid strWID;
d85f5326 1331 u16 u16DummyReasonCode = 0;
c5c77ba1 1332
a4ab1ade 1333 if (!hif_drv) {
c5c77ba1
JK		 1334 PRINT_ER("Driver handler is NULL\n");
1335 return s32Error;
1336 }
1337
a4ab1ade 1338 hif_drv->enuHostIFstate = HOST_IF_IDLE;
c5c77ba1 1339
72ed4dc7 1340 gbScanWhileConnected = false;
c5c77ba1
JK		 1341
1342
2cc46837 1343 memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
c5c77ba1 1344
a4ab1ade
TC		 1345 if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
1346 if (hif_drv->strWILC_UsrConnReq.pu8bssid != NULL) {
d00d2ba3 1347 memcpy(strConnectInfo.au8bssid,
a4ab1ade 1348 hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
c5c77ba1
JK		 1349 }
1350
a4ab1ade
TC		 1351 if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
1352 strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
1353 strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
d00d2ba3 1354 memcpy(strConnectInfo.pu8ReqIEs,
a4ab1ade
TC		 1355 hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
1356 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
c5c77ba1
JK		 1357 }
1358
a4ab1ade 1359 hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
c5c77ba1
JK		 1360 &strConnectInfo,
1361 MAC_DISCONNECTED,
1362 NULL,
a4ab1ade 1363 hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
c5c77ba1 1364
95f840fb
SB		 1365 kfree(strConnectInfo.pu8ReqIEs);
1366 strConnectInfo.pu8ReqIEs = NULL;
c5c77ba1 1367 } else {
03b2d5e7 1368 PRINT_ER("Connect callback function pointer is NULL\n");
c5c77ba1
JK		 1369 }
1370
daaf16ba 1371 strWID.id = (u16)WID_DISCONNECT;
416d8321 1372 strWID.type = WID_CHAR;
900bb4a6 1373 strWID.val = (s8 *)&u16DummyReasonCode;
2fd3e443 1374 strWID.size = sizeof(char);
c5c77ba1
JK		 1375
1376 PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
1377
03362286 1378 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1379 get_id_from_handler(hif_drv));
2b9d5b48 1380 if (s32Error)
c5c77ba1 1381 PRINT_ER("Failed to send dissconect config packet\n");
c5c77ba1 1382
a4ab1ade
TC		 1383 hif_drv->strWILC_UsrConnReq.ssidLen = 0;
1384 kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
1385 kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
1386 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
1387 kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
c5c77ba1 1388
281dd5ac 1389 eth_zero_addr(u8ConnectedSSID);
ae4dfa57 1390
a4ab1ade 1391 if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
49188af2 1392 kfree(gu8FlushedJoinReq);
c5c77ba1
JK		 1393 gu8FlushedJoinReq = NULL;
1394 }
a4ab1ade 1395 if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
49188af2 1396 kfree(gu8FlushedInfoElemAsoc);
c5c77ba1
JK		 1397 gu8FlushedInfoElemAsoc = NULL;
1398 }
1399
1400 return s32Error;
1401}
1402
a4ab1ade 1403static s32 Handle_RcvdNtwrkInfo(struct host_if_drv *hif_drv,
3bbd59f5 1404 struct rcvd_net_info *pstrRcvdNetworkInfo)
c5c77ba1 1405{
4e4467fd 1406 u32 i;
72ed4dc7 1407 bool bNewNtwrkFound;
c5c77ba1
JK		 1408
1409
1410
e6e12661 1411 s32 s32Error = 0;
c5c77ba1
JK		 1412 tstrNetworkInfo *pstrNetworkInfo = NULL;
1413 void *pJoinParams = NULL;
1414
72ed4dc7 1415 bNewNtwrkFound = true;
c5c77ba1
JK		 1416 PRINT_INFO(HOSTINF_DBG, "Handling received network info\n");
1417
a4ab1ade 1418 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
c5c77ba1 1419 PRINT_D(HOSTINF_DBG, "State: Scanning, parsing network information received\n");
b021b80b 1420 parse_network_info(pstrRcvdNetworkInfo->buffer, &pstrNetworkInfo);
c5c77ba1 1421 if ((pstrNetworkInfo == NULL)
a4ab1ade 1422 || (hif_drv->strWILC_UsrScanReq.pfUserScanResult == NULL)) {
24db713f
LK		 1423 PRINT_ER("driver is null\n");
1424 s32Error = -EINVAL;
1425 goto done;
c5c77ba1
JK		 1426 }
1427
a4ab1ade 1428 for (i = 0; i < hif_drv->strWILC_UsrScanReq.u32RcvdChCount; i++) {
c5c77ba1 1429
a4ab1ade 1430 if ((hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid != NULL) &&
c5c77ba1 1431 (pstrNetworkInfo->au8bssid != NULL)) {
a4ab1ade 1432 if (memcmp(hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid,
c5c77ba1 1433 pstrNetworkInfo->au8bssid, 6) == 0) {
a4ab1ade 1434 if (pstrNetworkInfo->s8rssi <= hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi) {
c5c77ba1
JK		 1435 PRINT_D(HOSTINF_DBG, "Network previously discovered\n");
1436 goto done;
1437 } else {
a4ab1ade 1438 hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
72ed4dc7 1439 bNewNtwrkFound = false;
c5c77ba1
JK		 1440 break;
1441 }
1442 }
1443 }
1444 }
1445
72ed4dc7 1446 if (bNewNtwrkFound == true) {
c5c77ba1
JK		 1447 PRINT_D(HOSTINF_DBG, "New network found\n");
1448
a4ab1ade
TC		 1449 if (hif_drv->strWILC_UsrScanReq.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
1450 hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi;
c5c77ba1 1451
a4ab1ade 1452 if ((hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid != NULL)
c5c77ba1 1453 && (pstrNetworkInfo->au8bssid != NULL)) {
a4ab1ade 1454 memcpy(hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid,
c5c77ba1
JK		 1455 pstrNetworkInfo->au8bssid, 6);
1456
a4ab1ade 1457 hif_drv->strWILC_UsrScanReq.u32RcvdChCount++;
c5c77ba1 1458
72ed4dc7 1459 pstrNetworkInfo->bNewNetwork = true;
c5c77ba1 1460 pJoinParams = host_int_ParseJoinBssParam(pstrNetworkInfo);
c5c77ba1 1461
a4ab1ade
TC		 1462 hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
1463 hif_drv->strWILC_UsrScanReq.u32UserScanPvoid,
c5c77ba1
JK		 1464 pJoinParams);
1465
1466
1467 }
1468 } else {
03b2d5e7 1469 PRINT_WRN(HOSTINF_DBG, "Discovered networks exceeded max. limit\n");
c5c77ba1
JK		 1470 }
1471 } else {
72ed4dc7 1472 pstrNetworkInfo->bNewNetwork = false;
a4ab1ade
TC		 1473 hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
1474 hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
c5c77ba1
JK		 1475 }
1476 }
1477
c5c77ba1 1478done:
95f840fb
SB		 1479 kfree(pstrRcvdNetworkInfo->buffer);
1480 pstrRcvdNetworkInfo->buffer = NULL;
c5c77ba1 1481
b1413b60 1482 if (pstrNetworkInfo != NULL) {
c5c77ba1 1483 DeallocateNetworkInfo(pstrNetworkInfo);
b1413b60 1484 pstrNetworkInfo = NULL;
c5c77ba1
JK		 1485 }
1486
1487 return s32Error;
1488}
1489
a4ab1ade 1490static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
f23a9eab 1491 struct rcvd_async_info *pstrRcvdGnrlAsyncInfo)
c5c77ba1 1492{
e6e12661 1493 s32 s32Error = 0;
63d03e47
GKH		 1494 u8 u8MsgType = 0;
1495 u8 u8MsgID = 0;
d85f5326
CL		 1496 u16 u16MsgLen = 0;
1497 u16 u16WidID = (u16)WID_NIL;
63d03e47
GKH		 1498 u8 u8WidLen = 0;
1499 u8 u8MacStatus;
1500 u8 u8MacStatusReasonCode;
1501 u8 u8MacStatusAdditionalInfo;
c5c77ba1
JK		 1502 tstrConnectInfo strConnectInfo;
1503 tstrDisconnectNotifInfo strDisconnectNotifInfo;
e6e12661 1504 s32 s32Err = 0;
78c87591 1505
a4ab1ade 1506 if (!hif_drv) {
c5c77ba1 1507 PRINT_ER("Driver handler is NULL\n");
234837de
LK		 1508 return -ENODEV;
1509 }
a4ab1ade 1510 PRINT_D(GENERIC_DBG, "Current State = %d,Received state = %d\n", hif_drv->enuHostIFstate,
33722ac7 1511 pstrRcvdGnrlAsyncInfo->buffer[7]);
c5c77ba1 1512
a4ab1ade
TC		 1513 if ((hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) ||
1514 (hif_drv->enuHostIFstate == HOST_IF_CONNECTED) ||
1515 hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
33722ac7 1516 if ((pstrRcvdGnrlAsyncInfo->buffer == NULL) ||
a4ab1ade 1517 (hif_drv->strWILC_UsrConnReq.pfUserConnectResult == NULL)) {
24db713f
LK		 1518 PRINT_ER("driver is null\n");
1519 return -EINVAL;
c5c77ba1
JK		 1520 }
1521
33722ac7 1522 u8MsgType = pstrRcvdGnrlAsyncInfo->buffer[0];
c5c77ba1 1523
c5c77ba1
JK		 1524 if ('I' != u8MsgType) {
1525 PRINT_ER("Received Message format incorrect.\n");
24db713f 1526 return -EFAULT;
c5c77ba1
JK		 1527 }
1528
33722ac7
LK		 1529 u8MsgID = pstrRcvdGnrlAsyncInfo->buffer[1];
1530 u16MsgLen = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->buffer[2], pstrRcvdGnrlAsyncInfo->buffer[3]);
1531 u16WidID = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->buffer[4], pstrRcvdGnrlAsyncInfo->buffer[5]);
1532 u8WidLen = pstrRcvdGnrlAsyncInfo->buffer[6];
1533 u8MacStatus = pstrRcvdGnrlAsyncInfo->buffer[7];
1534 u8MacStatusReasonCode = pstrRcvdGnrlAsyncInfo->buffer[8];
1535 u8MacStatusAdditionalInfo = pstrRcvdGnrlAsyncInfo->buffer[9];
c5c77ba1 1536 PRINT_INFO(HOSTINF_DBG, "Recieved MAC status = %d with Reason = %d , Info = %d\n", u8MacStatus, u8MacStatusReasonCode, u8MacStatusAdditionalInfo);
a4ab1ade 1537 if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
4e4467fd 1538 u32 u32RcvdAssocRespInfoLen;
c5c77ba1
JK		 1539 tstrConnectRespInfo *pstrConnectRespInfo = NULL;
1540
1541 PRINT_D(HOSTINF_DBG, "Recieved MAC status = %d with Reason = %d , Code = %d\n", u8MacStatus, u8MacStatusReasonCode, u8MacStatusAdditionalInfo);
1542
2cc46837 1543 memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
c5c77ba1
JK		 1544
1545 if (u8MacStatus == MAC_CONNECTED) {
2cc46837 1546 memset(gapu8RcvdAssocResp, 0, MAX_ASSOC_RESP_FRAME_SIZE);
c5c77ba1 1547
a4ab1ade 1548 host_int_get_assoc_res_info(hif_drv,
c5c77ba1
JK		 1549 gapu8RcvdAssocResp,
1550 MAX_ASSOC_RESP_FRAME_SIZE,
1551 &u32RcvdAssocRespInfoLen);
1552
1553 PRINT_INFO(HOSTINF_DBG, "Received association response with length = %d\n", u32RcvdAssocRespInfoLen);
1554
1555 if (u32RcvdAssocRespInfoLen != 0) {
1556
1557 PRINT_D(HOSTINF_DBG, "Parsing association response\n");
1558 s32Err = ParseAssocRespInfo(gapu8RcvdAssocResp, u32RcvdAssocRespInfoLen,
1559 &pstrConnectRespInfo);
1560 if (s32Err) {
03b2d5e7 1561 PRINT_ER("ParseAssocRespInfo() returned error %d\n", s32Err);
c5c77ba1 1562 } else {
c5c77ba1
JK		 1563 strConnectInfo.u16ConnectStatus = pstrConnectRespInfo->u16ConnectStatus;
1564
1565 if (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE) {
1566 PRINT_INFO(HOSTINF_DBG, "Association response received : Successful connection status\n");
1567 if (pstrConnectRespInfo->pu8RespIEs != NULL) {
1568 strConnectInfo.u16RespIEsLen = pstrConnectRespInfo->u16RespIEsLen;
1569
1570
f3052587 1571 strConnectInfo.pu8RespIEs = kmalloc(pstrConnectRespInfo->u16RespIEsLen, GFP_KERNEL);
d00d2ba3 1572 memcpy(strConnectInfo.pu8RespIEs, pstrConnectRespInfo->pu8RespIEs,
c5c77ba1
JK		 1573 pstrConnectRespInfo->u16RespIEsLen);
1574 }
1575 }
1576
c5c77ba1
JK		 1577 if (pstrConnectRespInfo != NULL) {
1578 DeallocateAssocRespInfo(pstrConnectRespInfo);
1579 pstrConnectRespInfo = NULL;
1580 }
1581 }
1582 }
1583 }
1584
c5c77ba1
JK		 1585 if ((u8MacStatus == MAC_CONNECTED) &&
1586 (strConnectInfo.u16ConnectStatus != SUCCESSFUL_STATUSCODE)) {
03b2d5e7 1587 PRINT_ER("Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE\n");
281dd5ac 1588 eth_zero_addr(u8ConnectedSSID);
c5c77ba1
JK		 1589
1590 } else if (u8MacStatus == MAC_DISCONNECTED) {
1591 PRINT_ER("Received MAC status is MAC_DISCONNECTED\n");
281dd5ac 1592 eth_zero_addr(u8ConnectedSSID);
c5c77ba1
JK		 1593 }
1594
a4ab1ade 1595 if (hif_drv->strWILC_UsrConnReq.pu8bssid != NULL) {
c5c77ba1 1596 PRINT_D(HOSTINF_DBG, "Retrieving actual BSSID from AP\n");
a4ab1ade 1597 memcpy(strConnectInfo.au8bssid, hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
c5c77ba1
JK		 1598
1599 if ((u8MacStatus == MAC_CONNECTED) &&
1600 (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
a4ab1ade
TC		 1601 memcpy(hif_drv->au8AssociatedBSSID,
1602 hif_drv->strWILC_UsrConnReq.pu8bssid, ETH_ALEN);
c5c77ba1
JK		 1603 }
1604 }
1605
1606
a4ab1ade
TC		 1607 if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
1608 strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
1609 strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
d00d2ba3 1610 memcpy(strConnectInfo.pu8ReqIEs,
a4ab1ade
TC		 1611 hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
1612 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
c5c77ba1
JK		 1613 }
1614
1615
a4ab1ade
TC		 1616 del_timer(&hif_drv->hConnectTimer);
1617 hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
c5c77ba1
JK		 1618 &strConnectInfo,
1619 u8MacStatus,
1620 NULL,
a4ab1ade 1621 hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
c5c77ba1 1622
c5c77ba1
JK		 1623 if ((u8MacStatus == MAC_CONNECTED) &&
1624 (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
a4ab1ade 1625 host_int_set_power_mgmt(hif_drv, 0, 0);
c5c77ba1
JK		 1626
1627 PRINT_D(HOSTINF_DBG, "MAC status : CONNECTED and Connect Status : Successful\n");
a4ab1ade 1628 hif_drv->enuHostIFstate = HOST_IF_CONNECTED;
c5c77ba1 1629
c5c77ba1 1630 PRINT_D(GENERIC_DBG, "Obtaining an IP, Disable Scan\n");
72ed4dc7 1631 g_obtainingIP = true;
9eb06643
GKH		 1632 mod_timer(&hDuringIpTimer,
1633 jiffies + msecs_to_jiffies(10000));
c5c77ba1
JK		 1634 } else {
1635 PRINT_D(HOSTINF_DBG, "MAC status : %d and Connect Status : %d\n", u8MacStatus, strConnectInfo.u16ConnectStatus);
a4ab1ade 1636 hif_drv->enuHostIFstate = HOST_IF_IDLE;
72ed4dc7 1637 gbScanWhileConnected = false;
c5c77ba1
JK		 1638 }
1639
95f840fb
SB		 1640 kfree(strConnectInfo.pu8RespIEs);
1641 strConnectInfo.pu8RespIEs = NULL;
c5c77ba1 1642
95f840fb
SB		 1643 kfree(strConnectInfo.pu8ReqIEs);
1644 strConnectInfo.pu8ReqIEs = NULL;
a4ab1ade
TC		 1645 hif_drv->strWILC_UsrConnReq.ssidLen = 0;
1646 kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
1647 kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
1648 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
1649 kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
c5c77ba1 1650 } else if ((u8MacStatus == MAC_DISCONNECTED) &&
a4ab1ade 1651 (hif_drv->enuHostIFstate == HOST_IF_CONNECTED)) {
c5c77ba1
JK		 1652 PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW\n");
1653
2cc46837 1654 memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo));
c5c77ba1 1655
a4ab1ade 1656 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
03b2d5e7 1657 PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running OBSS Scan >>\n\n");
a4ab1ade
TC		 1658 del_timer(&hif_drv->hScanTimer);
1659 Handle_ScanDone((void *)hif_drv, SCAN_EVENT_ABORTED);
c5c77ba1
JK		 1660 }
1661
1662 strDisconnectNotifInfo.u16reason = 0;
1663 strDisconnectNotifInfo.ie = NULL;
1664 strDisconnectNotifInfo.ie_len = 0;
1665
a4ab1ade 1666 if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
72ed4dc7 1667 g_obtainingIP = false;
a4ab1ade 1668 host_int_set_power_mgmt(hif_drv, 0, 0);
c5c77ba1 1669
a4ab1ade 1670 hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF,
c5c77ba1
JK		 1671 NULL,
1672 0,
1673 &strDisconnectNotifInfo,
a4ab1ade 1674 hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
c5c77ba1
JK		 1675
1676 } else {
03b2d5e7 1677 PRINT_ER("Connect result callback function is NULL\n");
c5c77ba1
JK		 1678 }
1679
a4ab1ade 1680 eth_zero_addr(hif_drv->au8AssociatedBSSID);
c5c77ba1 1681
a4ab1ade
TC		 1682 hif_drv->strWILC_UsrConnReq.ssidLen = 0;
1683 kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
1684 kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
1685 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
1686 kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
c5c77ba1 1687
a4ab1ade 1688 if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
49188af2 1689 kfree(gu8FlushedJoinReq);
c5c77ba1
JK		 1690 gu8FlushedJoinReq = NULL;
1691 }
a4ab1ade 1692 if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
49188af2 1693 kfree(gu8FlushedInfoElemAsoc);
c5c77ba1
JK		 1694 gu8FlushedInfoElemAsoc = NULL;
1695 }
1696
a4ab1ade 1697 hif_drv->enuHostIFstate = HOST_IF_IDLE;
72ed4dc7 1698 gbScanWhileConnected = false;
c5c77ba1
JK		 1699
1700 } else if ((u8MacStatus == MAC_DISCONNECTED) &&
a4ab1ade 1701 (hif_drv->strWILC_UsrScanReq.pfUserScanResult != NULL)) {
c5c77ba1 1702 PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW while scanning\n");
03b2d5e7 1703 PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running Scan >>\n\n");
ae4dfa57 1704
a4ab1ade
TC		 1705 del_timer(&hif_drv->hScanTimer);
1706 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult)
1707 Handle_ScanDone(hif_drv, SCAN_EVENT_ABORTED);
c5c77ba1 1708
c5c77ba1
JK		 1709 }
1710
1711 }
1712
95f840fb
SB		 1713 kfree(pstrRcvdGnrlAsyncInfo->buffer);
1714 pstrRcvdGnrlAsyncInfo->buffer = NULL;
c5c77ba1
JK		 1715
1716 return s32Error;
1717}
1718
a4ab1ade 1719static int Handle_Key(struct host_if_drv *hif_drv,
c98387a5 1720 struct key_attr *pstrHostIFkeyAttr)
c5c77ba1 1721{
e6e12661 1722 s32 s32Error = 0;
e9e0c260
LK		 1723 struct wid strWID;
1724 struct wid strWIDList[5];
63d03e47
GKH		 1725 u8 i;
1726 u8 *pu8keybuf;
ca356ada
CL		 1727 s8 s8idxarray[1];
1728 s8 ret = 0;
c5c77ba1 1729
8e9f427a 1730 switch (pstrHostIFkeyAttr->type) {
c5c77ba1
JK		 1731
1732
1733 case WEP:
1734
0d17e382 1735 if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
c5c77ba1
JK		 1736
1737 PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
73b2e381 1738 PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", (pstrHostIFkeyAttr->attr.wep.index));
daaf16ba 1739 strWIDList[0].id = (u16)WID_11I_MODE;
416d8321 1740 strWIDList[0].type = WID_CHAR;
2fd3e443 1741 strWIDList[0].size = sizeof(char);
73b2e381 1742 strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.mode));
c5c77ba1 1743
daaf16ba 1744 strWIDList[1].id = WID_AUTH_TYPE;
416d8321 1745 strWIDList[1].type = WID_CHAR;
2fd3e443 1746 strWIDList[1].size = sizeof(char);
73b2e381 1747 strWIDList[1].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.auth_type));
c5c77ba1 1748
daaf16ba 1749 strWIDList[2].id = (u16)WID_KEY_ID;
416d8321 1750 strWIDList[2].type = WID_CHAR;
c5c77ba1 1751
73b2e381 1752 strWIDList[2].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.index));
2fd3e443 1753 strWIDList[2].size = sizeof(char);
c5c77ba1 1754
73b2e381 1755 pu8keybuf = kmalloc(pstrHostIFkeyAttr->attr.wep.key_len, GFP_KERNEL);
c5c77ba1
JK		 1756
1757 if (pu8keybuf == NULL) {
1758 PRINT_ER("No buffer to send Key\n");
1759 return -1;
1760 }
1761
73b2e381
LK		 1762 memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wep.key,
1763 pstrHostIFkeyAttr->attr.wep.key_len);
c5c77ba1 1764
73b2e381 1765 kfree(pstrHostIFkeyAttr->attr.wep.key);
c5c77ba1 1766
daaf16ba 1767 strWIDList[3].id = (u16)WID_WEP_KEY_VALUE;
416d8321 1768 strWIDList[3].type = WID_STR;
73b2e381 1769 strWIDList[3].size = pstrHostIFkeyAttr->attr.wep.key_len;
900bb4a6 1770 strWIDList[3].val = (s8 *)pu8keybuf;
c5c77ba1
JK		 1771
1772
03362286 1773 s32Error = send_config_pkt(SET_CFG, strWIDList, 4,
a4ab1ade 1774 get_id_from_handler(hif_drv));
49188af2 1775 kfree(pu8keybuf);
c5c77ba1
JK		 1776
1777
1778 }
c5c77ba1 1779
0d17e382 1780 if (pstrHostIFkeyAttr->action & ADDKEY) {
c5c77ba1 1781 PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
73b2e381 1782 pu8keybuf = kmalloc(pstrHostIFkeyAttr->attr.wep.key_len + 2, GFP_KERNEL);
c5c77ba1
JK		 1783 if (pu8keybuf == NULL) {
1784 PRINT_ER("No buffer to send Key\n");
1785 return -1;
1786 }
73b2e381
LK		 1787 pu8keybuf[0] = pstrHostIFkeyAttr->attr.wep.index;
1788 memcpy(pu8keybuf + 1, &pstrHostIFkeyAttr->attr.wep.key_len, 1);
1789 memcpy(pu8keybuf + 2, pstrHostIFkeyAttr->attr.wep.key,
1790 pstrHostIFkeyAttr->attr.wep.key_len);
1791 kfree(pstrHostIFkeyAttr->attr.wep.key);
c5c77ba1 1792
daaf16ba 1793 strWID.id = (u16)WID_ADD_WEP_KEY;
416d8321 1794 strWID.type = WID_STR;
900bb4a6 1795 strWID.val = (s8 *)pu8keybuf;
73b2e381 1796 strWID.size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
c5c77ba1 1797
03362286 1798 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1799 get_id_from_handler(hif_drv));
49188af2 1800 kfree(pu8keybuf);
0d17e382 1801 } else if (pstrHostIFkeyAttr->action & REMOVEKEY) {
c5c77ba1
JK		 1802
1803 PRINT_D(HOSTINF_DBG, "Removing key\n");
daaf16ba 1804 strWID.id = (u16)WID_REMOVE_WEP_KEY;
416d8321 1805 strWID.type = WID_STR;
c5c77ba1 1806
73b2e381 1807 s8idxarray[0] = (s8)pstrHostIFkeyAttr->attr.wep.index;
900bb4a6 1808 strWID.val = s8idxarray;
2fd3e443 1809 strWID.size = 1;
c5c77ba1 1810
03362286 1811 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1812 get_id_from_handler(hif_drv));
c5c77ba1 1813 } else {
daaf16ba 1814 strWID.id = (u16)WID_KEY_ID;
416d8321 1815 strWID.type = WID_CHAR;
73b2e381 1816 strWID.val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.index));
2fd3e443 1817 strWID.size = sizeof(char);
c5c77ba1
JK		 1818
1819 PRINT_D(HOSTINF_DBG, "Setting default key index\n");
1820
03362286 1821 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1822 get_id_from_handler(hif_drv));
c5c77ba1 1823 }
a4ab1ade 1824 up(&hif_drv->hSemTestKeyBlock);
c5c77ba1
JK		 1825 break;
1826
1827 case WPARxGtk:
0d17e382 1828 if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
b156f1ed 1829 pu8keybuf = kzalloc(RX_MIC_KEY_MSG_LEN, GFP_KERNEL);
c5c77ba1
JK		 1830 if (pu8keybuf == NULL) {
1831 PRINT_ER("No buffer to send RxGTK Key\n");
1832 ret = -1;
1833 goto _WPARxGtk_end_case_;
1834 }
1835
0e74c009
LK		 1836 if (pstrHostIFkeyAttr->attr.wpa.seq != NULL)
1837 memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->attr.wpa.seq, 8);
c5c77ba1 1838
e2dfbac5 1839 memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
6acf2919 1840 memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
124968fc 1841 memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
6acf2919 1842 pstrHostIFkeyAttr->attr.wpa.key_len);
c5c77ba1 1843
daaf16ba 1844 strWIDList[0].id = (u16)WID_11I_MODE;
416d8321 1845 strWIDList[0].type = WID_CHAR;
2fd3e443 1846 strWIDList[0].size = sizeof(char);
7b2ebb28 1847 strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wpa.mode));
c5c77ba1 1848
daaf16ba 1849 strWIDList[1].id = (u16)WID_ADD_RX_GTK;
416d8321 1850 strWIDList[1].type = WID_STR;
900bb4a6 1851 strWIDList[1].val = (s8 *)pu8keybuf;
2fd3e443 1852 strWIDList[1].size = RX_MIC_KEY_MSG_LEN;
c5c77ba1 1853
03362286 1854 s32Error = send_config_pkt(SET_CFG, strWIDList, 2,
a4ab1ade 1855 get_id_from_handler(hif_drv));
c5c77ba1 1856
49188af2 1857 kfree(pu8keybuf);
a4ab1ade 1858 up(&hif_drv->hSemTestKeyBlock);
c5c77ba1
JK		 1859 }
1860
0d17e382 1861 if (pstrHostIFkeyAttr->action & ADDKEY) {
c5c77ba1
JK		 1862 PRINT_D(HOSTINF_DBG, "Handling group key(Rx) function\n");
1863
b156f1ed 1864 pu8keybuf = kzalloc(RX_MIC_KEY_MSG_LEN, GFP_KERNEL);
c5c77ba1
JK		 1865 if (pu8keybuf == NULL) {
1866 PRINT_ER("No buffer to send RxGTK Key\n");
1867 ret = -1;
1868 goto _WPARxGtk_end_case_;
1869 }
1870
a4ab1ade
TC		 1871 if (hif_drv->enuHostIFstate == HOST_IF_CONNECTED)
1872 memcpy(pu8keybuf, hif_drv->au8AssociatedBSSID, ETH_ALEN);
78174ada 1873 else
03b2d5e7 1874 PRINT_ER("Couldn't handle WPARxGtk while enuHostIFstate is not HOST_IF_CONNECTED\n");
c5c77ba1 1875
0e74c009 1876 memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->attr.wpa.seq, 8);
e2dfbac5 1877 memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
6acf2919 1878 memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
124968fc 1879 memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
6acf2919 1880 pstrHostIFkeyAttr->attr.wpa.key_len);
c5c77ba1 1881
daaf16ba 1882 strWID.id = (u16)WID_ADD_RX_GTK;
416d8321 1883 strWID.type = WID_STR;
900bb4a6 1884 strWID.val = (s8 *)pu8keybuf;
2fd3e443 1885 strWID.size = RX_MIC_KEY_MSG_LEN;
c5c77ba1 1886
03362286 1887 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1888 get_id_from_handler(hif_drv));
c5c77ba1 1889
49188af2 1890 kfree(pu8keybuf);
a4ab1ade 1891 up(&hif_drv->hSemTestKeyBlock);
c5c77ba1
JK		 1892 }
1893_WPARxGtk_end_case_:
124968fc 1894 kfree(pstrHostIFkeyAttr->attr.wpa.key);
0e74c009 1895 kfree(pstrHostIFkeyAttr->attr.wpa.seq);
c5c77ba1
JK		 1896 if (ret == -1)
1897 return ret;
1898
1899 break;
1900
1901 case WPAPtk:
0d17e382 1902 if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
c5c77ba1
JK		 1903
1904
f3052587 1905 pu8keybuf = kmalloc(PTK_KEY_MSG_LEN + 1, GFP_KERNEL);
c5c77ba1
JK		 1906
1907
1908
1909 if (pu8keybuf == NULL) {
1910 PRINT_ER("No buffer to send PTK Key\n");
1911 ret = -1;
1912 goto _WPAPtk_end_case_;
1913
1914 }
1915
248080aa 1916 memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
e2dfbac5 1917 memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->attr.wpa.index, 1);
6acf2919 1918 memcpy(pu8keybuf + 7, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
124968fc 1919 memcpy(pu8keybuf + 8, pstrHostIFkeyAttr->attr.wpa.key,
6acf2919 1920 pstrHostIFkeyAttr->attr.wpa.key_len);
c5c77ba1 1921
daaf16ba 1922 strWIDList[0].id = (u16)WID_11I_MODE;
416d8321 1923 strWIDList[0].type = WID_CHAR;
2fd3e443 1924 strWIDList[0].size = sizeof(char);
7b2ebb28 1925 strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wpa.mode));
c5c77ba1 1926
daaf16ba 1927 strWIDList[1].id = (u16)WID_ADD_PTK;
416d8321 1928 strWIDList[1].type = WID_STR;
900bb4a6 1929 strWIDList[1].val = (s8 *)pu8keybuf;
2fd3e443 1930 strWIDList[1].size = PTK_KEY_MSG_LEN + 1;
c5c77ba1 1931
03362286 1932 s32Error = send_config_pkt(SET_CFG, strWIDList, 2,
a4ab1ade 1933 get_id_from_handler(hif_drv));
49188af2 1934 kfree(pu8keybuf);
a4ab1ade 1935 up(&hif_drv->hSemTestKeyBlock);
c5c77ba1 1936 }
0d17e382 1937 if (pstrHostIFkeyAttr->action & ADDKEY) {
c5c77ba1
JK		 1938
1939
f3052587 1940 pu8keybuf = kmalloc(PTK_KEY_MSG_LEN, GFP_KERNEL);
c5c77ba1
JK		 1941
1942
1943
1944 if (pu8keybuf == NULL) {
1945 PRINT_ER("No buffer to send PTK Key\n");
1946 ret = -1;
1947 goto _WPAPtk_end_case_;
1948
1949 }
1950
248080aa 1951 memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
6acf2919 1952 memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
124968fc 1953 memcpy(pu8keybuf + 7, pstrHostIFkeyAttr->attr.wpa.key,
6acf2919 1954 pstrHostIFkeyAttr->attr.wpa.key_len);
c5c77ba1 1955
daaf16ba 1956 strWID.id = (u16)WID_ADD_PTK;
416d8321 1957 strWID.type = WID_STR;
900bb4a6 1958 strWID.val = (s8 *)pu8keybuf;
2fd3e443 1959 strWID.size = PTK_KEY_MSG_LEN;
c5c77ba1 1960
03362286 1961 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1962 get_id_from_handler(hif_drv));
49188af2 1963 kfree(pu8keybuf);
a4ab1ade 1964 up(&hif_drv->hSemTestKeyBlock);
c5c77ba1
JK		 1965 }
1966
1967_WPAPtk_end_case_:
124968fc 1968 kfree(pstrHostIFkeyAttr->attr.wpa.key);
c5c77ba1
JK		 1969 if (ret == -1)
1970 return ret;
1971
1972 break;
1973
1974
1975 case PMKSA:
1976
1977 PRINT_D(HOSTINF_DBG, "Handling PMKSA key\n");
1978
73b2e381 1979 pu8keybuf = kmalloc((pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1, GFP_KERNEL);
c5c77ba1
JK		 1980 if (pu8keybuf == NULL) {
1981 PRINT_ER("No buffer to send PMKSA Key\n");
1982 return -1;
1983 }
1984
73b2e381 1985 pu8keybuf[0] = pstrHostIFkeyAttr->attr.pmkid.numpmkid;
c5c77ba1 1986
73b2e381
LK		 1987 for (i = 0; i < pstrHostIFkeyAttr->attr.pmkid.numpmkid; i++) {
1988 memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + 1), pstrHostIFkeyAttr->attr.pmkid.pmkidlist[i].bssid, ETH_ALEN);
1989 memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + ETH_ALEN + 1), pstrHostIFkeyAttr->attr.pmkid.pmkidlist[i].pmkid, PMKID_LEN);
c5c77ba1
JK		 1990 }
1991
daaf16ba 1992 strWID.id = (u16)WID_PMKID_INFO;
416d8321 1993 strWID.type = WID_STR;
900bb4a6 1994 strWID.val = (s8 *)pu8keybuf;
73b2e381 1995 strWID.size = (pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1;
c5c77ba1 1996
03362286 1997 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 1998 get_id_from_handler(hif_drv));
c5c77ba1 1999
49188af2 2000 kfree(pu8keybuf);
c5c77ba1
JK		 2001 break;
2002 }
2003
2004 if (s32Error)
2005 PRINT_ER("Failed to send key config packet\n");
2006
2007
2008 return s32Error;
2009}
2010
a4ab1ade 2011static void Handle_Disconnect(struct host_if_drv *hif_drv)
c5c77ba1 2012{
e9e0c260 2013 struct wid strWID;
c5c77ba1 2014
e6e12661 2015 s32 s32Error = 0;
d85f5326 2016 u16 u16DummyReasonCode = 0;
c5c77ba1 2017
daaf16ba 2018 strWID.id = (u16)WID_DISCONNECT;
416d8321 2019 strWID.type = WID_CHAR;
900bb4a6 2020 strWID.val = (s8 *)&u16DummyReasonCode;
2fd3e443 2021 strWID.size = sizeof(char);
c5c77ba1
JK		 2022
2023
2024
2025 PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
2026
72ed4dc7 2027 g_obtainingIP = false;
a4ab1ade 2028 host_int_set_power_mgmt(hif_drv, 0, 0);
c5c77ba1 2029
281dd5ac 2030 eth_zero_addr(u8ConnectedSSID);
c5c77ba1 2031
03362286 2032 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2033 get_id_from_handler(hif_drv));
c5c77ba1
JK		 2034
2035 if (s32Error) {
2036 PRINT_ER("Failed to send dissconect config packet\n");
c5c77ba1
JK		 2037 } else {
2038 tstrDisconnectNotifInfo strDisconnectNotifInfo;
2039
2cc46837 2040 memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo));
c5c77ba1
JK		 2041
2042 strDisconnectNotifInfo.u16reason = 0;
2043 strDisconnectNotifInfo.ie = NULL;
2044 strDisconnectNotifInfo.ie_len = 0;
2045
a4ab1ade
TC		 2046 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
2047 del_timer(&hif_drv->hScanTimer);
2048 hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
2049 hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
c5c77ba1 2050
a4ab1ade 2051 hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
c5c77ba1
JK		 2052 }
2053
a4ab1ade 2054 if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
a4ab1ade 2055 if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
c5c77ba1 2056 PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n");
a4ab1ade 2057 del_timer(&hif_drv->hConnectTimer);
c5c77ba1
JK		 2058 }
2059
a4ab1ade
TC		 2060 hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL,
2061 0, &strDisconnectNotifInfo, hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
c5c77ba1 2062 } else {
03b2d5e7 2063 PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL\n");
c5c77ba1
JK		 2064 }
2065
72ed4dc7 2066 gbScanWhileConnected = false;
c5c77ba1 2067
a4ab1ade 2068 hif_drv->enuHostIFstate = HOST_IF_IDLE;
c5c77ba1 2069
a4ab1ade 2070 eth_zero_addr(hif_drv->au8AssociatedBSSID);
c5c77ba1 2071
a4ab1ade
TC		 2072 hif_drv->strWILC_UsrConnReq.ssidLen = 0;
2073 kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
2074 kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
2075 hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
2076 kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
c5c77ba1 2077
a4ab1ade 2078 if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
49188af2 2079 kfree(gu8FlushedJoinReq);
c5c77ba1
JK		 2080 gu8FlushedJoinReq = NULL;
2081 }
a4ab1ade 2082 if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
49188af2 2083 kfree(gu8FlushedInfoElemAsoc);
c5c77ba1
JK		 2084 gu8FlushedInfoElemAsoc = NULL;
2085 }
2086
2087 }
2088
a4ab1ade 2089 up(&hif_drv->hSemTestDisconnectBlock);
c5c77ba1
JK		 2090}
2091
2092
a4ab1ade 2093void resolve_disconnect_aberration(struct host_if_drv *hif_drv)
c5c77ba1 2094{
a4ab1ade 2095 if (!hif_drv)
c5c77ba1 2096 return;
a4ab1ade 2097 if ((hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) || (hif_drv->enuHostIFstate == HOST_IF_CONNECTING)) {
c5c77ba1 2098 PRINT_D(HOSTINF_DBG, "\n\n<< correcting Supplicant state machine >>\n\n");
a4ab1ade 2099 host_int_disconnect(hif_drv, 1);
c5c77ba1
JK		 2100 }
2101}
c5c77ba1 2102
a4ab1ade 2103static s32 Handle_GetChnl(struct host_if_drv *hif_drv)
c5c77ba1
JK		 2104{
2105
e6e12661 2106 s32 s32Error = 0;
e9e0c260 2107 struct wid strWID;
78c87591 2108
daaf16ba 2109 strWID.id = (u16)WID_CURRENT_CHANNEL;
416d8321 2110 strWID.type = WID_CHAR;
900bb4a6 2111 strWID.val = (s8 *)&gu8Chnl;
2fd3e443 2112 strWID.size = sizeof(char);
c5c77ba1
JK		 2113
2114 PRINT_D(HOSTINF_DBG, "Getting channel value\n");
2115
03362286 2116 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 2117 get_id_from_handler(hif_drv));
ae4dfa57 2118
c5c77ba1
JK		 2119 if (s32Error) {
2120 PRINT_ER("Failed to get channel number\n");
24db713f 2121 s32Error = -EFAULT;
c5c77ba1
JK		 2122 }
2123
a4ab1ade 2124 up(&hif_drv->hSemGetCHNL);
c5c77ba1
JK		 2125
2126 return s32Error;
2127
2128
2129
2130}
2131
a4ab1ade 2132static void Handle_GetRssi(struct host_if_drv *hif_drv)
c5c77ba1 2133{
e6e12661 2134 s32 s32Error = 0;
e9e0c260 2135 struct wid strWID;
c5c77ba1 2136
daaf16ba 2137 strWID.id = (u16)WID_RSSI;
416d8321 2138 strWID.type = WID_CHAR;
900bb4a6 2139 strWID.val = &gs8Rssi;
2fd3e443 2140 strWID.size = sizeof(char);
c5c77ba1 2141
c5c77ba1
JK		 2142 PRINT_D(HOSTINF_DBG, "Getting RSSI value\n");
2143
03362286 2144 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 2145 get_id_from_handler(hif_drv));
c5c77ba1
JK		 2146 if (s32Error) {
2147 PRINT_ER("Failed to get RSSI value\n");
24db713f 2148 s32Error = -EFAULT;
c5c77ba1
JK		 2149 }
2150
a4ab1ade 2151 up(&hif_drv->hSemGetRSSI);
c5c77ba1
JK		 2152
2153
2154}
2155
2156
a4ab1ade 2157static void Handle_GetLinkspeed(struct host_if_drv *hif_drv)
c5c77ba1 2158{
e6e12661 2159 s32 s32Error = 0;
e9e0c260 2160 struct wid strWID;
c5c77ba1
JK		 2161
2162 gs8lnkspd = 0;
2163
daaf16ba 2164 strWID.id = (u16)WID_LINKSPEED;
416d8321 2165 strWID.type = WID_CHAR;
900bb4a6 2166 strWID.val = &gs8lnkspd;
2fd3e443 2167 strWID.size = sizeof(char);
ae4dfa57 2168
c5c77ba1
JK		 2169 PRINT_D(HOSTINF_DBG, "Getting LINKSPEED value\n");
2170
03362286 2171 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 2172 get_id_from_handler(hif_drv));
c5c77ba1
JK		 2173 if (s32Error) {
2174 PRINT_ER("Failed to get LINKSPEED value\n");
24db713f 2175 s32Error = -EFAULT;
c5c77ba1
JK		 2176 }
2177
a4ab1ade 2178 up(&(hif_drv->hSemGetLINKSPEED));
c5c77ba1
JK		 2179
2180
2181}
2182
a4ab1ade 2183s32 Handle_GetStatistics(struct host_if_drv *hif_drv, struct rf_info *pstrStatistics)
c5c77ba1 2184{
e9e0c260 2185 struct wid strWIDList[5];
fbc2fe16 2186 u32 u32WidsCount = 0, s32Error = 0;
c5c77ba1 2187
daaf16ba 2188 strWIDList[u32WidsCount].id = WID_LINKSPEED;
416d8321 2189 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 2190 strWIDList[u32WidsCount].size = sizeof(char);
900bb4a6 2191 strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u8LinkSpeed));
c5c77ba1
JK		 2192 u32WidsCount++;
2193
daaf16ba 2194 strWIDList[u32WidsCount].id = WID_RSSI;
416d8321 2195 strWIDList[u32WidsCount].type = WID_CHAR;
2fd3e443 2196 strWIDList[u32WidsCount].size = sizeof(char);
900bb4a6 2197 strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->s8RSSI));
c5c77ba1
JK		 2198 u32WidsCount++;
2199
daaf16ba 2200 strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
416d8321 2201 strWIDList[u32WidsCount].type = WID_INT;
2fd3e443 2202 strWIDList[u32WidsCount].size = sizeof(u32);
900bb4a6 2203 strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32TxCount));
c5c77ba1
JK		 2204 u32WidsCount++;
2205
daaf16ba 2206 strWIDList[u32WidsCount].id = WID_RECEIVED_FRAGMENT_COUNT;
416d8321 2207 strWIDList[u32WidsCount].type = WID_INT;
2fd3e443 2208 strWIDList[u32WidsCount].size = sizeof(u32);
900bb4a6 2209 strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32RxCount));
c5c77ba1
JK		 2210 u32WidsCount++;
2211
daaf16ba 2212 strWIDList[u32WidsCount].id = WID_FAILED_COUNT;
416d8321 2213 strWIDList[u32WidsCount].type = WID_INT;
2fd3e443 2214 strWIDList[u32WidsCount].size = sizeof(u32);
900bb4a6 2215 strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32TxFailureCount));
c5c77ba1
JK		 2216 u32WidsCount++;
2217
03362286 2218 s32Error = send_config_pkt(GET_CFG, strWIDList, u32WidsCount,
a4ab1ade 2219 get_id_from_handler(hif_drv));
c5c77ba1 2220
24db713f 2221 if (s32Error)
c5c77ba1 2222 PRINT_ER("Failed to send scan paramters config packet\n");
24db713f 2223
2d25af87 2224 up(&hif_sema_wait_response);
c5c77ba1
JK		 2225 return 0;
2226
2227}
2228
a4ab1ade 2229static s32 Handle_Get_InActiveTime(struct host_if_drv *hif_drv,
3d1eac04 2230 struct sta_inactive_t *strHostIfStaInactiveT)
c5c77ba1
JK		 2231{
2232
e6e12661 2233 s32 s32Error = 0;
63d03e47 2234 u8 *stamac;
e9e0c260 2235 struct wid strWID;
c5c77ba1 2236
daaf16ba 2237 strWID.id = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
416d8321 2238 strWID.type = WID_STR;
2fd3e443 2239 strWID.size = ETH_ALEN;
900bb4a6 2240 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
c5c77ba1
JK		 2241
2242
900bb4a6 2243 stamac = strWID.val;
d00d2ba3 2244 memcpy(stamac, strHostIfStaInactiveT->mac, ETH_ALEN);
c5c77ba1
JK		 2245
2246
2247 PRINT_D(CFG80211_DBG, "SETING STA inactive time\n");
2248
2249
03362286 2250 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2251 get_id_from_handler(hif_drv));
ae4dfa57 2252
c5c77ba1
JK		 2253 if (s32Error) {
2254 PRINT_ER("Failed to SET incative time\n");
24db713f 2255 return -EFAULT;
c5c77ba1
JK		 2256 }
2257
2258
daaf16ba 2259 strWID.id = (u16)WID_GET_INACTIVE_TIME;
416d8321 2260 strWID.type = WID_INT;
900bb4a6 2261 strWID.val = (s8 *)&gu32InactiveTime;
2fd3e443 2262 strWID.size = sizeof(u32);
c5c77ba1
JK		 2263
2264
03362286 2265 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 2266 get_id_from_handler(hif_drv));
ae4dfa57 2267
c5c77ba1
JK		 2268 if (s32Error) {
2269 PRINT_ER("Failed to get incative time\n");
24db713f 2270 return -EFAULT;
c5c77ba1
JK		 2271 }
2272
2273
2274 PRINT_D(CFG80211_DBG, "Getting inactive time : %d\n", gu32InactiveTime);
2275
a4ab1ade 2276 up(&hif_drv->hSemInactiveTime);
c5c77ba1
JK		 2277
2278 return s32Error;
2279
2280
2281
2282}
2283
a4ab1ade 2284static void Handle_AddBeacon(struct host_if_drv *hif_drv,
7f33fecd 2285 struct beacon_attr *pstrSetBeaconParam)
c5c77ba1 2286{
e6e12661 2287 s32 s32Error = 0;
e9e0c260 2288 struct wid strWID;
63d03e47 2289 u8 *pu8CurrByte;
78c87591 2290
c5c77ba1
JK		 2291 PRINT_D(HOSTINF_DBG, "Adding BEACON\n");
2292
daaf16ba 2293 strWID.id = (u16)WID_ADD_BEACON;
416d8321 2294 strWID.type = WID_BIN;
030c57e2 2295 strWID.size = pstrSetBeaconParam->head_len + pstrSetBeaconParam->tail_len + 16;
900bb4a6
LK		 2296 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
2297 if (strWID.val == NULL)
24db713f 2298 goto ERRORHANDLER;
c5c77ba1 2299
900bb4a6 2300 pu8CurrByte = strWID.val;
12262dda
LK		 2301 *pu8CurrByte++ = (pstrSetBeaconParam->interval & 0xFF);
2302 *pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 8) & 0xFF);
2303 *pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 16) & 0xFF);
2304 *pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 24) & 0xFF);
c5c77ba1 2305
e76ab770
LK		 2306 *pu8CurrByte++ = (pstrSetBeaconParam->dtim_period & 0xFF);
2307 *pu8CurrByte++ = ((pstrSetBeaconParam->dtim_period >> 8) & 0xFF);
2308 *pu8CurrByte++ = ((pstrSetBeaconParam->dtim_period >> 16) & 0xFF);
2309 *pu8CurrByte++ = ((pstrSetBeaconParam->dtim_period >> 24) & 0xFF);
c5c77ba1 2310
51c66185
LK		 2311 *pu8CurrByte++ = (pstrSetBeaconParam->head_len & 0xFF);
2312 *pu8CurrByte++ = ((pstrSetBeaconParam->head_len >> 8) & 0xFF);
2313 *pu8CurrByte++ = ((pstrSetBeaconParam->head_len >> 16) & 0xFF);
2314 *pu8CurrByte++ = ((pstrSetBeaconParam->head_len >> 24) & 0xFF);
c5c77ba1 2315
8ce528b9 2316 memcpy(pu8CurrByte, pstrSetBeaconParam->head, pstrSetBeaconParam->head_len);
51c66185 2317 pu8CurrByte += pstrSetBeaconParam->head_len;
c5c77ba1 2318
030c57e2
LK		 2319 *pu8CurrByte++ = (pstrSetBeaconParam->tail_len & 0xFF);
2320 *pu8CurrByte++ = ((pstrSetBeaconParam->tail_len >> 8) & 0xFF);
2321 *pu8CurrByte++ = ((pstrSetBeaconParam->tail_len >> 16) & 0xFF);
2322 *pu8CurrByte++ = ((pstrSetBeaconParam->tail_len >> 24) & 0xFF);
c5c77ba1 2323
7dbcb6d3
LK		 2324 if (pstrSetBeaconParam->tail > 0)
2325 memcpy(pu8CurrByte, pstrSetBeaconParam->tail, pstrSetBeaconParam->tail_len);
030c57e2 2326 pu8CurrByte += pstrSetBeaconParam->tail_len;
c5c77ba1 2327
03362286 2328 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2329 get_id_from_handler(hif_drv));
24db713f 2330 if (s32Error)
c5c77ba1 2331 PRINT_ER("Failed to send add beacon config packet\n");
c5c77ba1 2332
24db713f 2333ERRORHANDLER:
900bb4a6 2334 kfree(strWID.val);
8ce528b9 2335 kfree(pstrSetBeaconParam->head);
7dbcb6d3 2336 kfree(pstrSetBeaconParam->tail);
c5c77ba1
JK		 2337}
2338
a4ab1ade 2339static void Handle_DelBeacon(struct host_if_drv *hif_drv)
c5c77ba1 2340{
e6e12661 2341 s32 s32Error = 0;
e9e0c260 2342 struct wid strWID;
63d03e47 2343 u8 *pu8CurrByte;
78c87591 2344
daaf16ba 2345 strWID.id = (u16)WID_DEL_BEACON;
416d8321 2346 strWID.type = WID_CHAR;
2fd3e443 2347 strWID.size = sizeof(char);
900bb4a6 2348 strWID.val = &gu8DelBcn;
c5c77ba1 2349
900bb4a6 2350 if (strWID.val == NULL)
24db713f 2351 return;
c5c77ba1 2352
900bb4a6 2353 pu8CurrByte = strWID.val;
c5c77ba1
JK		 2354
2355 PRINT_D(HOSTINF_DBG, "Deleting BEACON\n");
c5c77ba1 2356
03362286 2357 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2358 get_id_from_handler(hif_drv));
24db713f 2359 if (s32Error)
c5c77ba1 2360 PRINT_ER("Failed to send delete beacon config packet\n");
c5c77ba1
JK		 2361}
2362
6a89ba9c
TC		 2363static u32 WILC_HostIf_PackStaParam(u8 *pu8Buffer,
2364 struct add_sta_param *pstrStationParam)
c5c77ba1 2365{
63d03e47 2366 u8 *pu8CurrByte;
c5c77ba1
JK		 2367
2368 pu8CurrByte = pu8Buffer;
2369
2370 PRINT_D(HOSTINF_DBG, "Packing STA params\n");
d00d2ba3 2371 memcpy(pu8CurrByte, pstrStationParam->au8BSSID, ETH_ALEN);
c5c77ba1
JK		 2372 pu8CurrByte += ETH_ALEN;
2373
2374 *pu8CurrByte++ = pstrStationParam->u16AssocID & 0xFF;
2375 *pu8CurrByte++ = (pstrStationParam->u16AssocID >> 8) & 0xFF;
2376
2377 *pu8CurrByte++ = pstrStationParam->u8NumRates;
2b9d5b48 2378 if (pstrStationParam->u8NumRates > 0)
d00d2ba3 2379 memcpy(pu8CurrByte, pstrStationParam->pu8Rates, pstrStationParam->u8NumRates);
c5c77ba1
JK		 2380 pu8CurrByte += pstrStationParam->u8NumRates;
2381
2382 *pu8CurrByte++ = pstrStationParam->bIsHTSupported;
2383 *pu8CurrByte++ = pstrStationParam->u16HTCapInfo & 0xFF;
2384 *pu8CurrByte++ = (pstrStationParam->u16HTCapInfo >> 8) & 0xFF;
2385
2386 *pu8CurrByte++ = pstrStationParam->u8AmpduParams;
d00d2ba3 2387 memcpy(pu8CurrByte, pstrStationParam->au8SuppMCsSet, WILC_SUPP_MCS_SET_SIZE);
c5c77ba1
JK		 2388 pu8CurrByte += WILC_SUPP_MCS_SET_SIZE;
2389
2390 *pu8CurrByte++ = pstrStationParam->u16HTExtParams & 0xFF;
2391 *pu8CurrByte++ = (pstrStationParam->u16HTExtParams >> 8) & 0xFF;
2392
2393 *pu8CurrByte++ = pstrStationParam->u32TxBeamformingCap & 0xFF;
2394 *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 8) & 0xFF;
2395 *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 16) & 0xFF;
2396 *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 24) & 0xFF;
2397
2398 *pu8CurrByte++ = pstrStationParam->u8ASELCap;
2399
2400 *pu8CurrByte++ = pstrStationParam->u16FlagsMask & 0xFF;
2401 *pu8CurrByte++ = (pstrStationParam->u16FlagsMask >> 8) & 0xFF;
2402
2403 *pu8CurrByte++ = pstrStationParam->u16FlagsSet & 0xFF;
2404 *pu8CurrByte++ = (pstrStationParam->u16FlagsSet >> 8) & 0xFF;
2405
2406 return pu8CurrByte - pu8Buffer;
2407}
2408
a4ab1ade 2409static void Handle_AddStation(struct host_if_drv *hif_drv,
6a89ba9c 2410 struct add_sta_param *pstrStationParam)
c5c77ba1 2411{
e6e12661 2412 s32 s32Error = 0;
e9e0c260 2413 struct wid strWID;
63d03e47 2414 u8 *pu8CurrByte;
78c87591 2415
c5c77ba1 2416 PRINT_D(HOSTINF_DBG, "Handling add station\n");
daaf16ba 2417 strWID.id = (u16)WID_ADD_STA;
416d8321 2418 strWID.type = WID_BIN;
2fd3e443 2419 strWID.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
c5c77ba1 2420
900bb4a6
LK		 2421 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
2422 if (strWID.val == NULL)
24db713f 2423 goto ERRORHANDLER;
c5c77ba1 2424
900bb4a6 2425 pu8CurrByte = strWID.val;
c5c77ba1
JK		 2426 pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
2427
03362286 2428 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2429 get_id_from_handler(hif_drv));
e6e12661 2430 if (s32Error != 0)
c5c77ba1 2431 PRINT_ER("Failed to send add station config packet\n");
c5c77ba1 2432
24db713f 2433ERRORHANDLER:
969effe9 2434 kfree(pstrStationParam->pu8Rates);
900bb4a6 2435 kfree(strWID.val);
c5c77ba1
JK		 2436}
2437
a4ab1ade 2438static void Handle_DelAllSta(struct host_if_drv *hif_drv,
b4e644e4 2439 struct del_all_sta *pstrDelAllStaParam)
c5c77ba1 2440{
e6e12661 2441 s32 s32Error = 0;
78c87591 2442
e9e0c260 2443 struct wid strWID;
63d03e47 2444 u8 *pu8CurrByte;
63d03e47 2445 u8 i;
3703480b 2446 u8 au8Zero_Buff[6] = {0};
78c87591 2447
daaf16ba 2448 strWID.id = (u16)WID_DEL_ALL_STA;
416d8321 2449 strWID.type = WID_STR;
8ba1803f 2450 strWID.size = (pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1;
c5c77ba1 2451
03b2d5e7 2452 PRINT_D(HOSTINF_DBG, "Handling delete station\n");
c5c77ba1 2453
8ba1803f 2454 strWID.val = kmalloc((pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1, GFP_KERNEL);
900bb4a6 2455 if (strWID.val == NULL)
24db713f 2456 goto ERRORHANDLER;
c5c77ba1 2457
900bb4a6 2458 pu8CurrByte = strWID.val;
c5c77ba1 2459
8ba1803f 2460 *(pu8CurrByte++) = pstrDelAllStaParam->assoc_sta;
c5c77ba1
JK		 2461
2462 for (i = 0; i < MAX_NUM_STA; i++) {
e51b9216
LK		 2463 if (memcmp(pstrDelAllStaParam->del_all_sta[i], au8Zero_Buff, ETH_ALEN))
2464 memcpy(pu8CurrByte, pstrDelAllStaParam->del_all_sta[i], ETH_ALEN);
c5c77ba1
JK		 2465 else
2466 continue;
2467
2468 pu8CurrByte += ETH_ALEN;
2469 }
2470
03362286 2471 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2472 get_id_from_handler(hif_drv));
24db713f 2473 if (s32Error)
83cc9be5 2474 PRINT_ER("Failed to send add station config packet\n");
c5c77ba1 2475
24db713f 2476ERRORHANDLER:
900bb4a6 2477 kfree(strWID.val);
c5c77ba1 2478
2d25af87 2479 up(&hif_sema_wait_response);
c5c77ba1
JK		 2480}
2481
a4ab1ade 2482static void Handle_DelStation(struct host_if_drv *hif_drv,
fb93a1e1 2483 struct del_sta *pstrDelStaParam)
c5c77ba1 2484{
e6e12661 2485 s32 s32Error = 0;
e9e0c260 2486 struct wid strWID;
63d03e47 2487 u8 *pu8CurrByte;
c5c77ba1 2488
daaf16ba 2489 strWID.id = (u16)WID_REMOVE_STA;
416d8321 2490 strWID.type = WID_BIN;
2fd3e443 2491 strWID.size = ETH_ALEN;
c5c77ba1 2492
03b2d5e7 2493 PRINT_D(HOSTINF_DBG, "Handling delete station\n");
c5c77ba1 2494
900bb4a6
LK		 2495 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
2496 if (strWID.val == NULL)
24db713f 2497 goto ERRORHANDLER;
c5c77ba1 2498
900bb4a6 2499 pu8CurrByte = strWID.val;
c5c77ba1 2500
e4839d39 2501 memcpy(pu8CurrByte, pstrDelStaParam->mac_addr, ETH_ALEN);
c5c77ba1 2502
03362286 2503 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2504 get_id_from_handler(hif_drv));
24db713f 2505 if (s32Error)
83cc9be5 2506 PRINT_ER("Failed to send add station config packet\n");
c5c77ba1 2507
24db713f 2508ERRORHANDLER:
900bb4a6 2509 kfree(strWID.val);
c5c77ba1
JK		 2510}
2511
a4ab1ade 2512static void Handle_EditStation(struct host_if_drv *hif_drv,
6a89ba9c 2513 struct add_sta_param *pstrStationParam)
c5c77ba1 2514{
e6e12661 2515 s32 s32Error = 0;
e9e0c260 2516 struct wid strWID;
63d03e47 2517 u8 *pu8CurrByte;
c5c77ba1 2518
daaf16ba 2519 strWID.id = (u16)WID_EDIT_STA;
416d8321 2520 strWID.type = WID_BIN;
2fd3e443 2521 strWID.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
c5c77ba1
JK		 2522
2523 PRINT_D(HOSTINF_DBG, "Handling edit station\n");
900bb4a6
LK		 2524 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
2525 if (strWID.val == NULL)
24db713f 2526 goto ERRORHANDLER;
c5c77ba1 2527
900bb4a6 2528 pu8CurrByte = strWID.val;
c5c77ba1
JK		 2529 pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
2530
03362286 2531 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2532 get_id_from_handler(hif_drv));
24db713f 2533 if (s32Error)
c5c77ba1 2534 PRINT_ER("Failed to send edit station config packet\n");
c5c77ba1 2535
24db713f 2536ERRORHANDLER:
969effe9 2537 kfree(pstrStationParam->pu8Rates);
900bb4a6 2538 kfree(strWID.val);
c5c77ba1 2539}
c5c77ba1 2540
a4ab1ade 2541static int Handle_RemainOnChan(struct host_if_drv *hif_drv,
2f9c03f5 2542 struct remain_ch *pstrHostIfRemainOnChan)
c5c77ba1 2543{
e6e12661 2544 s32 s32Error = 0;
63d03e47 2545 u8 u8remain_on_chan_flag;
e9e0c260 2546 struct wid strWID;
c5c77ba1 2547
a4ab1ade
TC		 2548 if (!hif_drv->u8RemainOnChan_pendingreq) {
2549 hif_drv->strHostIfRemainOnChan.pVoid = pstrHostIfRemainOnChan->pVoid;
2550 hif_drv->strHostIfRemainOnChan.pRemainOnChanExpired = pstrHostIfRemainOnChan->pRemainOnChanExpired;
2551 hif_drv->strHostIfRemainOnChan.pRemainOnChanReady = pstrHostIfRemainOnChan->pRemainOnChanReady;
2552 hif_drv->strHostIfRemainOnChan.u16Channel = pstrHostIfRemainOnChan->u16Channel;
2553 hif_drv->strHostIfRemainOnChan.u32ListenSessionID = pstrHostIfRemainOnChan->u32ListenSessionID;
c5c77ba1 2554 } else {
a4ab1ade 2555 pstrHostIfRemainOnChan->u16Channel = hif_drv->strHostIfRemainOnChan.u16Channel;
c5c77ba1
JK		 2556 }
2557
a4ab1ade 2558 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
c5c77ba1 2559 PRINT_INFO(GENERIC_DBG, "Required to remain on chan while scanning return\n");
a4ab1ade 2560 hif_drv->u8RemainOnChan_pendingreq = 1;
24db713f
LK		 2561 s32Error = -EBUSY;
2562 goto ERRORHANDLER;
c5c77ba1 2563 }
a4ab1ade 2564 if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
c5c77ba1 2565 PRINT_INFO(GENERIC_DBG, "Required to remain on chan while connecting return\n");
24db713f
LK		 2566 s32Error = -EBUSY;
2567 goto ERRORHANDLER;
c5c77ba1
JK		 2568 }
2569
c5c77ba1
JK		 2570 if (g_obtainingIP || connecting) {
2571 PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
24db713f
LK		 2572 s32Error = -EBUSY;
2573 goto ERRORHANDLER;
c5c77ba1 2574 }
c5c77ba1
JK		 2575
2576 PRINT_D(HOSTINF_DBG, "Setting channel :%d\n", pstrHostIfRemainOnChan->u16Channel);
2577
72ed4dc7 2578 u8remain_on_chan_flag = true;
daaf16ba 2579 strWID.id = (u16)WID_REMAIN_ON_CHAN;
416d8321 2580 strWID.type = WID_STR;
2fd3e443 2581 strWID.size = 2;
900bb4a6 2582 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
c5c77ba1 2583
900bb4a6 2584 if (strWID.val == NULL) {
24db713f
LK		 2585 s32Error = -ENOMEM;
2586 goto ERRORHANDLER;
2587 }
c5c77ba1 2588
900bb4a6
LK		 2589 strWID.val[0] = u8remain_on_chan_flag;
2590 strWID.val[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
c5c77ba1 2591
03362286 2592 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2593 get_id_from_handler(hif_drv));
e6e12661 2594 if (s32Error != 0)
c5c77ba1 2595 PRINT_ER("Failed to set remain on channel\n");
c5c77ba1 2596
24db713f 2597ERRORHANDLER:
c5c77ba1
JK		 2598 {
2599 P2P_LISTEN_STATE = 1;
a4ab1ade
TC		 2600 hif_drv->hRemainOnChannel.data = (unsigned long)hif_drv;
2601 mod_timer(&hif_drv->hRemainOnChannel,
9eb06643
GKH		 2602 jiffies +
2603 msecs_to_jiffies(pstrHostIfRemainOnChan->u32duration));
c5c77ba1 2604
a4ab1ade
TC		 2605 if (hif_drv->strHostIfRemainOnChan.pRemainOnChanReady)
2606 hif_drv->strHostIfRemainOnChan.pRemainOnChanReady(hif_drv->strHostIfRemainOnChan.pVoid);
c5c77ba1 2607
a4ab1ade
TC		 2608 if (hif_drv->u8RemainOnChan_pendingreq)
2609 hif_drv->u8RemainOnChan_pendingreq = 0;
c5c77ba1
JK		 2610 }
2611 return s32Error;
2612}
2613
a4ab1ade 2614static int Handle_RegisterFrame(struct host_if_drv *hif_drv,
bc37c5df 2615 struct reg_frame *pstrHostIfRegisterFrame)
c5c77ba1 2616{
e6e12661 2617 s32 s32Error = 0;
e9e0c260 2618 struct wid strWID;
63d03e47 2619 u8 *pu8CurrByte;
c5c77ba1
JK		 2620
2621 PRINT_D(HOSTINF_DBG, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame->bReg, pstrHostIfRegisterFrame->u16FrameType);
2622
daaf16ba 2623 strWID.id = (u16)WID_REGISTER_FRAME;
416d8321 2624 strWID.type = WID_STR;
900bb4a6
LK		 2625 strWID.val = kmalloc(sizeof(u16) + 2, GFP_KERNEL);
2626 if (strWID.val == NULL)
24db713f 2627 return -ENOMEM;
c5c77ba1 2628
900bb4a6 2629 pu8CurrByte = strWID.val;
c5c77ba1
JK		 2630
2631 *pu8CurrByte++ = pstrHostIfRegisterFrame->bReg;
2632 *pu8CurrByte++ = pstrHostIfRegisterFrame->u8Regid;
d00d2ba3 2633 memcpy(pu8CurrByte, &(pstrHostIfRegisterFrame->u16FrameType), sizeof(u16));
c5c77ba1
JK		 2634
2635
2fd3e443 2636 strWID.size = sizeof(u16) + 2;
c5c77ba1 2637
03362286 2638 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2639 get_id_from_handler(hif_drv));
c5c77ba1
JK		 2640 if (s32Error) {
2641 PRINT_ER("Failed to frame register config packet\n");
24db713f 2642 s32Error = -EINVAL;
c5c77ba1
JK		 2643 }
2644
2645 return s32Error;
2646
2647}
2648
c5c77ba1 2649#define FALSE_FRMWR_CHANNEL 100
a4ab1ade 2650static u32 Handle_ListenStateExpired(struct host_if_drv *hif_drv,
2f9c03f5 2651 struct remain_ch *pstrHostIfRemainOnChan)
c5c77ba1 2652{
63d03e47 2653 u8 u8remain_on_chan_flag;
e9e0c260 2654 struct wid strWID;
e6e12661 2655 s32 s32Error = 0;
c5c77ba1
JK		 2656
2657 PRINT_D(HOSTINF_DBG, "CANCEL REMAIN ON CHAN\n");
2658
c5c77ba1 2659 if (P2P_LISTEN_STATE) {
72ed4dc7 2660 u8remain_on_chan_flag = false;
daaf16ba 2661 strWID.id = (u16)WID_REMAIN_ON_CHAN;
416d8321 2662 strWID.type = WID_STR;
2fd3e443 2663 strWID.size = 2;
900bb4a6 2664 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
c5c77ba1 2665
900bb4a6 2666 if (strWID.val == NULL)
c5c77ba1 2667 PRINT_ER("Failed to allocate memory\n");
c5c77ba1 2668
900bb4a6
LK		 2669 strWID.val[0] = u8remain_on_chan_flag;
2670 strWID.val[1] = FALSE_FRMWR_CHANNEL;
c5c77ba1 2671
03362286 2672 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2673 get_id_from_handler(hif_drv));
e6e12661 2674 if (s32Error != 0) {
c5c77ba1
JK		 2675 PRINT_ER("Failed to set remain on channel\n");
2676 goto _done_;
2677 }
2678
a4ab1ade
TC		 2679 if (hif_drv->strHostIfRemainOnChan.pRemainOnChanExpired) {
2680 hif_drv->strHostIfRemainOnChan.pRemainOnChanExpired(hif_drv->strHostIfRemainOnChan.pVoid
c5c77ba1
JK		 2681 , pstrHostIfRemainOnChan->u32ListenSessionID);
2682 }
2683 P2P_LISTEN_STATE = 0;
2684 } else {
2685 PRINT_D(GENERIC_DBG, "Not in listen state\n");
e6e12661 2686 s32Error = -EFAULT;
c5c77ba1
JK		 2687 }
2688
2689_done_:
2690 return s32Error;
2691}
2692
93dee8ee 2693static void ListenTimerCB(unsigned long arg)
c5c77ba1 2694{
e6e12661 2695 s32 s32Error = 0;
143eb95a 2696 struct host_if_msg msg;
a4ab1ade 2697 struct host_if_drv *hif_drv = (struct host_if_drv *)arg;
ae4dfa57 2698
a4ab1ade 2699 del_timer(&hif_drv->hRemainOnChannel);
c5c77ba1 2700
143eb95a 2701 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 2702 msg.id = HOST_IF_MSG_LISTEN_TIMER_FIRED;
a4ab1ade
TC		 2703 msg.drv = hif_drv;
2704 msg.body.remain_on_ch.u32ListenSessionID = hif_drv->strHostIfRemainOnChan.u32ListenSessionID;
c5c77ba1 2705
cb067dcf 2706 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 2707 if (s32Error)
24db713f 2708 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1 2709}
c5c77ba1 2710
a4ab1ade 2711static void Handle_PowerManagement(struct host_if_drv *hif_drv,
5a008f1c 2712 struct power_mgmt_param *strPowerMgmtParam)
c5c77ba1 2713{
e6e12661 2714 s32 s32Error = 0;
e9e0c260 2715 struct wid strWID;
ca356ada 2716 s8 s8PowerMode;
78c87591 2717
daaf16ba 2718 strWID.id = (u16)WID_POWER_MANAGEMENT;
c5c77ba1 2719
33c70c1b 2720 if (strPowerMgmtParam->enabled == true)
c5c77ba1 2721 s8PowerMode = MIN_FAST_PS;
78174ada 2722 else
c5c77ba1 2723 s8PowerMode = NO_POWERSAVE;
c5c77ba1 2724 PRINT_D(HOSTINF_DBG, "Handling power mgmt to %d\n", s8PowerMode);
900bb4a6 2725 strWID.val = &s8PowerMode;
2fd3e443 2726 strWID.size = sizeof(char);
c5c77ba1
JK		 2727
2728 PRINT_D(HOSTINF_DBG, "Handling Power Management\n");
2729
03362286 2730 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2731 get_id_from_handler(hif_drv));
24db713f 2732 if (s32Error)
c5c77ba1 2733 PRINT_ER("Failed to send power management config packet\n");
c5c77ba1
JK		 2734}
2735
a4ab1ade 2736static void Handle_SetMulticastFilter(struct host_if_drv *hif_drv,
641210ac 2737 struct set_multicast *strHostIfSetMulti)
c5c77ba1 2738{
e6e12661 2739 s32 s32Error = 0;
e9e0c260 2740 struct wid strWID;
63d03e47 2741 u8 *pu8CurrByte;
c5c77ba1
JK		 2742
2743 PRINT_D(HOSTINF_DBG, "Setup Multicast Filter\n");
2744
daaf16ba 2745 strWID.id = (u16)WID_SETUP_MULTICAST_FILTER;
416d8321 2746 strWID.type = WID_BIN;
adab2f71 2747 strWID.size = sizeof(struct set_multicast) + ((strHostIfSetMulti->cnt) * ETH_ALEN);
900bb4a6
LK		 2748 strWID.val = kmalloc(strWID.size, GFP_KERNEL);
2749 if (strWID.val == NULL)
24db713f 2750 goto ERRORHANDLER;
c5c77ba1 2751
900bb4a6 2752 pu8CurrByte = strWID.val;
bae636eb
LK		 2753 *pu8CurrByte++ = (strHostIfSetMulti->enabled & 0xFF);
2754 *pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 8) & 0xFF);
2755 *pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 16) & 0xFF);
2756 *pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 24) & 0xFF);
c5c77ba1 2757
adab2f71
LK		 2758 *pu8CurrByte++ = (strHostIfSetMulti->cnt & 0xFF);
2759 *pu8CurrByte++ = ((strHostIfSetMulti->cnt >> 8) & 0xFF);
2760 *pu8CurrByte++ = ((strHostIfSetMulti->cnt >> 16) & 0xFF);
2761 *pu8CurrByte++ = ((strHostIfSetMulti->cnt >> 24) & 0xFF);
c5c77ba1 2762
adab2f71
LK		 2763 if ((strHostIfSetMulti->cnt) > 0)
2764 memcpy(pu8CurrByte, gau8MulticastMacAddrList, ((strHostIfSetMulti->cnt) * ETH_ALEN));
c5c77ba1 2765
03362286 2766 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2767 get_id_from_handler(hif_drv));
24db713f 2768 if (s32Error)
c5c77ba1 2769 PRINT_ER("Failed to send setup multicast config packet\n");
c5c77ba1 2770
24db713f 2771ERRORHANDLER:
900bb4a6 2772 kfree(strWID.val);
c5c77ba1
JK		 2773
2774}
2775
a4ab1ade 2776static s32 Handle_AddBASession(struct host_if_drv *hif_drv,
54265472 2777 struct ba_session_info *strHostIfBASessionInfo)
c5c77ba1 2778{
e6e12661 2779 s32 s32Error = 0;
e9e0c260 2780 struct wid strWID;
c5c77ba1
JK		 2781 int AddbaTimeout = 100;
2782 char *ptr = NULL;
c5c77ba1 2783
03b2d5e7 2784 PRINT_D(HOSTINF_DBG, "Opening Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\nBufferSize == %d\nSessionTimeOut = %d\n",
c5c77ba1
JK		 2785 strHostIfBASessionInfo->au8Bssid[0],
2786 strHostIfBASessionInfo->au8Bssid[1],
2787 strHostIfBASessionInfo->au8Bssid[2],
2788 strHostIfBASessionInfo->u16BufferSize,
2789 strHostIfBASessionInfo->u16SessionTimeout,
2790 strHostIfBASessionInfo->u8Ted);
2791
daaf16ba 2792 strWID.id = (u16)WID_11E_P_ACTION_REQ;
416d8321 2793 strWID.type = WID_STR;
900bb4a6 2794 strWID.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
2fd3e443 2795 strWID.size = BLOCK_ACK_REQ_SIZE;
900bb4a6 2796 ptr = strWID.val;
c5c77ba1
JK		 2797 *ptr++ = 0x14;
2798 *ptr++ = 0x3;
2799 *ptr++ = 0x0;
d00d2ba3 2800 memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
c5c77ba1
JK		 2801 ptr += ETH_ALEN;
2802 *ptr++ = strHostIfBASessionInfo->u8Ted;
c5c77ba1 2803 *ptr++ = 1;
c5c77ba1
JK		 2804 *ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF);
2805 *ptr++ = ((strHostIfBASessionInfo->u16BufferSize >> 16) & 0xFF);
c5c77ba1
JK		 2806 *ptr++ = (strHostIfBASessionInfo->u16SessionTimeout & 0xFF);
2807 *ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
c5c77ba1
JK		 2808 *ptr++ = (AddbaTimeout & 0xFF);
2809 *ptr++ = ((AddbaTimeout >> 16) & 0xFF);
c5c77ba1 2810 *ptr++ = 8;
c5c77ba1
JK		 2811 *ptr++ = 0;
2812
03362286 2813 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2814 get_id_from_handler(hif_drv));
c5c77ba1
JK		 2815 if (s32Error)
2816 PRINT_D(HOSTINF_DBG, "Couldn't open BA Session\n");
2817
2818
daaf16ba 2819 strWID.id = (u16)WID_11E_P_ACTION_REQ;
416d8321 2820 strWID.type = WID_STR;
2fd3e443 2821 strWID.size = 15;
900bb4a6 2822 ptr = strWID.val;
c5c77ba1
JK		 2823 *ptr++ = 15;
2824 *ptr++ = 7;
2825 *ptr++ = 0x2;
d00d2ba3 2826 memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
c5c77ba1 2827 ptr += ETH_ALEN;
c5c77ba1 2828 *ptr++ = strHostIfBASessionInfo->u8Ted;
c5c77ba1 2829 *ptr++ = 8;
c5c77ba1
JK		 2830 *ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF);
2831 *ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
c5c77ba1 2832 *ptr++ = 3;
03362286 2833 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2834 get_id_from_handler(hif_drv));
c5c77ba1 2835
95f840fb 2836 kfree(strWID.val);
c5c77ba1
JK		 2837
2838 return s32Error;
2839
2840}
2841
a4ab1ade 2842static s32 Handle_DelAllRxBASessions(struct host_if_drv *hif_drv,
54265472 2843 struct ba_session_info *strHostIfBASessionInfo)
c5c77ba1 2844{
e6e12661 2845 s32 s32Error = 0;
e9e0c260 2846 struct wid strWID;
c5c77ba1 2847 char *ptr = NULL;
c5c77ba1 2848
03b2d5e7 2849 PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
c5c77ba1
JK		 2850 strHostIfBASessionInfo->au8Bssid[0],
2851 strHostIfBASessionInfo->au8Bssid[1],
2852 strHostIfBASessionInfo->au8Bssid[2],
2853 strHostIfBASessionInfo->u8Ted);
2854
daaf16ba 2855 strWID.id = (u16)WID_DEL_ALL_RX_BA;
416d8321 2856 strWID.type = WID_STR;
900bb4a6 2857 strWID.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
2fd3e443 2858 strWID.size = BLOCK_ACK_REQ_SIZE;
900bb4a6 2859 ptr = strWID.val;
c5c77ba1
JK		 2860 *ptr++ = 0x14;
2861 *ptr++ = 0x3;
2862 *ptr++ = 0x2;
d00d2ba3 2863 memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
c5c77ba1
JK		 2864 ptr += ETH_ALEN;
2865 *ptr++ = strHostIfBASessionInfo->u8Ted;
c5c77ba1 2866 *ptr++ = 0;
ae4dfa57 2867 *ptr++ = 32;
c5c77ba1 2868
03362286 2869 s32Error = send_config_pkt(SET_CFG, &strWID, 1,
a4ab1ade 2870 get_id_from_handler(hif_drv));
c5c77ba1
JK		 2871 if (s32Error)
2872 PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
2873
2874
95f840fb 2875 kfree(strWID.val);
c5c77ba1 2876
2d25af87 2877 up(&hif_sema_wait_response);
c5c77ba1
JK		 2878
2879 return s32Error;
2880
2881}
2882
1999bd52 2883static int hostIFthread(void *pvArg)
c5c77ba1 2884{
4e4467fd 2885 u32 u32Ret;
143eb95a 2886 struct host_if_msg msg;
a4ab1ade 2887 struct host_if_drv *hif_drv;
c5c77ba1 2888
143eb95a 2889 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 2890
2891 while (1) {
cb067dcf 2892 wilc_mq_recv(&hif_msg_q, &msg, sizeof(struct host_if_msg), &u32Ret);
a4ab1ade 2893 hif_drv = (struct host_if_drv *)msg.drv;
a9f812a6 2894 if (msg.id == HOST_IF_MSG_EXIT) {
c5c77ba1
JK		 2895 PRINT_D(GENERIC_DBG, "THREAD: Exiting HostIfThread\n");
2896 break;
2897 }
2898
c5c77ba1
JK		 2899 if ((!g_wilc_initialized)) {
2900 PRINT_D(GENERIC_DBG, "--WAIT--");
80e29c7a 2901 usleep_range(200 * 1000, 200 * 1000);
cb067dcf 2902 wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 2903 continue;
2904 }
2905
a4ab1ade 2906 if (msg.id == HOST_IF_MSG_CONNECT && hif_drv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
c5c77ba1 2907 PRINT_D(HOSTINF_DBG, "Requeue connect request till scan done received\n");
cb067dcf 2908 wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
80e29c7a 2909 usleep_range(2 * 1000, 2 * 1000);
c5c77ba1
JK		 2910 continue;
2911 }
2912
a9f812a6 2913 switch (msg.id) {
c5c77ba1
JK		 2914 case HOST_IF_MSG_Q_IDLE:
2915 Handle_wait_msg_q_empty();
2916 break;
2917
2918 case HOST_IF_MSG_SCAN:
2482a79f 2919 Handle_Scan(msg.drv, &msg.body.scan_info);
c5c77ba1
JK		 2920 break;
2921
2922 case HOST_IF_MSG_CONNECT:
2482a79f 2923 Handle_Connect(msg.drv, &msg.body.con_info);
c5c77ba1
JK		 2924 break;
2925
c5c77ba1 2926 case HOST_IF_MSG_FLUSH_CONNECT:
2482a79f 2927 Handle_FlushConnect(msg.drv);
c5c77ba1
JK		 2928 break;
2929
2930 case HOST_IF_MSG_RCVD_NTWRK_INFO:
2482a79f 2931 Handle_RcvdNtwrkInfo(msg.drv, &msg.body.net_info);
c5c77ba1
JK		 2932 break;
2933
2934 case HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO:
2482a79f 2935 Handle_RcvdGnrlAsyncInfo(msg.drv, &msg.body.async_info);
c5c77ba1
JK		 2936 break;
2937
2938 case HOST_IF_MSG_KEY:
2482a79f 2939 Handle_Key(msg.drv, &msg.body.key_info);
c5c77ba1
JK		 2940 break;
2941
2942 case HOST_IF_MSG_CFG_PARAMS:
2943
2482a79f 2944 Handle_CfgParam(msg.drv, &msg.body.cfg_info);
c5c77ba1
JK		 2945 break;
2946
2947 case HOST_IF_MSG_SET_CHANNEL:
2482a79f 2948 Handle_SetChannel(msg.drv, &msg.body.channel_info);
c5c77ba1
JK		 2949 break;
2950
2951 case HOST_IF_MSG_DISCONNECT:
2482a79f 2952 Handle_Disconnect(msg.drv);
c5c77ba1
JK		 2953 break;
2954
2955 case HOST_IF_MSG_RCVD_SCAN_COMPLETE:
a4ab1ade 2956 del_timer(&hif_drv->hScanTimer);
c5c77ba1
JK		 2957 PRINT_D(HOSTINF_DBG, "scan completed successfully\n");
2958
2b9d5b48 2959 if (!linux_wlan_get_num_conn_ifcs())
c5c77ba1 2960 chip_sleep_manually(INFINITE_SLEEP_TIME);
c5c77ba1 2961
2482a79f 2962 Handle_ScanDone(msg.drv, SCAN_EVENT_DONE);
c5c77ba1 2963
a4ab1ade 2964 if (hif_drv->u8RemainOnChan_pendingreq)
2482a79f 2965 Handle_RemainOnChan(msg.drv, &msg.body.remain_on_ch);
c5c77ba1
JK		 2966
2967 break;
2968
2969 case HOST_IF_MSG_GET_RSSI:
2482a79f 2970 Handle_GetRssi(msg.drv);
c5c77ba1
JK		 2971 break;
2972
2973 case HOST_IF_MSG_GET_LINKSPEED:
2482a79f 2974 Handle_GetLinkspeed(msg.drv);
c5c77ba1
JK		 2975 break;
2976
2977 case HOST_IF_MSG_GET_STATISTICS:
03e7b9c4 2978 Handle_GetStatistics(msg.drv, (struct rf_info *)msg.body.data);
c5c77ba1
JK		 2979 break;
2980
2981 case HOST_IF_MSG_GET_CHNL:
2482a79f 2982 Handle_GetChnl(msg.drv);
c5c77ba1
JK		 2983 break;
2984
c5c77ba1 2985 case HOST_IF_MSG_ADD_BEACON:
2482a79f 2986 Handle_AddBeacon(msg.drv, &msg.body.beacon_info);
c5c77ba1
JK		 2987 break;
2988
2989 case HOST_IF_MSG_DEL_BEACON:
2482a79f 2990 Handle_DelBeacon(msg.drv);
c5c77ba1
JK		 2991 break;
2992
2993 case HOST_IF_MSG_ADD_STATION:
2482a79f 2994 Handle_AddStation(msg.drv, &msg.body.add_sta_info);
c5c77ba1
JK		 2995 break;
2996
2997 case HOST_IF_MSG_DEL_STATION:
2482a79f 2998 Handle_DelStation(msg.drv, &msg.body.del_sta_info);
c5c77ba1
JK		 2999 break;
3000
3001 case HOST_IF_MSG_EDIT_STATION:
2482a79f 3002 Handle_EditStation(msg.drv, &msg.body.edit_sta_info);
c5c77ba1
JK		 3003 break;
3004
3005 case HOST_IF_MSG_GET_INACTIVETIME:
2482a79f 3006 Handle_Get_InActiveTime(msg.drv, &msg.body.mac_info);
c5c77ba1
JK		 3007 break;
3008
c5c77ba1
JK		 3009 case HOST_IF_MSG_SCAN_TIMER_FIRED:
3010 PRINT_D(HOSTINF_DBG, "Scan Timeout\n");
3011
2482a79f 3012 Handle_ScanDone(msg.drv, SCAN_EVENT_ABORTED);
c5c77ba1
JK		 3013 break;
3014
3015 case HOST_IF_MSG_CONNECT_TIMER_FIRED:
03b2d5e7 3016 PRINT_D(HOSTINF_DBG, "Connect Timeout\n");
2482a79f 3017 Handle_ConnectTimeout(msg.drv);
c5c77ba1
JK		 3018 break;
3019
3020 case HOST_IF_MSG_POWER_MGMT:
2482a79f 3021 Handle_PowerManagement(msg.drv, &msg.body.pwr_mgmt_info);
c5c77ba1
JK		 3022 break;
3023
3024 case HOST_IF_MSG_SET_WFIDRV_HANDLER:
2482a79f 3025 Handle_SetWfiDrvHandler(msg.drv,
5e4377e6 3026 &msg.body.drv);
c5c77ba1
JK		 3027 break;
3028
3029 case HOST_IF_MSG_SET_OPERATION_MODE:
2482a79f 3030 Handle_SetOperationMode(msg.drv, &msg.body.mode);
c5c77ba1
JK		 3031 break;
3032
3033 case HOST_IF_MSG_SET_IPADDRESS:
3034 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_IPADDRESS\n");
78675be5 3035 Handle_set_IPAddress(msg.drv, msg.body.ip_info.ip_addr, msg.body.ip_info.idx);
c5c77ba1
JK		 3036 break;
3037
3038 case HOST_IF_MSG_GET_IPADDRESS:
3039 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_IPADDRESS\n");
78675be5 3040 Handle_get_IPAddress(msg.drv, msg.body.ip_info.ip_addr, msg.body.ip_info.idx);
c5c77ba1
JK		 3041 break;
3042
c5c77ba1 3043 case HOST_IF_MSG_SET_MAC_ADDRESS:
2482a79f 3044 Handle_SetMacAddress(msg.drv, &msg.body.set_mac_info);
c5c77ba1
JK		 3045 break;
3046
c5c77ba1 3047 case HOST_IF_MSG_GET_MAC_ADDRESS:
2482a79f 3048 Handle_GetMacAddress(msg.drv, &msg.body.get_mac_info);
c5c77ba1
JK		 3049 break;
3050
c5c77ba1
JK		 3051 case HOST_IF_MSG_REMAIN_ON_CHAN:
3052 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_REMAIN_ON_CHAN\n");
2482a79f 3053 Handle_RemainOnChan(msg.drv, &msg.body.remain_on_ch);
c5c77ba1
JK		 3054 break;
3055
3056 case HOST_IF_MSG_REGISTER_FRAME:
3057 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_REGISTER_FRAME\n");
2482a79f 3058 Handle_RegisterFrame(msg.drv, &msg.body.reg_frame);
c5c77ba1
JK		 3059 break;
3060
3061 case HOST_IF_MSG_LISTEN_TIMER_FIRED:
2482a79f 3062 Handle_ListenStateExpired(msg.drv, &msg.body.remain_on_ch);
c5c77ba1
JK		 3063 break;
3064
c5c77ba1
JK		 3065 case HOST_IF_MSG_SET_MULTICAST_FILTER:
3066 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_MULTICAST_FILTER\n");
2482a79f 3067 Handle_SetMulticastFilter(msg.drv, &msg.body.multicast_info);
c5c77ba1
JK		 3068 break;
3069
c5c77ba1 3070 case HOST_IF_MSG_ADD_BA_SESSION:
2482a79f 3071 Handle_AddBASession(msg.drv, &msg.body.session_info);
c5c77ba1
JK		 3072 break;
3073
3074 case HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS:
2482a79f 3075 Handle_DelAllRxBASessions(msg.drv, &msg.body.session_info);
c5c77ba1
JK		 3076 break;
3077
3078 case HOST_IF_MSG_DEL_ALL_STA:
2482a79f 3079 Handle_DelAllSta(msg.drv, &msg.body.del_all_sta_info);
c5c77ba1
JK		 3080 break;
3081
3082 default:
03b2d5e7 3083 PRINT_ER("[Host Interface] undefined Received Msg ID\n");
c5c77ba1
JK		 3084 break;
3085 }
3086 }
3087
3088 PRINT_D(HOSTINF_DBG, "Releasing thread exit semaphore\n");
834e0cb0 3089 up(&hif_sema_thread);
1999bd52 3090 return 0;
c5c77ba1
JK		 3091}
3092
93dee8ee 3093static void TimerCB_Scan(unsigned long arg)
c5c77ba1 3094{
93dee8ee 3095 void *pvArg = (void *)arg;
143eb95a 3096 struct host_if_msg msg;
c5c77ba1 3097
143eb95a 3098 memset(&msg, 0, sizeof(struct host_if_msg));
2482a79f 3099 msg.drv = pvArg;
a9f812a6 3100 msg.id = HOST_IF_MSG_SCAN_TIMER_FIRED;
c5c77ba1 3101
cb067dcf 3102 wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3103}
3104
93dee8ee 3105static void TimerCB_Connect(unsigned long arg)
c5c77ba1 3106{
93dee8ee 3107 void *pvArg = (void *)arg;
143eb95a 3108 struct host_if_msg msg;
c5c77ba1 3109
143eb95a 3110 memset(&msg, 0, sizeof(struct host_if_msg));
2482a79f 3111 msg.drv = pvArg;
a9f812a6 3112 msg.id = HOST_IF_MSG_CONNECT_TIMER_FIRED;
c5c77ba1 3113
cb067dcf 3114 wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3115}
3116
a4ab1ade 3117s32 host_int_remove_key(struct host_if_drv *hif_drv, const u8 *pu8StaAddress)
c5c77ba1 3118{
e9e0c260 3119 struct wid strWID;
c5c77ba1 3120
daaf16ba 3121 strWID.id = (u16)WID_REMOVE_KEY;
416d8321 3122 strWID.type = WID_STR;
900bb4a6 3123 strWID.val = (s8 *)pu8StaAddress;
2fd3e443 3124 strWID.size = 6;
c5c77ba1 3125
b68d820b 3126 return 0;
c5c77ba1
JK		 3127}
3128
a4ab1ade 3129int host_int_remove_wep_key(struct host_if_drv *hif_drv, u8 index)
c5c77ba1 3130{
9e5e8b44 3131 int result = 0;
143eb95a 3132 struct host_if_msg msg;
c5c77ba1 3133
a4ab1ade 3134 if (!hif_drv) {
9e5e8b44 3135 result = -EFAULT;
24db713f 3136 PRINT_ER("Failed to send setup multicast config packet\n");
9e5e8b44 3137 return result;
24db713f 3138 }
c5c77ba1 3139
143eb95a 3140 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3141
a9f812a6 3142 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3143 msg.body.key_info.type = WEP;
0d17e382 3144 msg.body.key_info.action = REMOVEKEY;
a4ab1ade 3145 msg.drv = hif_drv;
73b2e381 3146 msg.body.key_info.attr.wep.index = index;
c5c77ba1 3147
cb067dcf 3148 result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
9e5e8b44 3149 if (result)
03b2d5e7 3150 PRINT_ER("Error in sending message queue : Request to remove WEP key\n");
a4ab1ade 3151 down(&hif_drv->hSemTestKeyBlock);
c5c77ba1 3152
9e5e8b44 3153 return result;
c5c77ba1
JK		 3154}
3155
a4ab1ade 3156s32 host_int_set_WEPDefaultKeyID(struct host_if_drv *hif_drv, u8 u8Index)
c5c77ba1 3157{
e6e12661 3158 s32 s32Error = 0;
143eb95a 3159 struct host_if_msg msg;
c5c77ba1
JK		 3160
3161
a4ab1ade 3162 if (!hif_drv) {
24db713f
LK		 3163 s32Error = -EFAULT;
3164 PRINT_ER("driver is null\n");
3165 return s32Error;
3166 }
c5c77ba1 3167
143eb95a 3168 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 3169
3170
a9f812a6 3171 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3172 msg.body.key_info.type = WEP;
0d17e382 3173 msg.body.key_info.action = DEFAULTKEY;
a4ab1ade 3174 msg.drv = hif_drv;
73b2e381 3175 msg.body.key_info.attr.wep.index = u8Index;
c5c77ba1 3176
cb067dcf 3177 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3178 if (s32Error)
3179 PRINT_ER("Error in sending message queue : Default key index\n");
a4ab1ade 3180 down(&hif_drv->hSemTestKeyBlock);
c5c77ba1 3181
c5c77ba1
JK		 3182 return s32Error;
3183}
3184
a4ab1ade
TC		 3185s32 host_int_add_wep_key_bss_sta(struct host_if_drv *hif_drv,
3186 const u8 *pu8WepKey,
3187 u8 u8WepKeylen,
3188 u8 u8Keyidx)
c5c77ba1
JK		 3189{
3190
e6e12661 3191 s32 s32Error = 0;
143eb95a 3192 struct host_if_msg msg;
c5c77ba1 3193
a4ab1ade 3194 if (!hif_drv) {
24db713f
LK		 3195 s32Error = -EFAULT;
3196 PRINT_ER("driver is null\n");
3197 return s32Error;
3198 }
c5c77ba1 3199
143eb95a 3200 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 3201
3202
a9f812a6 3203 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3204 msg.body.key_info.type = WEP;
0d17e382 3205 msg.body.key_info.action = ADDKEY;
a4ab1ade 3206 msg.drv = hif_drv;
73b2e381
LK		 3207 msg.body.key_info.attr.wep.key = kmalloc(u8WepKeylen, GFP_KERNEL);
3208 memcpy(msg.body.key_info.attr.wep.key, pu8WepKey, u8WepKeylen);
3209 msg.body.key_info.attr.wep.key_len = (u8WepKeylen);
3210 msg.body.key_info.attr.wep.index = u8Keyidx;
c5c77ba1 3211
cb067dcf 3212 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3213 if (s32Error)
3214 PRINT_ER("Error in sending message queue :WEP Key\n");
a4ab1ade 3215 down(&hif_drv->hSemTestKeyBlock);
c5c77ba1 3216
c5c77ba1
JK		 3217 return s32Error;
3218
3219}
3220
a4ab1ade
TC		 3221s32 host_int_add_wep_key_bss_ap(struct host_if_drv *hif_drv,
3222 const u8 *pu8WepKey,
3223 u8 u8WepKeylen,
3224 u8 u8Keyidx,
3225 u8 u8mode,
3226 enum AUTHTYPE tenuAuth_type)
c5c77ba1
JK		 3227{
3228
e6e12661 3229 s32 s32Error = 0;
143eb95a 3230 struct host_if_msg msg;
63d03e47 3231 u8 i;
c5c77ba1 3232
a4ab1ade 3233 if (!hif_drv) {
24db713f
LK		 3234 s32Error = -EFAULT;
3235 PRINT_ER("driver is null\n");
3236 return s32Error;
3237 }
c5c77ba1 3238
143eb95a 3239 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 3240
3241 if (INFO) {
3242 for (i = 0; i < u8WepKeylen; i++)
3243 PRINT_INFO(HOSTAPD_DBG, "KEY is %x\n", pu8WepKey[i]);
3244 }
a9f812a6 3245 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3246 msg.body.key_info.type = WEP;
0d17e382 3247 msg.body.key_info.action = ADDKEY_AP;
a4ab1ade 3248 msg.drv = hif_drv;
73b2e381
LK		 3249 msg.body.key_info.attr.wep.key = kmalloc(u8WepKeylen, GFP_KERNEL);
3250 memcpy(msg.body.key_info.attr.wep.key, pu8WepKey, (u8WepKeylen));
3251 msg.body.key_info.attr.wep.key_len = (u8WepKeylen);
3252 msg.body.key_info.attr.wep.index = u8Keyidx;
3253 msg.body.key_info.attr.wep.mode = u8mode;
3254 msg.body.key_info.attr.wep.auth_type = tenuAuth_type;
ae4dfa57 3255
cb067dcf 3256 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3257
3258 if (s32Error)
3259 PRINT_ER("Error in sending message queue :WEP Key\n");
a4ab1ade 3260 down(&hif_drv->hSemTestKeyBlock);
c5c77ba1 3261
c5c77ba1
JK		 3262 return s32Error;
3263
3264}
108b3439 3265
a4ab1ade
TC		 3266s32 host_int_add_ptk(struct host_if_drv *hif_drv, const u8 *pu8Ptk,
3267 u8 u8PtkKeylen, const u8 *mac_addr,
3268 const u8 *pu8RxMic, const u8 *pu8TxMic,
3269 u8 mode, u8 u8Ciphermode, u8 u8Idx)
c5c77ba1 3270{
e6e12661 3271 s32 s32Error = 0;
143eb95a 3272 struct host_if_msg msg;
63d03e47 3273 u8 u8KeyLen = u8PtkKeylen;
4e4467fd 3274 u32 i;
78c87591 3275
a4ab1ade 3276 if (!hif_drv) {
24db713f
LK		 3277 s32Error = -EFAULT;
3278 PRINT_ER("driver is null\n");
3279 return s32Error;
3280 }
2b9d5b48 3281 if (pu8RxMic != NULL)
c5c77ba1 3282 u8KeyLen += RX_MIC_KEY_LEN;
2b9d5b48 3283 if (pu8TxMic != NULL)
c5c77ba1 3284 u8KeyLen += TX_MIC_KEY_LEN;
c5c77ba1 3285
143eb95a 3286 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 3287
3288
a9f812a6 3289 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3290 msg.body.key_info.type = WPAPtk;
c5c77ba1 3291 if (mode == AP_MODE) {
0d17e382 3292 msg.body.key_info.action = ADDKEY_AP;
e2dfbac5 3293 msg.body.key_info.attr.wpa.index = u8Idx;
c5c77ba1 3294 }
c5c77ba1 3295 if (mode == STATION_MODE)
0d17e382 3296 msg.body.key_info.action = ADDKEY;
c5c77ba1 3297
124968fc
LK		 3298 msg.body.key_info.attr.wpa.key = kmalloc(u8PtkKeylen, GFP_KERNEL);
3299 memcpy(msg.body.key_info.attr.wpa.key, pu8Ptk, u8PtkKeylen);
c5c77ba1
JK		 3300
3301 if (pu8RxMic != NULL) {
124968fc 3302 memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic, RX_MIC_KEY_LEN);
c5c77ba1
JK		 3303 if (INFO) {
3304 for (i = 0; i < RX_MIC_KEY_LEN; i++)
3305 PRINT_INFO(CFG80211_DBG, "PairwiseRx[%d] = %x\n", i, pu8RxMic[i]);
3306 }
3307 }
3308 if (pu8TxMic != NULL) {
124968fc 3309 memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic, TX_MIC_KEY_LEN);
c5c77ba1
JK		 3310 if (INFO) {
3311 for (i = 0; i < TX_MIC_KEY_LEN; i++)
3312 PRINT_INFO(CFG80211_DBG, "PairwiseTx[%d] = %x\n", i, pu8TxMic[i]);
3313 }
3314 }
3315
6acf2919 3316 msg.body.key_info.attr.wpa.key_len = u8KeyLen;
248080aa 3317 msg.body.key_info.attr.wpa.mac_addr = mac_addr;
7b2ebb28 3318 msg.body.key_info.attr.wpa.mode = u8Ciphermode;
a4ab1ade 3319 msg.drv = hif_drv;
c5c77ba1 3320
cb067dcf 3321 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3322
3323 if (s32Error)
3324 PRINT_ER("Error in sending message queue: PTK Key\n");
3325
a4ab1ade 3326 down(&hif_drv->hSemTestKeyBlock);
c5c77ba1 3327
c5c77ba1
JK		 3328 return s32Error;
3329}
3330
a4ab1ade
TC		 3331s32 host_int_add_rx_gtk(struct host_if_drv *hif_drv, const u8 *pu8RxGtk,
3332 u8 u8GtkKeylen, u8 u8KeyIdx,
3333 u32 u32KeyRSClen, const u8 *KeyRSC,
3334 const u8 *pu8RxMic, const u8 *pu8TxMic,
3335 u8 mode, u8 u8Ciphermode)
c5c77ba1 3336{
e6e12661 3337 s32 s32Error = 0;
143eb95a 3338 struct host_if_msg msg;
63d03e47 3339 u8 u8KeyLen = u8GtkKeylen;
c5c77ba1 3340
a4ab1ade 3341 if (!hif_drv) {
24db713f
LK		 3342 s32Error = -EFAULT;
3343 PRINT_ER("driver is null\n");
3344 return s32Error;
3345 }
143eb95a 3346 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 3347
3348
2b9d5b48 3349 if (pu8RxMic != NULL)
c5c77ba1 3350 u8KeyLen += RX_MIC_KEY_LEN;
2b9d5b48 3351 if (pu8TxMic != NULL)
c5c77ba1 3352 u8KeyLen += TX_MIC_KEY_LEN;
c5c77ba1 3353 if (KeyRSC != NULL) {
0e74c009
LK		 3354 msg.body.key_info.attr.wpa.seq = kmalloc(u32KeyRSClen, GFP_KERNEL);
3355 memcpy(msg.body.key_info.attr.wpa.seq, KeyRSC, u32KeyRSClen);
c5c77ba1
JK		 3356 }
3357
3358
a9f812a6 3359 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3360 msg.body.key_info.type = WPARxGtk;
a4ab1ade 3361 msg.drv = hif_drv;
c5c77ba1 3362
c5c77ba1 3363 if (mode == AP_MODE) {
0d17e382 3364 msg.body.key_info.action = ADDKEY_AP;
7b2ebb28 3365 msg.body.key_info.attr.wpa.mode = u8Ciphermode;
c5c77ba1 3366 }
c5c77ba1 3367 if (mode == STATION_MODE)
0d17e382 3368 msg.body.key_info.action = ADDKEY;
c5c77ba1 3369
124968fc
LK		 3370 msg.body.key_info.attr.wpa.key = kmalloc(u8KeyLen, GFP_KERNEL);
3371 memcpy(msg.body.key_info.attr.wpa.key, pu8RxGtk, u8GtkKeylen);
c5c77ba1
JK		 3372
3373 if (pu8RxMic != NULL) {
124968fc 3374 memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic, RX_MIC_KEY_LEN);
c5c77ba1
JK		 3375 }
3376 if (pu8TxMic != NULL) {
124968fc 3377 memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic, TX_MIC_KEY_LEN);
c5c77ba1
JK		 3378 }
3379
e2dfbac5 3380 msg.body.key_info.attr.wpa.index = u8KeyIdx;
6acf2919 3381 msg.body.key_info.attr.wpa.key_len = u8KeyLen;
dacc594d 3382 msg.body.key_info.attr.wpa.seq_len = u32KeyRSClen;
c5c77ba1 3383
cb067dcf 3384 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3385 if (s32Error)
3386 PRINT_ER("Error in sending message queue: RX GTK\n");
ae4dfa57 3387
a4ab1ade 3388 down(&hif_drv->hSemTestKeyBlock);
c5c77ba1 3389
c5c77ba1
JK		 3390 return s32Error;
3391}
c5c77ba1 3392
a4ab1ade 3393s32 host_int_set_pmkid_info(struct host_if_drv *hif_drv, struct host_if_pmkid_attr *pu8PmkidInfoArray)
c5c77ba1 3394{
e6e12661 3395 s32 s32Error = 0;
143eb95a 3396 struct host_if_msg msg;
4e4467fd 3397 u32 i;
c5c77ba1
JK		 3398
3399
a4ab1ade 3400 if (!hif_drv) {
24db713f
LK		 3401 s32Error = -EFAULT;
3402 PRINT_ER("driver is null\n");
3403 return s32Error;
3404 }
c5c77ba1 3405
143eb95a 3406 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3407
a9f812a6 3408 msg.id = HOST_IF_MSG_KEY;
8e9f427a 3409 msg.body.key_info.type = PMKSA;
0d17e382 3410 msg.body.key_info.action = ADDKEY;
a4ab1ade 3411 msg.drv = hif_drv;
c5c77ba1
JK		 3412
3413 for (i = 0; i < pu8PmkidInfoArray->numpmkid; i++) {
73b2e381 3414 memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].bssid, &pu8PmkidInfoArray->pmkidlist[i].bssid,
c5c77ba1 3415 ETH_ALEN);
73b2e381 3416 memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].pmkid, &pu8PmkidInfoArray->pmkidlist[i].pmkid,
c5c77ba1
JK		 3417 PMKID_LEN);
3418 }
3419
cb067dcf 3420 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3421 if (s32Error)
3422 PRINT_ER(" Error in sending messagequeue: PMKID Info\n");
3423
c5c77ba1
JK		 3424 return s32Error;
3425}
3426
a4ab1ade
TC		 3427s32 host_int_get_pmkid_info(struct host_if_drv *hif_drv,
3428 u8 *pu8PmkidInfoArray,
3429 u32 u32PmkidInfoLen)
c5c77ba1 3430{
e9e0c260 3431 struct wid strWID;
c5c77ba1 3432
daaf16ba 3433 strWID.id = (u16)WID_PMKID_INFO;
416d8321 3434 strWID.type = WID_STR;
2fd3e443 3435 strWID.size = u32PmkidInfoLen;
900bb4a6 3436 strWID.val = pu8PmkidInfoArray;
c5c77ba1 3437
b68d820b 3438 return 0;
c5c77ba1
JK		 3439}
3440
a4ab1ade
TC		 3441s32 host_int_set_RSNAConfigPSKPassPhrase(struct host_if_drv *hif_drv,
3442 u8 *pu8PassPhrase,
3443 u8 u8Psklength)
c5c77ba1 3444{
e9e0c260 3445 struct wid strWID;
c5c77ba1 3446
c5c77ba1 3447 if ((u8Psklength > 7) && (u8Psklength < 65)) {
daaf16ba 3448 strWID.id = (u16)WID_11I_PSK;
416d8321 3449 strWID.type = WID_STR;
900bb4a6 3450 strWID.val = pu8PassPhrase;
2fd3e443 3451 strWID.size = u8Psklength;
c5c77ba1
JK		 3452 }
3453
b68d820b 3454 return 0;
c5c77ba1 3455}
ae4dfa57 3456
a4ab1ade 3457s32 host_int_get_MacAddress(struct host_if_drv *hif_drv, u8 *pu8MacAddress)
c5c77ba1 3458{
e6e12661 3459 s32 s32Error = 0;
143eb95a 3460 struct host_if_msg msg;
c5c77ba1 3461
143eb95a 3462 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3463
a9f812a6 3464 msg.id = HOST_IF_MSG_GET_MAC_ADDRESS;
a5848695 3465 msg.body.get_mac_info.u8MacAddress = pu8MacAddress;
a4ab1ade 3466 msg.drv = hif_drv;
ae4dfa57 3467
cb067dcf 3468 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3469 if (s32Error) {
3470 PRINT_ER("Failed to send get mac address\n");
e6e12661 3471 return -EFAULT;
c5c77ba1
JK		 3472 }
3473
2d25af87 3474 down(&hif_sema_wait_response);
c5c77ba1
JK		 3475 return s32Error;
3476}
3477
a4ab1ade 3478s32 host_int_set_MacAddress(struct host_if_drv *hif_drv, u8 *pu8MacAddress)
c5c77ba1 3479{
e6e12661 3480 s32 s32Error = 0;
143eb95a 3481 struct host_if_msg msg;
c5c77ba1
JK		 3482
3483 PRINT_D(GENERIC_DBG, "mac addr = %x:%x:%x\n", pu8MacAddress[0], pu8MacAddress[1], pu8MacAddress[2]);
3484
143eb95a 3485 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 3486 msg.id = HOST_IF_MSG_SET_MAC_ADDRESS;
15326e28 3487 memcpy(msg.body.set_mac_info.u8MacAddress, pu8MacAddress, ETH_ALEN);
a4ab1ade 3488 msg.drv = hif_drv;
c5c77ba1 3489
cb067dcf 3490 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
24db713f 3491 if (s32Error)
c5c77ba1 3492 PRINT_ER("Failed to send message queue: Set mac address\n");
c5c77ba1
JK		 3493
3494 return s32Error;
3495
3496}
3497
a4ab1ade
TC		 3498s32 host_int_get_RSNAConfigPSKPassPhrase(struct host_if_drv *hif_drv,
3499 u8 *pu8PassPhrase, u8 u8Psklength)
c5c77ba1 3500{
e9e0c260 3501 struct wid strWID;
c5c77ba1 3502
daaf16ba 3503 strWID.id = (u16)WID_11I_PSK;
416d8321 3504 strWID.type = WID_STR;
2fd3e443 3505 strWID.size = u8Psklength;
900bb4a6 3506 strWID.val = pu8PassPhrase;
c5c77ba1 3507
b68d820b 3508 return 0;
c5c77ba1
JK		 3509}
3510
a4ab1ade 3511s32 host_int_set_start_scan_req(struct host_if_drv *hif_drv, u8 scanSource)
c5c77ba1 3512{
e9e0c260 3513 struct wid strWID;
c5c77ba1 3514
daaf16ba 3515 strWID.id = (u16)WID_START_SCAN_REQ;
416d8321 3516 strWID.type = WID_CHAR;
900bb4a6 3517 strWID.val = (s8 *)&scanSource;
2fd3e443 3518 strWID.size = sizeof(char);
c5c77ba1 3519
b68d820b 3520 return 0;
c5c77ba1
JK		 3521}
3522
a4ab1ade 3523s32 host_int_get_start_scan_req(struct host_if_drv *hif_drv, u8 *pu8ScanSource)
c5c77ba1 3524{
e9e0c260 3525 struct wid strWID;
c5c77ba1 3526
daaf16ba 3527 strWID.id = (u16)WID_START_SCAN_REQ;
416d8321 3528 strWID.type = WID_CHAR;
900bb4a6 3529 strWID.val = (s8 *)pu8ScanSource;
2fd3e443 3530 strWID.size = sizeof(char);
c5c77ba1 3531
b68d820b 3532 return 0;
c5c77ba1
JK		 3533}
3534
a4ab1ade
TC		 3535s32 host_int_set_join_req(struct host_if_drv *hif_drv, u8 *pu8bssid,
3536 const u8 *pu8ssid, size_t ssidLen,
3537 const u8 *pu8IEs, size_t IEsLen,
3538 wilc_connect_result pfConnectResult, void *pvUserArg,
3539 u8 u8security, enum AUTHTYPE tenuAuth_type,
3540 u8 u8channel, void *pJoinParams)
c5c77ba1 3541{
e6e12661 3542 s32 s32Error = 0;
143eb95a 3543 struct host_if_msg msg;
c5c77ba1 3544
a4ab1ade 3545 if (!hif_drv || pfConnectResult == NULL) {
24db713f
LK		 3546 s32Error = -EFAULT;
3547 PRINT_ER("Driver is null\n");
3548 return s32Error;
3549 }
c5c77ba1 3550
c5c77ba1
JK		 3551 if (pJoinParams == NULL) {
3552 PRINT_ER("Unable to Join - JoinParams is NULL\n");
24db713f 3553 return -EFAULT;
c5c77ba1 3554 }
24db713f 3555
143eb95a 3556 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3557
a9f812a6 3558 msg.id = HOST_IF_MSG_CONNECT;
c5c77ba1 3559
a64fd677 3560 msg.body.con_info.security = u8security;
61b4fd02 3561 msg.body.con_info.auth_type = tenuAuth_type;
0d1527e6 3562 msg.body.con_info.ch = u8channel;
6abcc11d 3563 msg.body.con_info.result = pfConnectResult;
8f38db89 3564 msg.body.con_info.arg = pvUserArg;
f2bed2ca 3565 msg.body.con_info.params = pJoinParams;
a4ab1ade 3566 msg.drv = hif_drv ;
c5c77ba1
JK		 3567
3568 if (pu8bssid != NULL) {
9254db07
LK		 3569 msg.body.con_info.bssid = kmalloc(6, GFP_KERNEL);
3570 memcpy(msg.body.con_info.bssid, pu8bssid, 6);
c5c77ba1
JK		 3571 }
3572
3573 if (pu8ssid != NULL) {
8b3c9fa6 3574 msg.body.con_info.ssid_len = ssidLen;
f7bbd9cf
LK		 3575 msg.body.con_info.ssid = kmalloc(ssidLen, GFP_KERNEL);
3576 memcpy(msg.body.con_info.ssid, pu8ssid, ssidLen);
c5c77ba1
JK		 3577 }
3578
3579 if (pu8IEs != NULL) {
b59d5c5b 3580 msg.body.con_info.ies_len = IEsLen;
2ea158c4
LK		 3581 msg.body.con_info.ies = kmalloc(IEsLen, GFP_KERNEL);
3582 memcpy(msg.body.con_info.ies, pu8IEs, IEsLen);
c5c77ba1 3583 }
a4ab1ade
TC		 3584 if (hif_drv->enuHostIFstate < HOST_IF_CONNECTING)
3585 hif_drv->enuHostIFstate = HOST_IF_CONNECTING;
78174ada 3586 else
a4ab1ade 3587 PRINT_D(GENERIC_DBG, "Don't set state to 'connecting' as state is %d\n", hif_drv->enuHostIFstate);
c5c77ba1 3588
cb067dcf 3589 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3590 if (s32Error) {
3591 PRINT_ER("Failed to send message queue: Set join request\n");
24db713f 3592 return -EFAULT;
c5c77ba1
JK		 3593 }
3594
a4ab1ade
TC		 3595 hif_drv->hConnectTimer.data = (unsigned long)hif_drv;
3596 mod_timer(&hif_drv->hConnectTimer,
9eb06643 3597 jiffies + msecs_to_jiffies(HOST_IF_CONNECT_TIMEOUT));
c5c77ba1 3598
c5c77ba1
JK		 3599 return s32Error;
3600}
3601
a4ab1ade 3602s32 host_int_flush_join_req(struct host_if_drv *hif_drv)
c5c77ba1 3603{
e6e12661 3604 s32 s32Error = 0;
143eb95a 3605 struct host_if_msg msg;
c5c77ba1
JK		 3606
3607 if (!gu8FlushedJoinReq) {
e6e12661 3608 s32Error = -EFAULT;
c5c77ba1
JK		 3609 return s32Error;
3610 }
3611
3612
a4ab1ade 3613 if (!hif_drv) {
24db713f
LK		 3614 s32Error = -EFAULT;
3615 PRINT_ER("Driver is null\n");
3616 return s32Error;
3617 }
c5c77ba1 3618
a9f812a6 3619 msg.id = HOST_IF_MSG_FLUSH_CONNECT;
a4ab1ade 3620 msg.drv = hif_drv;
c5c77ba1 3621
cb067dcf 3622 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3623 if (s32Error) {
3624 PRINT_ER("Failed to send message queue: Flush join request\n");
24db713f 3625 return -EFAULT;
c5c77ba1
JK		 3626 }
3627
c5c77ba1
JK		 3628 return s32Error;
3629}
3630
a4ab1ade 3631s32 host_int_disconnect(struct host_if_drv *hif_drv, u16 u16ReasonCode)
c5c77ba1 3632{
e6e12661 3633 s32 s32Error = 0;
143eb95a 3634 struct host_if_msg msg;
c5c77ba1 3635
a4ab1ade 3636 if (!hif_drv) {
24db713f
LK		 3637 PRINT_ER("Driver is null\n");
3638 return -EFAULT;
c5c77ba1
JK		 3639 }
3640
143eb95a 3641 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3642
a9f812a6 3643 msg.id = HOST_IF_MSG_DISCONNECT;
a4ab1ade 3644 msg.drv = hif_drv;
c5c77ba1 3645
cb067dcf 3646 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3647 if (s32Error)
3648 PRINT_ER("Failed to send message queue: disconnect\n");
ae4dfa57 3649
a4ab1ade 3650 down(&hif_drv->hSemTestDisconnectBlock);
c5c77ba1 3651
c5c77ba1
JK		 3652 return s32Error;
3653}
3654
a4ab1ade 3655s32 host_int_disconnect_station(struct host_if_drv *hif_drv, u8 assoc_id)
c5c77ba1 3656{
e9e0c260 3657 struct wid strWID;
c5c77ba1 3658
daaf16ba 3659 strWID.id = (u16)WID_DISCONNECT;
416d8321 3660 strWID.type = WID_CHAR;
900bb4a6 3661 strWID.val = (s8 *)&assoc_id;
2fd3e443 3662 strWID.size = sizeof(char);
c5c77ba1 3663
b68d820b 3664 return 0;
c5c77ba1
JK		 3665}
3666
a4ab1ade 3667s32 host_int_get_assoc_req_info(struct host_if_drv *hif_drv, u8 *pu8AssocReqInfo,
4e4467fd 3668 u32 u32AssocReqInfoLen)
c5c77ba1 3669{
e9e0c260 3670 struct wid strWID;
c5c77ba1 3671
daaf16ba 3672 strWID.id = (u16)WID_ASSOC_REQ_INFO;
416d8321 3673 strWID.type = WID_STR;
900bb4a6 3674 strWID.val = pu8AssocReqInfo;
2fd3e443 3675 strWID.size = u32AssocReqInfoLen;
c5c77ba1 3676
b68d820b 3677 return 0;
c5c77ba1
JK		 3678}
3679
a4ab1ade 3680s32 host_int_get_assoc_res_info(struct host_if_drv *hif_drv, u8 *pu8AssocRespInfo,
4e4467fd 3681 u32 u32MaxAssocRespInfoLen, u32 *pu32RcvdAssocRespInfoLen)
c5c77ba1 3682{
e6e12661 3683 s32 s32Error = 0;
e9e0c260 3684 struct wid strWID;
c5c77ba1 3685
a4ab1ade 3686 if (!hif_drv) {
24db713f
LK		 3687 PRINT_ER("Driver is null\n");
3688 return -EFAULT;
c5c77ba1
JK		 3689 }
3690
daaf16ba 3691 strWID.id = (u16)WID_ASSOC_RES_INFO;
416d8321 3692 strWID.type = WID_STR;
900bb4a6 3693 strWID.val = pu8AssocRespInfo;
2fd3e443 3694 strWID.size = u32MaxAssocRespInfoLen;
c5c77ba1 3695
03362286 3696 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 3697 get_id_from_handler(hif_drv));
c5c77ba1 3698 if (s32Error) {
c5c77ba1 3699 *pu32RcvdAssocRespInfoLen = 0;
24db713f
LK		 3700 PRINT_ER("Failed to send association response config packet\n");
3701 return -EINVAL;
c5c77ba1 3702 } else {
2fd3e443 3703 *pu32RcvdAssocRespInfoLen = strWID.size;
c5c77ba1
JK		 3704 }
3705
c5c77ba1
JK		 3706 return s32Error;
3707}
3708
a4ab1ade 3709s32 host_int_get_rx_power_level(struct host_if_drv *hif_drv, u8 *pu8RxPowerLevel,
4e4467fd 3710 u32 u32RxPowerLevelLen)
c5c77ba1 3711{
e9e0c260 3712 struct wid strWID;
c5c77ba1 3713
daaf16ba 3714 strWID.id = (u16)WID_RX_POWER_LEVEL;
416d8321 3715 strWID.type = WID_STR;
900bb4a6 3716 strWID.val = pu8RxPowerLevel;
2fd3e443 3717 strWID.size = u32RxPowerLevelLen;
c5c77ba1 3718
b68d820b 3719 return 0;
c5c77ba1
JK		 3720}
3721
a4ab1ade 3722int host_int_set_mac_chnl_num(struct host_if_drv *hif_drv, u8 channel)
c5c77ba1 3723{
792fb25b 3724 int result;
143eb95a 3725 struct host_if_msg msg;
c5c77ba1 3726
a4ab1ade 3727 if (!hif_drv) {
24db713f
LK		 3728 PRINT_ER("driver is null\n");
3729 return -EFAULT;
3730 }
c5c77ba1 3731
143eb95a 3732 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 3733 msg.id = HOST_IF_MSG_SET_CHANNEL;
730ee059 3734 msg.body.channel_info.set_ch = channel;
a4ab1ade 3735 msg.drv = hif_drv;
c5c77ba1 3736
cb067dcf 3737 result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
1ef58e42 3738 if (result) {
24db713f 3739 PRINT_ER("wilc mq send fail\n");
792fb25b 3740 return -EINVAL;
c5c77ba1
JK		 3741 }
3742
792fb25b 3743 return 0;
c5c77ba1
JK		 3744}
3745
244efb1f 3746int host_int_wait_msg_queue_idle(void)
c5c77ba1 3747{
6d6c9bbb 3748 int result = 0;
c5c77ba1 3749
143eb95a 3750 struct host_if_msg msg;
143eb95a 3751 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 3752 msg.id = HOST_IF_MSG_Q_IDLE;
cb067dcf 3753 result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
6d6c9bbb 3754 if (result) {
24db713f 3755 PRINT_ER("wilc mq send fail\n");
6d6c9bbb 3756 result = -EINVAL;
c5c77ba1
JK		 3757 }
3758
2d25af87 3759 down(&hif_sema_wait_response);
c5c77ba1 3760
6d6c9bbb 3761 return result;
c5c77ba1
JK		 3762}
3763
a4ab1ade 3764int host_int_set_wfi_drv_handler(struct host_if_drv *hif_drv)
c5c77ba1 3765{
a094101c 3766 int result = 0;
c5c77ba1 3767
143eb95a 3768 struct host_if_msg msg;
143eb95a 3769 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 3770 msg.id = HOST_IF_MSG_SET_WFIDRV_HANDLER;
a4ab1ade
TC		 3771 msg.body.drv.u32Address = get_id_from_handler(hif_drv);
3772 msg.drv = hif_drv;
c5c77ba1 3773
cb067dcf 3774 result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
a094101c 3775 if (result) {
24db713f 3776 PRINT_ER("wilc mq send fail\n");
a094101c 3777 result = -EINVAL;
c5c77ba1
JK		 3778 }
3779
a094101c 3780 return result;
c5c77ba1
JK		 3781}
3782
a4ab1ade 3783int host_int_set_operation_mode(struct host_if_drv *hif_drv, u32 mode)
c5c77ba1 3784{
a0c1ee0c 3785 int result = 0;
c5c77ba1 3786
143eb95a 3787 struct host_if_msg msg;
143eb95a 3788 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 3789 msg.id = HOST_IF_MSG_SET_OPERATION_MODE;
49fb6f71 3790 msg.body.mode.u32Mode = mode;
a4ab1ade 3791 msg.drv = hif_drv;
c5c77ba1 3792
cb067dcf 3793 result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
a0c1ee0c 3794 if (result) {
24db713f 3795 PRINT_ER("wilc mq send fail\n");
a0c1ee0c 3796 result = -EINVAL;
c5c77ba1
JK		 3797 }
3798
a0c1ee0c 3799 return result;
c5c77ba1
JK		 3800}
3801
a4ab1ade 3802s32 host_int_get_host_chnl_num(struct host_if_drv *hif_drv, u8 *pu8ChNo)
c5c77ba1 3803{
e6e12661 3804 s32 s32Error = 0;
143eb95a 3805 struct host_if_msg msg;
c5c77ba1 3806
a4ab1ade 3807 if (!hif_drv) {
24db713f
LK		 3808 PRINT_ER("driver is null\n");
3809 return -EFAULT;
c5c77ba1
JK		 3810 }
3811
143eb95a 3812 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3813
a9f812a6 3814 msg.id = HOST_IF_MSG_GET_CHNL;
a4ab1ade 3815 msg.drv = hif_drv;
c5c77ba1 3816
cb067dcf 3817 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1 3818 if (s32Error)
24db713f 3819 PRINT_ER("wilc mq send fail\n");
a4ab1ade 3820 down(&hif_drv->hSemGetCHNL);
c5c77ba1
JK		 3821
3822 *pu8ChNo = gu8Chnl;
3823
c5c77ba1
JK		 3824 return s32Error;
3825
3826
3827}
3828
a4ab1ade
TC		 3829s32 host_int_get_inactive_time(struct host_if_drv *hif_drv,
3830 const u8 *mac, u32 *pu32InactiveTime)
c5c77ba1 3831{
e6e12661 3832 s32 s32Error = 0;
143eb95a 3833 struct host_if_msg msg;
c5c77ba1 3834
a4ab1ade 3835 if (!hif_drv) {
24db713f
LK		 3836 PRINT_ER("driver is null\n");
3837 return -EFAULT;
c5c77ba1
JK		 3838 }
3839
143eb95a 3840 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 3841
3842
66bac7f2 3843 memcpy(msg.body.mac_info.mac,
c5c77ba1
JK		 3844 mac, ETH_ALEN);
3845
a9f812a6 3846 msg.id = HOST_IF_MSG_GET_INACTIVETIME;
a4ab1ade 3847 msg.drv = hif_drv;
c5c77ba1 3848
cb067dcf 3849 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3850 if (s32Error)
3851 PRINT_ER("Failed to send get host channel param's message queue ");
3852
a4ab1ade 3853 down(&hif_drv->hSemInactiveTime);
c5c77ba1
JK		 3854
3855 *pu32InactiveTime = gu32InactiveTime;
3856
c5c77ba1
JK		 3857 return s32Error;
3858}
108b3439 3859
a4ab1ade 3860s32 host_int_test_get_int_wid(struct host_if_drv *hif_drv, u32 *pu32TestMemAddr)
c5c77ba1
JK		 3861{
3862
e6e12661 3863 s32 s32Error = 0;
e9e0c260 3864 struct wid strWID;
c5c77ba1 3865
a4ab1ade 3866 if (!hif_drv) {
24db713f
LK		 3867 PRINT_ER("driver is null\n");
3868 return -EFAULT;
c5c77ba1
JK		 3869 }
3870
daaf16ba 3871 strWID.id = (u16)WID_MEMORY_ADDRESS;
416d8321 3872 strWID.type = WID_INT;
900bb4a6 3873 strWID.val = (s8 *)pu32TestMemAddr;
2fd3e443 3874 strWID.size = sizeof(u32);
c5c77ba1 3875
03362286 3876 s32Error = send_config_pkt(GET_CFG, &strWID, 1,
a4ab1ade 3877 get_id_from_handler(hif_drv));
ae4dfa57 3878
c5c77ba1 3879 if (s32Error) {
24db713f
LK		 3880 PRINT_ER("Failed to get wid value\n");
3881 return -EINVAL;
c5c77ba1
JK		 3882 } else {
3883 PRINT_D(HOSTINF_DBG, "Successfully got wid value\n");
3884
3885 }
3886
c5c77ba1
JK		 3887 return s32Error;
3888}
3889
a4ab1ade 3890s32 host_int_get_rssi(struct host_if_drv *hif_drv, s8 *ps8Rssi)
c5c77ba1 3891{
e6e12661 3892 s32 s32Error = 0;
143eb95a 3893 struct host_if_msg msg;
143eb95a 3894 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3895
a9f812a6 3896 msg.id = HOST_IF_MSG_GET_RSSI;
a4ab1ade 3897 msg.drv = hif_drv;
c5c77ba1 3898
cb067dcf 3899 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3900 if (s32Error) {
3901 PRINT_ER("Failed to send get host channel param's message queue ");
e6e12661 3902 return -EFAULT;
c5c77ba1
JK		 3903 }
3904
a4ab1ade 3905 down(&hif_drv->hSemGetRSSI);
c5c77ba1
JK		 3906
3907
3908 if (ps8Rssi == NULL) {
3909 PRINT_ER("RSS pointer value is null");
e6e12661 3910 return -EFAULT;
c5c77ba1
JK		 3911 }
3912
3913
3914 *ps8Rssi = gs8Rssi;
3915
3916
3917 return s32Error;
3918}
3919
a4ab1ade 3920s32 host_int_get_link_speed(struct host_if_drv *hif_drv, s8 *ps8lnkspd)
c5c77ba1 3921{
143eb95a 3922 struct host_if_msg msg;
e6e12661 3923 s32 s32Error = 0;
143eb95a 3924 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3925
a9f812a6 3926 msg.id = HOST_IF_MSG_GET_LINKSPEED;
a4ab1ade 3927 msg.drv = hif_drv;
c5c77ba1 3928
cb067dcf 3929 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3930 if (s32Error) {
3931 PRINT_ER("Failed to send GET_LINKSPEED to message queue ");
e6e12661 3932 return -EFAULT;
c5c77ba1
JK		 3933 }
3934
a4ab1ade 3935 down(&hif_drv->hSemGetLINKSPEED);
c5c77ba1
JK		 3936
3937
3938 if (ps8lnkspd == NULL) {
3939 PRINT_ER("LINKSPEED pointer value is null");
e6e12661 3940 return -EFAULT;
c5c77ba1
JK		 3941 }
3942
3943
3944 *ps8lnkspd = gs8lnkspd;
3945
3946
3947 return s32Error;
3948}
3949
a4ab1ade 3950s32 host_int_get_statistics(struct host_if_drv *hif_drv, struct rf_info *pstrStatistics)
c5c77ba1 3951{
e6e12661 3952 s32 s32Error = 0;
143eb95a 3953 struct host_if_msg msg;
143eb95a 3954 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3955
a9f812a6 3956 msg.id = HOST_IF_MSG_GET_STATISTICS;
e60831e9 3957 msg.body.data = (char *)pstrStatistics;
a4ab1ade 3958 msg.drv = hif_drv;
ae4dfa57 3959
cb067dcf 3960 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 3961 if (s32Error) {
3962 PRINT_ER("Failed to send get host channel param's message queue ");
e6e12661 3963 return -EFAULT;
c5c77ba1
JK		 3964 }
3965
2d25af87 3966 down(&hif_sema_wait_response);
c5c77ba1
JK		 3967 return s32Error;
3968}
3969
a4ab1ade
TC		 3970s32 host_int_scan(struct host_if_drv *hif_drv, u8 u8ScanSource,
3971 u8 u8ScanType, u8 *pu8ChnlFreqList,
3972 u8 u8ChnlListLen, const u8 *pu8IEs,
3973 size_t IEsLen, wilc_scan_result ScanResult,
3974 void *pvUserArg, struct hidden_network *pstrHiddenNetwork)
c5c77ba1 3975{
e6e12661 3976 s32 s32Error = 0;
143eb95a 3977 struct host_if_msg msg;
c5c77ba1 3978
a4ab1ade
TC		 3979 if (!hif_drv || ScanResult == NULL) {
3980 PRINT_ER("hif_drv or ScanResult = NULL\n");
24db713f
LK		 3981 return -EFAULT;
3982 }
c5c77ba1 3983
143eb95a 3984 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 3985
a9f812a6 3986 msg.id = HOST_IF_MSG_SCAN;
c5c77ba1
JK		 3987
3988 if (pstrHiddenNetwork != NULL) {
629b9ca0
LK		 3989 msg.body.scan_info.hidden_network.pstrHiddenNetworkInfo = pstrHiddenNetwork->pstrHiddenNetworkInfo;
3990 msg.body.scan_info.hidden_network.u8ssidnum = pstrHiddenNetwork->u8ssidnum;
c5c77ba1
JK		 3991
3992 } else
3993 PRINT_D(HOSTINF_DBG, "pstrHiddenNetwork IS EQUAL TO NULL\n");
3994
a4ab1ade 3995 msg.drv = hif_drv;
42568898 3996 msg.body.scan_info.src = u8ScanSource;
1e276c88 3997 msg.body.scan_info.type = u8ScanType;
c17c6da6 3998 msg.body.scan_info.result = ScanResult;
5f2b50c8 3999 msg.body.scan_info.arg = pvUserArg;
4528bdb5 4000
f97bd9ca 4001 msg.body.scan_info.ch_list_len = u8ChnlListLen;
82eeb0ad
LK		 4002 msg.body.scan_info.ch_freq_list = kmalloc(u8ChnlListLen, GFP_KERNEL);
4003 memcpy(msg.body.scan_info.ch_freq_list, pu8ChnlFreqList, u8ChnlListLen);
c5c77ba1 4004
7b1f76cd 4005 msg.body.scan_info.ies_len = IEsLen;
d6f19aa5
LK		 4006 msg.body.scan_info.ies = kmalloc(IEsLen, GFP_KERNEL);
4007 memcpy(msg.body.scan_info.ies, pu8IEs, IEsLen);
c5c77ba1 4008
cb067dcf 4009 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1 4010 if (s32Error) {
24db713f
LK		 4011 PRINT_ER("Error in sending message queue\n");
4012 return -EINVAL;
c5c77ba1
JK		 4013 }
4014
c5c77ba1 4015 PRINT_D(HOSTINF_DBG, ">> Starting the SCAN timer\n");
a4ab1ade
TC		 4016 hif_drv->hScanTimer.data = (unsigned long)hif_drv;
4017 mod_timer(&hif_drv->hScanTimer,
9eb06643 4018 jiffies + msecs_to_jiffies(HOST_IF_SCAN_TIMEOUT));
c5c77ba1 4019
c5c77ba1
JK		 4020 return s32Error;
4021
4022}
ae4dfa57 4023
a4ab1ade
TC		 4024s32 hif_set_cfg(struct host_if_drv *hif_drv,
4025 struct cfg_param_val *pstrCfgParamVal)
c5c77ba1
JK		 4026{
4027
e6e12661 4028 s32 s32Error = 0;
143eb95a 4029 struct host_if_msg msg;
c5c77ba1
JK		 4030
4031
a4ab1ade
TC		 4032 if (!hif_drv) {
4033 PRINT_ER("hif_drv NULL\n");
24db713f
LK		 4034 return -EFAULT;
4035 }
ae4dfa57 4036
143eb95a 4037 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 4038 msg.id = HOST_IF_MSG_CFG_PARAMS;
221371e5 4039 msg.body.cfg_info.cfg_attr_info = *pstrCfgParamVal;
a4ab1ade 4040 msg.drv = hif_drv;
c5c77ba1 4041
cb067dcf 4042 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1 4043
c5c77ba1
JK		 4044 return s32Error;
4045
4046}
4047
a4ab1ade 4048s32 hif_get_cfg(struct host_if_drv *hif_drv, u16 u16WID, u16 *pu16WID_Value)
c5c77ba1 4049{
e6e12661 4050 s32 s32Error = 0;
c5c77ba1 4051
a4ab1ade 4052 down(&hif_drv->gtOsCfgValuesSem);
c5c77ba1 4053
a4ab1ade
TC		 4054 if (!hif_drv) {
4055 PRINT_ER("hif_drv NULL\n");
24db713f 4056 return -EFAULT;
c5c77ba1
JK		 4057 }
4058 PRINT_D(HOSTINF_DBG, "Getting configuration parameters\n");
4059 switch (u16WID) {
4060
4061 case WID_BSS_TYPE:
a4ab1ade 4062 *pu16WID_Value = (u16)hif_drv->strCfgValues.bss_type;
c5c77ba1
JK		 4063 break;
4064
4065 case WID_AUTH_TYPE:
a4ab1ade 4066 *pu16WID_Value = (u16)hif_drv->strCfgValues.auth_type;
c5c77ba1
JK		 4067 break;
4068
4069 case WID_AUTH_TIMEOUT:
a4ab1ade 4070 *pu16WID_Value = hif_drv->strCfgValues.auth_timeout;
c5c77ba1
JK		 4071 break;
4072
4073 case WID_POWER_MANAGEMENT:
a4ab1ade 4074 *pu16WID_Value = (u16)hif_drv->strCfgValues.power_mgmt_mode;
c5c77ba1
JK		 4075 break;
4076
4077 case WID_SHORT_RETRY_LIMIT:
a4ab1ade 4078 *pu16WID_Value = hif_drv->strCfgValues.short_retry_limit;
c5c77ba1
JK		 4079 break;
4080
4081 case WID_LONG_RETRY_LIMIT:
a4ab1ade 4082 *pu16WID_Value = hif_drv->strCfgValues.long_retry_limit;
c5c77ba1
JK		 4083 break;
4084
4085 case WID_FRAG_THRESHOLD:
a4ab1ade 4086 *pu16WID_Value = hif_drv->strCfgValues.frag_threshold;
c5c77ba1
JK		 4087 break;
4088
4089 case WID_RTS_THRESHOLD:
a4ab1ade 4090 *pu16WID_Value = hif_drv->strCfgValues.rts_threshold;
c5c77ba1
JK		 4091 break;
4092
4093 case WID_PREAMBLE:
a4ab1ade 4094 *pu16WID_Value = (u16)hif_drv->strCfgValues.preamble_type;
c5c77ba1
JK		 4095 break;
4096
4097 case WID_SHORT_SLOT_ALLOWED:
a4ab1ade 4098 *pu16WID_Value = (u16) hif_drv->strCfgValues.short_slot_allowed;
c5c77ba1
JK		 4099 break;
4100
4101 case WID_11N_TXOP_PROT_DISABLE:
a4ab1ade 4102 *pu16WID_Value = (u16)hif_drv->strCfgValues.txop_prot_disabled;
c5c77ba1
JK		 4103 break;
4104
4105 case WID_BEACON_INTERVAL:
a4ab1ade 4106 *pu16WID_Value = hif_drv->strCfgValues.beacon_interval;
c5c77ba1
JK		 4107 break;
4108
4109 case WID_DTIM_PERIOD:
a4ab1ade 4110 *pu16WID_Value = (u16)hif_drv->strCfgValues.dtim_period;
c5c77ba1
JK		 4111 break;
4112
4113 case WID_SITE_SURVEY:
a4ab1ade 4114 *pu16WID_Value = (u16)hif_drv->strCfgValues.site_survey_enabled;
c5c77ba1
JK		 4115 break;
4116
4117 case WID_SITE_SURVEY_SCAN_TIME:
a4ab1ade 4118 *pu16WID_Value = hif_drv->strCfgValues.site_survey_scan_time;
c5c77ba1
JK		 4119 break;
4120
4121 case WID_ACTIVE_SCAN_TIME:
a4ab1ade 4122 *pu16WID_Value = hif_drv->strCfgValues.active_scan_time;
c5c77ba1
JK		 4123 break;
4124
4125 case WID_PASSIVE_SCAN_TIME:
a4ab1ade 4126 *pu16WID_Value = hif_drv->strCfgValues.passive_scan_time;
c5c77ba1
JK		 4127 break;
4128
4129 case WID_CURRENT_TX_RATE:
a4ab1ade 4130 *pu16WID_Value = hif_drv->strCfgValues.curr_tx_rate;
c5c77ba1
JK		 4131 break;
4132
4133 default:
4134 break;
4135 }
4136
a4ab1ade 4137 up(&hif_drv->gtOsCfgValuesSem);
c5c77ba1 4138
c5c77ba1
JK		 4139 return s32Error;
4140
4141}
4142
c5c77ba1 4143void host_int_send_join_leave_info_to_host
72ed4dc7 4144 (u16 assocId, u8 *stationAddr, bool joining)
c5c77ba1
JK		 4145{
4146}
c5c77ba1 4147
93dee8ee 4148static void GetPeriodicRSSI(unsigned long arg)
c5c77ba1 4149{
a4ab1ade 4150 struct host_if_drv *hif_drv = (struct host_if_drv *)arg;
78c87591 4151
a4ab1ade 4152 if (!hif_drv) {
c5c77ba1
JK		 4153 PRINT_ER("Driver handler is NULL\n");
4154 return;
4155 }
4156
a4ab1ade 4157 if (hif_drv->enuHostIFstate == HOST_IF_CONNECTED) {
e6e12661 4158 s32 s32Error = 0;
143eb95a 4159 struct host_if_msg msg;
c5c77ba1 4160
143eb95a 4161 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4162
a9f812a6 4163 msg.id = HOST_IF_MSG_GET_RSSI;
a4ab1ade 4164 msg.drv = hif_drv;
c5c77ba1 4165
cb067dcf 4166 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1
JK		 4167 if (s32Error) {
4168 PRINT_ER("Failed to send get host channel param's message queue ");
4169 return;
4170 }
4171 }
262f55e1
LK		 4172 periodic_rssi.data = (unsigned long)hif_drv;
4173 mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
c5c77ba1
JK		 4174}
4175
4176
4177void host_int_send_network_info_to_host
ca356ada 4178 (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi)
c5c77ba1
JK		 4179{
4180}
ae4dfa57 4181
4e4467fd 4182static u32 clients_count;
c5c77ba1 4183
a4ab1ade 4184s32 host_int_init(struct host_if_drv **hif_drv_handler)
c5c77ba1 4185{
5b09bd32 4186 s32 result = 0;
a4ab1ade 4187 struct host_if_drv *hif_drv;
d42ab083 4188 int err;
c5c77ba1 4189
c5c77ba1
JK		 4190 PRINT_D(HOSTINF_DBG, "Initializing host interface for client %d\n", clients_count + 1);
4191
72ed4dc7 4192 gbScanWhileConnected = false;
c5c77ba1 4193
2d25af87 4194 sema_init(&hif_sema_wait_response, 0);
c5c77ba1 4195
a4ab1ade
TC		 4196 hif_drv = kzalloc(sizeof(struct host_if_drv), GFP_KERNEL);
4197 if (!hif_drv) {
5b09bd32 4198 result = -ENOMEM;
17db84eb 4199 goto _fail_;
c5c77ba1 4200 }
a4ab1ade
TC		 4201 *hif_drv_handler = hif_drv;
4202 err = add_handler_in_list(hif_drv);
d42ab083 4203 if (err) {
5b09bd32 4204 result = -EFAULT;
d42ab083
JK		 4205 goto _fail_timer_2;
4206 }
c5c77ba1 4207
72ed4dc7 4208 g_obtainingIP = false;
c5c77ba1 4209
a4ab1ade 4210 PRINT_D(HOSTINF_DBG, "Global handle pointer value=%p\n", hif_drv);
c5c77ba1 4211 if (clients_count == 0) {
834e0cb0 4212 sema_init(&hif_sema_thread, 0);
27ff2168 4213 sema_init(&hif_sema_driver, 0);
440e8993 4214 sema_init(&hif_sema_deinit, 1);
83383ea3
AB		 4215 }
4216
a4ab1ade
TC		 4217 sema_init(&hif_drv->hSemTestKeyBlock, 0);
4218 sema_init(&hif_drv->hSemTestDisconnectBlock, 0);
4219 sema_init(&hif_drv->hSemGetRSSI, 0);
4220 sema_init(&hif_drv->hSemGetLINKSPEED, 0);
4221 sema_init(&hif_drv->hSemGetCHNL, 0);
4222 sema_init(&hif_drv->hSemInactiveTime, 0);
c5c77ba1 4223
c5c77ba1
JK		 4224 PRINT_D(HOSTINF_DBG, "INIT: CLIENT COUNT %d\n", clients_count);
4225
4226 if (clients_count == 0) {
cb067dcf 4227 result = wilc_mq_create(&hif_msg_q);
c5c77ba1 4228
5b09bd32 4229 if (result < 0) {
c5c77ba1
JK		 4230 PRINT_ER("Failed to creat MQ\n");
4231 goto _fail_;
4232 }
c2115d8e
LK		 4233
4234 hif_thread_handler = kthread_run(hostIFthread, NULL, "WILC_kthread");
4235
4236 if (IS_ERR(hif_thread_handler)) {
c5c77ba1 4237 PRINT_ER("Failed to creat Thread\n");
5b09bd32 4238 result = -EFAULT;
c5c77ba1
JK		 4239 goto _fail_mq_;
4240 }
262f55e1 4241 setup_timer(&periodic_rssi, GetPeriodicRSSI,
a4ab1ade 4242 (unsigned long)hif_drv);
262f55e1 4243 mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
c5c77ba1
JK		 4244 }
4245
a4ab1ade 4246 setup_timer(&hif_drv->hScanTimer, TimerCB_Scan, 0);
c5c77ba1 4247
a4ab1ade 4248 setup_timer(&hif_drv->hConnectTimer, TimerCB_Connect, 0);
c5c77ba1 4249
a4ab1ade 4250 setup_timer(&hif_drv->hRemainOnChannel, ListenTimerCB, 0);
c5c77ba1 4251
a4ab1ade
TC		 4252 sema_init(&(hif_drv->gtOsCfgValuesSem), 1);
4253 down(&hif_drv->gtOsCfgValuesSem);
c5c77ba1 4254
a4ab1ade 4255 hif_drv->enuHostIFstate = HOST_IF_IDLE;
a4ab1ade
TC		 4256 hif_drv->strCfgValues.site_survey_enabled = SITE_SURVEY_OFF;
4257 hif_drv->strCfgValues.scan_source = DEFAULT_SCAN;
4258 hif_drv->strCfgValues.active_scan_time = ACTIVE_SCAN_TIME;
4259 hif_drv->strCfgValues.passive_scan_time = PASSIVE_SCAN_TIME;
4260 hif_drv->strCfgValues.curr_tx_rate = AUTORATE;
c5c77ba1 4261
a4ab1ade 4262 hif_drv->u64P2p_MgmtTimeout = 0;
c5c77ba1 4263
c5c77ba1
JK		 4264 PRINT_INFO(HOSTINF_DBG, "Initialization values, Site survey value: %d\n Scan source: %d\n Active scan time: %d\n Passive scan time: %d\nCurrent tx Rate = %d\n",
4265
a4ab1ade
TC		 4266 hif_drv->strCfgValues.site_survey_enabled, hif_drv->strCfgValues.scan_source,
4267 hif_drv->strCfgValues.active_scan_time, hif_drv->strCfgValues.passive_scan_time,
4268 hif_drv->strCfgValues.curr_tx_rate);
c5c77ba1 4269
a4ab1ade 4270 up(&hif_drv->gtOsCfgValuesSem);
c5c77ba1 4271
ae4dfa57 4272 clients_count++;
c5c77ba1 4273
5b09bd32 4274 return result;
c5c77ba1 4275
c5c77ba1 4276_fail_timer_2:
a4ab1ade
TC		 4277 up(&hif_drv->gtOsCfgValuesSem);
4278 del_timer_sync(&hif_drv->hConnectTimer);
4279 del_timer_sync(&hif_drv->hScanTimer);
c2115d8e 4280 kthread_stop(hif_thread_handler);
c5c77ba1 4281_fail_mq_:
cb067dcf 4282 wilc_mq_destroy(&hif_msg_q);
c5c77ba1 4283_fail_:
5b09bd32 4284 return result;
c5c77ba1 4285}
c5c77ba1 4286
a4ab1ade 4287s32 host_int_deinit(struct host_if_drv *hif_drv)
c5c77ba1 4288{
e6e12661 4289 s32 s32Error = 0;
143eb95a 4290 struct host_if_msg msg;
d42ab083 4291 int ret;
c5c77ba1 4292
a4ab1ade
TC		 4293 if (!hif_drv) {
4294 PRINT_ER("hif_drv = NULL\n");
c5c77ba1
JK		 4295 return 0;
4296 }
4297
440e8993 4298 down(&hif_sema_deinit);
c5c77ba1 4299
a4ab1ade 4300 terminated_handle = hif_drv;
c5c77ba1
JK		 4301 PRINT_D(HOSTINF_DBG, "De-initializing host interface for client %d\n", clients_count);
4302
a4ab1ade 4303 if (del_timer_sync(&hif_drv->hScanTimer)) {
03b2d5e7 4304 PRINT_D(HOSTINF_DBG, ">> Scan timer is active\n");
c5c77ba1
JK		 4305 }
4306
a4ab1ade 4307 if (del_timer_sync(&hif_drv->hConnectTimer)) {
03b2d5e7 4308 PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
c5c77ba1
JK		 4309 }
4310
262f55e1 4311 if (del_timer_sync(&periodic_rssi))
03b2d5e7 4312 PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
c5c77ba1 4313
a4ab1ade 4314 del_timer_sync(&hif_drv->hRemainOnChannel);
c5c77ba1 4315
218dc407 4316 host_int_set_wfi_drv_handler(NULL);
27ff2168 4317 down(&hif_sema_driver);
c5c77ba1 4318
a4ab1ade
TC		 4319 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
4320 hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
4321 hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
c5c77ba1 4322
a4ab1ade 4323 hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
c5c77ba1 4324 }
c5c77ba1 4325
a4ab1ade 4326 hif_drv->enuHostIFstate = HOST_IF_IDLE;
c5c77ba1 4327
72ed4dc7 4328 gbScanWhileConnected = false;
c5c77ba1 4329
143eb95a 4330 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 4331
4332 if (clients_count == 1) {
262f55e1 4333 if (del_timer_sync(&periodic_rssi))
03b2d5e7 4334 PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
262f55e1 4335
a9f812a6 4336 msg.id = HOST_IF_MSG_EXIT;
a4ab1ade 4337 msg.drv = hif_drv;
c5c77ba1 4338
cb067dcf 4339 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
e6e12661 4340 if (s32Error != 0)
c5c77ba1 4341 PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", s32Error);
c5c77ba1 4342
834e0cb0 4343 down(&hif_sema_thread);
c5c77ba1 4344
cb067dcf 4345 wilc_mq_destroy(&hif_msg_q);
c5c77ba1
JK		 4346 }
4347
a4ab1ade 4348 down(&(hif_drv->gtOsCfgValuesSem));
c5c77ba1 4349
a4ab1ade 4350 ret = remove_handler_in_list(hif_drv);
d42ab083 4351 if (ret)
e6e12661 4352 s32Error = -ENOENT;
d42ab083 4353
a4ab1ade 4354 kfree(hif_drv);
c5c77ba1 4355
ae4dfa57 4356 clients_count--;
b1413b60 4357 terminated_handle = NULL;
440e8993 4358 up(&hif_sema_deinit);
c5c77ba1
JK		 4359 return s32Error;
4360}
4361
4e4467fd 4362void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length)
c5c77ba1 4363{
e6e12661 4364 s32 s32Error = 0;
143eb95a 4365 struct host_if_msg msg;
d42ab083 4366 int id;
a4ab1ade 4367 struct host_if_drv *hif_drv = NULL;
c5c77ba1 4368
d42ab083 4369 id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
a4ab1ade 4370 hif_drv = get_handler_from_id(id);
c5c77ba1
JK		 4371
4372
4373
4374
a4ab1ade
TC		 4375 if (!hif_drv || hif_drv == terminated_handle) {
4376 PRINT_ER("NetworkInfo received but driver not init[%p]\n", hif_drv);
c5c77ba1
JK		 4377 return;
4378 }
4379
143eb95a 4380 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4381
a9f812a6 4382 msg.id = HOST_IF_MSG_RCVD_NTWRK_INFO;
a4ab1ade 4383 msg.drv = hif_drv;
c5c77ba1 4384
3bffac68 4385 msg.body.net_info.len = u32Length;
b021b80b
LK		 4386 msg.body.net_info.buffer = kmalloc(u32Length, GFP_KERNEL);
4387 memcpy(msg.body.net_info.buffer, pu8Buffer, u32Length);
c5c77ba1 4388
cb067dcf 4389 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4390 if (s32Error)
c5c77ba1 4391 PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", s32Error);
c5c77ba1
JK		 4392}
4393
4e4467fd 4394void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length)
c5c77ba1 4395{
e6e12661 4396 s32 s32Error = 0;
143eb95a 4397 struct host_if_msg msg;
d42ab083 4398 int id;
a4ab1ade 4399 struct host_if_drv *hif_drv = NULL;
c5c77ba1 4400
440e8993 4401 down(&hif_sema_deinit);
c5c77ba1 4402
d42ab083 4403 id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
a4ab1ade 4404 hif_drv = get_handler_from_id(id);
03b2d5e7 4405 PRINT_D(HOSTINF_DBG, "General asynchronous info packet received\n");
c5c77ba1
JK		 4406
4407
a4ab1ade 4408 if (!hif_drv || hif_drv == terminated_handle) {
c5c77ba1 4409 PRINT_D(HOSTINF_DBG, "Wifi driver handler is equal to NULL\n");
440e8993 4410 up(&hif_sema_deinit);
c5c77ba1
JK		 4411 return;
4412 }
4413
a4ab1ade 4414 if (!hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
c5c77ba1 4415 PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
440e8993 4416 up(&hif_sema_deinit);
c5c77ba1
JK		 4417 return;
4418 }
4419
143eb95a 4420 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 4421
4422
a9f812a6 4423 msg.id = HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO;
a4ab1ade 4424 msg.drv = hif_drv;
c5c77ba1 4425
f94f4889 4426 msg.body.async_info.len = u32Length;
33722ac7
LK		 4427 msg.body.async_info.buffer = kmalloc(u32Length, GFP_KERNEL);
4428 memcpy(msg.body.async_info.buffer, pu8Buffer, u32Length);
c5c77ba1 4429
cb067dcf 4430 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4431 if (s32Error)
c5c77ba1 4432 PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", s32Error);
c5c77ba1 4433
440e8993 4434 up(&hif_sema_deinit);
c5c77ba1
JK		 4435}
4436
4e4467fd 4437void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length)
c5c77ba1 4438{
e6e12661 4439 s32 s32Error = 0;
143eb95a 4440 struct host_if_msg msg;
d42ab083 4441 int id;
a4ab1ade 4442 struct host_if_drv *hif_drv = NULL;
78c87591 4443
d42ab083 4444 id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
a4ab1ade 4445 hif_drv = get_handler_from_id(id);
c5c77ba1
JK		 4446
4447
a4ab1ade 4448 PRINT_D(GENERIC_DBG, "Scan notification received %p\n", hif_drv);
c5c77ba1 4449
a4ab1ade 4450 if (!hif_drv || hif_drv == terminated_handle)
c5c77ba1 4451 return;
c5c77ba1 4452
a4ab1ade 4453 if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
143eb95a 4454 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4455
a9f812a6 4456 msg.id = HOST_IF_MSG_RCVD_SCAN_COMPLETE;
a4ab1ade 4457 msg.drv = hif_drv;
c5c77ba1 4458
cb067dcf 4459 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4460 if (s32Error)
c5c77ba1 4461 PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", s32Error);
c5c77ba1
JK		 4462 }
4463
4464
4465 return;
4466
4467}
4468
a4ab1ade
TC		 4469s32 host_int_remain_on_channel(struct host_if_drv *hif_drv, u32 u32SessionID,
4470 u32 u32duration, u16 chan,
4471 wilc_remain_on_chan_expired RemainOnChanExpired,
4472 wilc_remain_on_chan_ready RemainOnChanReady,
4473 void *pvUserArg)
c5c77ba1 4474{
e6e12661 4475 s32 s32Error = 0;
143eb95a 4476 struct host_if_msg msg;
c5c77ba1 4477
a4ab1ade 4478 if (!hif_drv) {
24db713f
LK		 4479 PRINT_ER("driver is null\n");
4480 return -EFAULT;
4481 }
c5c77ba1 4482
143eb95a 4483 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4484
a9f812a6 4485 msg.id = HOST_IF_MSG_REMAIN_ON_CHAN;
070d365c
TC		 4486 msg.body.remain_on_ch.u16Channel = chan;
4487 msg.body.remain_on_ch.pRemainOnChanExpired = RemainOnChanExpired;
4488 msg.body.remain_on_ch.pRemainOnChanReady = RemainOnChanReady;
4489 msg.body.remain_on_ch.pVoid = pvUserArg;
4490 msg.body.remain_on_ch.u32duration = u32duration;
4491 msg.body.remain_on_ch.u32ListenSessionID = u32SessionID;
a4ab1ade 4492 msg.drv = hif_drv;
143eb95a 4493
cb067dcf 4494 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4495 if (s32Error)
24db713f 4496 PRINT_ER("wilc mq send fail\n");
c5c77ba1
JK		 4497
4498 return s32Error;
4499}
4500
a4ab1ade 4501s32 host_int_ListenStateExpired(struct host_if_drv *hif_drv, u32 u32SessionID)
c5c77ba1 4502{
e6e12661 4503 s32 s32Error = 0;
143eb95a 4504 struct host_if_msg msg;
c5c77ba1 4505
a4ab1ade 4506 if (!hif_drv) {
24db713f
LK		 4507 PRINT_ER("driver is null\n");
4508 return -EFAULT;
4509 }
c5c77ba1 4510
a4ab1ade 4511 del_timer(&hif_drv->hRemainOnChannel);
c5c77ba1 4512
143eb95a 4513 memset(&msg, 0, sizeof(struct host_if_msg));
a9f812a6 4514 msg.id = HOST_IF_MSG_LISTEN_TIMER_FIRED;
a4ab1ade 4515 msg.drv = hif_drv;
070d365c 4516 msg.body.remain_on_ch.u32ListenSessionID = u32SessionID;
c5c77ba1 4517
cb067dcf 4518 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4519 if (s32Error)
24db713f 4520 PRINT_ER("wilc mq send fail\n");
c5c77ba1 4521
c5c77ba1
JK		 4522 return s32Error;
4523}
4524
a4ab1ade 4525s32 host_int_frame_register(struct host_if_drv *hif_drv, u16 u16FrameType, bool bReg)
c5c77ba1 4526{
e6e12661 4527 s32 s32Error = 0;
143eb95a 4528 struct host_if_msg msg;
c5c77ba1 4529
a4ab1ade 4530 if (!hif_drv) {
24db713f
LK		 4531 PRINT_ER("driver is null\n");
4532 return -EFAULT;
4533 }
c5c77ba1 4534
143eb95a 4535 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4536
a9f812a6 4537 msg.id = HOST_IF_MSG_REGISTER_FRAME;
c5c77ba1
JK		 4538 switch (u16FrameType) {
4539 case ACTION:
4540 PRINT_D(HOSTINF_DBG, "ACTION\n");
5c4008db 4541 msg.body.reg_frame.u8Regid = ACTION_FRM_IDX;
c5c77ba1
JK		 4542 break;
4543
4544 case PROBE_REQ:
4545 PRINT_D(HOSTINF_DBG, "PROBE REQ\n");
5c4008db 4546 msg.body.reg_frame.u8Regid = PROBE_REQ_IDX;
c5c77ba1
JK		 4547 break;
4548
4549 default:
4550 PRINT_D(HOSTINF_DBG, "Not valid frame type\n");
4551 break;
4552 }
5c4008db
TC		 4553 msg.body.reg_frame.u16FrameType = u16FrameType;
4554 msg.body.reg_frame.bReg = bReg;
a4ab1ade 4555 msg.drv = hif_drv;
c5c77ba1 4556
cb067dcf 4557 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4558 if (s32Error)
24db713f 4559 PRINT_ER("wilc mq send fail\n");
c5c77ba1
JK		 4560
4561 return s32Error;
4562
4563
4564}
c5c77ba1 4565
a4ab1ade
TC		 4566s32 host_int_add_beacon(struct host_if_drv *hif_drv, u32 u32Interval,
4567 u32 u32DTIMPeriod, u32 u32HeadLen, u8 *pu8Head,
4568 u32 u32TailLen, u8 *pu8Tail)
c5c77ba1 4569{
e6e12661 4570 s32 s32Error = 0;
143eb95a 4571 struct host_if_msg msg;
a98491e5 4572 struct beacon_attr *pstrSetBeaconParam = &msg.body.beacon_info;
c5c77ba1 4573
a4ab1ade 4574 if (!hif_drv) {
24db713f
LK		 4575 PRINT_ER("driver is null\n");
4576 return -EFAULT;
4577 }
c5c77ba1 4578
143eb95a 4579 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 4580
4581 PRINT_D(HOSTINF_DBG, "Setting adding beacon message queue params\n");
4582
a9f812a6 4583 msg.id = HOST_IF_MSG_ADD_BEACON;
a4ab1ade 4584 msg.drv = hif_drv;
12262dda 4585 pstrSetBeaconParam->interval = u32Interval;
e76ab770 4586 pstrSetBeaconParam->dtim_period = u32DTIMPeriod;
51c66185 4587 pstrSetBeaconParam->head_len = u32HeadLen;
8ce528b9
LK		 4588 pstrSetBeaconParam->head = kmalloc(u32HeadLen, GFP_KERNEL);
4589 if (pstrSetBeaconParam->head == NULL) {
24db713f
LK		 4590 s32Error = -ENOMEM;
4591 goto ERRORHANDLER;
4592 }
8ce528b9 4593 memcpy(pstrSetBeaconParam->head, pu8Head, u32HeadLen);
030c57e2 4594 pstrSetBeaconParam->tail_len = u32TailLen;
c5c77ba1 4595
c5c77ba1 4596 if (u32TailLen > 0) {
7dbcb6d3
LK		 4597 pstrSetBeaconParam->tail = kmalloc(u32TailLen, GFP_KERNEL);
4598 if (pstrSetBeaconParam->tail == NULL) {
24db713f
LK		 4599 s32Error = -ENOMEM;
4600 goto ERRORHANDLER;
4601 }
7dbcb6d3 4602 memcpy(pstrSetBeaconParam->tail, pu8Tail, u32TailLen);
c5c77ba1 4603 } else {
7dbcb6d3 4604 pstrSetBeaconParam->tail = NULL;
c5c77ba1
JK		 4605 }
4606
cb067dcf 4607 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4608 if (s32Error)
24db713f 4609 PRINT_ER("wilc mq send fail\n");
c5c77ba1 4610
24db713f
LK		 4611ERRORHANDLER:
4612 if (s32Error) {
95f840fb 4613 kfree(pstrSetBeaconParam->head);
c5c77ba1 4614
95f840fb 4615 kfree(pstrSetBeaconParam->tail);
c5c77ba1
JK		 4616 }
4617
4618 return s32Error;
4619
4620}
4621
a4ab1ade 4622s32 host_int_del_beacon(struct host_if_drv *hif_drv)
c5c77ba1 4623{
e6e12661 4624 s32 s32Error = 0;
143eb95a 4625 struct host_if_msg msg;
c5c77ba1 4626
a4ab1ade 4627 if (!hif_drv) {
24db713f
LK		 4628 PRINT_ER("driver is null\n");
4629 return -EFAULT;
4630 }
c5c77ba1 4631
a9f812a6 4632 msg.id = HOST_IF_MSG_DEL_BEACON;
a4ab1ade 4633 msg.drv = hif_drv;
c5c77ba1
JK		 4634 PRINT_D(HOSTINF_DBG, "Setting deleting beacon message queue params\n");
4635
cb067dcf 4636 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
7dc1d0cc
LK		 4637 if (s32Error)
4638 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1 4639
c5c77ba1
JK		 4640 return s32Error;
4641}
4642
a4ab1ade 4643s32 host_int_add_station(struct host_if_drv *hif_drv,
6a89ba9c 4644 struct add_sta_param *pstrStaParams)
c5c77ba1 4645{
e6e12661 4646 s32 s32Error = 0;
143eb95a 4647 struct host_if_msg msg;
ca8f47f8 4648 struct add_sta_param *pstrAddStationMsg = &msg.body.add_sta_info;
c5c77ba1
JK		 4649
4650
a4ab1ade 4651 if (!hif_drv) {
24db713f
LK		 4652 PRINT_ER("driver is null\n");
4653 return -EFAULT;
4654 }
c5c77ba1 4655
143eb95a 4656 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 4657
4658 PRINT_D(HOSTINF_DBG, "Setting adding station message queue params\n");
4659
a9f812a6 4660 msg.id = HOST_IF_MSG_ADD_STATION;
a4ab1ade 4661 msg.drv = hif_drv;
c5c77ba1 4662
6a89ba9c 4663 memcpy(pstrAddStationMsg, pstrStaParams, sizeof(struct add_sta_param));
c5c77ba1 4664 if (pstrAddStationMsg->u8NumRates > 0) {
f3052587 4665 u8 *rates = kmalloc(pstrAddStationMsg->u8NumRates, GFP_KERNEL);
78c87591 4666
7ae43363
LK		 4667 if (!rates)
4668 return -ENOMEM;
c5c77ba1 4669
d00d2ba3 4670 memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
057d1e97 4671 pstrAddStationMsg->pu8Rates = rates;
c5c77ba1
JK		 4672 }
4673
cb067dcf 4674 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4675 if (s32Error)
24db713f 4676 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1
JK		 4677 return s32Error;
4678}
4679
a4ab1ade 4680s32 host_int_del_station(struct host_if_drv *hif_drv, const u8 *pu8MacAddr)
c5c77ba1 4681{
e6e12661 4682 s32 s32Error = 0;
143eb95a 4683 struct host_if_msg msg;
889c25be 4684 struct del_sta *pstrDelStationMsg = &msg.body.del_sta_info;
c5c77ba1 4685
a4ab1ade 4686 if (!hif_drv) {
24db713f
LK		 4687 PRINT_ER("driver is null\n");
4688 return -EFAULT;
4689 }
c5c77ba1 4690
143eb95a 4691 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 4692
4693 PRINT_D(HOSTINF_DBG, "Setting deleting station message queue params\n");
4694
a9f812a6 4695 msg.id = HOST_IF_MSG_DEL_STATION;
a4ab1ade 4696 msg.drv = hif_drv;
c5c77ba1 4697
b1413b60 4698 if (pu8MacAddr == NULL)
e4839d39 4699 memset(pstrDelStationMsg->mac_addr, 255, ETH_ALEN);
c5c77ba1 4700 else
e4839d39 4701 memcpy(pstrDelStationMsg->mac_addr, pu8MacAddr, ETH_ALEN);
c5c77ba1 4702
cb067dcf 4703 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4704 if (s32Error)
24db713f 4705 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1
JK		 4706 return s32Error;
4707}
ae4dfa57 4708
a4ab1ade 4709s32 host_int_del_allstation(struct host_if_drv *hif_drv,
441dc609 4710 u8 pu8MacAddr[][ETH_ALEN])
c5c77ba1 4711{
e6e12661 4712 s32 s32Error = 0;
143eb95a 4713 struct host_if_msg msg;
b0c1e80e 4714 struct del_all_sta *pstrDelAllStationMsg = &msg.body.del_all_sta_info;
63d03e47 4715 u8 au8Zero_Buff[ETH_ALEN] = {0};
4e4467fd 4716 u32 i;
63d03e47 4717 u8 u8AssocNumb = 0;
c5c77ba1
JK		 4718
4719
a4ab1ade 4720 if (!hif_drv) {
24db713f
LK		 4721 PRINT_ER("driver is null\n");
4722 return -EFAULT;
4723 }
c5c77ba1 4724
143eb95a 4725 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1
JK		 4726
4727 PRINT_D(HOSTINF_DBG, "Setting deauthenticating station message queue params\n");
4728
a9f812a6 4729 msg.id = HOST_IF_MSG_DEL_ALL_STA;
a4ab1ade 4730 msg.drv = hif_drv;
c5c77ba1 4731
c5c77ba1
JK		 4732 for (i = 0; i < MAX_NUM_STA; i++) {
4733 if (memcmp(pu8MacAddr[i], au8Zero_Buff, ETH_ALEN)) {
e51b9216
LK		 4734 memcpy(pstrDelAllStationMsg->del_all_sta[i], pu8MacAddr[i], ETH_ALEN);
4735 PRINT_D(CFG80211_DBG, "BSSID = %x%x%x%x%x%x\n",
4736 pstrDelAllStationMsg->del_all_sta[i][0],
4737 pstrDelAllStationMsg->del_all_sta[i][1],
4738 pstrDelAllStationMsg->del_all_sta[i][2],
4739 pstrDelAllStationMsg->del_all_sta[i][3],
4740 pstrDelAllStationMsg->del_all_sta[i][4],
4741 pstrDelAllStationMsg->del_all_sta[i][5]);
c5c77ba1
JK		 4742 u8AssocNumb++;
4743 }
4744 }
4745 if (!u8AssocNumb) {
4746 PRINT_D(CFG80211_DBG, "NO ASSOCIATED STAS\n");
4747 return s32Error;
4748 }
4749
8ba1803f 4750 pstrDelAllStationMsg->assoc_sta = u8AssocNumb;
cb067dcf 4751 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
c5c77ba1 4752
2b9d5b48 4753 if (s32Error)
24db713f 4754 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1 4755
2d25af87 4756 down(&hif_sema_wait_response);
c5c77ba1
JK		 4757
4758 return s32Error;
4759
4760}
4761
a4ab1ade 4762s32 host_int_edit_station(struct host_if_drv *hif_drv,
6a89ba9c 4763 struct add_sta_param *pstrStaParams)
c5c77ba1 4764{
e6e12661 4765 s32 s32Error = 0;
143eb95a 4766 struct host_if_msg msg;
ca8f47f8 4767 struct add_sta_param *pstrAddStationMsg = &msg.body.add_sta_info;
c5c77ba1 4768
a4ab1ade 4769 if (!hif_drv) {
24db713f
LK		 4770 PRINT_ER("driver is null\n");
4771 return -EFAULT;
4772 }
c5c77ba1
JK		 4773
4774 PRINT_D(HOSTINF_DBG, "Setting editing station message queue params\n");
4775
143eb95a 4776 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4777
a9f812a6 4778 msg.id = HOST_IF_MSG_EDIT_STATION;
a4ab1ade 4779 msg.drv = hif_drv;
c5c77ba1 4780
6a89ba9c 4781 memcpy(pstrAddStationMsg, pstrStaParams, sizeof(struct add_sta_param));
c5c77ba1 4782 if (pstrAddStationMsg->u8NumRates > 0) {
f3052587 4783 u8 *rates = kmalloc(pstrAddStationMsg->u8NumRates, GFP_KERNEL);
78c87591 4784
7ae43363
LK		 4785 if (!rates)
4786 return -ENOMEM;
4787
d00d2ba3 4788 memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
057d1e97 4789 pstrAddStationMsg->pu8Rates = rates;
c5c77ba1
JK		 4790 }
4791
cb067dcf 4792 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4793 if (s32Error)
24db713f
LK		 4794 PRINT_ER("wilc_mq_send fail\n");
4795
c5c77ba1
JK		 4796 return s32Error;
4797}
108b3439 4798
a4ab1ade
TC		 4799s32 host_int_set_power_mgmt(struct host_if_drv *hif_drv,
4800 bool bIsEnabled,
4801 u32 u32Timeout)
c5c77ba1 4802{
e6e12661 4803 s32 s32Error = 0;
143eb95a 4804 struct host_if_msg msg;
49e1f81b 4805 struct power_mgmt_param *pstrPowerMgmtParam = &msg.body.pwr_mgmt_info;
c5c77ba1 4806
03b2d5e7 4807 PRINT_INFO(HOSTINF_DBG, "\n\n>> Setting PS to %d <<\n\n", bIsEnabled);
c5c77ba1 4808
a4ab1ade 4809 if (!hif_drv) {
24db713f
LK		 4810 PRINT_ER("driver is null\n");
4811 return -EFAULT;
4812 }
c5c77ba1
JK		 4813
4814 PRINT_D(HOSTINF_DBG, "Setting Power management message queue params\n");
4815
143eb95a 4816 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4817
a9f812a6 4818 msg.id = HOST_IF_MSG_POWER_MGMT;
a4ab1ade 4819 msg.drv = hif_drv;
c5c77ba1 4820
33c70c1b 4821 pstrPowerMgmtParam->enabled = bIsEnabled;
937918ff 4822 pstrPowerMgmtParam->timeout = u32Timeout;
c5c77ba1 4823
cb067dcf 4824 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4825 if (s32Error)
24db713f 4826 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1
JK		 4827 return s32Error;
4828}
4829
a4ab1ade
TC		 4830s32 host_int_setup_multicast_filter(struct host_if_drv *hif_drv,
4831 bool bIsEnabled,
4832 u32 u32count)
c5c77ba1 4833{
e6e12661 4834 s32 s32Error = 0;
143eb95a 4835 struct host_if_msg msg;
a079cf4d 4836 struct set_multicast *pstrMulticastFilterParam = &msg.body.multicast_info;
c5c77ba1
JK		 4837
4838
a4ab1ade 4839 if (!hif_drv) {
24db713f
LK		 4840 PRINT_ER("driver is null\n");
4841 return -EFAULT;
4842 }
c5c77ba1
JK		 4843
4844 PRINT_D(HOSTINF_DBG, "Setting Multicast Filter params\n");
4845
143eb95a 4846 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 4847
a9f812a6 4848 msg.id = HOST_IF_MSG_SET_MULTICAST_FILTER;
a4ab1ade 4849 msg.drv = hif_drv;
c5c77ba1 4850
bae636eb 4851 pstrMulticastFilterParam->enabled = bIsEnabled;
adab2f71 4852 pstrMulticastFilterParam->cnt = u32count;
c5c77ba1 4853
cb067dcf 4854 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 4855 if (s32Error)
24db713f 4856 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1
JK		 4857 return s32Error;
4858}
4859
c5c77ba1
JK		 4860static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo)
4861{
e0a12217 4862 struct join_bss_param *pNewJoinBssParam = NULL;
63d03e47 4863 u8 *pu8IEs;
d85f5326
CL		 4864 u16 u16IEsLen;
4865 u16 index = 0;
63d03e47
GKH		 4866 u8 suppRatesNo = 0;
4867 u8 extSuppRatesNo;
d85f5326 4868 u16 jumpOffset;
63d03e47
GKH		 4869 u8 pcipherCount;
4870 u8 authCount;
4871 u8 pcipherTotalCount = 0;
4872 u8 authTotalCount = 0;
4873 u8 i, j;
c5c77ba1
JK		 4874
4875 pu8IEs = ptstrNetworkInfo->pu8IEs;
4876 u16IEsLen = ptstrNetworkInfo->u16IEsLen;
4877
b156f1ed 4878 pNewJoinBssParam = kzalloc(sizeof(struct join_bss_param), GFP_KERNEL);
c5c77ba1 4879 if (pNewJoinBssParam != NULL) {
c5c77ba1
JK		 4880 pNewJoinBssParam->dtim_period = ptstrNetworkInfo->u8DtimPeriod;
4881 pNewJoinBssParam->beacon_period = ptstrNetworkInfo->u16BeaconPeriod;
4882 pNewJoinBssParam->cap_info = ptstrNetworkInfo->u16CapInfo;
d00d2ba3 4883 memcpy(pNewJoinBssParam->au8bssid, ptstrNetworkInfo->au8bssid, 6);
d00d2ba3 4884 memcpy((u8 *)pNewJoinBssParam->ssid, ptstrNetworkInfo->au8ssid, ptstrNetworkInfo->u8SsidLen + 1);
619d27b8 4885 pNewJoinBssParam->ssid_len = ptstrNetworkInfo->u8SsidLen;
2cc46837
CL		 4886 memset(pNewJoinBssParam->rsn_pcip_policy, 0xFF, 3);
4887 memset(pNewJoinBssParam->rsn_auth_policy, 0xFF, 3);
c5c77ba1 4888
c5c77ba1 4889 while (index < u16IEsLen) {
c5c77ba1 4890 if (pu8IEs[index] == SUPP_RATES_IE) {
c5c77ba1
JK		 4891 suppRatesNo = pu8IEs[index + 1];
4892 pNewJoinBssParam->supp_rates[0] = suppRatesNo;
ae4dfa57 4893 index += 2;
c5c77ba1
JK		 4894
4895 for (i = 0; i < suppRatesNo; i++) {
4896 pNewJoinBssParam->supp_rates[i + 1] = pu8IEs[index + i];
c5c77ba1
JK		 4897 }
4898 index += suppRatesNo;
4899 continue;
ae4dfa57 4900 } else if (pu8IEs[index] == EXT_SUPP_RATES_IE) {
c5c77ba1
JK		 4901 extSuppRatesNo = pu8IEs[index + 1];
4902 if (extSuppRatesNo > (MAX_RATES_SUPPORTED - suppRatesNo))
4903 pNewJoinBssParam->supp_rates[0] = MAX_RATES_SUPPORTED;
4904 else
4905 pNewJoinBssParam->supp_rates[0] += extSuppRatesNo;
4906 index += 2;
c5c77ba1
JK		 4907 for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++) {
4908 pNewJoinBssParam->supp_rates[suppRatesNo + i + 1] = pu8IEs[index + i];
c5c77ba1
JK		 4909 }
4910 index += extSuppRatesNo;
4911 continue;
ae4dfa57 4912 } else if (pu8IEs[index] == HT_CAPABILITY_IE) {
0be1eb74 4913 pNewJoinBssParam->ht_capable = true;
ae4dfa57 4914 index += pu8IEs[index + 1] + 2;
c5c77ba1 4915 continue;
ae4dfa57 4916 } else if ((pu8IEs[index] == WMM_IE) &&
c5c77ba1 4917 (pu8IEs[index + 2] == 0x00) && (pu8IEs[index + 3] == 0x50) &&
ae4dfa57
LK		 4918 (pu8IEs[index + 4] == 0xF2) &&
4919 (pu8IEs[index + 5] == 0x02) &&
4920 ((pu8IEs[index + 6] == 0x00) || (pu8IEs[index + 6] == 0x01)) &&
c5c77ba1 4921 (pu8IEs[index + 7] == 0x01)) {
0be1eb74 4922 pNewJoinBssParam->wmm_cap = true;
c5c77ba1 4923
ffda203c 4924 if (pu8IEs[index + 8] & BIT(7))
0be1eb74 4925 pNewJoinBssParam->uapsd_cap = true;
c5c77ba1
JK		 4926 index += pu8IEs[index + 1] + 2;
4927 continue;
ae4dfa57 4928 } else if ((pu8IEs[index] == P2P_IE) &&
c5c77ba1 4929 (pu8IEs[index + 2] == 0x50) && (pu8IEs[index + 3] == 0x6f) &&
ae4dfa57
LK		 4930 (pu8IEs[index + 4] == 0x9a) &&
4931 (pu8IEs[index + 5] == 0x09) && (pu8IEs[index + 6] == 0x0c)) {
d85f5326 4932 u16 u16P2P_count;
78c87591 4933
c5c77ba1 4934 pNewJoinBssParam->tsf = ptstrNetworkInfo->u32Tsf;
7a8d51d7 4935 pNewJoinBssParam->noa_enabled = 1;
cc179008 4936 pNewJoinBssParam->idx = pu8IEs[index + 9];
c5c77ba1 4937
ffda203c 4938 if (pu8IEs[index + 10] & BIT(7)) {
d72b33ca 4939 pNewJoinBssParam->opp_enabled = 1;
99b66945 4940 pNewJoinBssParam->ct_window = pu8IEs[index + 10];
d72b33ca
LK		 4941 } else {
4942 pNewJoinBssParam->opp_enabled = 0;
4943 }
ae4dfa57 4944
03b2d5e7 4945 PRINT_D(GENERIC_DBG, "P2P Dump\n");
c5c77ba1 4946 for (i = 0; i < pu8IEs[index + 7]; i++)
03b2d5e7 4947 PRINT_D(GENERIC_DBG, " %x\n", pu8IEs[index + 9 + i]);
c5c77ba1 4948
c21047ed 4949 pNewJoinBssParam->cnt = pu8IEs[index + 11];
c5c77ba1
JK		 4950 u16P2P_count = index + 12;
4951
109e6cab 4952 memcpy(pNewJoinBssParam->duration, pu8IEs + u16P2P_count, 4);
c5c77ba1
JK		 4953 u16P2P_count += 4;
4954
1d8b76b3 4955 memcpy(pNewJoinBssParam->interval, pu8IEs + u16P2P_count, 4);
c5c77ba1
JK		 4956 u16P2P_count += 4;
4957
d00d2ba3 4958 memcpy(pNewJoinBssParam->au8StartTime, pu8IEs + u16P2P_count, 4);
c5c77ba1
JK		 4959
4960 index += pu8IEs[index + 1] + 2;
4961 continue;
4962
ae4dfa57 4963 } else if ((pu8IEs[index] == RSN_IE) ||
c5c77ba1
JK		 4964 ((pu8IEs[index] == WPA_IE) && (pu8IEs[index + 2] == 0x00) &&
4965 (pu8IEs[index + 3] == 0x50) && (pu8IEs[index + 4] == 0xF2) &&
4966 (pu8IEs[index + 5] == 0x01))) {
d85f5326 4967 u16 rsnIndex = index;
ae4dfa57 4968
c5c77ba1
JK		 4969 if (pu8IEs[rsnIndex] == RSN_IE) {
4970 pNewJoinBssParam->mode_802_11i = 2;
ae4dfa57 4971 } else {
c5c77ba1
JK		 4972 if (pNewJoinBssParam->mode_802_11i == 0)
4973 pNewJoinBssParam->mode_802_11i = 1;
c5c77ba1
JK		 4974 rsnIndex += 4;
4975 }
ae4dfa57
LK		 4976
4977 rsnIndex += 7;
c5c77ba1
JK		 4978 pNewJoinBssParam->rsn_grp_policy = pu8IEs[rsnIndex];
4979 rsnIndex++;
ae4dfa57 4980 jumpOffset = pu8IEs[rsnIndex] * 4;
c5c77ba1 4981 pcipherCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
ae4dfa57 4982 rsnIndex += 2;
c5c77ba1 4983
c5c77ba1 4984 for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++) {
c5c77ba1 4985 pNewJoinBssParam->rsn_pcip_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
c5c77ba1
JK		 4986 }
4987 pcipherTotalCount += pcipherCount;
4988 rsnIndex += jumpOffset;
4989
4990 jumpOffset = pu8IEs[rsnIndex] * 4;
4991
c5c77ba1 4992 authCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
ae4dfa57 4993 rsnIndex += 2;
c5c77ba1
JK		 4994
4995 for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++) {
c5c77ba1
JK		 4996 pNewJoinBssParam->rsn_auth_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
4997 }
4998 authTotalCount += authCount;
4999 rsnIndex += jumpOffset;
ae4dfa57 5000
c5c77ba1
JK		 5001 if (pu8IEs[index] == RSN_IE) {
5002 pNewJoinBssParam->rsn_cap[0] = pu8IEs[rsnIndex];
5003 pNewJoinBssParam->rsn_cap[1] = pu8IEs[rsnIndex + 1];
5004 rsnIndex += 2;
5005 }
f717c0eb 5006 pNewJoinBssParam->rsn_found = true;
ae4dfa57 5007 index += pu8IEs[index + 1] + 2;
c5c77ba1
JK		 5008 continue;
5009 } else
ae4dfa57 5010 index += pu8IEs[index + 1] + 2;
c5c77ba1
JK		 5011
5012 }
5013
5014
5015 }
5016
5017 return (void *)pNewJoinBssParam;
5018
5019}
5020
5021void host_int_freeJoinParams(void *pJoinParams)
5022{
e0a12217
LK		 5023 if ((struct bss_param *)pJoinParams != NULL)
5024 kfree((struct bss_param *)pJoinParams);
c5c77ba1
JK		 5025 else
5026 PRINT_ER("Unable to FREE null pointer\n");
5027}
c5c77ba1 5028
a4ab1ade 5029s32 host_int_delBASession(struct host_if_drv *hif_drv, char *pBSSID, char TID)
c5c77ba1 5030{
e6e12661 5031 s32 s32Error = 0;
143eb95a 5032 struct host_if_msg msg;
c833b474 5033 struct ba_session_info *pBASessionInfo = &msg.body.session_info;
c5c77ba1 5034
a4ab1ade 5035 if (!hif_drv) {
24db713f
LK		 5036 PRINT_ER("driver is null\n");
5037 return -EFAULT;
5038 }
c5c77ba1 5039
143eb95a 5040 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 5041
a9f812a6 5042 msg.id = HOST_IF_MSG_DEL_BA_SESSION;
c5c77ba1
JK		 5043
5044 memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN);
5045 pBASessionInfo->u8Ted = TID;
a4ab1ade 5046 msg.drv = hif_drv;
c5c77ba1 5047
cb067dcf 5048 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 5049 if (s32Error)
24db713f 5050 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1 5051
2d25af87 5052 down(&hif_sema_wait_response);
c5c77ba1
JK		 5053
5054 return s32Error;
5055}
5056
a4ab1ade
TC		 5057s32 host_int_del_All_Rx_BASession(struct host_if_drv *hif_drv,
5058 char *pBSSID,
5059 char TID)
c5c77ba1 5060{
e6e12661 5061 s32 s32Error = 0;
143eb95a 5062 struct host_if_msg msg;
c833b474 5063 struct ba_session_info *pBASessionInfo = &msg.body.session_info;
c5c77ba1 5064
a4ab1ade 5065 if (!hif_drv) {
24db713f
LK		 5066 PRINT_ER("driver is null\n");
5067 return -EFAULT;
5068 }
c5c77ba1 5069
143eb95a 5070 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 5071
a9f812a6 5072 msg.id = HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS;
c5c77ba1
JK		 5073
5074 memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN);
5075 pBASessionInfo->u8Ted = TID;
a4ab1ade 5076 msg.drv = hif_drv;
c5c77ba1 5077
cb067dcf 5078 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 5079 if (s32Error)
24db713f 5080 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1 5081
2d25af87 5082 down(&hif_sema_wait_response);
c5c77ba1
JK		 5083
5084 return s32Error;
5085}
5086
a4ab1ade 5087s32 host_int_setup_ipaddress(struct host_if_drv *hif_drv, u8 *u16ipadd, u8 idx)
c5c77ba1 5088{
e6e12661 5089 s32 s32Error = 0;
143eb95a 5090 struct host_if_msg msg;
c5c77ba1 5091
c5c77ba1
JK		 5092 return 0;
5093
a4ab1ade 5094 if (!hif_drv) {
24db713f
LK		 5095 PRINT_ER("driver is null\n");
5096 return -EFAULT;
5097 }
c5c77ba1 5098
143eb95a 5099 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 5100
a9f812a6 5101 msg.id = HOST_IF_MSG_SET_IPADDRESS;
c5c77ba1 5102
78675be5 5103 msg.body.ip_info.ip_addr = u16ipadd;
a4ab1ade 5104 msg.drv = hif_drv;
fb2d65ed 5105 msg.body.ip_info.idx = idx;
c5c77ba1 5106
cb067dcf 5107 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 5108 if (s32Error)
24db713f 5109 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1
JK		 5110
5111 return s32Error;
5112
5113
5114}
5115
a4ab1ade 5116s32 host_int_get_ipaddress(struct host_if_drv *hif_drv, u8 *u16ipadd, u8 idx)
c5c77ba1 5117{
e6e12661 5118 s32 s32Error = 0;
143eb95a 5119 struct host_if_msg msg;
c5c77ba1 5120
a4ab1ade 5121 if (!hif_drv) {
24db713f
LK		 5122 PRINT_ER("driver is null\n");
5123 return -EFAULT;
5124 }
c5c77ba1 5125
143eb95a 5126 memset(&msg, 0, sizeof(struct host_if_msg));
c5c77ba1 5127
a9f812a6 5128 msg.id = HOST_IF_MSG_GET_IPADDRESS;
c5c77ba1 5129
78675be5 5130 msg.body.ip_info.ip_addr = u16ipadd;
a4ab1ade 5131 msg.drv = hif_drv;
fb2d65ed 5132 msg.body.ip_info.idx = idx;
c5c77ba1 5133
cb067dcf 5134 s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
2b9d5b48 5135 if (s32Error)
24db713f 5136 PRINT_ER("wilc_mq_send fail\n");
c5c77ba1
JK		 5137
5138 return s32Error;
5139
5140
5141}
Linux kernel - Deliverables
This page took 0.900877 seconds and 5 git commands to generate.