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