projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge 4.2-rc4 into staging-next
[deliverable/linux.git] / drivers / staging / wilc1000 / host_interface.c
1 #include "host_interface.h"
2 #include "coreconfigurator.h"
3
4 extern s32 TransportInit(void);
5 extern s32 TransportDeInit(void);
6 extern u8 connecting;
7
8 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
9 extern WILC_TimerHandle hDuringIpTimer;
10 #endif
11
12 extern bool bEnablePS;
13 /*BugID_5137*/
14 extern u8 g_wilc_initialized;
15 /*****************************************************************************/
16 /* Macros */
17 /*****************************************************************************/
18
19 /* Message types of the Host IF Message Queue*/
20 #define HOST_IF_MSG_SCAN 0
21 #define HOST_IF_MSG_CONNECT 1
22 #define HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO 2
23 #define HOST_IF_MSG_KEY 3
24 #define HOST_IF_MSG_RCVD_NTWRK_INFO 4
25 #define HOST_IF_MSG_RCVD_SCAN_COMPLETE 5
26 #define HOST_IF_MSG_CFG_PARAMS 6
27 #define HOST_IF_MSG_SET_CHANNEL 7
28 #define HOST_IF_MSG_DISCONNECT 8
29 #define HOST_IF_MSG_GET_RSSI 9
30 #define HOST_IF_MSG_GET_CHNL 10
31 #define HOST_IF_MSG_ADD_BEACON 11
32 #define HOST_IF_MSG_DEL_BEACON 12
33 #define HOST_IF_MSG_ADD_STATION 13
34 #define HOST_IF_MSG_DEL_STATION 14
35 #define HOST_IF_MSG_EDIT_STATION 15
36 #define HOST_IF_MSG_SCAN_TIMER_FIRED 16
37 #define HOST_IF_MSG_CONNECT_TIMER_FIRED 17
38 #define HOST_IF_MSG_POWER_MGMT 18
39 #define HOST_IF_MSG_GET_INACTIVETIME 19
40 #define HOST_IF_MSG_REMAIN_ON_CHAN 20
41 #define HOST_IF_MSG_REGISTER_FRAME 21
42 #define HOST_IF_MSG_LISTEN_TIMER_FIRED 22
43 #define HOST_IF_MSG_GET_LINKSPEED 23
44 #define HOST_IF_MSG_SET_WFIDRV_HANDLER 24
45 #define HOST_IF_MSG_SET_MAC_ADDRESS 25
46 #define HOST_IF_MSG_GET_MAC_ADDRESS 26
47 #define HOST_IF_MSG_SET_OPERATION_MODE 27
48 #define HOST_IF_MSG_SET_IPADDRESS 28
49 #define HOST_IF_MSG_GET_IPADDRESS 29
50 #define HOST_IF_MSG_FLUSH_CONNECT 30
51 #define HOST_IF_MSG_GET_STATISTICS 31
52 #define HOST_IF_MSG_SET_MULTICAST_FILTER 32
53 #define HOST_IF_MSG_ADD_BA_SESSION 33
54 #define HOST_IF_MSG_DEL_BA_SESSION 34
55 #define HOST_IF_MSG_Q_IDLE 35
56 #define HOST_IF_MSG_DEL_ALL_STA 36
57 #define HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS 34
58 #define HOST_IF_MSG_EXIT 100
59
60 #define HOST_IF_SCAN_TIMEOUT 4000
61 #define HOST_IF_CONNECT_TIMEOUT 9500
62
63 #define BA_SESSION_DEFAULT_BUFFER_SIZE 16
64 #define BA_SESSION_DEFAULT_TIMEOUT 1000
65 #define BLOCK_ACK_REQ_SIZE 0x14
66 /*****************************************************************************/
67 /* Type Definitions */
68 /*****************************************************************************/
69
70 /*!
71 * @struct tstrHostIFCfgParamAttr
72 * @brief Structure to hold Host IF CFG Params Attributes
73 * @details
74 * @todo
75 * @sa
76 * @author Mai Daftedar
77 * @date 02 April 2012
78 * @version 1.0
79 */
80 typedef struct _tstrHostIFCfgParamAttr {
81 tstrCfgParamVal pstrCfgParamVal;
82
83 } tstrHostIFCfgParamAttr;
84
85 /*!
86 * @struct tstrHostIFwpaAttr
87 * @brief Structure to hold Host IF Scan Attributes
88 * @details
89 * @todo
90 * @sa
91 * @author Mai Daftedar
92 * @date 25 March 2012
93 * @version 1.0
94 */
95 typedef struct _tstrHostIFwpaAttr {
96 u8 *pu8key;
97 const u8 *pu8macaddr;
98 u8 *pu8seq;
99 u8 u8seqlen;
100 u8 u8keyidx;
101 u8 u8Keylen;
102 u8 u8Ciphermode;
103 } tstrHostIFwpaAttr;
104
105
106 /*!
107 * @struct tstrHostIFwepAttr
108 * @brief Structure to hold Host IF Scan Attributes
109 * @details
110 * @todo
111 * @sa
112 * @author Mai Daftedar
113 * @date 25 March 2012
114 * @version 1.0
115 */
116 typedef struct _tstrHostIFwepAttr {
117 u8 *pu8WepKey;
118 u8 u8WepKeylen;
119 u8 u8Wepidx;
120 u8 u8mode;
121 AUTHTYPE_T tenuAuth_type;
122
123 } tstrHostIFwepAttr;
124
125 /*!
126 * @struct tuniHostIFkeyAttr
127 * @brief Structure to hold Host IF Scan Attributes
128 * @details
129 * @todo
130 * @sa
131 * @author Mai Daftedar
132 * @date 25 March 2012
133 * @version 1.0
134 */
135 typedef union _tuniHostIFkeyAttr {
136 tstrHostIFwepAttr strHostIFwepAttr;
137 tstrHostIFwpaAttr strHostIFwpaAttr;
138 tstrHostIFpmkidAttr strHostIFpmkidAttr;
139 } tuniHostIFkeyAttr;
140
141 /*!
142 * @struct tstrHostIFkeyAttr
143 * @brief Structure to hold Host IF Scan Attributes
144 * @details
145 * @todo
146 * @sa
147 * @author Mai Daftedar
148 * @date 25 March 2012
149 * @version 1.0
150 */
151 typedef struct _tstrHostIFkeyAttr {
152 tenuKeyType enuKeyType;
153 u8 u8KeyAction;
154 tuniHostIFkeyAttr uniHostIFkeyAttr;
155 } tstrHostIFkeyAttr;
156
157
158
159
160 /*!
161 * @struct tstrHostIFscanAttr
162 * @brief Structure to hold Host IF Scan Attributes
163 * @details
164 * @todo
165 * @sa
166 * @author Mostafa Abu Bakr
167 * @date 25 March 2012
168 * @version 1.0
169 */
170 typedef struct _tstrHostIFscanAttr {
171 u8 u8ScanSource;
172 u8 u8ScanType;
173 u8 *pu8ChnlFreqList;
174 u8 u8ChnlListLen;
175 u8 *pu8IEs;
176 size_t IEsLen;
177 tWILCpfScanResult pfScanResult;
178 void *pvUserArg;
179 /*BugID_4189*/
180 tstrHiddenNetwork strHiddenNetwork;
181
182 } tstrHostIFscanAttr;
183
184 /*!
185 * @struct tstrHostIFconnectAttr
186 * @brief Structure to hold Host IF Connect Attributes
187 * @details
188 * @todo
189 * @sa
190 * @author Mostafa Abu Bakr
191 * @date 25 March 2012
192 * @version 1.0
193 */
194 typedef struct _tstrHostIFconnectAttr {
195 u8 *pu8bssid;
196 u8 *pu8ssid;
197 size_t ssidLen;
198 u8 *pu8IEs;
199 size_t IEsLen;
200 u8 u8security;
201 tWILCpfConnectResult pfConnectResult;
202 void *pvUserArg;
203 AUTHTYPE_T tenuAuth_type;
204 u8 u8channel;
205 void *pJoinParams;
206 } tstrHostIFconnectAttr;
207
208 /*!
209 * @struct tstrRcvdGnrlAsyncInfo
210 * @brief Structure to hold Received General Asynchronous info
211 * @details
212 * @todo
213 * @sa
214 * @author Mostafa Abu Bakr
215 * @date 25 March 2012
216 * @version 1.0
217 */
218 typedef struct _tstrRcvdGnrlAsyncInfo {
219 u8 *pu8Buffer;
220 u32 u32Length;
221 } tstrRcvdGnrlAsyncInfo;
222
223 /*!
224 * @struct tstrHostIFSetChan
225 * @brief Set Channel message body
226 * @details
227 * @todo
228 * @sa
229 * @author Mai Daftedar
230 * @date 25 March 2012
231 * @version 1.0
232 */
233 typedef struct _tstrHostIFSetChan {
234 u8 u8SetChan;
235 } tstrHostIFSetChan;
236
237 /*!
238 * @struct tstrHostIFSetChan
239 * @brief Get Channel message body
240 * @details
241 * @todo
242 * @sa
243 * @author Mai Daftedar
244 * @date 01 Jule 2012
245 * @version 1.0
246 */
247 typedef struct _tstrHostIFGetChan {
248 u8 u8GetChan;
249 } tstrHostIFGetChan;
250
251 /*bug3819: Add Scan acomplete notification to host*/
252 /*!
253 * @struct tstrScanComplete
254 * @brief hold received Async. Scan Complete message body
255 * @details
256 * @todo
257 * @sa
258 * @author zsalah
259 * @date 25 March 2012
260 * @version 1.0
261 */
262 /*typedef struct _tstrScanComplete
263 * {
264 * u8* pu8Buffer;
265 * u32 u32Length;
266 * } tstrScanComplete;*/
267
268 /*!
269 * @struct tstrHostIFSetBeacon
270 * @brief Set Beacon message body
271 * @details
272 * @todo
273 * @sa
274 * @author Adham Abozaeid
275 * @date 10 July 2012
276 * @version 1.0
277 */
278 typedef struct _tstrHostIFSetBeacon {
279 u32 u32Interval; /*!< Beacon Interval. Period between two successive beacons on air */
280 u32 u32DTIMPeriod; /*!< DTIM Period. Indicates how many Beacon frames
281 * (including the current frame) appear before the next DTIM */
282 u32 u32HeadLen; /*!< Length of the head buffer in bytes */
283 u8 *pu8Head; /*!< Pointer to the beacon's head buffer. Beacon's head is the part
284 * from the beacon's start till the TIM element, NOT including the TIM */
285 u32 u32TailLen; /*!< Length of the tail buffer in bytes */
286 u8 *pu8Tail; /*!< Pointer to the beacon's tail buffer. Beacon's tail starts just
287 * after the TIM inormation element */
288 } tstrHostIFSetBeacon;
289
290
291
292 /*!
293 * @struct tstrHostIFDelBeacon
294 * @brief Del Beacon message body
295 * @details
296 * @todo
297 * @sa
298 * @author Adham Abozaeid
299 * @date 15 July 2012
300 * @version 1.0
301 */
302 typedef struct _tstrHostIFDelBeacon {
303 u8 u8dummy;
304 } tstrHostIFDelBeacon;
305
306 /*!
307 * @struct tstrHostIFSetMulti
308 * @brief set Multicast filter Address
309 * @details
310 * @todo
311 * @sa
312 * @author Abdelrahman Sobhy
313 * @date 30 August 2013
314 * @version 1.0 Description
315 */
316
317 typedef struct {
318 bool bIsEnabled;
319 u32 u32count;
320 } tstrHostIFSetMulti;
321
322 /*!
323 * @struct tstrHostIFDelAllSta
324 * @brief Deauth station message body
325 * @details
326 * @todo
327 * @sa
328 * @author Mai Daftedar
329 * @date 09 April 2014
330 * @version 1.0 Description
331 */
332
333 typedef struct {
334 u8 au8Sta_DelAllSta[MAX_NUM_STA][ETH_ALEN];
335 u8 u8Num_AssocSta;
336 } tstrHostIFDelAllSta;
337
338 /*!
339 * @struct tstrHostIFDelSta
340 * @brief Delete station message body
341 * @details
342 * @todo
343 * @sa
344 * @author Adham Abozaeid
345 * @date 15 July 2012
346 * @version 1.0 Description
347 */
348
349 typedef struct {
350 u8 au8MacAddr[ETH_ALEN];
351 } tstrHostIFDelSta;
352
353 /*!
354 * @struct tstrTimerCb
355 * @brief Timer callback message body
356 * @details
357 * @todo
358 * @sa
359 * @author Mostafa Abu Bakr
360 * @date 25 March 2012
361 * @version 1.0
362 */
363 typedef struct _tstrTimerCb {
364 void *pvUsrArg; /*!< Private data passed at timer start */
365 } tstrTimerCb;
366
367 /*!
368 * @struct tstrHostIfPowerMgmtParam
369 * @brief Power management message body
370 * @details
371 * @todo
372 * @sa
373 * @author Adham Abozaeid
374 * @date 24 November 2012
375 * @version 1.0
376 */
377 typedef struct {
378
379 bool bIsEnabled;
380 u32 u32Timeout;
381 } tstrHostIfPowerMgmtParam;
382
383 /*!
384 * @struct tstrHostIFSetIPAddr
385 * @brief set IP Address message body
386 * @details
387 * @todo
388 * @sa
389 * @author Abdelrahman Sobhy
390 * @date 30 August 2013
391 * @version 1.0 Description
392 */
393
394 typedef struct {
395 u8 *au8IPAddr;
396 u8 idx;
397 } tstrHostIFSetIPAddr;
398
399 /*!
400 * @struct tstrHostIfStaInactiveT
401 * @brief Get station message body
402 * @details
403 * @todo
404 * @sa
405 * @author Mai Daftedar
406 * @date 16 April 2013
407 * @version 1.0
408 */
409 typedef struct {
410 u8 mac[6];
411
412 } tstrHostIfStaInactiveT;
413 /**/
414 /*!
415 * @union tuniHostIFmsgBody
416 * @brief Message body for the Host Interface message_q
417 * @details
418 * @todo
419 * @sa
420 * @author Mostafa Abu Bakr
421 * @date 25 March 2012
422 * @version 1.0
423 */
424 typedef union _tuniHostIFmsgBody {
425 tstrHostIFscanAttr strHostIFscanAttr; /*!< Host IF Scan Request Attributes message body */
426 tstrHostIFconnectAttr strHostIFconnectAttr; /*!< Host IF Connect Request Attributes message body */
427 tstrRcvdNetworkInfo strRcvdNetworkInfo; /*!< Received Asynchronous Network Info message body */
428 tstrRcvdGnrlAsyncInfo strRcvdGnrlAsyncInfo; /*!< Received General Asynchronous Info message body */
429 tstrHostIFkeyAttr strHostIFkeyAttr; /*!<>*/
430 tstrHostIFCfgParamAttr strHostIFCfgParamAttr; /*! <CFG Parameter message Body> */
431 tstrHostIFSetChan strHostIFSetChan;
432 tstrHostIFGetChan strHostIFGetChan;
433 tstrHostIFSetBeacon strHostIFSetBeacon; /*!< Set beacon message body */
434 tstrHostIFDelBeacon strHostIFDelBeacon; /*!< Del beacon message body */
435 tstrWILC_AddStaParam strAddStaParam; /*!< Add station message body */
436 tstrHostIFDelSta strDelStaParam; /*!< Del Station message body */
437 tstrWILC_AddStaParam strEditStaParam; /*!< Edit station message body */
438 /* tstrScanComplete strScanComplete; / *Received Async. Scan Complete message body* / */
439 tstrTimerCb strTimerCb; /*!< Timer callback message body */
440 tstrHostIfPowerMgmtParam strPowerMgmtparam; /*!< Power Management message body */
441 tstrHostIfStaInactiveT strHostIfStaInactiveT;
442 tstrHostIFSetIPAddr strHostIfSetIP;
443 tstrHostIfSetDrvHandler strHostIfSetDrvHandler;
444 tstrHostIFSetMulti strHostIfSetMulti;
445 tstrHostIfSetOperationMode strHostIfSetOperationMode;
446 tstrHostIfSetMacAddress strHostIfSetMacAddress;
447 tstrHostIfGetMacAddress strHostIfGetMacAddress;
448 tstrHostIfBASessionInfo strHostIfBASessionInfo;
449 #ifdef WILC_P2P
450 tstrHostIfRemainOnChan strHostIfRemainOnChan;
451 tstrHostIfRegisterFrame strHostIfRegisterFrame;
452 #endif
453 char *pUserData;
454 tstrHostIFDelAllSta strHostIFDelAllSta;
455 } tuniHostIFmsgBody;
456
457 /*!
458 * @struct tstrHostIFmsg
459 * @brief Host Interface message
460 * @details
461 * @todo
462 * @sa
463 * @author Mostafa Abu Bakr
464 * @date 25 March 2012
465 * @version 1.0
466 */
467 typedef struct _tstrHostIFmsg {
468 u16 u16MsgId; /*!< Message ID */
469 tuniHostIFmsgBody uniHostIFmsgBody; /*!< Message body */
470 void *drvHandler;
471 } tstrHostIFmsg;
472
473 #ifdef CONNECT_DIRECT
474 typedef struct _tstrWidJoinReqExt {
475 char SSID[MAX_SSID_LEN];
476 u8 u8channel;
477 u8 BSSID[6];
478 } tstrWidJoinReqExt;
479 #endif
480
481 /*Bug4218: Parsing Join Param*/
482 #ifdef WILC_PARSE_SCAN_IN_HOST
483 /*Struct containg joinParam of each AP*/
484 typedef struct _tstrJoinBssParam {
485 BSSTYPE_T bss_type;
486 u8 dtim_period;
487 u16 beacon_period;
488 u16 cap_info;
489 u8 au8bssid[6];
490 char ssid[MAX_SSID_LEN];
491 u8 ssidLen;
492 u8 supp_rates[MAX_RATES_SUPPORTED + 1];
493 u8 ht_capable;
494 u8 wmm_cap;
495 u8 uapsd_cap;
496 bool rsn_found;
497 u8 rsn_grp_policy;
498 u8 mode_802_11i;
499 u8 rsn_pcip_policy[3];
500 u8 rsn_auth_policy[3];
501 u8 rsn_cap[2];
502 struct _tstrJoinParam *nextJoinBss;
503 #ifdef WILC_P2P
504 u32 tsf;
505 u8 u8NoaEnbaled;
506 u8 u8OppEnable;
507 u8 u8CtWindow;
508 u8 u8Count;
509 u8 u8Index;
510 u8 au8Duration[4];
511 u8 au8Interval[4];
512 u8 au8StartTime[4];
513 #endif
514 } tstrJoinBssParam;
515 /*Bug4218: Parsing Join Param*/
516 /*a linked list table containing needed join parameters entries for each AP found in most recent scan*/
517 typedef struct _tstrBssTable {
518 u8 u8noBssEntries;
519 tstrJoinBssParam *head;
520 tstrJoinBssParam *tail;
521 } tstrBssTable;
522 #endif /*WILC_PARSE_SCAN_IN_HOST*/
523
524 typedef enum {
525 SCAN_TIMER = 0,
526 CONNECT_TIMER = 1,
527 SCAN_CONNECT_TIMER_FORCE_32BIT = 0xFFFFFFFF
528 } tenuScanConnTimer;
529
530 /*****************************************************************************/
531 /* */
532 /* Global Variabls */
533 /* */
534 /*****************************************************************************/
535
536
537 tstrWILC_WFIDrv *terminated_handle;
538 tstrWILC_WFIDrv *gWFiDrvHandle;
539 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
540 bool g_obtainingIP = false;
541 #endif
542 u8 P2P_LISTEN_STATE;
543 static struct task_struct *HostIFthreadHandler;
544 static WILC_MsgQueueHandle gMsgQHostIF;
545 static struct semaphore hSemHostIFthrdEnd;
546
547 struct semaphore hSemDeinitDrvHandle;
548 static struct semaphore hWaitResponse;
549 struct semaphore hSemHostIntDeinit;
550 WILC_TimerHandle g_hPeriodicRSSI;
551
552
553
554 u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
555
556 #ifndef CONNECT_DIRECT
557 static u8 gapu8RcvdSurveyResults[2][MAX_SURVEY_RESULT_FRAG_SIZE];
558 #endif
559
560 static u8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE];
561
562 bool gbScanWhileConnected = false;
563
564 static s8 gs8Rssi;
565 static s8 gs8lnkspd;
566 static u8 gu8Chnl;
567 static u8 gs8SetIP[2][4];
568 static u8 gs8GetIP[2][4];
569 #ifdef WILC_AP_EXTERNAL_MLME
570 static u32 gu32InactiveTime;
571 static u8 gu8DelBcn;
572 #endif
573 #ifndef SIMULATION
574 static u32 gu32WidConnRstHack;
575 #endif
576
577 /*BugID_5137*/
578 u8 *gu8FlushedJoinReq;
579 u8 *gu8FlushedInfoElemAsoc;
580 u8 gu8Flushed11iMode;
581 u8 gu8FlushedAuthType;
582 u32 gu32FlushedJoinReqSize;
583 u32 gu32FlushedInfoElemAsocSize;
584 u32 gu8FlushedJoinReqDrvHandler;
585 #define REAL_JOIN_REQ 0
586 #define FLUSHED_JOIN_REQ 1
587 #define FLUSHED_BYTE_POS 79 /* Position the byte indicating flushing in the flushed request */
588
589 /*Bug4218: Parsing Join Param*/
590 #ifdef WILC_PARSE_SCAN_IN_HOST
591 /*Bug4218: Parsing Join Param*/
592 static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo);
593 #endif /*WILC_PARSE_SCAN_IN_HOST*/
594
595 extern void chip_sleep_manually(u32 u32SleepTime);
596 extern int linux_wlan_get_num_conn_ifcs(void);
597
598 /**
599 * @brief Handle_SetChannel
600 * @details Sending config packet to firmware to set channel
601 * @param[in] tstrHostIFSetChan* pstrHostIFSetChan
602 * @return Error code.
603 * @author
604 * @date
605 * @version 1.0
606 */
607 static s32 Handle_SetChannel(void *drvHandler, tstrHostIFSetChan *pstrHostIFSetChan)
608 {
609
610 s32 s32Error = WILC_SUCCESS;
611 tstrWID strWID;
612 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
613
614 /*prepare configuration packet*/
615 strWID.u16WIDid = (u16)WID_CURRENT_CHANNEL;
616 strWID.enuWIDtype = WID_CHAR;
617 strWID.ps8WidVal = (char *)&(pstrHostIFSetChan->u8SetChan);
618 strWID.s32ValueSize = sizeof(char);
619
620 PRINT_D(HOSTINF_DBG, "Setting channel\n");
621 /*Sending Cfg*/
622 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
623 if (s32Error) {
624 PRINT_ER("Failed to set channel\n");
625 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
626 }
627 WILC_CATCH(s32Error)
628 {
629
630 }
631
632 return s32Error;
633 }
634 /**
635 * @brief Handle_SetWfiDrvHandler
636 * @details Sending config packet to firmware to set driver handler
637 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
638 * @return Error code.
639 * @author
640 * @date
641 * @version 1.0
642 */
643 static s32 Handle_SetWfiDrvHandler(tstrHostIfSetDrvHandler *pstrHostIfSetDrvHandler)
644 {
645
646 s32 s32Error = WILC_SUCCESS;
647 tstrWID strWID;
648 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)((pstrHostIfSetDrvHandler->u32Address));
649
650
651 /*prepare configuration packet*/
652 strWID.u16WIDid = (u16)WID_SET_DRV_HANDLER;
653 strWID.enuWIDtype = WID_INT;
654 strWID.ps8WidVal = (s8 *)&(pstrHostIfSetDrvHandler->u32Address);
655 strWID.s32ValueSize = sizeof(u32);
656
657 /*Sending Cfg*/
658
659 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
660
661
662 if ((pstrHostIfSetDrvHandler->u32Address) == (u32)NULL)
663 up(&hSemDeinitDrvHandle);
664
665
666 if (s32Error) {
667 PRINT_ER("Failed to set driver handler\n");
668 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
669 }
670 WILC_CATCH(s32Error)
671 {
672
673 }
674
675 return s32Error;
676 }
677
678 /**
679 * @brief Handle_SetWfiAPDrvHandler
680 * @details Sending config packet to firmware to set driver handler
681 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
682 * @return Error code.
683 * @author
684 * @date
685 * @version 1.0
686 */
687 static s32 Handle_SetOperationMode(void *drvHandler, tstrHostIfSetOperationMode *pstrHostIfSetOperationMode)
688 {
689
690 s32 s32Error = WILC_SUCCESS;
691 tstrWID strWID;
692 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
693
694
695 /*prepare configuration packet*/
696 strWID.u16WIDid = (u16)WID_SET_OPERATION_MODE;
697 strWID.enuWIDtype = WID_INT;
698 strWID.ps8WidVal = (s8 *)&(pstrHostIfSetOperationMode->u32Mode);
699 strWID.s32ValueSize = sizeof(u32);
700
701 /*Sending Cfg*/
702 PRINT_INFO(HOSTINF_DBG, "pstrWFIDrv= %p\n", pstrWFIDrv);
703
704 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
705
706
707 if ((pstrHostIfSetOperationMode->u32Mode) == (u32)NULL)
708 up(&hSemDeinitDrvHandle);
709
710
711 if (s32Error) {
712 PRINT_ER("Failed to set driver handler\n");
713 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
714 }
715 WILC_CATCH(s32Error)
716 {
717
718 }
719
720 return s32Error;
721 }
722
723 /**
724 * @brief host_int_set_IPAddress
725 * @details Setting IP address params in message queue
726 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr
727 * @return Error code.
728 * @author
729 * @date
730 * @version 1.0
731 */
732 s32 Handle_set_IPAddress(void *drvHandler, u8 *pu8IPAddr, u8 idx)
733 {
734
735 s32 s32Error = WILC_SUCCESS;
736 tstrWID strWID;
737 char firmwareIPAddress[4] = {0};
738 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
739
740 if (pu8IPAddr[0] < 192)
741 pu8IPAddr[0] = 0;
742
743 PRINT_INFO(HOSTINF_DBG, "Indx = %d, Handling set IP = %pI4\n", idx, pu8IPAddr);
744
745 WILC_memcpy(gs8SetIP[idx], pu8IPAddr, IP_ALEN);
746
747 /*prepare configuration packet*/
748 strWID.u16WIDid = (u16)WID_IP_ADDRESS;
749 strWID.enuWIDtype = WID_STR;
750 strWID.ps8WidVal = (u8 *)pu8IPAddr;
751 strWID.s32ValueSize = IP_ALEN;
752
753 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
754
755
756
757 host_int_get_ipaddress((WILC_WFIDrvHandle)drvHandler, firmwareIPAddress, idx);
758
759 if (s32Error) {
760 PRINT_D(HOSTINF_DBG, "Failed to set IP address\n");
761 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
762 } else {
763 PRINT_INFO(HOSTINF_DBG, "IP address set\n");
764 }
765
766 WILC_CATCH(s32Error)
767 {
768
769 }
770
771 return s32Error;
772 }
773
774
775 /**
776 * @brief Handle_get_IPAddress
777 * @details Setting IP address params in message queue
778 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr
779 * @return Error code.
780 * @author
781 * @date
782 * @version 1.0
783 */
784 s32 Handle_get_IPAddress(void *drvHandler, u8 *pu8IPAddr, u8 idx)
785 {
786
787 s32 s32Error = WILC_SUCCESS;
788 tstrWID strWID;
789 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
790
791 /*prepare configuration packet*/
792 strWID.u16WIDid = (u16)WID_IP_ADDRESS;
793 strWID.enuWIDtype = WID_STR;
794 strWID.ps8WidVal = (u8 *)WILC_MALLOC(IP_ALEN);
795 strWID.s32ValueSize = IP_ALEN;
796
797 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
798
799 PRINT_INFO(HOSTINF_DBG, "%pI4\n", strWID.ps8WidVal);
800
801 WILC_memcpy(gs8GetIP[idx], strWID.ps8WidVal, IP_ALEN);
802
803 /*get the value by searching the local copy*/
804 WILC_FREE(strWID.ps8WidVal);
805
806 if (WILC_memcmp(gs8GetIP[idx], gs8SetIP[idx], IP_ALEN) != 0)
807 host_int_setup_ipaddress((WILC_WFIDrvHandle)pstrWFIDrv, gs8SetIP[idx], idx);
808
809 if (s32Error != WILC_SUCCESS) {
810 PRINT_ER("Failed to get IP address\n");
811 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
812 } else {
813 PRINT_INFO(HOSTINF_DBG, "IP address retrieved:: u8IfIdx = %d\n", idx);
814 PRINT_INFO(HOSTINF_DBG, "%pI4\n", gs8GetIP[idx]);
815 PRINT_INFO(HOSTINF_DBG, "\n");
816 }
817
818 WILC_CATCH(s32Error)
819 {
820
821 }
822
823 return s32Error;
824 }
825
826
827 /*BugId_5077*/
828 /**
829 * @brief Handle_SetMacAddress
830 * @details Setting mac address
831 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
832 * @return Error code.
833 * @author Amr Abdel-Moghny
834 * @date November 2013
835 * @version 7.0
836 */
837 static s32 Handle_SetMacAddress(void *drvHandler, tstrHostIfSetMacAddress *pstrHostIfSetMacAddress)
838 {
839
840 s32 s32Error = WILC_SUCCESS;
841 tstrWID strWID;
842 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
843 u8 *mac_buf = (u8 *)WILC_MALLOC(ETH_ALEN);
844
845 if (mac_buf == NULL) {
846 PRINT_ER("No buffer to send mac address\n");
847 return WILC_FAIL;
848 }
849 WILC_memcpy(mac_buf, pstrHostIfSetMacAddress->u8MacAddress, ETH_ALEN);
850
851 /*prepare configuration packet*/
852 strWID.u16WIDid = (u16)WID_MAC_ADDR;
853 strWID.enuWIDtype = WID_STR;
854 strWID.ps8WidVal = mac_buf;
855 strWID.s32ValueSize = ETH_ALEN;
856 PRINT_D(GENERIC_DBG, "mac addr = :%x:%x:%x:%x:%x:%x\n", strWID.ps8WidVal[0], strWID.ps8WidVal[1], strWID.ps8WidVal[2], strWID.ps8WidVal[3], strWID.ps8WidVal[4], strWID.ps8WidVal[5]);
857 /*Sending Cfg*/
858 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
859 if (s32Error) {
860 PRINT_ER("Failed to set mac address\n");
861 WILC_ERRORREPORT(s32Error, WILC_FAIL);
862 }
863
864 WILC_CATCH(s32Error)
865 {
866
867 }
868 WILC_FREE(mac_buf);
869 return s32Error;
870 }
871
872
873 /*BugID_5213*/
874 /**
875 * @brief Handle_GetMacAddress
876 * @details Getting mac address
877 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
878 * @return Error code.
879 * @author Amr Abdel-Moghny
880 * @date JAN 2013
881 * @version 8.0
882 */
883 static s32 Handle_GetMacAddress(void *drvHandler, tstrHostIfGetMacAddress *pstrHostIfGetMacAddress)
884 {
885
886 s32 s32Error = WILC_SUCCESS;
887 tstrWID strWID;
888
889 /*prepare configuration packet*/
890 strWID.u16WIDid = (u16)WID_MAC_ADDR;
891 strWID.enuWIDtype = WID_STR;
892 strWID.ps8WidVal = pstrHostIfGetMacAddress->u8MacAddress;
893 strWID.s32ValueSize = ETH_ALEN;
894
895 /*Sending Cfg*/
896 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, false, (u32)drvHandler);
897 if (s32Error) {
898 PRINT_ER("Failed to get mac address\n");
899 WILC_ERRORREPORT(s32Error, WILC_FAIL);
900 }
901 WILC_CATCH(s32Error)
902 {
903
904 }
905 up(&hWaitResponse);
906
907 return s32Error;
908 }
909
910
911 /**
912 * @brief Handle_CfgParam
913 * @details Sending config packet to firmware to set CFG params
914 * @param[in] tstrHostIFCfgParamAttr* strHostIFCfgParamAttr
915 * @return Error code.
916 * @author
917 * @date
918 * @version 1.0
919 */
920 static s32 Handle_CfgParam(void *drvHandler, tstrHostIFCfgParamAttr *strHostIFCfgParamAttr)
921 {
922 s32 s32Error = WILC_SUCCESS;
923 tstrWID strWIDList[32];
924 u8 u8WidCnt = 0;
925 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
926
927
928 down(&(pstrWFIDrv->gtOsCfgValuesSem));
929
930
931 PRINT_D(HOSTINF_DBG, "Setting CFG params\n");
932
933 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & BSS_TYPE) {
934 /*----------------------------------------------------------*/
935 /*Input Value: INFRASTRUCTURE = 1, */
936 /* INDEPENDENT= 2, */
937 /* ANY_BSS= 3 */
938 /*----------------------------------------------------------*/
939 /* validate input then copy>> need to check value 4 and 5 */
940 if (strHostIFCfgParamAttr->pstrCfgParamVal.bss_type < 6) {
941 strWIDList[u8WidCnt].u16WIDid = WID_BSS_TYPE;
942 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
943 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
944 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
945 pstrWFIDrv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
946 } else {
947 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
948 }
949 u8WidCnt++;
950 }
951 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & AUTH_TYPE) {
952 /*------------------------------------------------------*/
953 /*Input Values: OPEN_SYSTEM = 0, */
954 /* SHARED_KEY = 1, */
955 /* ANY = 2 */
956 /*------------------------------------------------------*/
957 /*validate Possible values*/
958 if ((strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 1 || (strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 2 || (strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 5) {
959 strWIDList[u8WidCnt].u16WIDid = WID_AUTH_TYPE;
960 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
961 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
962 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
963 pstrWFIDrv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
964 } else {
965 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
966 }
967 u8WidCnt++;
968 }
969 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & AUTHEN_TIMEOUT) {
970 /* range is 1 to 65535. */
971 if (strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout < 65536) {
972 strWIDList[u8WidCnt].u16WIDid = WID_AUTH_TIMEOUT;
973 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout;
974 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
975 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
976 pstrWFIDrv->strCfgValues.auth_timeout = strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout;
977 } else {
978 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
979 }
980 u8WidCnt++;
981 }
982 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & POWER_MANAGEMENT) {
983 /*-----------------------------------------------------------*/
984 /*Input Values: NO_POWERSAVE = 0, */
985 /* MIN_FAST_PS = 1, */
986 /* MAX_FAST_PS = 2, */
987 /* MIN_PSPOLL_PS = 3, */
988 /* MAX_PSPOLL_PS = 4 */
989 /*----------------------------------------------------------*/
990 if (strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode < 5) {
991 strWIDList[u8WidCnt].u16WIDid = WID_POWER_MANAGEMENT;
992 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
993 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
994 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
995 pstrWFIDrv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
996 } else {
997 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
998 }
999 u8WidCnt++;
1000 }
1001 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & RETRY_SHORT) {
1002 /* range from 1 to 256 */
1003 if ((strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit > 0) && (strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit < 256)) {
1004 strWIDList[u8WidCnt].u16WIDid = WID_SHORT_RETRY_LIMIT;
1005 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit;
1006 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1007 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1008 pstrWFIDrv->strCfgValues.short_retry_limit = strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit;
1009 } else {
1010 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1011 }
1012 u8WidCnt++;
1013 }
1014 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & RETRY_LONG) {
1015 /* range from 1 to 256 */
1016 if ((strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit > 0) && (strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit < 256)) {
1017 strWIDList[u8WidCnt].u16WIDid = WID_LONG_RETRY_LIMIT;
1018 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit;
1019
1020 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1021 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1022 pstrWFIDrv->strCfgValues.long_retry_limit = strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit;
1023 } else {
1024 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1025 }
1026 u8WidCnt++;
1027 }
1028 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & FRAG_THRESHOLD) {
1029
1030 if (strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold < 7937) {
1031 strWIDList[u8WidCnt].u16WIDid = WID_FRAG_THRESHOLD;
1032 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold;
1033 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1034 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1035 pstrWFIDrv->strCfgValues.frag_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold;
1036 } else {
1037 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1038 }
1039 u8WidCnt++;
1040 }
1041 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & RTS_THRESHOLD) {
1042 /* range 256 to 65535 */
1043 if (strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold < 65536) {
1044 strWIDList[u8WidCnt].u16WIDid = WID_RTS_THRESHOLD;
1045 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold;
1046 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1047 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1048 pstrWFIDrv->strCfgValues.rts_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold;
1049 } else {
1050 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1051 }
1052 u8WidCnt++;
1053 }
1054 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & PREAMBLE) {
1055 /*-----------------------------------------------------*/
1056 /*Input Values: Short= 0, */
1057 /* Long= 1, */
1058 /* Auto= 2 */
1059 /*------------------------------------------------------*/
1060 if (strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type < 3) {
1061 strWIDList[u8WidCnt].u16WIDid = WID_PREAMBLE;
1062 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type;
1063 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
1064 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
1065 pstrWFIDrv->strCfgValues.preamble_type = strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type;
1066 } else {
1067 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1068 }
1069 u8WidCnt++;
1070 }
1071 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SHORT_SLOT_ALLOWED) {
1072 if (strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed < 2) {
1073 strWIDList[u8WidCnt].u16WIDid = WID_SHORT_SLOT_ALLOWED;
1074 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
1075 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
1076 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
1077 pstrWFIDrv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
1078 } else {
1079 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1080 }
1081 u8WidCnt++;
1082 }
1083 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & TXOP_PROT_DISABLE) {
1084 /*Description: used to Disable RTS-CTS protection for TXOP burst*/
1085 /*transmission when the acknowledgement policy is No-Ack or Block-Ack */
1086 /* this information is useful for external supplicant */
1087 /*Input Values: 1 for enable and 0 for disable. */
1088 if (strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled < 2) {
1089 strWIDList[u8WidCnt].u16WIDid = WID_11N_TXOP_PROT_DISABLE;
1090 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
1091 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
1092 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
1093 pstrWFIDrv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
1094 } else {
1095 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1096 }
1097 u8WidCnt++;
1098 }
1099 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & BEACON_INTERVAL) {
1100 /* range is 1 to 65535. */
1101 if (strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval < 65536) {
1102 strWIDList[u8WidCnt].u16WIDid = WID_BEACON_INTERVAL;
1103 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval;
1104 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1105 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1106 pstrWFIDrv->strCfgValues.beacon_interval = strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval;
1107 } else {
1108 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1109 }
1110 u8WidCnt++;
1111 }
1112 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & DTIM_PERIOD) {
1113 /* range is 1 to 255. */
1114 if (strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period < 256) {
1115 strWIDList[u8WidCnt].u16WIDid = WID_DTIM_PERIOD;
1116 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period;
1117 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
1118 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
1119 pstrWFIDrv->strCfgValues.dtim_period = strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period;
1120 } else {
1121 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1122 }
1123 u8WidCnt++;
1124 }
1125 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SITE_SURVEY) {
1126 /*----------------------------------------------------------------------*/
1127 /*Input Values: SITE_SURVEY_1CH = 0, i.e.: currently set channel */
1128 /* SITE_SURVEY_ALL_CH = 1, */
1129 /* SITE_SURVEY_OFF = 2 */
1130 /*----------------------------------------------------------------------*/
1131 if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled < 3) {
1132 strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY;
1133 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
1134 strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
1135 strWIDList[u8WidCnt].s32ValueSize = sizeof(char);
1136 pstrWFIDrv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
1137 } else {
1138 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1139 }
1140 u8WidCnt++;
1141 }
1142 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SITE_SURVEY_SCAN_TIME) {
1143 /* range is 1 to 65535. */
1144 if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time < 65536) {
1145 strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY_SCAN_TIME;
1146 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time;
1147 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1148 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1149 pstrWFIDrv->strCfgValues.site_survey_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time;
1150 } else {
1151 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1152 }
1153 u8WidCnt++;
1154 }
1155 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & ACTIVE_SCANTIME) {
1156 /* range is 1 to 65535. */
1157 if (strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time < 65536) {
1158 strWIDList[u8WidCnt].u16WIDid = WID_ACTIVE_SCAN_TIME;
1159 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time;
1160 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1161 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1162 pstrWFIDrv->strCfgValues.active_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time;
1163 } else {
1164 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1165 }
1166 u8WidCnt++;
1167 }
1168 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & PASSIVE_SCANTIME) {
1169 /* range is 1 to 65535. */
1170 if (strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time < 65536) {
1171 strWIDList[u8WidCnt].u16WIDid = WID_PASSIVE_SCAN_TIME;
1172 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time;
1173 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1174 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1175 pstrWFIDrv->strCfgValues.passive_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time;
1176 } else {
1177 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1178 }
1179 u8WidCnt++;
1180 }
1181 if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & CURRENT_TX_RATE) {
1182 CURRENT_TX_RATE_T curr_tx_rate = strHostIFCfgParamAttr->pstrCfgParamVal.curr_tx_rate;
1183 /*----------------------------------------------------------------------*/
1184 /*Rates: 1 2 5.5 11 6 9 12 18 24 36 48 54 Auto */
1185 /*InputValues: 1 2 3 4 5 6 7 8 9 10 11 12 0 */
1186 /*----------------------------------------------------------------------*/
1187 /* validate rate */
1188 if (curr_tx_rate == AUTORATE || curr_tx_rate == MBPS_1
1189 || curr_tx_rate == MBPS_2 || curr_tx_rate == MBPS_5_5
1190 || curr_tx_rate == MBPS_11 || curr_tx_rate == MBPS_6
1191 || curr_tx_rate == MBPS_9 || curr_tx_rate == MBPS_12
1192 || curr_tx_rate == MBPS_18 || curr_tx_rate == MBPS_24
1193 || curr_tx_rate == MBPS_36 || curr_tx_rate == MBPS_48 || curr_tx_rate == MBPS_54) {
1194 strWIDList[u8WidCnt].u16WIDid = WID_CURRENT_TX_RATE;
1195 strWIDList[u8WidCnt].ps8WidVal = (s8 *)&curr_tx_rate;
1196 strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
1197 strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
1198 pstrWFIDrv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate;
1199 } else {
1200 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
1201 }
1202 u8WidCnt++;
1203 }
1204 s32Error = SendConfigPkt(SET_CFG, strWIDList, u8WidCnt, false, (u32)pstrWFIDrv);
1205
1206 if (s32Error)
1207 PRINT_ER("Error in setting CFG params\n");
1208
1209 WILC_CATCH(s32Error)
1210 {
1211 }
1212 up(&(pstrWFIDrv->gtOsCfgValuesSem));
1213 return s32Error;
1214 }
1215
1216
1217 /**
1218 * @brief Handle_wait_msg_q_empty
1219 * @details this should be the last msg and then the msg Q becomes idle
1220 * @param[in] tstrHostIFscanAttr* pstrHostIFscanAttr
1221 * @return Error code.
1222 * @author
1223 * @date
1224 * @version 1.0
1225 */
1226 static s32 Handle_wait_msg_q_empty(void)
1227 {
1228 s32 s32Error = WILC_SUCCESS;
1229
1230 g_wilc_initialized = 0;
1231 up(&hWaitResponse);
1232 return s32Error;
1233 }
1234
1235 /**
1236 * @brief Handle_Scan
1237 * @details Sending config packet to firmware to set the scan params
1238 * @param[in] tstrHostIFscanAttr* pstrHostIFscanAttr
1239 * @return Error code.
1240 * @author
1241 * @date
1242 * @version 1.0
1243 */
1244 static s32 Handle_Scan(void *drvHandler, tstrHostIFscanAttr *pstrHostIFscanAttr)
1245 {
1246 s32 s32Error = WILC_SUCCESS;
1247 tstrWID strWIDList[5];
1248 u32 u32WidsCount = 0;
1249 u32 i;
1250 u8 *pu8Buffer;
1251 u8 valuesize = 0;
1252 u8 *pu8HdnNtwrksWidVal = NULL;
1253 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
1254
1255 PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
1256 PRINT_D(HOSTINF_DBG, "Scanning: In [%d] state\n", pstrWFIDrv->enuHostIFstate);
1257
1258 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = pstrHostIFscanAttr->pfScanResult;
1259 pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid = pstrHostIFscanAttr->pvUserArg;
1260
1261 #ifdef WILC_P2P
1262 #endif
1263
1264 if ((pstrWFIDrv->enuHostIFstate >= HOST_IF_SCANNING) && (pstrWFIDrv->enuHostIFstate < HOST_IF_CONNECTED)) {
1265 /* here we either in HOST_IF_SCANNING, HOST_IF_WAITING_CONN_REQ or HOST_IF_WAITING_CONN_RESP */
1266 PRINT_D(GENERIC_DBG, "Don't scan we are already in [%d] state\n", pstrWFIDrv->enuHostIFstate);
1267 WILC_ERRORREPORT(s32Error, WILC_BUSY);
1268 }
1269
1270 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
1271 if (g_obtainingIP || connecting) {
1272 PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
1273 WILC_ERRORREPORT(s32Error, WILC_BUSY);
1274 }
1275 #endif
1276
1277 PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
1278
1279
1280 pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount = 0;
1281
1282 /*BugID_4189*/
1283 strWIDList[u32WidsCount].u16WIDid = (u16)WID_SSID_PROBE_REQ;
1284 strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1285
1286 for (i = 0; i < pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum; i++)
1287 valuesize += ((pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen) + 1);
1288 pu8HdnNtwrksWidVal = WILC_MALLOC(valuesize + 1);
1289 strWIDList[u32WidsCount].ps8WidVal = pu8HdnNtwrksWidVal;
1290 if (strWIDList[u32WidsCount].ps8WidVal != NULL) {
1291 pu8Buffer = strWIDList[u32WidsCount].ps8WidVal;
1292
1293 *pu8Buffer++ = pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum;
1294
1295 PRINT_D(HOSTINF_DBG, "In Handle_ProbeRequest number of ssid %d\n", pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum);
1296
1297 for (i = 0; i < pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum; i++) {
1298 *pu8Buffer++ = pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen;
1299 WILC_memcpy(pu8Buffer, pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].pu8ssid, pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen);
1300 pu8Buffer += pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen;
1301 }
1302
1303
1304
1305 strWIDList[u32WidsCount].s32ValueSize = (s32)(valuesize + 1);
1306 u32WidsCount++;
1307 }
1308
1309 /*filling cfg param array*/
1310
1311 /* if((pstrHostIFscanAttr->pu8IEs != NULL) && (pstrHostIFscanAttr->IEsLen != 0)) */
1312 {
1313 /* IEs to be inserted in Probe Request */
1314 strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_PROBE;
1315 strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA;
1316 strWIDList[u32WidsCount].ps8WidVal = pstrHostIFscanAttr->pu8IEs;
1317 strWIDList[u32WidsCount].s32ValueSize = pstrHostIFscanAttr->IEsLen;
1318 u32WidsCount++;
1319 }
1320
1321 /*Scan Type*/
1322 strWIDList[u32WidsCount].u16WIDid = WID_SCAN_TYPE;
1323 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1324 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1325 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrHostIFscanAttr->u8ScanType));
1326 u32WidsCount++;
1327
1328 /*list of channels to be scanned*/
1329 strWIDList[u32WidsCount].u16WIDid = WID_SCAN_CHANNEL_LIST;
1330 strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA;
1331
1332 /* Bug 4648: Convert channel numbers to start from 0 not 1. */
1333 if (pstrHostIFscanAttr->pu8ChnlFreqList != NULL && pstrHostIFscanAttr->u8ChnlListLen > 0) {
1334 int i;
1335
1336 for (i = 0; i < pstrHostIFscanAttr->u8ChnlListLen; i++) {
1337 if (pstrHostIFscanAttr->pu8ChnlFreqList[i] > 0)
1338 pstrHostIFscanAttr->pu8ChnlFreqList[i] = pstrHostIFscanAttr->pu8ChnlFreqList[i] - 1;
1339 }
1340 }
1341
1342 strWIDList[u32WidsCount].ps8WidVal = pstrHostIFscanAttr->pu8ChnlFreqList;
1343 strWIDList[u32WidsCount].s32ValueSize = pstrHostIFscanAttr->u8ChnlListLen;
1344 u32WidsCount++;
1345
1346 /*Scan Request*/
1347 strWIDList[u32WidsCount].u16WIDid = WID_START_SCAN_REQ;
1348 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1349 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1350 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrHostIFscanAttr->u8ScanSource));
1351 u32WidsCount++;
1352
1353 /*keep the state as is , no need to change it*/
1354 /* gWFiDrvHandle->enuHostIFstate = HOST_IF_SCANNING; */
1355
1356 if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) {
1357 gbScanWhileConnected = true;
1358 } else if (pstrWFIDrv->enuHostIFstate == HOST_IF_IDLE) {
1359 gbScanWhileConnected = false;
1360 }
1361
1362 s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv);
1363
1364 if (s32Error) {
1365 PRINT_ER("Failed to send scan paramters config packet\n");
1366 WILC_ERRORREPORT(s32Error, s32Error);
1367 } else {
1368 PRINT_D(HOSTINF_DBG, "Successfully sent SCAN params config packet\n");
1369 }
1370
1371 WILC_CATCH(s32Error)
1372 {
1373 WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
1374 /*if there is an ongoing scan request*/
1375 Handle_ScanDone(drvHandler, SCAN_EVENT_ABORTED);
1376 }
1377
1378 /* Deallocate pstrHostIFscanAttr->u8ChnlListLen which was prevoisuly allocated by the sending thread */
1379 if (pstrHostIFscanAttr->pu8ChnlFreqList != NULL) {
1380 WILC_FREE(pstrHostIFscanAttr->pu8ChnlFreqList);
1381 pstrHostIFscanAttr->pu8ChnlFreqList = NULL;
1382 }
1383
1384 /* Deallocate pstrHostIFscanAttr->pu8IEs which was previously allocated by the sending thread */
1385 if (pstrHostIFscanAttr->pu8IEs != NULL) {
1386 WILC_FREE(pstrHostIFscanAttr->pu8IEs);
1387 pstrHostIFscanAttr->pu8IEs = NULL;
1388 }
1389 if (pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo != NULL) {
1390 WILC_FREE(pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo);
1391 pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo = NULL;
1392 }
1393
1394 /* Deallocate pstrHostIFscanAttr->u8ChnlListLen which was prevoisuly allocated by the sending thread */
1395 if (pstrHostIFscanAttr->pu8ChnlFreqList != NULL) {
1396 WILC_FREE(pstrHostIFscanAttr->pu8ChnlFreqList);
1397 pstrHostIFscanAttr->pu8ChnlFreqList = NULL;
1398 }
1399
1400 if (pu8HdnNtwrksWidVal != NULL)
1401 WILC_FREE(pu8HdnNtwrksWidVal);
1402
1403 return s32Error;
1404 }
1405
1406 /**
1407 * @brief Handle_ScanDone
1408 * @details Call scan notification callback function
1409 * @param[in] NONE
1410 * @return Error code.
1411 * @author
1412 * @date
1413 * @version 1.0
1414 */
1415 static s32 Handle_ScanDone(void *drvHandler, tenuScanEvent enuEvent)
1416 {
1417 s32 s32Error = WILC_SUCCESS;
1418
1419 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
1420
1421
1422 u8 u8abort_running_scan;
1423 tstrWID strWID;
1424
1425
1426 PRINT_D(HOSTINF_DBG, "in Handle_ScanDone()\n");
1427
1428 /*BugID_4978*/
1429 /*Ask FW to abort the running scan, if any*/
1430 if (enuEvent == SCAN_EVENT_ABORTED) {
1431 PRINT_D(GENERIC_DBG, "Abort running scan\n");
1432 u8abort_running_scan = 1;
1433 strWID.u16WIDid = (u16)WID_ABORT_RUNNING_SCAN;
1434 strWID.enuWIDtype = WID_CHAR;
1435 strWID.ps8WidVal = (s8 *)&u8abort_running_scan;
1436 strWID.s32ValueSize = sizeof(char);
1437
1438 /*Sending Cfg*/
1439 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
1440 if (s32Error != WILC_SUCCESS) {
1441 PRINT_ER("Failed to set abort running scan\n");
1442 WILC_ERRORREPORT(s32Error, WILC_FAIL);
1443 }
1444 WILC_CATCH(s32Error)
1445 {
1446 }
1447 }
1448
1449 if (pstrWFIDrv == NULL) {
1450 PRINT_ER("Driver handler is NULL\n");
1451 return s32Error;
1452 }
1453
1454 /*if there is an ongoing scan request*/
1455 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
1456 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, NULL,
1457 pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
1458 /*delete current scan request*/
1459 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL;
1460 }
1461
1462 return s32Error;
1463 }
1464
1465 /**
1466 * @brief Handle_Connect
1467 * @details Sending config packet to firmware to starting connection
1468 * @param[in] tstrHostIFconnectAttr* pstrHostIFconnectAttr
1469 * @return Error code.
1470 * @author
1471 * @date
1472 * @version 1.0
1473 */
1474 u8 u8ConnectedSSID[6] = {0};
1475 static s32 Handle_Connect(void *drvHandler, tstrHostIFconnectAttr *pstrHostIFconnectAttr)
1476 {
1477 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
1478 s32 s32Error = WILC_SUCCESS;
1479 tstrWID strWIDList[8];
1480 u32 u32WidsCount = 0, dummyval = 0;
1481 /* char passphrase[] = "12345678"; */
1482 #ifndef CONNECT_DIRECT
1483 s32 s32Err = WILC_SUCCESS;
1484 u32 i;
1485 u8 u8bssDscListIndex;
1486 wid_site_survey_reslts_s *pstrSurveyResults = NULL;
1487 #else
1488 u8 *pu8CurrByte = NULL;
1489 /*Bug4218: Parsing Join Param*/
1490 #ifdef WILC_PARSE_SCAN_IN_HOST
1491 tstrJoinBssParam *ptstrJoinBssParam;
1492 #endif /*WILC_PARSE_SCAN_IN_HOST*/
1493
1494 #endif
1495
1496 PRINT_D(GENERIC_DBG, "Handling connect request\n");
1497
1498 #ifndef CONNECT_DIRECT
1499 WILC_memset(gapu8RcvdSurveyResults[0], 0, MAX_SURVEY_RESULT_FRAG_SIZE);
1500 WILC_memset(gapu8RcvdSurveyResults[1], 0, MAX_SURVEY_RESULT_FRAG_SIZE);
1501
1502
1503 PRINT_D(HOSTINF_DBG, "Getting site survey results\n");
1504 s32Err = host_int_get_site_survey_results((WILC_WFIDrvHandle)pstrWFIDrv,
1505 gapu8RcvdSurveyResults,
1506 MAX_SURVEY_RESULT_FRAG_SIZE);
1507 if (s32Err) {
1508 PRINT_ER("Failed to get site survey results\n");
1509 WILC_ERRORREPORT(s32Error, WILC_FAIL);
1510
1511 }
1512 s32Err = ParseSurveyResults(gapu8RcvdSurveyResults, &pstrSurveyResults,
1513 &pstrWFIDrv->u32SurveyResultsCount);
1514
1515
1516 if (s32Err == WILC_SUCCESS) {
1517 /* use the parsed info in pstrSurveyResults, then deallocate it */
1518 PRINT_D(HOSTINF_DBG, "Copying site survey results in global structure, then deallocate\n");
1519 for (i = 0; i < pstrWFIDrv->u32SurveyResultsCount; i++) {
1520 WILC_memcpy(&pstrWFIDrv->astrSurveyResults[i], &pstrSurveyResults[i],
1521 sizeof(wid_site_survey_reslts_s));
1522 }
1523
1524 DeallocateSurveyResults(pstrSurveyResults);
1525 } else {
1526 WILC_ERRORREPORT(s32Error, WILC_FAIL);
1527 PRINT_ER("ParseSurveyResults() Error(%d)\n", s32Err);
1528 }
1529
1530
1531 for (i = 0; i < pstrWFIDrv->u32SurveyResultsCount; i++) {
1532 if (WILC_memcmp(pstrWFIDrv->astrSurveyResults[i].SSID,
1533 pstrHostIFconnectAttr->pu8ssid,
1534 pstrHostIFconnectAttr->ssidLen) == 0) {
1535 PRINT_INFO(HOSTINF_DBG, "Network with required SSID is found %s\n", pstrHostIFconnectAttr->pu8ssid);
1536 if (pstrHostIFconnectAttr->pu8bssid == NULL) {
1537 /* BSSID is not passed from the user, so decision of matching
1538 * is done by SSID only */
1539 PRINT_INFO(HOSTINF_DBG, "BSSID is not passed from the user\n");
1540 break;
1541 } else {
1542 /* BSSID is also passed from the user, so decision of matching
1543 * should consider also this passed BSSID */
1544
1545 if (WILC_memcmp(pstrWFIDrv->astrSurveyResults[i].BSSID,
1546 pstrHostIFconnectAttr->pu8bssid,
1547 6) == 0) {
1548 PRINT_INFO(HOSTINF_DBG, "BSSID is passed from the user and matched\n");
1549 break;
1550 }
1551 }
1552 }
1553 }
1554
1555 if (i < pstrWFIDrv->u32SurveyResultsCount) {
1556 u8bssDscListIndex = i;
1557
1558 PRINT_INFO(HOSTINF_DBG, "Connecting to network of Bss Idx%d and SSID %s and channel%d\n",
1559 u8bssDscListIndex, pstrWFIDrv->astrSurveyResults[u8bssDscListIndex].SSID,
1560 pstrWFIDrv->astrSurveyResults[u8bssDscListIndex].Channel);
1561
1562 PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n");
1563
1564 if (pstrHostIFconnectAttr->pu8bssid != NULL) {
1565 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (u8 *)WILC_MALLOC(6);
1566 WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->pu8bssid, 6);
1567 }
1568
1569 pstrWFIDrv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssidLen;
1570 if (pstrHostIFconnectAttr->pu8ssid != NULL) {
1571 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1);
1572 WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->pu8ssid,
1573 pstrHostIFconnectAttr->ssidLen);
1574 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssidLen] = '\0';
1575 }
1576
1577 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->IEsLen;
1578 if (pstrHostIFconnectAttr->pu8IEs != NULL) {
1579 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
1580 WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->pu8IEs,
1581 pstrHostIFconnectAttr->IEsLen);
1582 }
1583
1584 pstrWFIDrv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->u8security;
1585 pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->tenuAuth_type;
1586 pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->pfConnectResult;
1587 pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->pvUserArg;
1588
1589
1590 /* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */
1591 /* (gWFiDrvHandle->strWILC_UsrConnReq.ConnReqIEsLen != 0)) */
1592 {
1593 /* IEs to be inserted in Association Request */
1594 strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_ASSOCIATE;
1595 strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA;
1596 strWIDList[u32WidsCount].ps8WidVal = pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs;
1597 strWIDList[u32WidsCount].s32ValueSize = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
1598 u32WidsCount++;
1599 }
1600 strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
1601 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1602 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1603 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security));
1604 u32WidsCount++;
1605
1606 PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", pstrWFIDrv->strWILC_UsrConnReq.u8security);
1607
1608 strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
1609 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1610 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1611 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
1612 u32WidsCount++;
1613
1614 PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
1615 /*
1616 * strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
1617 * strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1618 * strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
1619 * strWIDList[u32WidsCount].ps8WidVal = (s8*)(passphrase);
1620 * u32WidsCount++;
1621 */
1622
1623 strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ;
1624 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1625 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1626 strWIDList[u32WidsCount].ps8WidVal = (s8 *)&u8bssDscListIndex;
1627 u32WidsCount++;
1628
1629 #ifndef SIMULATION
1630 /* A temporary workaround to avoid handling the misleading MAC_DISCONNECTED raised from the
1631 * firmware at chip reset when processing the WIDs of the Connect Request.
1632 * (This workaround should be removed in the future when the Chip reset of the Connect WIDs is disabled) */
1633 /* ////////////////////// */
1634 gu32WidConnRstHack = 0;
1635 /* ////////////////////// */
1636 #endif
1637
1638 s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv);
1639 if (s32Error) {
1640 PRINT_ER("Handle_Connect()] failed to send config packet\n");
1641 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
1642 } else {
1643 pstrWFIDrv->enuHostIFstate = HOST_IF_WAITING_CONN_RESP;
1644 }
1645
1646 } else {
1647 PRINT_ER("Required BSSID not found\n");
1648 WILC_ERRORREPORT(s32Error, WILC_NOT_FOUND);
1649 }
1650
1651 #else
1652
1653 /* if we try to connect to an already connected AP then discard the request */
1654
1655 if (WILC_memcmp(pstrHostIFconnectAttr->pu8bssid, u8ConnectedSSID, ETH_ALEN) == 0) {
1656
1657 s32Error = WILC_SUCCESS;
1658 PRINT_ER("Trying to connect to an already connected AP, Discard connect request\n");
1659 return s32Error;
1660 }
1661
1662 PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n");
1663
1664 /*Bug4218: Parsing Join Param*/
1665 #ifdef WILC_PARSE_SCAN_IN_HOST
1666 ptstrJoinBssParam = (tstrJoinBssParam *)pstrHostIFconnectAttr->pJoinParams;
1667 if (ptstrJoinBssParam == NULL) {
1668 PRINT_ER("Required BSSID not found\n");
1669 WILC_ERRORREPORT(s32Error, WILC_NOT_FOUND);
1670 }
1671 #endif /*WILC_PARSE_SCAN_IN_HOST*/
1672
1673 if (pstrHostIFconnectAttr->pu8bssid != NULL) {
1674 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (u8 *)WILC_MALLOC(6);
1675 WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->pu8bssid, 6);
1676 }
1677
1678 pstrWFIDrv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssidLen;
1679 if (pstrHostIFconnectAttr->pu8ssid != NULL) {
1680 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1);
1681 WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->pu8ssid,
1682 pstrHostIFconnectAttr->ssidLen);
1683 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssidLen] = '\0';
1684 }
1685
1686 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->IEsLen;
1687 if (pstrHostIFconnectAttr->pu8IEs != NULL) {
1688 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
1689 WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->pu8IEs,
1690 pstrHostIFconnectAttr->IEsLen);
1691 }
1692
1693 pstrWFIDrv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->u8security;
1694 pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->tenuAuth_type;
1695 pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->pfConnectResult;
1696 pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->pvUserArg;
1697
1698 strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT;
1699 strWIDList[u32WidsCount].enuWIDtype = WID_INT;
1700 strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
1701 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval));
1702 u32WidsCount++;
1703
1704 strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT;
1705 strWIDList[u32WidsCount].enuWIDtype = WID_INT;
1706 strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
1707 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval));
1708 u32WidsCount++;
1709
1710 strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT;
1711 strWIDList[u32WidsCount].enuWIDtype = WID_INT;
1712 strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
1713 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval));
1714 u32WidsCount++;
1715
1716 /* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */
1717 /* (gWFiDrvHandle->strWILC_UsrConnReq.ConnReqIEsLen != 0)) */
1718 {
1719 /* IEs to be inserted in Association Request */
1720 strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_ASSOCIATE;
1721 strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA;
1722 strWIDList[u32WidsCount].ps8WidVal = pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs;
1723 strWIDList[u32WidsCount].s32ValueSize = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
1724 u32WidsCount++;
1725
1726 /*BugID_5137*/
1727 if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) {
1728
1729 gu32FlushedInfoElemAsocSize = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
1730 gu8FlushedInfoElemAsoc = WILC_MALLOC(gu32FlushedInfoElemAsocSize);
1731 memcpy(gu8FlushedInfoElemAsoc, pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs,
1732 gu32FlushedInfoElemAsocSize);
1733 }
1734 }
1735 strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
1736 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1737 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1738 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security));
1739 u32WidsCount++;
1740
1741 /*BugID_5137*/
1742 if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7))
1743 gu8Flushed11iMode = pstrWFIDrv->strWILC_UsrConnReq.u8security;
1744
1745 PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", pstrWFIDrv->strWILC_UsrConnReq.u8security);
1746
1747
1748 strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
1749 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
1750 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
1751 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
1752 u32WidsCount++;
1753
1754 /*BugID_5137*/
1755 if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7))
1756 gu8FlushedAuthType = (u8)pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type;
1757
1758 PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
1759 /*
1760 * strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
1761 * strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1762 * strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
1763 * strWIDList[u32WidsCount].ps8WidVal = (s8*)(passphrase);
1764 * u32WidsCount++;
1765 */
1766
1767 PRINT_D(HOSTINF_DBG, "Connecting to network of SSID %s on channel %d\n",
1768 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->u8channel);
1769
1770
1771 #ifndef WILC_PARSE_SCAN_IN_HOST
1772 strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED;
1773 strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1774 strWIDList[u32WidsCount].s32ValueSize = MAX_SSID_LEN + 7;
1775 strWIDList[u32WidsCount].ps8WidVal = WILC_MALLOC(strWIDList[u32WidsCount].s32ValueSize);
1776
1777 if (strWIDList[u32WidsCount].ps8WidVal == NULL)
1778 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
1779
1780 pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
1781
1782 if (pstrHostIFconnectAttr->pu8ssid != NULL) {
1783 WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen);
1784 pu8CurrByte[pstrHostIFconnectAttr->ssidLen] = '\0';
1785 }
1786 pu8CurrByte += MAX_SSID_LEN;
1787 if ((pstrHostIFconnectAttr->u8channel >= 1) && (pstrHostIFconnectAttr->u8channel <= 14)) {
1788 *(pu8CurrByte++) = pstrHostIFconnectAttr->u8channel;
1789 } else {
1790 PRINT_ER("Channel out of range\n");
1791 *(pu8CurrByte++) = 0xFF;
1792 }
1793 if (pstrHostIFconnectAttr->pu8bssid != NULL)
1794 WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8bssid, 6);
1795 pu8CurrByte += 6;
1796
1797 /* keep the buffer at the start of the allocated pointer to use it with the free*/
1798 pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
1799
1800 #else
1801
1802 strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED;
1803 strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1804
1805 /*Sending NoA attributes during connection*/
1806 strWIDList[u32WidsCount].s32ValueSize = 112; /* 79; */
1807 strWIDList[u32WidsCount].ps8WidVal = WILC_MALLOC(strWIDList[u32WidsCount].s32ValueSize);
1808
1809 /*BugID_5137*/
1810 if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) {
1811 gu32FlushedJoinReqSize = strWIDList[u32WidsCount].s32ValueSize;
1812 gu8FlushedJoinReq = WILC_MALLOC(gu32FlushedJoinReqSize);
1813 }
1814 if (strWIDList[u32WidsCount].ps8WidVal == NULL)
1815 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
1816
1817 pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
1818
1819
1820 if (pstrHostIFconnectAttr->pu8ssid != NULL) {
1821 WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen);
1822 pu8CurrByte[pstrHostIFconnectAttr->ssidLen] = '\0';
1823 }
1824 pu8CurrByte += MAX_SSID_LEN;
1825
1826 /* BSS type*/
1827 *(pu8CurrByte++) = INFRASTRUCTURE;
1828 /* Channel*/
1829 if ((pstrHostIFconnectAttr->u8channel >= 1) && (pstrHostIFconnectAttr->u8channel <= 14)) {
1830 *(pu8CurrByte++) = pstrHostIFconnectAttr->u8channel;
1831 } else {
1832 PRINT_ER("Channel out of range\n");
1833 *(pu8CurrByte++) = 0xFF;
1834 }
1835 /* Cap Info*/
1836 *(pu8CurrByte++) = (ptstrJoinBssParam->cap_info) & 0xFF;
1837 *(pu8CurrByte++) = ((ptstrJoinBssParam->cap_info) >> 8) & 0xFF;
1838 PRINT_D(HOSTINF_DBG, "* Cap Info %0x*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8)));
1839
1840 /* sa*/
1841 if (pstrHostIFconnectAttr->pu8bssid != NULL)
1842 WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8bssid, 6);
1843 pu8CurrByte += 6;
1844
1845 /* bssid*/
1846 if (pstrHostIFconnectAttr->pu8bssid != NULL)
1847 WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8bssid, 6);
1848 pu8CurrByte += 6;
1849
1850 /* Beacon Period*/
1851 *(pu8CurrByte++) = (ptstrJoinBssParam->beacon_period) & 0xFF;
1852 *(pu8CurrByte++) = ((ptstrJoinBssParam->beacon_period) >> 8) & 0xFF;
1853 PRINT_D(HOSTINF_DBG, "* Beacon Period %d*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8)));
1854 /* DTIM Period*/
1855 *(pu8CurrByte++) = ptstrJoinBssParam->dtim_period;
1856 PRINT_D(HOSTINF_DBG, "* DTIM Period %d*\n", (*(pu8CurrByte - 1)));
1857 /* Supported rates*/
1858 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->supp_rates, MAX_RATES_SUPPORTED + 1);
1859 pu8CurrByte += (MAX_RATES_SUPPORTED + 1);
1860
1861 /* wmm cap*/
1862 *(pu8CurrByte++) = ptstrJoinBssParam->wmm_cap;
1863 PRINT_D(HOSTINF_DBG, "* wmm cap%d*\n", (*(pu8CurrByte - 1)));
1864 /* uapsd cap*/
1865 *(pu8CurrByte++) = ptstrJoinBssParam->uapsd_cap;
1866
1867 /* ht cap*/
1868 *(pu8CurrByte++) = ptstrJoinBssParam->ht_capable;
1869 /* copy this information to the user request */
1870 pstrWFIDrv->strWILC_UsrConnReq.IsHTCapable = ptstrJoinBssParam->ht_capable;
1871
1872 /* rsn found*/
1873 *(pu8CurrByte++) = ptstrJoinBssParam->rsn_found;
1874 PRINT_D(HOSTINF_DBG, "* rsn found %d*\n", *(pu8CurrByte - 1));
1875 /* rsn group policy*/
1876 *(pu8CurrByte++) = ptstrJoinBssParam->rsn_grp_policy;
1877 PRINT_D(HOSTINF_DBG, "* rsn group policy %0x*\n", (*(pu8CurrByte - 1)));
1878 /* mode_802_11i*/
1879 *(pu8CurrByte++) = ptstrJoinBssParam->mode_802_11i;
1880 PRINT_D(HOSTINF_DBG, "* mode_802_11i %d*\n", (*(pu8CurrByte - 1)));
1881 /* rsn pcip policy*/
1882 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_pcip_policy, sizeof(ptstrJoinBssParam->rsn_pcip_policy));
1883 pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_pcip_policy);
1884
1885 /* rsn auth policy*/
1886 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_auth_policy, sizeof(ptstrJoinBssParam->rsn_auth_policy));
1887 pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_auth_policy);
1888
1889 /* rsn auth policy*/
1890 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_cap, sizeof(ptstrJoinBssParam->rsn_cap));
1891 pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_cap);
1892
1893 /*BugID_5137*/
1894 *(pu8CurrByte++) = REAL_JOIN_REQ;
1895
1896 #ifdef WILC_P2P
1897 *(pu8CurrByte++) = ptstrJoinBssParam->u8NoaEnbaled;
1898 if (ptstrJoinBssParam->u8NoaEnbaled) {
1899 PRINT_D(HOSTINF_DBG, "NOA present\n");
1900
1901 *(pu8CurrByte++) = (ptstrJoinBssParam->tsf) & 0xFF;
1902 *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 8) & 0xFF;
1903 *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 16) & 0xFF;
1904 *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 24) & 0xFF;
1905
1906 *(pu8CurrByte++) = ptstrJoinBssParam->u8Index;
1907
1908 *(pu8CurrByte++) = ptstrJoinBssParam->u8OppEnable;
1909
1910 if (ptstrJoinBssParam->u8OppEnable)
1911 *(pu8CurrByte++) = ptstrJoinBssParam->u8CtWindow;
1912
1913 *(pu8CurrByte++) = ptstrJoinBssParam->u8Count;
1914
1915 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->au8Duration, sizeof(ptstrJoinBssParam->au8Duration));
1916
1917 pu8CurrByte += sizeof(ptstrJoinBssParam->au8Duration);
1918
1919 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->au8Interval, sizeof(ptstrJoinBssParam->au8Interval));
1920
1921 pu8CurrByte += sizeof(ptstrJoinBssParam->au8Interval);
1922
1923 WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->au8StartTime, sizeof(ptstrJoinBssParam->au8StartTime));
1924
1925 pu8CurrByte += sizeof(ptstrJoinBssParam->au8StartTime);
1926
1927 } else
1928 PRINT_D(HOSTINF_DBG, "NOA not present\n");
1929 #endif
1930
1931
1932 /* keep the buffer at the start of the allocated pointer to use it with the free*/
1933 pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
1934
1935
1936 #endif /* #ifdef WILC_PARSE_SCAN_IN_HOST*/
1937 u32WidsCount++;
1938
1939 #ifndef SIMULATION
1940 /* A temporary workaround to avoid handling the misleading MAC_DISCONNECTED raised from the
1941 * firmware at chip reset when processing the WIDs of the Connect Request.
1942 * (This workaround should be removed in the future when the Chip reset of the Connect WIDs is disabled) */
1943 /* ////////////////////// */
1944 gu32WidConnRstHack = 0;
1945 /* ////////////////////// */
1946 #endif
1947
1948 /*BugID_5137*/
1949 if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) {
1950 memcpy(gu8FlushedJoinReq, pu8CurrByte, gu32FlushedJoinReqSize);
1951 gu8FlushedJoinReqDrvHandler = (u32)pstrWFIDrv;
1952 }
1953
1954 PRINT_D(GENERIC_DBG, "send HOST_IF_WAITING_CONN_RESP\n");
1955
1956 if (pstrHostIFconnectAttr->pu8bssid != NULL) {
1957 WILC_memcpy(u8ConnectedSSID, pstrHostIFconnectAttr->pu8bssid, ETH_ALEN);
1958
1959 PRINT_D(GENERIC_DBG, "save Bssid = %x:%x:%x:%x:%x:%x\n", (pstrHostIFconnectAttr->pu8bssid[0]), (pstrHostIFconnectAttr->pu8bssid[1]), (pstrHostIFconnectAttr->pu8bssid[2]), (pstrHostIFconnectAttr->pu8bssid[3]), (pstrHostIFconnectAttr->pu8bssid[4]), (pstrHostIFconnectAttr->pu8bssid[5]));
1960 PRINT_D(GENERIC_DBG, "save bssid = %x:%x:%x:%x:%x:%x\n", (u8ConnectedSSID[0]), (u8ConnectedSSID[1]), (u8ConnectedSSID[2]), (u8ConnectedSSID[3]), (u8ConnectedSSID[4]), (u8ConnectedSSID[5]));
1961 }
1962
1963 s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv);
1964 if (s32Error) {
1965 PRINT_ER("Handle_Connect()] failed to send config packet\n");
1966 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
1967 } else {
1968 PRINT_D(GENERIC_DBG, "set HOST_IF_WAITING_CONN_RESP\n");
1969 pstrWFIDrv->enuHostIFstate = HOST_IF_WAITING_CONN_RESP;
1970 }
1971 #endif
1972
1973 WILC_CATCH(s32Error)
1974 {
1975 tstrConnectInfo strConnectInfo;
1976
1977 WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL);
1978
1979 PRINT_D(HOSTINF_DBG, "could not start connecting to the required network\n");
1980
1981 WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
1982
1983 if (pstrHostIFconnectAttr->pfConnectResult != NULL) {
1984 if (pstrHostIFconnectAttr->pu8bssid != NULL)
1985 WILC_memcpy(strConnectInfo.au8bssid, pstrHostIFconnectAttr->pu8bssid, 6);
1986
1987 if (pstrHostIFconnectAttr->pu8IEs != NULL) {
1988 strConnectInfo.ReqIEsLen = pstrHostIFconnectAttr->IEsLen;
1989 strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
1990 WILC_memcpy(strConnectInfo.pu8ReqIEs,
1991 pstrHostIFconnectAttr->pu8IEs,
1992 pstrHostIFconnectAttr->IEsLen);
1993 }
1994
1995 pstrHostIFconnectAttr->pfConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
1996 &strConnectInfo,
1997 MAC_DISCONNECTED,
1998 NULL,
1999 pstrHostIFconnectAttr->pvUserArg);
2000 /*Change state to idle*/
2001 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
2002 /* Deallocation */
2003 if (strConnectInfo.pu8ReqIEs != NULL) {
2004 WILC_FREE(strConnectInfo.pu8ReqIEs);
2005 strConnectInfo.pu8ReqIEs = NULL;
2006 }
2007
2008 } else {
2009 PRINT_ER("Connect callback function pointer is NULL\n");
2010 }
2011 }
2012
2013 PRINT_D(HOSTINF_DBG, "Deallocating connection parameters\n");
2014 /* Deallocate pstrHostIFconnectAttr->pu8bssid which was prevoisuly allocated by the sending thread */
2015 if (pstrHostIFconnectAttr->pu8bssid != NULL) {
2016 WILC_FREE(pstrHostIFconnectAttr->pu8bssid);
2017 pstrHostIFconnectAttr->pu8bssid = NULL;
2018 }
2019
2020 /* Deallocate pstrHostIFconnectAttr->pu8ssid which was prevoisuly allocated by the sending thread */
2021 if (pstrHostIFconnectAttr->pu8ssid != NULL) {
2022 WILC_FREE(pstrHostIFconnectAttr->pu8ssid);
2023 pstrHostIFconnectAttr->pu8ssid = NULL;
2024 }
2025
2026 /* Deallocate pstrHostIFconnectAttr->pu8IEs which was prevoisuly allocated by the sending thread */
2027 if (pstrHostIFconnectAttr->pu8IEs != NULL) {
2028 WILC_FREE(pstrHostIFconnectAttr->pu8IEs);
2029 pstrHostIFconnectAttr->pu8IEs = NULL;
2030 }
2031
2032 if (pu8CurrByte != NULL)
2033 WILC_FREE(pu8CurrByte);
2034 return s32Error;
2035 }
2036
2037 /**
2038 * @brief Handle_FlushConnect
2039 * @details Sending config packet to firmware to flush an old connection
2040 * after switching FW from station one to hybrid one
2041 * @param[in] void * drvHandler
2042 * @return Error code.
2043 * @author Amr Abdel-Moghny
2044 * @date 19 DEC 2013
2045 * @version 8.0
2046 */
2047
2048 static s32 Handle_FlushConnect(void *drvHandler)
2049 {
2050 s32 s32Error = WILC_SUCCESS;
2051 tstrWID strWIDList[5];
2052 u32 u32WidsCount = 0;
2053 u8 *pu8CurrByte = NULL;
2054
2055
2056 /* IEs to be inserted in Association Request */
2057 strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_ASSOCIATE;
2058 strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA;
2059 strWIDList[u32WidsCount].ps8WidVal = gu8FlushedInfoElemAsoc;
2060 strWIDList[u32WidsCount].s32ValueSize = gu32FlushedInfoElemAsocSize;
2061 u32WidsCount++;
2062
2063 strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
2064 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
2065 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
2066 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(gu8Flushed11iMode));
2067 u32WidsCount++;
2068
2069
2070
2071 strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
2072 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
2073 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
2074 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&gu8FlushedAuthType);
2075 u32WidsCount++;
2076
2077
2078 #ifdef WILC_PARSE_SCAN_IN_HOST
2079 strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED;
2080 strWIDList[u32WidsCount].enuWIDtype = WID_STR;
2081 strWIDList[u32WidsCount].s32ValueSize = gu32FlushedJoinReqSize;
2082 strWIDList[u32WidsCount].ps8WidVal = (s8 *)gu8FlushedJoinReq;
2083 pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
2084
2085 pu8CurrByte += FLUSHED_BYTE_POS;
2086 *(pu8CurrByte) = FLUSHED_JOIN_REQ;
2087
2088 u32WidsCount++;
2089
2090 #endif
2091
2092 s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, gu8FlushedJoinReqDrvHandler);
2093 if (s32Error) {
2094 PRINT_ER("Handle_Flush_Connect()] failed to send config packet\n");
2095 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
2096 }
2097
2098 WILC_CATCH(s32Error)
2099 {
2100
2101 }
2102
2103 return s32Error;
2104 }
2105
2106 /**
2107 * @brief Handle_ConnectTimeout
2108 * @details Call connect notification callback function indicating connection failure
2109 * @param[in] NONE
2110 * @return Error code.
2111 * @author
2112 * @date
2113 * @version 1.0
2114 */
2115 static s32 Handle_ConnectTimeout(void *drvHandler)
2116 {
2117 s32 s32Error = WILC_SUCCESS;
2118 tstrConnectInfo strConnectInfo;
2119 tstrWID strWID;
2120 u16 u16DummyReasonCode = 0;
2121 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
2122
2123 if (pstrWFIDrv == NULL) {
2124 PRINT_ER("Driver handler is NULL\n");
2125 return s32Error;
2126 }
2127
2128 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
2129
2130 gbScanWhileConnected = false;
2131
2132
2133 WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
2134
2135
2136 /* First, we will notify the upper layer with the Connection failure {through the Connect Callback function},
2137 * then we will notify our firmware also with the Connection failure {through sending to it Cfg packet carrying
2138 * WID_DISCONNECT} */
2139 if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
2140 if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) {
2141 WILC_memcpy(strConnectInfo.au8bssid,
2142 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, 6);
2143 }
2144
2145 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
2146 strConnectInfo.ReqIEsLen = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
2147 strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
2148 WILC_memcpy(strConnectInfo.pu8ReqIEs,
2149 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs,
2150 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
2151 }
2152
2153 pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
2154 &strConnectInfo,
2155 MAC_DISCONNECTED,
2156 NULL,
2157 pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid);
2158
2159 /* Deallocation of strConnectInfo.pu8ReqIEs */
2160 if (strConnectInfo.pu8ReqIEs != NULL) {
2161 WILC_FREE(strConnectInfo.pu8ReqIEs);
2162 strConnectInfo.pu8ReqIEs = NULL;
2163 }
2164 } else {
2165 PRINT_ER("Connect callback function pointer is NULL\n");
2166 }
2167
2168 /* Here we will notify our firmware also with the Connection failure {through sending to it Cfg packet carrying
2169 * WID_DISCONNECT} */
2170 strWID.u16WIDid = (u16)WID_DISCONNECT;
2171 strWID.enuWIDtype = WID_CHAR;
2172 strWID.ps8WidVal = (s8 *)&u16DummyReasonCode;
2173 strWID.s32ValueSize = sizeof(char);
2174
2175 PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
2176
2177 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
2178 if (s32Error)
2179 PRINT_ER("Failed to send dissconect config packet\n");
2180
2181 /* Deallocation of the Saved Connect Request in the global Handle */
2182 pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0;
2183 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) {
2184 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid);
2185 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL;
2186 }
2187
2188 if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) {
2189 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid);
2190 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL;
2191 }
2192
2193 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
2194 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
2195 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs);
2196 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL;
2197 }
2198
2199 WILC_memset(u8ConnectedSSID, 0, ETH_ALEN);
2200 /*BugID_5213*/
2201 /*Freeing flushed join request params on connect timeout*/
2202 if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) {
2203 WILC_FREE(gu8FlushedJoinReq);
2204 gu8FlushedJoinReq = NULL;
2205 }
2206 if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) {
2207 WILC_FREE(gu8FlushedInfoElemAsoc);
2208 gu8FlushedInfoElemAsoc = NULL;
2209 }
2210
2211 return s32Error;
2212 }
2213
2214 /**
2215 * @brief Handle_RcvdNtwrkInfo
2216 * @details Handling received network information
2217 * @param[in] tstrRcvdNetworkInfo* pstrRcvdNetworkInfo
2218 * @return Error code.
2219 * @author
2220 * @date
2221 * @version 1.0
2222 */
2223 static s32 Handle_RcvdNtwrkInfo(void *drvHandler, tstrRcvdNetworkInfo *pstrRcvdNetworkInfo)
2224 {
2225 u32 i;
2226 bool bNewNtwrkFound;
2227
2228
2229
2230 s32 s32Error = WILC_SUCCESS;
2231 tstrNetworkInfo *pstrNetworkInfo = NULL;
2232 void *pJoinParams = NULL;
2233
2234 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
2235
2236
2237
2238 bNewNtwrkFound = true;
2239 PRINT_INFO(HOSTINF_DBG, "Handling received network info\n");
2240
2241 /*if there is a an ongoing scan request*/
2242 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
2243 PRINT_D(HOSTINF_DBG, "State: Scanning, parsing network information received\n");
2244 ParseNetworkInfo(pstrRcvdNetworkInfo->pu8Buffer, &pstrNetworkInfo);
2245 if ((pstrNetworkInfo == NULL)
2246 || (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult == NULL)) {
2247 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
2248 }
2249
2250 /* check whether this network is discovered before */
2251 for (i = 0; i < pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount; i++) {
2252
2253 if ((pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid != NULL) &&
2254 (pstrNetworkInfo->au8bssid != NULL)) {
2255 if (WILC_memcmp(pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid,
2256 pstrNetworkInfo->au8bssid, 6) == 0) {
2257 if (pstrNetworkInfo->s8rssi <= pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi) {
2258 /*we have already found this network with better rssi, so keep the old cached one and don't
2259 * send anything to the upper layer */
2260 PRINT_D(HOSTINF_DBG, "Network previously discovered\n");
2261 goto done;
2262 } else {
2263 /* here the same already found network is found again but with a better rssi, so just update
2264 * the rssi for this cached network and send this updated network to the upper layer but
2265 * don't add a new record for it */
2266 pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
2267 bNewNtwrkFound = false;
2268 break;
2269 }
2270 }
2271 }
2272 }
2273
2274 if (bNewNtwrkFound == true) {
2275 /* here it is confirmed that it is a new discovered network,
2276 * so add its record then call the User CallBack function */
2277
2278 PRINT_D(HOSTINF_DBG, "New network found\n");
2279
2280 if (pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
2281 pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi;
2282
2283 if ((pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid != NULL)
2284 && (pstrNetworkInfo->au8bssid != NULL)) {
2285 WILC_memcpy(pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid,
2286 pstrNetworkInfo->au8bssid, 6);
2287
2288 pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount++;
2289
2290 pstrNetworkInfo->bNewNetwork = true;
2291 /*Bug4218: Parsing Join Param*/
2292 /* add new BSS to JoinBssTable */
2293 #ifdef WILC_PARSE_SCAN_IN_HOST
2294 pJoinParams = host_int_ParseJoinBssParam(pstrNetworkInfo);
2295 #endif /*WILC_PARSE_SCAN_IN_HOST*/
2296
2297 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
2298 pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid,
2299 pJoinParams);
2300
2301
2302 }
2303 } else {
2304 PRINT_WRN(HOSTINF_DBG, "Discovered networks exceeded max. limit\n");
2305 }
2306 } else {
2307 pstrNetworkInfo->bNewNetwork = false;
2308 /* just call the User CallBack function to send the same discovered network with its updated RSSI */
2309 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
2310 pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
2311 }
2312 }
2313
2314
2315 WILC_CATCH(s32Error)
2316 {
2317
2318 }
2319
2320 done:
2321 /* Deallocate pstrRcvdNetworkInfo->pu8Buffer which was prevoisuly allocated by the sending thread */
2322 if (pstrRcvdNetworkInfo->pu8Buffer != NULL) {
2323 WILC_FREE(pstrRcvdNetworkInfo->pu8Buffer);
2324 pstrRcvdNetworkInfo->pu8Buffer = NULL;
2325 }
2326
2327 /*free structure allocated*/
2328 if (pstrNetworkInfo != NULL) {
2329 DeallocateNetworkInfo(pstrNetworkInfo);
2330 pstrNetworkInfo = NULL;
2331 }
2332
2333 return s32Error;
2334 }
2335
2336 /**
2337 * @brief Handle_RcvdGnrlAsyncInfo
2338 * @details Handling received asynchrous general network information
2339 * @param[in] tstrRcvdGnrlAsyncInfo* pstrRcvdGnrlAsyncInfo
2340 * @return Error code.
2341 * @author
2342 * @date
2343 * @version 1.0
2344 */
2345 static s32 Handle_RcvdGnrlAsyncInfo(void *drvHandler, tstrRcvdGnrlAsyncInfo *pstrRcvdGnrlAsyncInfo)
2346 {
2347 /* TODO: mostafa: till now, this function just handles only the received mac status msg, */
2348 /* which carries only 1 WID which have WID ID = WID_STATUS */
2349 s32 s32Error = WILC_SUCCESS;
2350 u8 u8MsgType = 0;
2351 u8 u8MsgID = 0;
2352 u16 u16MsgLen = 0;
2353 u16 u16WidID = (u16)WID_NIL;
2354 u8 u8WidLen = 0;
2355 u8 u8MacStatus;
2356 u8 u8MacStatusReasonCode;
2357 u8 u8MacStatusAdditionalInfo;
2358 tstrConnectInfo strConnectInfo;
2359 tstrDisconnectNotifInfo strDisconnectNotifInfo;
2360 s32 s32Err = WILC_SUCCESS;
2361 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
2362
2363 if (pstrWFIDrv == NULL)
2364 PRINT_ER("Driver handler is NULL\n");
2365 PRINT_D(GENERIC_DBG, "Current State = %d,Received state = %d\n", pstrWFIDrv->enuHostIFstate,
2366 pstrRcvdGnrlAsyncInfo->pu8Buffer[7]);
2367
2368 if ((pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) ||
2369 (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) ||
2370 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
2371 if ((pstrRcvdGnrlAsyncInfo->pu8Buffer == NULL) ||
2372 (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == NULL)) {
2373 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
2374 }
2375
2376 u8MsgType = pstrRcvdGnrlAsyncInfo->pu8Buffer[0];
2377
2378 /* Check whether the received message type is 'I' */
2379 if ('I' != u8MsgType) {
2380 PRINT_ER("Received Message format incorrect.\n");
2381 WILC_ERRORREPORT(s32Error, WILC_FAIL);
2382 }
2383
2384 /* Extract message ID */
2385 u8MsgID = pstrRcvdGnrlAsyncInfo->pu8Buffer[1];
2386
2387 /* Extract message Length */
2388 u16MsgLen = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->pu8Buffer[2], pstrRcvdGnrlAsyncInfo->pu8Buffer[3]);
2389
2390 /* Extract WID ID [expected to be = WID_STATUS] */
2391 u16WidID = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->pu8Buffer[4], pstrRcvdGnrlAsyncInfo->pu8Buffer[5]);
2392
2393 /* Extract WID Length [expected to be = 1] */
2394 u8WidLen = pstrRcvdGnrlAsyncInfo->pu8Buffer[6];
2395
2396 /* get the WID value [expected to be one of two values: either MAC_CONNECTED = (1) or MAC_DISCONNECTED = (0)] */
2397 u8MacStatus = pstrRcvdGnrlAsyncInfo->pu8Buffer[7];
2398 u8MacStatusReasonCode = pstrRcvdGnrlAsyncInfo->pu8Buffer[8];
2399 u8MacStatusAdditionalInfo = pstrRcvdGnrlAsyncInfo->pu8Buffer[9];
2400 PRINT_INFO(HOSTINF_DBG, "Recieved MAC status = %d with Reason = %d , Info = %d\n", u8MacStatus, u8MacStatusReasonCode, u8MacStatusAdditionalInfo);
2401 if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
2402 /* our station had sent Association Request frame, so here it will get the Association Response frame then parse it */
2403 u32 u32RcvdAssocRespInfoLen;
2404 tstrConnectRespInfo *pstrConnectRespInfo = NULL;
2405
2406 PRINT_D(HOSTINF_DBG, "Recieved MAC status = %d with Reason = %d , Code = %d\n", u8MacStatus, u8MacStatusReasonCode, u8MacStatusAdditionalInfo);
2407
2408 WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
2409
2410 if (u8MacStatus == MAC_CONNECTED) {
2411 WILC_memset(gapu8RcvdAssocResp, 0, MAX_ASSOC_RESP_FRAME_SIZE);
2412
2413 host_int_get_assoc_res_info((WILC_WFIDrvHandle)pstrWFIDrv,
2414 gapu8RcvdAssocResp,
2415 MAX_ASSOC_RESP_FRAME_SIZE,
2416 &u32RcvdAssocRespInfoLen);
2417
2418 PRINT_INFO(HOSTINF_DBG, "Received association response with length = %d\n", u32RcvdAssocRespInfoLen);
2419
2420 if (u32RcvdAssocRespInfoLen != 0) {
2421
2422 PRINT_D(HOSTINF_DBG, "Parsing association response\n");
2423 s32Err = ParseAssocRespInfo(gapu8RcvdAssocResp, u32RcvdAssocRespInfoLen,
2424 &pstrConnectRespInfo);
2425 if (s32Err) {
2426 PRINT_ER("ParseAssocRespInfo() returned error %d\n", s32Err);
2427 } else {
2428 /* use the necessary parsed Info from the Received Association Response */
2429 strConnectInfo.u16ConnectStatus = pstrConnectRespInfo->u16ConnectStatus;
2430
2431 if (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE) {
2432 PRINT_INFO(HOSTINF_DBG, "Association response received : Successful connection status\n");
2433 if (pstrConnectRespInfo->pu8RespIEs != NULL) {
2434 strConnectInfo.u16RespIEsLen = pstrConnectRespInfo->u16RespIEsLen;
2435
2436
2437 strConnectInfo.pu8RespIEs = (u8 *)WILC_MALLOC(pstrConnectRespInfo->u16RespIEsLen);
2438 WILC_memcpy(strConnectInfo.pu8RespIEs, pstrConnectRespInfo->pu8RespIEs,
2439 pstrConnectRespInfo->u16RespIEsLen);
2440 }
2441 }
2442
2443 /* deallocate the Assoc. Resp. parsed structure as it is not needed anymore */
2444 if (pstrConnectRespInfo != NULL) {
2445 DeallocateAssocRespInfo(pstrConnectRespInfo);
2446 pstrConnectRespInfo = NULL;
2447 }
2448 }
2449 }
2450 }
2451
2452 /* The station has just received mac status and it also received assoc. response which
2453 * it was waiting for.
2454 * So check first the matching between the received mac status and the received status code in Asoc Resp */
2455 if ((u8MacStatus == MAC_CONNECTED) &&
2456 (strConnectInfo.u16ConnectStatus != SUCCESSFUL_STATUSCODE)) {
2457 PRINT_ER("Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE\n");
2458 WILC_memset(u8ConnectedSSID, 0, ETH_ALEN);
2459
2460 } else if (u8MacStatus == MAC_DISCONNECTED) {
2461 PRINT_ER("Received MAC status is MAC_DISCONNECTED\n");
2462 WILC_memset(u8ConnectedSSID, 0, ETH_ALEN);
2463 }
2464
2465 /* TODO: mostafa: correct BSSID should be retrieved from actual BSSID received from AP */
2466 /* through a structure of type tstrConnectRespInfo */
2467 if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) {
2468 PRINT_D(HOSTINF_DBG, "Retrieving actual BSSID from AP\n");
2469 WILC_memcpy(strConnectInfo.au8bssid, pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, 6);
2470
2471 if ((u8MacStatus == MAC_CONNECTED) &&
2472 (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
2473 WILC_memcpy(pstrWFIDrv->au8AssociatedBSSID,
2474 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, ETH_ALEN);
2475 }
2476 }
2477
2478
2479 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
2480 strConnectInfo.ReqIEsLen = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
2481 strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
2482 WILC_memcpy(strConnectInfo.pu8ReqIEs,
2483 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs,
2484 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
2485 }
2486
2487
2488 WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL);
2489 pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
2490 &strConnectInfo,
2491 u8MacStatus,
2492 NULL,
2493 pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid);
2494
2495
2496 /* if received mac status is MAC_CONNECTED and
2497 * received status code in Asoc Resp is SUCCESSFUL_STATUSCODE, change state to CONNECTED
2498 * else change state to IDLE */
2499 if ((u8MacStatus == MAC_CONNECTED) &&
2500 (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
2501 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
2502
2503 host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0);
2504 #endif
2505
2506 PRINT_D(HOSTINF_DBG, "MAC status : CONNECTED and Connect Status : Successful\n");
2507 pstrWFIDrv->enuHostIFstate = HOST_IF_CONNECTED;
2508
2509 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
2510 PRINT_D(GENERIC_DBG, "Obtaining an IP, Disable Scan\n");
2511 g_obtainingIP = true;
2512 WILC_TimerStart(&hDuringIpTimer, 10000, NULL, NULL);
2513 #endif
2514
2515 #ifdef WILC_PARSE_SCAN_IN_HOST
2516 /* open a BA session if possible */
2517 /* if(pstrWFIDrv->strWILC_UsrConnReq.IsHTCapable) */
2518
2519 #endif
2520
2521 /* host_int_addBASession(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid,0, */
2522 /* BA_SESSION_DEFAULT_BUFFER_SIZE,BA_SESSION_DEFAULT_TIMEOUT); */
2523 } else {
2524 PRINT_D(HOSTINF_DBG, "MAC status : %d and Connect Status : %d\n", u8MacStatus, strConnectInfo.u16ConnectStatus);
2525 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
2526 gbScanWhileConnected = false;
2527 }
2528
2529 /* Deallocation */
2530 if (strConnectInfo.pu8RespIEs != NULL) {
2531 WILC_FREE(strConnectInfo.pu8RespIEs);
2532 strConnectInfo.pu8RespIEs = NULL;
2533 }
2534
2535 if (strConnectInfo.pu8ReqIEs != NULL) {
2536 WILC_FREE(strConnectInfo.pu8ReqIEs);
2537 strConnectInfo.pu8ReqIEs = NULL;
2538 }
2539
2540
2541 pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0;
2542 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) {
2543 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid);
2544 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL;
2545 }
2546
2547 if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) {
2548 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid);
2549 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL;
2550 }
2551
2552 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
2553 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
2554 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs);
2555 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL;
2556 }
2557
2558 } else if ((u8MacStatus == MAC_DISCONNECTED) &&
2559 (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED)) {
2560 /* Disassociation or Deauthentication frame has been received */
2561 PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW\n");
2562
2563 WILC_memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo));
2564
2565 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
2566 PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running OBSS Scan >>\n\n");
2567 WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
2568 Handle_ScanDone((void *)pstrWFIDrv, SCAN_EVENT_ABORTED);
2569 }
2570
2571 strDisconnectNotifInfo.u16reason = 0;
2572 strDisconnectNotifInfo.ie = NULL;
2573 strDisconnectNotifInfo.ie_len = 0;
2574
2575 if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
2576 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
2577
2578 g_obtainingIP = false;
2579 host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0);
2580 #endif
2581
2582 pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF,
2583 NULL,
2584 0,
2585 &strDisconnectNotifInfo,
2586 pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid);
2587
2588 } else {
2589 PRINT_ER("Connect result callback function is NULL\n");
2590 }
2591
2592 WILC_memset(pstrWFIDrv->au8AssociatedBSSID, 0, ETH_ALEN);
2593
2594
2595 /* Deallocation */
2596
2597 /* if Information Elements were retrieved from the Received deauth/disassoc frame, then they
2598 * should be deallocated here */
2599 /*
2600 * if(strDisconnectNotifInfo.ie != NULL)
2601 * {
2602 * WILC_FREE(strDisconnectNotifInfo.ie);
2603 * strDisconnectNotifInfo.ie = NULL;
2604 * }
2605 */
2606
2607 pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0;
2608 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) {
2609 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid);
2610 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL;
2611 }
2612
2613 if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) {
2614 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid);
2615 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL;
2616 }
2617
2618 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
2619 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
2620 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs);
2621 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL;
2622 }
2623
2624 /*BugID_5213*/
2625 /*Freeing flushed join request params on receiving*/
2626 /*MAC_DISCONNECTED while connected*/
2627 if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) {
2628 WILC_FREE(gu8FlushedJoinReq);
2629 gu8FlushedJoinReq = NULL;
2630 }
2631 if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) {
2632 WILC_FREE(gu8FlushedInfoElemAsoc);
2633 gu8FlushedInfoElemAsoc = NULL;
2634 }
2635
2636 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
2637 gbScanWhileConnected = false;
2638
2639 } else if ((u8MacStatus == MAC_DISCONNECTED) &&
2640 (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL)) {
2641 PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW while scanning\n");
2642 PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running Scan >>\n\n");
2643 /*Abort the running scan*/
2644 WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
2645 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult)
2646 Handle_ScanDone((void *)pstrWFIDrv, SCAN_EVENT_ABORTED);
2647
2648 }
2649
2650 }
2651
2652 WILC_CATCH(s32Error)
2653 {
2654
2655 }
2656
2657 /* Deallocate pstrRcvdGnrlAsyncInfo->pu8Buffer which was prevoisuly allocated by the sending thread */
2658 if (pstrRcvdGnrlAsyncInfo->pu8Buffer != NULL) {
2659 WILC_FREE(pstrRcvdGnrlAsyncInfo->pu8Buffer);
2660 pstrRcvdGnrlAsyncInfo->pu8Buffer = NULL;
2661 }
2662
2663 return s32Error;
2664 }
2665
2666 /**
2667 * @brief Handle_Key
2668 * @details Sending config packet to firmware to set key
2669 * @param[in] tstrHostIFkeyAttr* pstrHostIFkeyAttr
2670 * @return Error code.
2671 * @author
2672 * @date
2673 * @version 1.0
2674 */
2675 static int Handle_Key(void *drvHandler, tstrHostIFkeyAttr *pstrHostIFkeyAttr)
2676 {
2677 s32 s32Error = WILC_SUCCESS;
2678 tstrWID strWID;
2679 #ifdef WILC_AP_EXTERNAL_MLME
2680 tstrWID strWIDList[5];
2681 #endif
2682 u8 i;
2683 u8 *pu8keybuf;
2684 s8 s8idxarray[1];
2685 s8 ret = 0;
2686 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
2687
2688
2689 switch (pstrHostIFkeyAttr->enuKeyType) {
2690
2691
2692 case WEP:
2693
2694 #ifdef WILC_AP_EXTERNAL_MLME
2695 if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) {
2696
2697 PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
2698 PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
2699 strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
2700 strWIDList[0].enuWIDtype = WID_CHAR;
2701 strWIDList[0].s32ValueSize = sizeof(char);
2702 strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8mode));
2703
2704 strWIDList[1].u16WIDid = WID_AUTH_TYPE;
2705 strWIDList[1].enuWIDtype = WID_CHAR;
2706 strWIDList[1].s32ValueSize = sizeof(char);
2707 strWIDList[1].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type));
2708
2709 strWIDList[2].u16WIDid = (u16)WID_KEY_ID;
2710 strWIDList[2].enuWIDtype = WID_CHAR;
2711
2712 strWIDList[2].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
2713 strWIDList[2].s32ValueSize = sizeof(char);
2714
2715
2716 pu8keybuf = (u8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen);
2717
2718
2719 if (pu8keybuf == NULL) {
2720 PRINT_ER("No buffer to send Key\n");
2721 return -1;
2722 }
2723
2724 WILC_memcpy(pu8keybuf, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey,
2725 pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen);
2726
2727
2728 WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey);
2729
2730 strWIDList[3].u16WIDid = (u16)WID_WEP_KEY_VALUE;
2731 strWIDList[3].enuWIDtype = WID_STR;
2732 strWIDList[3].s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen;
2733 strWIDList[3].ps8WidVal = (s8 *)pu8keybuf;
2734
2735
2736 s32Error = SendConfigPkt(SET_CFG, strWIDList, 4, true, (u32)pstrWFIDrv);
2737 WILC_FREE(pu8keybuf);
2738
2739
2740 }
2741 #endif
2742
2743 if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
2744 PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
2745 pu8keybuf = (u8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2);
2746 if (pu8keybuf == NULL) {
2747 PRINT_ER("No buffer to send Key\n");
2748 return -1;
2749 }
2750 pu8keybuf[0] = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx;
2751
2752 WILC_memcpy(pu8keybuf + 1, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen, 1);
2753
2754 WILC_memcpy(pu8keybuf + 2, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey,
2755 pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen);
2756
2757 WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey);
2758
2759 strWID.u16WIDid = (u16)WID_ADD_WEP_KEY;
2760 strWID.enuWIDtype = WID_STR;
2761 strWID.ps8WidVal = (s8 *)pu8keybuf;
2762 strWID.s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2;
2763
2764 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
2765 WILC_FREE(pu8keybuf);
2766 } else if (pstrHostIFkeyAttr->u8KeyAction & REMOVEKEY) {
2767
2768 PRINT_D(HOSTINF_DBG, "Removing key\n");
2769 strWID.u16WIDid = (u16)WID_REMOVE_WEP_KEY;
2770 strWID.enuWIDtype = WID_STR;
2771
2772 s8idxarray[0] = (s8)pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx;
2773 strWID.ps8WidVal = s8idxarray;
2774 strWID.s32ValueSize = 1;
2775
2776 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
2777 } else {
2778 strWID.u16WIDid = (u16)WID_KEY_ID;
2779 strWID.enuWIDtype = WID_CHAR;
2780 strWID.ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
2781 strWID.s32ValueSize = sizeof(char);
2782
2783 PRINT_D(HOSTINF_DBG, "Setting default key index\n");
2784
2785 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
2786 }
2787 up(&(pstrWFIDrv->hSemTestKeyBlock));
2788 break;
2789
2790 case WPARxGtk:
2791 #ifdef WILC_AP_EXTERNAL_MLME
2792 if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) {
2793 pu8keybuf = (u8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN);
2794 if (pu8keybuf == NULL) {
2795 PRINT_ER("No buffer to send RxGTK Key\n");
2796 ret = -1;
2797 goto _WPARxGtk_end_case_;
2798 }
2799
2800 WILC_memset(pu8keybuf, 0, RX_MIC_KEY_MSG_LEN);
2801
2802
2803 /*|----------------------------------------------------------------------------|
2804 * |Sta Address | Key RSC | KeyID | Key Length | Temporal Key | Rx Michael Key |
2805 * |------------|---------|-------|------------|---------------|----------------|
2806 | 6 bytes | 8 byte |1 byte | 1 byte | 16 bytes | 8 bytes |*/
2807
2808
2809
2810 if (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq != NULL)
2811 WILC_memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq, 8);
2812
2813
2814 WILC_memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx, 1);
2815
2816 WILC_memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1);
2817
2818 WILC_memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
2819 pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen);
2820 /* pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = 0X51; */
2821 strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
2822 strWIDList[0].enuWIDtype = WID_CHAR;
2823 strWIDList[0].s32ValueSize = sizeof(char);
2824 strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode));
2825
2826 strWIDList[1].u16WIDid = (u16)WID_ADD_RX_GTK;
2827 strWIDList[1].enuWIDtype = WID_STR;
2828 strWIDList[1].ps8WidVal = (s8 *)pu8keybuf;
2829 strWIDList[1].s32ValueSize = RX_MIC_KEY_MSG_LEN;
2830
2831 s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, true, (u32)pstrWFIDrv);
2832
2833 WILC_FREE(pu8keybuf);
2834
2835 /* ////////////////////////// */
2836 up(&(pstrWFIDrv->hSemTestKeyBlock));
2837 /* ///////////////////////// */
2838 }
2839
2840 #endif
2841 if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
2842 PRINT_D(HOSTINF_DBG, "Handling group key(Rx) function\n");
2843
2844 pu8keybuf = (u8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN);
2845 if (pu8keybuf == NULL) {
2846 PRINT_ER("No buffer to send RxGTK Key\n");
2847 ret = -1;
2848 goto _WPARxGtk_end_case_;
2849 }
2850
2851 WILC_memset(pu8keybuf, 0, RX_MIC_KEY_MSG_LEN);
2852
2853
2854 /*|----------------------------------------------------------------------------|
2855 * |Sta Address | Key RSC | KeyID | Key Length | Temporal Key | Rx Michael Key |
2856 * |------------|---------|-------|------------|---------------|----------------|
2857 | 6 bytes | 8 byte |1 byte | 1 byte | 16 bytes | 8 bytes |*/
2858
2859 if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) {
2860 WILC_memcpy(pu8keybuf, pstrWFIDrv->au8AssociatedBSSID, ETH_ALEN);
2861 } else {
2862 PRINT_ER("Couldn't handle WPARxGtk while enuHostIFstate is not HOST_IF_CONNECTED\n");
2863 }
2864
2865 WILC_memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq, 8);
2866
2867 WILC_memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx, 1);
2868
2869 WILC_memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1);
2870 WILC_memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
2871 pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen);
2872
2873 strWID.u16WIDid = (u16)WID_ADD_RX_GTK;
2874 strWID.enuWIDtype = WID_STR;
2875 strWID.ps8WidVal = (s8 *)pu8keybuf;
2876 strWID.s32ValueSize = RX_MIC_KEY_MSG_LEN;
2877
2878 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
2879
2880 WILC_FREE(pu8keybuf);
2881
2882 /* ////////////////////////// */
2883 up(&(pstrWFIDrv->hSemTestKeyBlock));
2884 /* ///////////////////////// */
2885 }
2886 _WPARxGtk_end_case_:
2887 WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key);
2888 WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq);
2889 if (ret == -1)
2890 return ret;
2891
2892 break;
2893
2894 case WPAPtk:
2895 #ifdef WILC_AP_EXTERNAL_MLME
2896 if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) {
2897
2898
2899 pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN + 1);
2900
2901
2902
2903 if (pu8keybuf == NULL) {
2904 PRINT_ER("No buffer to send PTK Key\n");
2905 ret = -1;
2906 goto _WPAPtk_end_case_;
2907
2908 }
2909
2910 /*|-----------------------------------------------------------------------------|
2911 * |Station address | keyidx |Key Length |Temporal Key | Rx Michael Key |Tx Michael Key |
2912 * |----------------|------------ |--------------|----------------|---------------|
2913 | 6 bytes | 1 byte | 1byte | 16 bytes | 8 bytes | 8 bytes |
2914 |-----------------------------------------------------------------------------|*/
2915
2916 WILC_memcpy(pu8keybuf, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8macaddr, 6); /*1 bytes Key Length */
2917
2918 WILC_memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx, 1);
2919 WILC_memcpy(pu8keybuf + 7, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1);
2920 /*16 byte TK*/
2921 WILC_memcpy(pu8keybuf + 8, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
2922 pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen);
2923
2924
2925 strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
2926 strWIDList[0].enuWIDtype = WID_CHAR;
2927 strWIDList[0].s32ValueSize = sizeof(char);
2928 strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode));
2929
2930 strWIDList[1].u16WIDid = (u16)WID_ADD_PTK;
2931 strWIDList[1].enuWIDtype = WID_STR;
2932 strWIDList[1].ps8WidVal = (s8 *)pu8keybuf;
2933 strWIDList[1].s32ValueSize = PTK_KEY_MSG_LEN + 1;
2934
2935 s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, true, (u32)pstrWFIDrv);
2936 WILC_FREE(pu8keybuf);
2937
2938 /* ////////////////////////// */
2939 up(&(pstrWFIDrv->hSemTestKeyBlock));
2940 /* ///////////////////////// */
2941 }
2942 #endif
2943 if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
2944
2945
2946 pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN);
2947
2948
2949
2950 if (pu8keybuf == NULL) {
2951 PRINT_ER("No buffer to send PTK Key\n");
2952 ret = -1;
2953 goto _WPAPtk_end_case_;
2954
2955 }
2956
2957 /*|-----------------------------------------------------------------------------|
2958 * |Station address | Key Length | Temporal Key | Rx Michael Key |Tx Michael Key |
2959 * |----------------|------------|--------------|----------------|---------------|
2960 | 6 bytes | 1byte | 16 bytes | 8 bytes | 8 bytes |
2961 |-----------------------------------------------------------------------------|*/
2962
2963 WILC_memcpy(pu8keybuf, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8macaddr, 6); /*1 bytes Key Length */
2964
2965 WILC_memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1);
2966 /*16 byte TK*/
2967 WILC_memcpy(pu8keybuf + 7, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
2968 pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen);
2969
2970
2971 strWID.u16WIDid = (u16)WID_ADD_PTK;
2972 strWID.enuWIDtype = WID_STR;
2973 strWID.ps8WidVal = (s8 *)pu8keybuf;
2974 strWID.s32ValueSize = PTK_KEY_MSG_LEN;
2975
2976 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
2977 WILC_FREE(pu8keybuf);
2978
2979 /* ////////////////////////// */
2980 up(&(pstrWFIDrv->hSemTestKeyBlock));
2981 /* ///////////////////////// */
2982 }
2983
2984 _WPAPtk_end_case_:
2985 WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key);
2986 if (ret == -1)
2987 return ret;
2988
2989 break;
2990
2991
2992 case PMKSA:
2993
2994 PRINT_D(HOSTINF_DBG, "Handling PMKSA key\n");
2995
2996 pu8keybuf = (u8 *)WILC_MALLOC((pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1);
2997 if (pu8keybuf == NULL) {
2998 PRINT_ER("No buffer to send PMKSA Key\n");
2999 return -1;
3000 }
3001
3002 pu8keybuf[0] = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid;
3003
3004 for (i = 0; i < pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid; i++) {
3005
3006 WILC_memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + 1), pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].bssid, ETH_ALEN);
3007 WILC_memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + ETH_ALEN + 1), pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].pmkid, PMKID_LEN);
3008 }
3009
3010 strWID.u16WIDid = (u16)WID_PMKID_INFO;
3011 strWID.enuWIDtype = WID_STR;
3012 strWID.ps8WidVal = (s8 *)pu8keybuf;
3013 strWID.s32ValueSize = (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1;
3014
3015 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3016
3017 WILC_FREE(pu8keybuf);
3018 break;
3019 }
3020
3021 if (s32Error)
3022 PRINT_ER("Failed to send key config packet\n");
3023
3024
3025 return s32Error;
3026 }
3027
3028
3029 /**
3030 * @brief Handle_Disconnect
3031 * @details Sending config packet to firmware to disconnect
3032 * @param[in] NONE
3033 * @return NONE
3034 * @author
3035 * @date
3036 * @version 1.0
3037 */
3038 static void Handle_Disconnect(void *drvHandler)
3039 {
3040 tstrWID strWID;
3041
3042 s32 s32Error = WILC_SUCCESS;
3043 u16 u16DummyReasonCode = 0;
3044 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3045
3046
3047 strWID.u16WIDid = (u16)WID_DISCONNECT;
3048 strWID.enuWIDtype = WID_CHAR;
3049 strWID.ps8WidVal = (s8 *)&u16DummyReasonCode;
3050 strWID.s32ValueSize = sizeof(char);
3051
3052
3053
3054 PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
3055
3056 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
3057
3058 g_obtainingIP = false;
3059 host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0);
3060 #endif
3061
3062 WILC_memset(u8ConnectedSSID, 0, ETH_ALEN);
3063
3064 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
3065
3066 if (s32Error) {
3067 PRINT_ER("Failed to send dissconect config packet\n");
3068 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3069 } else {
3070 tstrDisconnectNotifInfo strDisconnectNotifInfo;
3071
3072 WILC_memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo));
3073
3074 strDisconnectNotifInfo.u16reason = 0;
3075 strDisconnectNotifInfo.ie = NULL;
3076 strDisconnectNotifInfo.ie_len = 0;
3077
3078 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
3079 WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
3080 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
3081 pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
3082
3083 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL;
3084 }
3085
3086 if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
3087
3088 /*BugID_5193*/
3089 /*Stop connect timer, if connection in progress*/
3090 if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
3091 PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n");
3092 WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL);
3093 }
3094
3095 pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL,
3096 0, &strDisconnectNotifInfo, pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid);
3097 } else {
3098 PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL\n");
3099 }
3100
3101 gbScanWhileConnected = false;
3102
3103 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
3104
3105 WILC_memset(pstrWFIDrv->au8AssociatedBSSID, 0, ETH_ALEN);
3106
3107
3108 /* Deallocation */
3109 pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0;
3110 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) {
3111 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid);
3112 pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL;
3113 }
3114
3115 if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) {
3116 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid);
3117 pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL;
3118 }
3119
3120 pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
3121 if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
3122 WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs);
3123 pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL;
3124 }
3125
3126
3127 /*BugID_5137*/
3128 if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) {
3129 WILC_FREE(gu8FlushedJoinReq);
3130 gu8FlushedJoinReq = NULL;
3131 }
3132 if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) {
3133 WILC_FREE(gu8FlushedInfoElemAsoc);
3134 gu8FlushedInfoElemAsoc = NULL;
3135 }
3136
3137 }
3138
3139 WILC_CATCH(s32Error)
3140 {
3141
3142 }
3143
3144 /* ////////////////////////// */
3145 up(&(pstrWFIDrv->hSemTestDisconnectBlock));
3146 /* ///////////////////////// */
3147
3148 }
3149
3150
3151 void resolve_disconnect_aberration(void *drvHandler)
3152 {
3153 tstrWILC_WFIDrv *pstrWFIDrv;
3154
3155 pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3156 if (pstrWFIDrv == NULL)
3157 return;
3158 if ((pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) || (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTING)) {
3159 PRINT_D(HOSTINF_DBG, "\n\n<< correcting Supplicant state machine >>\n\n");
3160 host_int_disconnect((WILC_WFIDrvHandle)pstrWFIDrv, 1);
3161 }
3162 }
3163 static s32 Switch_Log_Terminal(void *drvHandler)
3164 {
3165
3166
3167 s32 s32Error = WILC_SUCCESS;
3168 tstrWID strWID;
3169 static char dummy = 9;
3170 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3171
3172 strWID.u16WIDid = (u16)WID_LOGTerminal_Switch;
3173 strWID.enuWIDtype = WID_CHAR;
3174 strWID.ps8WidVal = &dummy;
3175 strWID.s32ValueSize = sizeof(char);
3176
3177 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3178
3179
3180 if (s32Error) {
3181 PRINT_D(HOSTINF_DBG, "Failed to switch log terminal\n");
3182 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
3183 } else {
3184 PRINT_INFO(HOSTINF_DBG, "MAC address set ::\n");
3185
3186
3187 }
3188
3189 WILC_CATCH(s32Error)
3190 {
3191
3192 }
3193
3194 return s32Error;
3195 }
3196
3197 /**
3198 * @brief Handle_GetChnl
3199 * @details Sending config packet to get channel
3200 * @param[in] NONE
3201 * @return NONE
3202 *
3203 * @author
3204 * @date
3205 * @version 1.0
3206 */
3207 static s32 Handle_GetChnl(void *drvHandler)
3208 {
3209
3210 s32 s32Error = WILC_SUCCESS;
3211 tstrWID strWID;
3212 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
3213 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3214
3215 strWID.u16WIDid = (u16)WID_CURRENT_CHANNEL;
3216 strWID.enuWIDtype = WID_CHAR;
3217 strWID.ps8WidVal = (s8 *)&gu8Chnl;
3218 strWID.s32ValueSize = sizeof(char);
3219
3220 PRINT_D(HOSTINF_DBG, "Getting channel value\n");
3221
3222 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3223 /*get the value by searching the local copy*/
3224 if (s32Error) {
3225 PRINT_ER("Failed to get channel number\n");
3226 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3227 }
3228
3229
3230 WILC_CATCH(s32Error)
3231 {
3232
3233 }
3234 up(&(pstrWFIDrv->hSemGetCHNL));
3235
3236 return s32Error;
3237
3238
3239
3240 }
3241
3242
3243 /**
3244 * @brief Handle_GetRssi
3245 * @details Sending config packet to get RSSI
3246 * @param[in] NONE
3247 * @return NONE
3248 * @author
3249 * @date
3250 * @version 1.0
3251 */
3252 static void Handle_GetRssi(void *drvHandler)
3253 {
3254 s32 s32Error = WILC_SUCCESS;
3255 tstrWID strWID;
3256 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3257
3258 strWID.u16WIDid = (u16)WID_RSSI;
3259 strWID.enuWIDtype = WID_CHAR;
3260 strWID.ps8WidVal = &gs8Rssi;
3261 strWID.s32ValueSize = sizeof(char);
3262
3263 /*Sending Cfg*/
3264 PRINT_D(HOSTINF_DBG, "Getting RSSI value\n");
3265
3266 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3267 if (s32Error) {
3268 PRINT_ER("Failed to get RSSI value\n");
3269 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3270 }
3271
3272 WILC_CATCH(s32Error)
3273 {
3274
3275 }
3276 up(&(pstrWFIDrv->hSemGetRSSI));
3277
3278
3279 }
3280
3281
3282 static void Handle_GetLinkspeed(void *drvHandler)
3283 {
3284 s32 s32Error = WILC_SUCCESS;
3285 tstrWID strWID;
3286 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3287
3288 gs8lnkspd = 0;
3289
3290 strWID.u16WIDid = (u16)WID_LINKSPEED;
3291 strWID.enuWIDtype = WID_CHAR;
3292 strWID.ps8WidVal = &gs8lnkspd;
3293 strWID.s32ValueSize = sizeof(char);
3294 /*Sending Cfg*/
3295 PRINT_D(HOSTINF_DBG, "Getting LINKSPEED value\n");
3296
3297 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3298 if (s32Error) {
3299 PRINT_ER("Failed to get LINKSPEED value\n");
3300 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3301 }
3302
3303 WILC_CATCH(s32Error)
3304 {
3305
3306 }
3307 up(&(pstrWFIDrv->hSemGetLINKSPEED));
3308
3309
3310 }
3311
3312 s32 Handle_GetStatistics(void *drvHandler, tstrStatistics *pstrStatistics)
3313 {
3314 tstrWID strWIDList[5];
3315 uint32_t u32WidsCount = 0, s32Error = 0;
3316
3317 strWIDList[u32WidsCount].u16WIDid = WID_LINKSPEED;
3318 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
3319 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
3320 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u8LinkSpeed));
3321 u32WidsCount++;
3322
3323 strWIDList[u32WidsCount].u16WIDid = WID_RSSI;
3324 strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
3325 strWIDList[u32WidsCount].s32ValueSize = sizeof(char);
3326 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->s8RSSI));
3327 u32WidsCount++;
3328
3329 strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT;
3330 strWIDList[u32WidsCount].enuWIDtype = WID_INT;
3331 strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
3332 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxCount));
3333 u32WidsCount++;
3334
3335 strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT;
3336 strWIDList[u32WidsCount].enuWIDtype = WID_INT;
3337 strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
3338 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32RxCount));
3339 u32WidsCount++;
3340
3341 strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT;
3342 strWIDList[u32WidsCount].enuWIDtype = WID_INT;
3343 strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
3344 strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxFailureCount));
3345 u32WidsCount++;
3346
3347 s32Error = SendConfigPkt(GET_CFG, strWIDList, u32WidsCount, false, (u32)drvHandler);
3348
3349 if (s32Error) {
3350 PRINT_ER("Failed to send scan paramters config packet\n");
3351 /* WILC_ERRORREPORT(s32Error, s32Error); */
3352 }
3353 up(&hWaitResponse);
3354 return 0;
3355
3356 }
3357
3358
3359 #ifdef WILC_AP_EXTERNAL_MLME
3360
3361
3362 /**
3363 * @brief Handle_Get_InActiveTime
3364 * @details Sending config packet to set mac adddress for station and
3365 * get inactive time
3366 * @param[in] NONE
3367 * @return NONE
3368 *
3369 * @author
3370 * @date
3371 * @version 1.0
3372 */
3373 static s32 Handle_Get_InActiveTime(void *drvHandler, tstrHostIfStaInactiveT *strHostIfStaInactiveT)
3374 {
3375
3376 s32 s32Error = WILC_SUCCESS;
3377 u8 *stamac;
3378 tstrWID strWID;
3379 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3380
3381
3382 strWID.u16WIDid = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
3383 strWID.enuWIDtype = WID_STR;
3384 strWID.s32ValueSize = ETH_ALEN;
3385 strWID.ps8WidVal = (u8 *)WILC_MALLOC(strWID.s32ValueSize);
3386
3387
3388 stamac = strWID.ps8WidVal;
3389 WILC_memcpy(stamac, strHostIfStaInactiveT->mac, ETH_ALEN);
3390
3391
3392 PRINT_D(CFG80211_DBG, "SETING STA inactive time\n");
3393
3394
3395 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3396 /*get the value by searching the local copy*/
3397 if (s32Error) {
3398 PRINT_ER("Failed to SET incative time\n");
3399 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3400 }
3401
3402
3403 strWID.u16WIDid = (u16)WID_GET_INACTIVE_TIME;
3404 strWID.enuWIDtype = WID_INT;
3405 strWID.ps8WidVal = (s8 *)&gu32InactiveTime;
3406 strWID.s32ValueSize = sizeof(u32);
3407
3408
3409 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3410 /*get the value by searching the local copy*/
3411 if (s32Error) {
3412 PRINT_ER("Failed to get incative time\n");
3413 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3414 }
3415
3416
3417 PRINT_D(CFG80211_DBG, "Getting inactive time : %d\n", gu32InactiveTime);
3418
3419 up(&(pstrWFIDrv->hSemInactiveTime));
3420 WILC_CATCH(s32Error)
3421 {
3422
3423 }
3424
3425
3426 return s32Error;
3427
3428
3429
3430 }
3431
3432
3433 /**
3434 * @brief Handle_AddBeacon
3435 * @details Sending config packet to add beacon
3436 * @param[in] tstrHostIFSetBeacon* pstrSetBeaconParam
3437 * @return NONE
3438 * @author
3439 * @date
3440 * @version 1.0
3441 */
3442 static void Handle_AddBeacon(void *drvHandler, tstrHostIFSetBeacon *pstrSetBeaconParam)
3443 {
3444 s32 s32Error = WILC_SUCCESS;
3445 tstrWID strWID;
3446 u8 *pu8CurrByte;
3447 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3448
3449 PRINT_D(HOSTINF_DBG, "Adding BEACON\n");
3450
3451 strWID.u16WIDid = (u16)WID_ADD_BEACON;
3452 strWID.enuWIDtype = WID_BIN;
3453 strWID.s32ValueSize = pstrSetBeaconParam->u32HeadLen + pstrSetBeaconParam->u32TailLen + 16;
3454 strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
3455 if (strWID.ps8WidVal == NULL)
3456 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3457
3458 pu8CurrByte = strWID.ps8WidVal;
3459 *pu8CurrByte++ = (pstrSetBeaconParam->u32Interval & 0xFF);
3460 *pu8CurrByte++ = ((pstrSetBeaconParam->u32Interval >> 8) & 0xFF);
3461 *pu8CurrByte++ = ((pstrSetBeaconParam->u32Interval >> 16) & 0xFF);
3462 *pu8CurrByte++ = ((pstrSetBeaconParam->u32Interval >> 24) & 0xFF);
3463
3464 *pu8CurrByte++ = (pstrSetBeaconParam->u32DTIMPeriod & 0xFF);
3465 *pu8CurrByte++ = ((pstrSetBeaconParam->u32DTIMPeriod >> 8) & 0xFF);
3466 *pu8CurrByte++ = ((pstrSetBeaconParam->u32DTIMPeriod >> 16) & 0xFF);
3467 *pu8CurrByte++ = ((pstrSetBeaconParam->u32DTIMPeriod >> 24) & 0xFF);
3468
3469 *pu8CurrByte++ = (pstrSetBeaconParam->u32HeadLen & 0xFF);
3470 *pu8CurrByte++ = ((pstrSetBeaconParam->u32HeadLen >> 8) & 0xFF);
3471 *pu8CurrByte++ = ((pstrSetBeaconParam->u32HeadLen >> 16) & 0xFF);
3472 *pu8CurrByte++ = ((pstrSetBeaconParam->u32HeadLen >> 24) & 0xFF);
3473
3474 memcpy(pu8CurrByte, pstrSetBeaconParam->pu8Head, pstrSetBeaconParam->u32HeadLen);
3475 pu8CurrByte += pstrSetBeaconParam->u32HeadLen;
3476
3477 *pu8CurrByte++ = (pstrSetBeaconParam->u32TailLen & 0xFF);
3478 *pu8CurrByte++ = ((pstrSetBeaconParam->u32TailLen >> 8) & 0xFF);
3479 *pu8CurrByte++ = ((pstrSetBeaconParam->u32TailLen >> 16) & 0xFF);
3480 *pu8CurrByte++ = ((pstrSetBeaconParam->u32TailLen >> 24) & 0xFF);
3481
3482 /* Bug 4599 : if tail length = 0 skip copying */
3483 if (pstrSetBeaconParam->pu8Tail > 0)
3484 memcpy(pu8CurrByte, pstrSetBeaconParam->pu8Tail, pstrSetBeaconParam->u32TailLen);
3485 pu8CurrByte += pstrSetBeaconParam->u32TailLen;
3486
3487
3488
3489 /*Sending Cfg*/
3490 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
3491 if (s32Error) {
3492 PRINT_ER("Failed to send add beacon config packet\n");
3493 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3494 }
3495
3496 WILC_CATCH(s32Error)
3497 {
3498 }
3499 WILC_FREE_IF_TRUE(strWID.ps8WidVal);
3500 WILC_FREE_IF_TRUE(pstrSetBeaconParam->pu8Head);
3501 WILC_FREE_IF_TRUE(pstrSetBeaconParam->pu8Tail);
3502 }
3503
3504
3505 /**
3506 * @brief Handle_AddBeacon
3507 * @details Sending config packet to delete beacon
3508 * @param[in] tstrHostIFDelBeacon* pstrDelBeacon
3509 * @return NONE
3510 * @author
3511 * @date
3512 * @version 1.0
3513 */
3514 static void Handle_DelBeacon(void *drvHandler, tstrHostIFDelBeacon *pstrDelBeacon)
3515 {
3516 s32 s32Error = WILC_SUCCESS;
3517 tstrWID strWID;
3518 u8 *pu8CurrByte;
3519 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3520
3521 strWID.u16WIDid = (u16)WID_DEL_BEACON;
3522 strWID.enuWIDtype = WID_CHAR;
3523 strWID.s32ValueSize = sizeof(char);
3524 strWID.ps8WidVal = &gu8DelBcn;
3525
3526 if (strWID.ps8WidVal == NULL)
3527 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3528
3529 pu8CurrByte = strWID.ps8WidVal;
3530
3531 PRINT_D(HOSTINF_DBG, "Deleting BEACON\n");
3532 /* TODO: build del beacon message*/
3533
3534 /*Sending Cfg*/
3535 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
3536 if (s32Error) {
3537
3538 PRINT_ER("Failed to send delete beacon config packet\n");
3539 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3540 }
3541
3542 WILC_CATCH(s32Error)
3543 {
3544 }
3545 }
3546
3547
3548 /**
3549 * @brief WILC_HostIf_PackStaParam
3550 * @details Handling packing of the station params in a buffer
3551 * @param[in] u8* pu8Buffer, tstrWILC_AddStaParam* pstrStationParam
3552 * @return NONE
3553 * @author
3554 * @date
3555 * @version 1.0
3556 */
3557 static u32 WILC_HostIf_PackStaParam(u8 *pu8Buffer, tstrWILC_AddStaParam *pstrStationParam)
3558 {
3559 u8 *pu8CurrByte;
3560
3561 pu8CurrByte = pu8Buffer;
3562
3563 PRINT_D(HOSTINF_DBG, "Packing STA params\n");
3564 WILC_memcpy(pu8CurrByte, pstrStationParam->au8BSSID, ETH_ALEN);
3565 pu8CurrByte += ETH_ALEN;
3566
3567 *pu8CurrByte++ = pstrStationParam->u16AssocID & 0xFF;
3568 *pu8CurrByte++ = (pstrStationParam->u16AssocID >> 8) & 0xFF;
3569
3570 *pu8CurrByte++ = pstrStationParam->u8NumRates;
3571 if (pstrStationParam->u8NumRates > 0)
3572 WILC_memcpy(pu8CurrByte, pstrStationParam->pu8Rates, pstrStationParam->u8NumRates);
3573 pu8CurrByte += pstrStationParam->u8NumRates;
3574
3575 *pu8CurrByte++ = pstrStationParam->bIsHTSupported;
3576 *pu8CurrByte++ = pstrStationParam->u16HTCapInfo & 0xFF;
3577 *pu8CurrByte++ = (pstrStationParam->u16HTCapInfo >> 8) & 0xFF;
3578
3579 *pu8CurrByte++ = pstrStationParam->u8AmpduParams;
3580 WILC_memcpy(pu8CurrByte, pstrStationParam->au8SuppMCsSet, WILC_SUPP_MCS_SET_SIZE);
3581 pu8CurrByte += WILC_SUPP_MCS_SET_SIZE;
3582
3583 *pu8CurrByte++ = pstrStationParam->u16HTExtParams & 0xFF;
3584 *pu8CurrByte++ = (pstrStationParam->u16HTExtParams >> 8) & 0xFF;
3585
3586 *pu8CurrByte++ = pstrStationParam->u32TxBeamformingCap & 0xFF;
3587 *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 8) & 0xFF;
3588 *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 16) & 0xFF;
3589 *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 24) & 0xFF;
3590
3591 *pu8CurrByte++ = pstrStationParam->u8ASELCap;
3592
3593 *pu8CurrByte++ = pstrStationParam->u16FlagsMask & 0xFF;
3594 *pu8CurrByte++ = (pstrStationParam->u16FlagsMask >> 8) & 0xFF;
3595
3596 *pu8CurrByte++ = pstrStationParam->u16FlagsSet & 0xFF;
3597 *pu8CurrByte++ = (pstrStationParam->u16FlagsSet >> 8) & 0xFF;
3598
3599 return pu8CurrByte - pu8Buffer;
3600 }
3601
3602 /**
3603 * @brief Handle_AddStation
3604 * @details Sending config packet to add station
3605 * @param[in] tstrWILC_AddStaParam* pstrStationParam
3606 * @return NONE
3607 * @author
3608 * @date
3609 * @version 1.0
3610 */
3611 static void Handle_AddStation(void *drvHandler, tstrWILC_AddStaParam *pstrStationParam)
3612 {
3613 s32 s32Error = WILC_SUCCESS;
3614 tstrWID strWID;
3615 u8 *pu8CurrByte;
3616 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3617
3618 PRINT_D(HOSTINF_DBG, "Handling add station\n");
3619 strWID.u16WIDid = (u16)WID_ADD_STA;
3620 strWID.enuWIDtype = WID_BIN;
3621 strWID.s32ValueSize = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
3622
3623 strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
3624 if (strWID.ps8WidVal == NULL)
3625 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3626
3627 pu8CurrByte = strWID.ps8WidVal;
3628 pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
3629
3630 /*Sending Cfg*/
3631 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
3632 if (s32Error != WILC_SUCCESS) {
3633
3634 PRINT_ER("Failed to send add station config packet\n");
3635 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3636 }
3637
3638 WILC_CATCH(s32Error)
3639 {
3640 }
3641 WILC_FREE_IF_TRUE(pstrStationParam->pu8Rates);
3642 WILC_FREE_IF_TRUE(strWID.ps8WidVal);
3643 }
3644
3645 /**
3646 * @brief Handle_DelAllSta
3647 * @details Sending config packet to delete station
3648 * @param[in] tstrHostIFDelSta* pstrDelStaParam
3649 * @return NONE
3650 * @author
3651 * @date
3652 * @version 1.0
3653 */
3654 static void Handle_DelAllSta(void *drvHandler, tstrHostIFDelAllSta *pstrDelAllStaParam)
3655 {
3656 s32 s32Error = WILC_SUCCESS;
3657
3658 tstrWID strWID;
3659 u8 *pu8CurrByte;
3660 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3661 u8 i;
3662 u8 au8Zero_Buff[6] = {0};
3663
3664 strWID.u16WIDid = (u16)WID_DEL_ALL_STA;
3665 strWID.enuWIDtype = WID_STR;
3666 strWID.s32ValueSize = (pstrDelAllStaParam->u8Num_AssocSta * ETH_ALEN) + 1;
3667
3668 PRINT_D(HOSTINF_DBG, "Handling delete station\n");
3669
3670 strWID.ps8WidVal = WILC_MALLOC((pstrDelAllStaParam->u8Num_AssocSta * ETH_ALEN) + 1);
3671 if (strWID.ps8WidVal == NULL)
3672 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3673
3674 pu8CurrByte = strWID.ps8WidVal;
3675
3676 *(pu8CurrByte++) = pstrDelAllStaParam->u8Num_AssocSta;
3677
3678 for (i = 0; i < MAX_NUM_STA; i++) {
3679 if (memcmp(pstrDelAllStaParam->au8Sta_DelAllSta[i], au8Zero_Buff, ETH_ALEN))
3680 WILC_memcpy(pu8CurrByte, pstrDelAllStaParam->au8Sta_DelAllSta[i], ETH_ALEN);
3681 else
3682 continue;
3683
3684 pu8CurrByte += ETH_ALEN;
3685 }
3686
3687 /*Sending Cfg*/
3688 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3689 if (s32Error) {
3690
3691 PRINT_ER("Failed to send add station config packet\n");
3692 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3693 }
3694
3695 WILC_CATCH(s32Error)
3696 {
3697 }
3698 WILC_FREE_IF_TRUE(strWID.ps8WidVal);
3699
3700 up(&hWaitResponse);
3701 }
3702
3703
3704 /**
3705 * @brief Handle_DelStation
3706 * @details Sending config packet to delete station
3707 * @param[in] tstrHostIFDelSta* pstrDelStaParam
3708 * @return NONE
3709 * @author
3710 * @date
3711 * @version 1.0
3712 */
3713 static void Handle_DelStation(void *drvHandler, tstrHostIFDelSta *pstrDelStaParam)
3714 {
3715 s32 s32Error = WILC_SUCCESS;
3716 tstrWID strWID;
3717 u8 *pu8CurrByte;
3718 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3719
3720 strWID.u16WIDid = (u16)WID_REMOVE_STA;
3721 strWID.enuWIDtype = WID_BIN;
3722 strWID.s32ValueSize = ETH_ALEN;
3723
3724 PRINT_D(HOSTINF_DBG, "Handling delete station\n");
3725
3726 strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
3727 if (strWID.ps8WidVal == NULL)
3728 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3729
3730 pu8CurrByte = strWID.ps8WidVal;
3731
3732 WILC_memcpy(pu8CurrByte, pstrDelStaParam->au8MacAddr, ETH_ALEN);
3733
3734 /*Sending Cfg*/
3735 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
3736 if (s32Error) {
3737
3738 PRINT_ER("Failed to send add station config packet\n");
3739 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3740 }
3741
3742 WILC_CATCH(s32Error)
3743 {
3744 }
3745 WILC_FREE_IF_TRUE(strWID.ps8WidVal);
3746 }
3747
3748
3749 /**
3750 * @brief Handle_EditStation
3751 * @details Sending config packet to edit station
3752 * @param[in] tstrWILC_AddStaParam* pstrStationParam
3753 * @return NONE
3754 * @author
3755 * @date
3756 * @version 1.0
3757 */
3758 static void Handle_EditStation(void *drvHandler, tstrWILC_AddStaParam *pstrStationParam)
3759 {
3760 s32 s32Error = WILC_SUCCESS;
3761 tstrWID strWID;
3762 u8 *pu8CurrByte;
3763 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3764
3765 strWID.u16WIDid = (u16)WID_EDIT_STA;
3766 strWID.enuWIDtype = WID_BIN;
3767 strWID.s32ValueSize = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
3768
3769 PRINT_D(HOSTINF_DBG, "Handling edit station\n");
3770 strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
3771 if (strWID.ps8WidVal == NULL)
3772 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3773
3774 pu8CurrByte = strWID.ps8WidVal;
3775 pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
3776
3777 /*Sending Cfg*/
3778 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
3779 if (s32Error) {
3780
3781 PRINT_ER("Failed to send edit station config packet\n");
3782 WILC_ERRORREPORT(s32Error, WILC_FAIL);
3783 }
3784
3785 WILC_CATCH(s32Error)
3786 {
3787 }
3788 WILC_FREE_IF_TRUE(pstrStationParam->pu8Rates);
3789 WILC_FREE_IF_TRUE(strWID.ps8WidVal);
3790 }
3791 #endif /*WILC_AP_EXTERNAL_MLME*/
3792
3793 #ifdef WILC_P2P
3794 /**
3795 * @brief Handle_RemainOnChan
3796 * @details Sending config packet to edit station
3797 * @param[in] tstrWILC_AddStaParam* pstrStationParam
3798 * @return NONE
3799 * @author
3800 * @date
3801 * @version 1.0
3802 */
3803 static int Handle_RemainOnChan(void *drvHandler, tstrHostIfRemainOnChan *pstrHostIfRemainOnChan)
3804 {
3805 s32 s32Error = WILC_SUCCESS;
3806 u8 u8remain_on_chan_flag;
3807 tstrWID strWID;
3808 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
3809
3810 /*If it's a pendig remain-on-channel, don't overwrite gWFiDrvHandle values (since incoming msg is garbbage)*/
3811 if (!pstrWFIDrv->u8RemainOnChan_pendingreq) {
3812 pstrWFIDrv->strHostIfRemainOnChan.pVoid = pstrHostIfRemainOnChan->pVoid;
3813 pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanExpired = pstrHostIfRemainOnChan->pRemainOnChanExpired;
3814 pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady = pstrHostIfRemainOnChan->pRemainOnChanReady;
3815 pstrWFIDrv->strHostIfRemainOnChan.u16Channel = pstrHostIfRemainOnChan->u16Channel;
3816 pstrWFIDrv->strHostIfRemainOnChan.u32ListenSessionID = pstrHostIfRemainOnChan->u32ListenSessionID;
3817 } else {
3818 /*Set the channel to use it as a wid val*/
3819 pstrHostIfRemainOnChan->u16Channel = pstrWFIDrv->strHostIfRemainOnChan.u16Channel;
3820 }
3821
3822 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
3823 PRINT_INFO(GENERIC_DBG, "Required to remain on chan while scanning return\n");
3824 pstrWFIDrv->u8RemainOnChan_pendingreq = 1;
3825 WILC_ERRORREPORT(s32Error, WILC_BUSY);
3826 }
3827 if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
3828 PRINT_INFO(GENERIC_DBG, "Required to remain on chan while connecting return\n");
3829 WILC_ERRORREPORT(s32Error, WILC_BUSY);
3830 }
3831
3832 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
3833 if (g_obtainingIP || connecting) {
3834 PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
3835 WILC_ERRORREPORT(s32Error, WILC_BUSY);
3836 }
3837 #endif
3838
3839 PRINT_D(HOSTINF_DBG, "Setting channel :%d\n", pstrHostIfRemainOnChan->u16Channel);
3840
3841 u8remain_on_chan_flag = true;
3842 strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN;
3843 strWID.enuWIDtype = WID_STR;
3844 strWID.s32ValueSize = 2;
3845 strWID.ps8WidVal = (s8 *)WILC_MALLOC(strWID.s32ValueSize);
3846
3847 if (strWID.ps8WidVal == NULL)
3848 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3849
3850 strWID.ps8WidVal[0] = u8remain_on_chan_flag;
3851 strWID.ps8WidVal[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
3852
3853 /*Sending Cfg*/
3854 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3855 if (s32Error != WILC_SUCCESS)
3856 PRINT_ER("Failed to set remain on channel\n");
3857
3858 WILC_CATCH(-1)
3859 {
3860 P2P_LISTEN_STATE = 1;
3861 WILC_TimerStart(&(pstrWFIDrv->hRemainOnChannel), pstrHostIfRemainOnChan->u32duration, (void *)pstrWFIDrv, NULL);
3862
3863 /*Calling CFG ready_on_channel*/
3864 if (pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady)
3865 pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady(pstrWFIDrv->strHostIfRemainOnChan.pVoid);
3866
3867 if (pstrWFIDrv->u8RemainOnChan_pendingreq)
3868 pstrWFIDrv->u8RemainOnChan_pendingreq = 0;
3869 }
3870 return s32Error;
3871 }
3872
3873 /**
3874 * @brief Handle_RegisterFrame
3875 * @details
3876 * @param[in]
3877 * @return NONE
3878 * @author
3879 * @date
3880 * @version 1.0
3881 */
3882 static int Handle_RegisterFrame(void *drvHandler, tstrHostIfRegisterFrame *pstrHostIfRegisterFrame)
3883 {
3884 s32 s32Error = WILC_SUCCESS;
3885 tstrWID strWID;
3886 u8 *pu8CurrByte;
3887 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
3888
3889 PRINT_D(HOSTINF_DBG, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame->bReg, pstrHostIfRegisterFrame->u16FrameType);
3890
3891 /*prepare configuration packet*/
3892 strWID.u16WIDid = (u16)WID_REGISTER_FRAME;
3893 strWID.enuWIDtype = WID_STR;
3894 strWID.ps8WidVal = WILC_MALLOC(sizeof(u16) + 2);
3895 if (strWID.ps8WidVal == NULL)
3896 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
3897
3898 pu8CurrByte = strWID.ps8WidVal;
3899
3900 *pu8CurrByte++ = pstrHostIfRegisterFrame->bReg;
3901 *pu8CurrByte++ = pstrHostIfRegisterFrame->u8Regid;
3902 WILC_memcpy(pu8CurrByte, &(pstrHostIfRegisterFrame->u16FrameType), sizeof(u16));
3903
3904
3905 strWID.s32ValueSize = sizeof(u16) + 2;
3906
3907
3908 /*Sending Cfg*/
3909 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3910 if (s32Error) {
3911 PRINT_ER("Failed to frame register config packet\n");
3912 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
3913 }
3914
3915
3916 WILC_CATCH(s32Error)
3917 {
3918 }
3919
3920 return s32Error;
3921
3922 }
3923
3924 /**
3925 * @brief Handle_ListenStateExpired
3926 * @details Handle of listen state expiration
3927 * @param[in] NONE
3928 * @return Error code.
3929 * @author
3930 * @date
3931 * @version 1.0
3932 */
3933 #define FALSE_FRMWR_CHANNEL 100
3934 static u32 Handle_ListenStateExpired(void *drvHandler, tstrHostIfRemainOnChan *pstrHostIfRemainOnChan)
3935 {
3936 u8 u8remain_on_chan_flag;
3937 tstrWID strWID;
3938 s32 s32Error = WILC_SUCCESS;
3939 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
3940
3941 PRINT_D(HOSTINF_DBG, "CANCEL REMAIN ON CHAN\n");
3942
3943 /*BugID_5477*/
3944 /*Make sure we are already in listen state*/
3945 /*This is to handle duplicate expiry messages (listen timer fired and supplicant called cancel_remain_on_channel())*/
3946 if (P2P_LISTEN_STATE) {
3947 u8remain_on_chan_flag = false;
3948 strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN;
3949 strWID.enuWIDtype = WID_STR;
3950 strWID.s32ValueSize = 2;
3951 strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
3952
3953 if (strWID.ps8WidVal == NULL)
3954 PRINT_ER("Failed to allocate memory\n");
3955
3956 strWID.ps8WidVal[0] = u8remain_on_chan_flag;
3957 strWID.ps8WidVal[1] = FALSE_FRMWR_CHANNEL;
3958
3959 /*Sending Cfg*/
3960 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
3961 if (s32Error != WILC_SUCCESS) {
3962 PRINT_ER("Failed to set remain on channel\n");
3963 goto _done_;
3964 }
3965
3966 if (pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanExpired) {
3967 pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanExpired(pstrWFIDrv->strHostIfRemainOnChan.pVoid
3968 , pstrHostIfRemainOnChan->u32ListenSessionID);
3969 }
3970 P2P_LISTEN_STATE = 0;
3971 } else {
3972 PRINT_D(GENERIC_DBG, "Not in listen state\n");
3973 s32Error = WILC_FAIL;
3974 }
3975
3976 _done_:
3977 return s32Error;
3978 }
3979
3980
3981 /**
3982 * @brief ListenTimerCB
3983 * @details Callback function of remain-on-channel timer
3984 * @param[in] NONE
3985 * @return Error code.
3986 * @author
3987 * @date
3988 * @version 1.0
3989 */
3990 static void ListenTimerCB(void *pvArg)
3991 {
3992 s32 s32Error = WILC_SUCCESS;
3993 tstrHostIFmsg strHostIFmsg;
3994 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)pvArg;
3995 /*Stopping remain-on-channel timer*/
3996 WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), NULL);
3997
3998 /* prepare the Timer Callback message */
3999 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4000 strHostIFmsg.u16MsgId = HOST_IF_MSG_LISTEN_TIMER_FIRED;
4001 strHostIFmsg.drvHandler = pstrWFIDrv;
4002 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = pstrWFIDrv->strHostIfRemainOnChan.u32ListenSessionID;
4003
4004 /* send the message */
4005 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4006 if (s32Error)
4007 WILC_ERRORREPORT(s32Error, s32Error);
4008 WILC_CATCH(s32Error)
4009 {
4010
4011 }
4012 }
4013 #endif
4014
4015
4016 /**
4017 * @brief Handle_EditStation
4018 * @details Sending config packet to edit station
4019 * @param[in] tstrWILC_AddStaParam* pstrStationParam
4020 * @return NONE
4021 * @author
4022 * @date
4023 * @version 1.0
4024 */
4025 static void Handle_PowerManagement(void *drvHandler, tstrHostIfPowerMgmtParam *strPowerMgmtParam)
4026 {
4027 s32 s32Error = WILC_SUCCESS;
4028 tstrWID strWID;
4029 s8 s8PowerMode;
4030 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
4031
4032 strWID.u16WIDid = (u16)WID_POWER_MANAGEMENT;
4033
4034 if (strPowerMgmtParam->bIsEnabled == true) {
4035 s8PowerMode = MIN_FAST_PS;
4036 } else {
4037 s8PowerMode = NO_POWERSAVE;
4038 }
4039 PRINT_D(HOSTINF_DBG, "Handling power mgmt to %d\n", s8PowerMode);
4040 strWID.ps8WidVal = &s8PowerMode;
4041 strWID.s32ValueSize = sizeof(char);
4042
4043 PRINT_D(HOSTINF_DBG, "Handling Power Management\n");
4044
4045 /*Sending Cfg*/
4046 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
4047 if (s32Error) {
4048 PRINT_ER("Failed to send power management config packet\n");
4049 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
4050 }
4051
4052 WILC_CATCH(s32Error)
4053 {
4054
4055 }
4056 }
4057
4058 /**
4059 * @brief Handle_SetMulticastFilter
4060 * @details Set Multicast filter in firmware
4061 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4062 * @return NONE
4063 * @author asobhy
4064 * @date
4065 * @version 1.0
4066 */
4067 static void Handle_SetMulticastFilter(void *drvHandler, tstrHostIFSetMulti *strHostIfSetMulti)
4068 {
4069 s32 s32Error = WILC_SUCCESS;
4070 tstrWID strWID;
4071 u8 *pu8CurrByte;
4072
4073 PRINT_D(HOSTINF_DBG, "Setup Multicast Filter\n");
4074
4075 strWID.u16WIDid = (u16)WID_SETUP_MULTICAST_FILTER;
4076 strWID.enuWIDtype = WID_BIN;
4077 strWID.s32ValueSize = sizeof(tstrHostIFSetMulti) + ((strHostIfSetMulti->u32count) * ETH_ALEN);
4078 strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
4079 if (strWID.ps8WidVal == NULL)
4080 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
4081
4082 pu8CurrByte = strWID.ps8WidVal;
4083 *pu8CurrByte++ = (strHostIfSetMulti->bIsEnabled & 0xFF);
4084 *pu8CurrByte++ = ((strHostIfSetMulti->bIsEnabled >> 8) & 0xFF);
4085 *pu8CurrByte++ = ((strHostIfSetMulti->bIsEnabled >> 16) & 0xFF);
4086 *pu8CurrByte++ = ((strHostIfSetMulti->bIsEnabled >> 24) & 0xFF);
4087
4088 *pu8CurrByte++ = (strHostIfSetMulti->u32count & 0xFF);
4089 *pu8CurrByte++ = ((strHostIfSetMulti->u32count >> 8) & 0xFF);
4090 *pu8CurrByte++ = ((strHostIfSetMulti->u32count >> 16) & 0xFF);
4091 *pu8CurrByte++ = ((strHostIfSetMulti->u32count >> 24) & 0xFF);
4092
4093 if ((strHostIfSetMulti->u32count) > 0)
4094 memcpy(pu8CurrByte, gau8MulticastMacAddrList, ((strHostIfSetMulti->u32count) * ETH_ALEN));
4095
4096 /*Sending Cfg*/
4097 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)drvHandler);
4098 if (s32Error) {
4099 PRINT_ER("Failed to send setup multicast config packet\n");
4100 WILC_ERRORREPORT(s32Error, WILC_FAIL);
4101 }
4102
4103 WILC_CATCH(s32Error)
4104 {
4105 }
4106 WILC_FREE_IF_TRUE(strWID.ps8WidVal);
4107
4108 }
4109
4110
4111 /*BugID_5222*/
4112 /**
4113 * @brief Handle_AddBASession
4114 * @details Add block ack session
4115 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4116 * @return NONE
4117 * @author Amr Abdel-Moghny
4118 * @date Feb. 2014
4119 * @version 9.0
4120 */
4121 static s32 Handle_AddBASession(void *drvHandler, tstrHostIfBASessionInfo *strHostIfBASessionInfo)
4122 {
4123 s32 s32Error = WILC_SUCCESS;
4124 tstrWID strWID;
4125 int AddbaTimeout = 100;
4126 char *ptr = NULL;
4127 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
4128
4129 PRINT_D(HOSTINF_DBG, "Opening Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\nBufferSize == %d\nSessionTimeOut = %d\n",
4130 strHostIfBASessionInfo->au8Bssid[0],
4131 strHostIfBASessionInfo->au8Bssid[1],
4132 strHostIfBASessionInfo->au8Bssid[2],
4133 strHostIfBASessionInfo->u16BufferSize,
4134 strHostIfBASessionInfo->u16SessionTimeout,
4135 strHostIfBASessionInfo->u8Ted);
4136
4137 strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ;
4138 strWID.enuWIDtype = WID_STR;
4139 strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
4140 strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE;
4141 ptr = strWID.ps8WidVal;
4142 /* *ptr++ = 0x14; */
4143 *ptr++ = 0x14;
4144 *ptr++ = 0x3;
4145 *ptr++ = 0x0;
4146 WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
4147 ptr += ETH_ALEN;
4148 *ptr++ = strHostIfBASessionInfo->u8Ted;
4149 /* BA Policy*/
4150 *ptr++ = 1;
4151 /* Buffer size*/
4152 *ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF);
4153 *ptr++ = ((strHostIfBASessionInfo->u16BufferSize >> 16) & 0xFF);
4154 /* BA timeout*/
4155 *ptr++ = (strHostIfBASessionInfo->u16SessionTimeout & 0xFF);
4156 *ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
4157 /* ADDBA timeout*/
4158 *ptr++ = (AddbaTimeout & 0xFF);
4159 *ptr++ = ((AddbaTimeout >> 16) & 0xFF);
4160 /* Group Buffer Max Frames*/
4161 *ptr++ = 8;
4162 /* Group Buffer Timeout */
4163 *ptr++ = 0;
4164
4165 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
4166 if (s32Error)
4167 PRINT_D(HOSTINF_DBG, "Couldn't open BA Session\n");
4168
4169
4170 strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ;
4171 strWID.enuWIDtype = WID_STR;
4172 strWID.s32ValueSize = 15;
4173 ptr = strWID.ps8WidVal;
4174 /* *ptr++ = 0x14; */
4175 *ptr++ = 15;
4176 *ptr++ = 7;
4177 *ptr++ = 0x2;
4178 WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
4179 ptr += ETH_ALEN;
4180 /* TID*/
4181 *ptr++ = strHostIfBASessionInfo->u8Ted;
4182 /* Max Num MSDU */
4183 *ptr++ = 8;
4184 /* BA timeout*/
4185 *ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF);
4186 *ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
4187 /*Ack-Policy */
4188 *ptr++ = 3;
4189 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
4190
4191 if (strWID.ps8WidVal != NULL)
4192 WILC_FREE(strWID.ps8WidVal);
4193
4194 return s32Error;
4195
4196 }
4197
4198
4199 /*BugID_5222*/
4200 /**
4201 * @brief Handle_DelBASession
4202 * @details Delete block ack session
4203 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4204 * @return NONE
4205 * @author Amr Abdel-Moghny
4206 * @date Feb. 2013
4207 * @version 9.0
4208 */
4209 static s32 Handle_DelBASession(void *drvHandler, tstrHostIfBASessionInfo *strHostIfBASessionInfo)
4210 {
4211 s32 s32Error = WILC_SUCCESS;
4212 tstrWID strWID;
4213 char *ptr = NULL;
4214 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
4215
4216 PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
4217 strHostIfBASessionInfo->au8Bssid[0],
4218 strHostIfBASessionInfo->au8Bssid[1],
4219 strHostIfBASessionInfo->au8Bssid[2],
4220 strHostIfBASessionInfo->u8Ted);
4221
4222 strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ;
4223 strWID.enuWIDtype = WID_STR;
4224 strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
4225 strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE;
4226 ptr = strWID.ps8WidVal;
4227 /* *ptr++ = 0x14; */
4228 *ptr++ = 0x14;
4229 *ptr++ = 0x3;
4230 *ptr++ = 0x2;
4231 WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
4232 ptr += ETH_ALEN;
4233 *ptr++ = strHostIfBASessionInfo->u8Ted;
4234 /* BA direction = recipent*/
4235 *ptr++ = 0;
4236 /* Delba Reason */
4237 *ptr++ = 32; /* Unspecific QOS reason */
4238
4239 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
4240 if (s32Error)
4241 PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
4242
4243
4244 strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ;
4245 strWID.enuWIDtype = WID_STR;
4246 strWID.s32ValueSize = 15;
4247 ptr = strWID.ps8WidVal;
4248 /* *ptr++ = 0x14; */
4249 *ptr++ = 15;
4250 *ptr++ = 7;
4251 *ptr++ = 0x3;
4252 WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
4253 ptr += ETH_ALEN;
4254 /* TID*/
4255 *ptr++ = strHostIfBASessionInfo->u8Ted;
4256
4257 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
4258
4259 if (strWID.ps8WidVal != NULL)
4260 WILC_FREE(strWID.ps8WidVal);
4261
4262 /*BugID_5222*/
4263 up(&hWaitResponse);
4264
4265 return s32Error;
4266
4267 }
4268
4269
4270 /**
4271 * @brief Handle_DelAllRxBASessions
4272 * @details Delete all Rx BA sessions
4273 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4274 * @return NONE
4275 * @author Abdelrahman Sobhy
4276 * @date Feb. 2013
4277 * @version 9.0
4278 */
4279 static s32 Handle_DelAllRxBASessions(void *drvHandler, tstrHostIfBASessionInfo *strHostIfBASessionInfo)
4280 {
4281 s32 s32Error = WILC_SUCCESS;
4282 tstrWID strWID;
4283 char *ptr = NULL;
4284 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
4285
4286 PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
4287 strHostIfBASessionInfo->au8Bssid[0],
4288 strHostIfBASessionInfo->au8Bssid[1],
4289 strHostIfBASessionInfo->au8Bssid[2],
4290 strHostIfBASessionInfo->u8Ted);
4291
4292 strWID.u16WIDid = (u16)WID_DEL_ALL_RX_BA;
4293 strWID.enuWIDtype = WID_STR;
4294 strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
4295 strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE;
4296 ptr = strWID.ps8WidVal;
4297 *ptr++ = 0x14;
4298 *ptr++ = 0x3;
4299 *ptr++ = 0x2;
4300 WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN);
4301 ptr += ETH_ALEN;
4302 *ptr++ = strHostIfBASessionInfo->u8Ted;
4303 /* BA direction = recipent*/
4304 *ptr++ = 0;
4305 /* Delba Reason */
4306 *ptr++ = 32; /* Unspecific QOS reason */
4307
4308 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
4309 if (s32Error)
4310 PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
4311
4312
4313 if (strWID.ps8WidVal != NULL)
4314 WILC_FREE(strWID.ps8WidVal);
4315
4316 /*BugID_5222*/
4317 up(&hWaitResponse);
4318
4319 return s32Error;
4320
4321 }
4322
4323 /**
4324 * @brief hostIFthread
4325 * @details Main thread to handle message queue requests
4326 * @param[in] void* pvArg
4327 * @return NONE
4328 * @author
4329 * @date
4330 * @version 1.0
4331 */
4332 static int hostIFthread(void *pvArg)
4333 {
4334 u32 u32Ret;
4335 tstrHostIFmsg strHostIFmsg;
4336 tstrWILC_WFIDrv *pstrWFIDrv;
4337
4338 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4339
4340 while (1) {
4341 WILC_MsgQueueRecv(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), &u32Ret, NULL);
4342 pstrWFIDrv = (tstrWILC_WFIDrv *)strHostIFmsg.drvHandler;
4343 if (strHostIFmsg.u16MsgId == HOST_IF_MSG_EXIT) {
4344 PRINT_D(GENERIC_DBG, "THREAD: Exiting HostIfThread\n");
4345 break;
4346 }
4347
4348
4349 /*Re-Queue HIF message*/
4350 if ((!g_wilc_initialized)) {
4351 PRINT_D(GENERIC_DBG, "--WAIT--");
4352 WILC_Sleep(200);
4353 WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4354 continue;
4355 }
4356
4357 if (strHostIFmsg.u16MsgId == HOST_IF_MSG_CONNECT && pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
4358 PRINT_D(HOSTINF_DBG, "Requeue connect request till scan done received\n");
4359 WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4360 WILC_Sleep(2);
4361 continue;
4362 }
4363
4364 switch (strHostIFmsg.u16MsgId) {
4365 case HOST_IF_MSG_Q_IDLE:
4366 Handle_wait_msg_q_empty();
4367 break;
4368
4369 case HOST_IF_MSG_SCAN:
4370 Handle_Scan(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr);
4371 break;
4372
4373 case HOST_IF_MSG_CONNECT:
4374 Handle_Connect(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr);
4375 break;
4376
4377 /*BugID_5137*/
4378 case HOST_IF_MSG_FLUSH_CONNECT:
4379 Handle_FlushConnect(strHostIFmsg.drvHandler);
4380 break;
4381
4382 case HOST_IF_MSG_RCVD_NTWRK_INFO:
4383 Handle_RcvdNtwrkInfo(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo);
4384 break;
4385
4386 case HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO:
4387 Handle_RcvdGnrlAsyncInfo(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo);
4388 break;
4389
4390 case HOST_IF_MSG_KEY:
4391 Handle_Key(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr);
4392 break;
4393
4394 case HOST_IF_MSG_CFG_PARAMS:
4395
4396 Handle_CfgParam(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFCfgParamAttr);
4397 break;
4398
4399 case HOST_IF_MSG_SET_CHANNEL:
4400 Handle_SetChannel(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFSetChan);
4401 break;
4402
4403 case HOST_IF_MSG_DISCONNECT:
4404 Handle_Disconnect(strHostIFmsg.drvHandler);
4405 break;
4406
4407 case HOST_IF_MSG_RCVD_SCAN_COMPLETE:
4408 WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
4409 PRINT_D(HOSTINF_DBG, "scan completed successfully\n");
4410
4411 /*BugID_5213*/
4412 /*Allow chip sleep, only if both interfaces are not connected*/
4413 if (!linux_wlan_get_num_conn_ifcs())
4414 chip_sleep_manually(INFINITE_SLEEP_TIME);
4415
4416 Handle_ScanDone(strHostIFmsg.drvHandler, SCAN_EVENT_DONE);
4417
4418 #ifdef WILC_P2P
4419 if (pstrWFIDrv->u8RemainOnChan_pendingreq)
4420 Handle_RemainOnChan(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan);
4421 #endif
4422
4423 break;
4424
4425 case HOST_IF_MSG_GET_RSSI:
4426 Handle_GetRssi(strHostIFmsg.drvHandler);
4427 break;
4428
4429 case HOST_IF_MSG_GET_LINKSPEED:
4430 Handle_GetLinkspeed(strHostIFmsg.drvHandler);
4431 break;
4432
4433 case HOST_IF_MSG_GET_STATISTICS:
4434 Handle_GetStatistics(strHostIFmsg.drvHandler, (tstrStatistics *)strHostIFmsg.uniHostIFmsgBody.pUserData);
4435 break;
4436
4437 case HOST_IF_MSG_GET_CHNL:
4438 Handle_GetChnl(strHostIFmsg.drvHandler);
4439 break;
4440
4441 #ifdef WILC_AP_EXTERNAL_MLME
4442 case HOST_IF_MSG_ADD_BEACON:
4443 Handle_AddBeacon(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFSetBeacon);
4444 break;
4445
4446 case HOST_IF_MSG_DEL_BEACON:
4447 Handle_DelBeacon(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFDelBeacon);
4448 break;
4449
4450 case HOST_IF_MSG_ADD_STATION:
4451 Handle_AddStation(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strAddStaParam);
4452 break;
4453
4454 case HOST_IF_MSG_DEL_STATION:
4455 Handle_DelStation(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strDelStaParam);
4456 break;
4457
4458 case HOST_IF_MSG_EDIT_STATION:
4459 Handle_EditStation(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strEditStaParam);
4460 break;
4461
4462 case HOST_IF_MSG_GET_INACTIVETIME:
4463 Handle_Get_InActiveTime(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfStaInactiveT);
4464 break;
4465
4466 #endif /*WILC_AP_EXTERNAL_MLME*/
4467 case HOST_IF_MSG_SCAN_TIMER_FIRED:
4468 PRINT_D(HOSTINF_DBG, "Scan Timeout\n");
4469
4470 Handle_ScanDone(strHostIFmsg.drvHandler, SCAN_EVENT_ABORTED);
4471 break;
4472
4473 case HOST_IF_MSG_CONNECT_TIMER_FIRED:
4474 PRINT_D(HOSTINF_DBG, "Connect Timeout\n");
4475 Handle_ConnectTimeout(strHostIFmsg.drvHandler);
4476 break;
4477
4478 case HOST_IF_MSG_POWER_MGMT:
4479 Handle_PowerManagement(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strPowerMgmtparam);
4480 break;
4481
4482 case HOST_IF_MSG_SET_WFIDRV_HANDLER:
4483 Handle_SetWfiDrvHandler(&strHostIFmsg.uniHostIFmsgBody.strHostIfSetDrvHandler);
4484 break;
4485
4486 case HOST_IF_MSG_SET_OPERATION_MODE:
4487 Handle_SetOperationMode(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfSetOperationMode);
4488 break;
4489
4490 case HOST_IF_MSG_SET_IPADDRESS:
4491 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_IPADDRESS\n");
4492 Handle_set_IPAddress(strHostIFmsg.drvHandler, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx);
4493 break;
4494
4495 case HOST_IF_MSG_GET_IPADDRESS:
4496 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_IPADDRESS\n");
4497 Handle_get_IPAddress(strHostIFmsg.drvHandler, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx);
4498 break;
4499
4500 /*BugID_5077*/
4501 case HOST_IF_MSG_SET_MAC_ADDRESS:
4502 Handle_SetMacAddress(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMacAddress);
4503 break;
4504
4505 /*BugID_5213*/
4506 case HOST_IF_MSG_GET_MAC_ADDRESS:
4507 Handle_GetMacAddress(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfGetMacAddress);
4508 break;
4509
4510 #ifdef WILC_P2P
4511 case HOST_IF_MSG_REMAIN_ON_CHAN:
4512 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_REMAIN_ON_CHAN\n");
4513 Handle_RemainOnChan(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan);
4514 break;
4515
4516 case HOST_IF_MSG_REGISTER_FRAME:
4517 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_REGISTER_FRAME\n");
4518 Handle_RegisterFrame(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame);
4519 break;
4520
4521 case HOST_IF_MSG_LISTEN_TIMER_FIRED:
4522 Handle_ListenStateExpired(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan);
4523 break;
4524
4525 #endif
4526 case HOST_IF_MSG_SET_MULTICAST_FILTER:
4527 PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_MULTICAST_FILTER\n");
4528 Handle_SetMulticastFilter(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMulti);
4529 break;
4530
4531 /*BugID_5222*/
4532 case HOST_IF_MSG_ADD_BA_SESSION:
4533 Handle_AddBASession(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo);
4534 break;
4535
4536 case HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS:
4537 Handle_DelAllRxBASessions(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo);
4538 break;
4539
4540 case HOST_IF_MSG_DEL_ALL_STA:
4541 Handle_DelAllSta(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFDelAllSta);
4542 break;
4543
4544 default:
4545 PRINT_ER("[Host Interface] undefined Received Msg ID\n");
4546 break;
4547 }
4548 }
4549
4550 PRINT_D(HOSTINF_DBG, "Releasing thread exit semaphore\n");
4551 up(&hSemHostIFthrdEnd);
4552 return 0;
4553 }
4554
4555 static void TimerCB_Scan(void *pvArg)
4556 {
4557 tstrHostIFmsg strHostIFmsg;
4558
4559 /* prepare the Timer Callback message */
4560 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4561 strHostIFmsg.drvHandler = pvArg;
4562 strHostIFmsg.u16MsgId = HOST_IF_MSG_SCAN_TIMER_FIRED;
4563
4564 /* send the message */
4565 WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4566 }
4567
4568 static void TimerCB_Connect(void *pvArg)
4569 {
4570 tstrHostIFmsg strHostIFmsg;
4571
4572 /* prepare the Timer Callback message */
4573 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4574 strHostIFmsg.drvHandler = pvArg;
4575 strHostIFmsg.u16MsgId = HOST_IF_MSG_CONNECT_TIMER_FIRED;
4576
4577 /* send the message */
4578 WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4579 }
4580
4581
4582 /**
4583 * @brief removes wpa/wpa2 keys
4584 * @details only in BSS STA mode if External Supplicant support is enabled.
4585 * removes all WPA/WPA2 station key entries from MAC hardware.
4586 * @param[in,out] handle to the wifi driver
4587 * @param[in] 6 bytes of Station Adress in the station entry table
4588 * @return Error code indicating success/failure
4589 * @note
4590 * @author zsalah
4591 * @date 8 March 2012
4592 * @version 1.0
4593 */
4594 /* Check implementation in core adding 9 bytes to the input! */
4595 s32 host_int_remove_key(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8StaAddress)
4596 {
4597 s32 s32Error = WILC_SUCCESS;
4598 tstrWID strWID;
4599 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
4600
4601 strWID.u16WIDid = (u16)WID_REMOVE_KEY;
4602 strWID.enuWIDtype = WID_STR;
4603 strWID.ps8WidVal = (s8 *)pu8StaAddress;
4604 strWID.s32ValueSize = 6;
4605
4606 return s32Error;
4607
4608 }
4609
4610 /**
4611 * @brief removes WEP key
4612 * @details valid only in BSS STA mode if External Supplicant support is enabled.
4613 * remove a WEP key entry from MAC HW.
4614 * The BSS Station automatically finds the index of the entry using its
4615 * BSS ID and removes that entry from the MAC hardware.
4616 * @param[in,out] handle to the wifi driver
4617 * @param[in] 6 bytes of Station Adress in the station entry table
4618 * @return Error code indicating success/failure
4619 * @note NO need for the STA add since it is not used for processing
4620 * @author zsalah
4621 * @date 8 March 2012
4622 * @version 1.0
4623 */
4624 s32 host_int_remove_wep_key(WILC_WFIDrvHandle hWFIDrv, u8 u8keyIdx)
4625 {
4626 s32 s32Error = WILC_SUCCESS;
4627 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
4628 tstrHostIFmsg strHostIFmsg;
4629
4630
4631 if (pstrWFIDrv == NULL)
4632 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
4633
4634 /* prepare the Remove Wep Key Message */
4635 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4636
4637
4638 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
4639 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP;
4640 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = REMOVEKEY;
4641 strHostIFmsg.drvHandler = hWFIDrv;
4642
4643
4644
4645 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4646 uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8keyIdx;
4647
4648 /* send the message */
4649 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4650 if (s32Error)
4651 PRINT_ER("Error in sending message queue : Request to remove WEP key\n");
4652 down(&(pstrWFIDrv->hSemTestKeyBlock));
4653
4654 WILC_CATCH(s32Error)
4655 {
4656
4657 }
4658 return s32Error;
4659 }
4660
4661 /**
4662 * @brief sets WEP default key
4663 * @details Sets the index of the WEP encryption key in use,
4664 * in the key table
4665 * @param[in,out] handle to the wifi driver
4666 * @param[in] key index ( 0, 1, 2, 3)
4667 * @return Error code indicating success/failure
4668 * @note
4669 * @author zsalah
4670 * @date 8 March 2012
4671 * @version 1.0
4672 */
4673 s32 host_int_set_WEPDefaultKeyID(WILC_WFIDrvHandle hWFIDrv, u8 u8Index)
4674 {
4675 s32 s32Error = WILC_SUCCESS;
4676 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
4677 tstrHostIFmsg strHostIFmsg;
4678
4679
4680 if (pstrWFIDrv == NULL)
4681 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
4682
4683 /* prepare the Key Message */
4684 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4685
4686
4687 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
4688 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP;
4689 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = DEFAULTKEY;
4690 strHostIFmsg.drvHandler = hWFIDrv;
4691
4692
4693 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4694 uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Index;
4695
4696 /* send the message */
4697 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4698 if (s32Error)
4699 PRINT_ER("Error in sending message queue : Default key index\n");
4700 down(&(pstrWFIDrv->hSemTestKeyBlock));
4701
4702 WILC_CATCH(s32Error)
4703 {
4704
4705 }
4706
4707 return s32Error;
4708 }
4709
4710 /**
4711 * @brief sets WEP deafault key
4712 * @details valid only in BSS STA mode if External Supplicant support is enabled.
4713 * sets WEP key entry into MAC hardware when it receives the
4714 * corresponding request from NDIS.
4715 * @param[in,out] handle to the wifi driver
4716 * @param[in] message containing WEP Key in the following format
4717 *|---------------------------------------|
4718 *|Key ID Value | Key Length | Key |
4719 *|-------------|------------|------------|
4720 | 1byte | 1byte | Key Length |
4721 ||---------------------------------------|
4722 |
4723 * @return Error code indicating success/failure
4724 * @note
4725 * @author zsalah
4726 * @date 8 March 2012
4727 * @version 1.0
4728 */
4729 s32 host_int_add_wep_key_bss_sta(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8WepKey, u8 u8WepKeylen, u8 u8Keyidx)
4730 {
4731
4732 s32 s32Error = WILC_SUCCESS;
4733 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
4734 tstrHostIFmsg strHostIFmsg;
4735
4736 if (pstrWFIDrv == NULL)
4737 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
4738
4739
4740 /* prepare the Key Message */
4741 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4742
4743
4744 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
4745 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP;
4746 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY;
4747 strHostIFmsg.drvHandler = hWFIDrv;
4748
4749
4750 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4751 uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (u8 *)WILC_MALLOC(u8WepKeylen);
4752
4753 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey,
4754 pu8WepKey, u8WepKeylen);
4755
4756
4757 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4758 uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen = (u8WepKeylen);
4759
4760 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4761 uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Keyidx;
4762
4763 /* send the message */
4764 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4765 if (s32Error)
4766 PRINT_ER("Error in sending message queue :WEP Key\n");
4767 down(&(pstrWFIDrv->hSemTestKeyBlock));
4768
4769 WILC_CATCH(s32Error)
4770 {
4771
4772 }
4773 return s32Error;
4774
4775 }
4776
4777 #ifdef WILC_AP_EXTERNAL_MLME
4778 /**
4779 *
4780 * @brief host_int_add_wep_key_bss_ap
4781 * @details valid only in BSS AP mode if External Supplicant support is enabled.
4782 * sets WEP key entry into MAC hardware when it receives the
4783 *
4784 * corresponding request from NDIS.
4785 * @param[in,out] handle to the wifi driver
4786 *
4787 *
4788 * @return Error code indicating success/failure
4789 * @note
4790 * @author mdaftedar
4791 * @date 28 FEB 2013
4792 * @version 1.0
4793 */
4794 s32 host_int_add_wep_key_bss_ap(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8WepKey, u8 u8WepKeylen, u8 u8Keyidx, u8 u8mode, AUTHTYPE_T tenuAuth_type)
4795 {
4796
4797 s32 s32Error = WILC_SUCCESS;
4798 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
4799 tstrHostIFmsg strHostIFmsg;
4800 u8 i;
4801
4802 if (pstrWFIDrv == NULL)
4803 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
4804
4805
4806 /* prepare the Key Message */
4807 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4808
4809 if (INFO) {
4810 for (i = 0; i < u8WepKeylen; i++)
4811 PRINT_INFO(HOSTAPD_DBG, "KEY is %x\n", pu8WepKey[i]);
4812 }
4813 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
4814 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP;
4815 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY_AP;
4816 strHostIFmsg.drvHandler = hWFIDrv;
4817
4818
4819 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4820 uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (u8 *)WILC_MALLOC((u8WepKeylen));
4821
4822
4823 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey,
4824 pu8WepKey, (u8WepKeylen));
4825
4826
4827 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4828 uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen = (u8WepKeylen);
4829
4830 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4831 uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Keyidx;
4832
4833 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4834 uniHostIFkeyAttr.strHostIFwepAttr.u8mode = u8mode;
4835
4836 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4837 uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type = tenuAuth_type;
4838 /* send the message */
4839 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4840
4841 if (s32Error)
4842 PRINT_ER("Error in sending message queue :WEP Key\n");
4843 down(&(pstrWFIDrv->hSemTestKeyBlock));
4844
4845 WILC_CATCH(s32Error)
4846 {
4847
4848 }
4849 return s32Error;
4850
4851 }
4852 #endif
4853 /**
4854 * @brief adds ptk Key
4855 * @details
4856 * @param[in,out] handle to the wifi driver
4857 * @param[in] message containing PTK Key in the following format
4858 *|-----------------------------------------------------------------------------|
4859 *|Station address | Key Length | Temporal Key | Rx Michael Key |Tx Michael Key |
4860 *|----------------|------------|--------------|----------------|---------------|
4861 | 6 bytes | 1byte | 16 bytes | 8 bytes | 8 bytes |
4862 ||-----------------------------------------------------------------------------|
4863 * @return Error code indicating success/failure
4864 * @note
4865 * @author zsalah
4866 * @date 8 March 2012
4867 * @version 1.0
4868 */
4869 s32 host_int_add_ptk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8Ptk, u8 u8PtkKeylen,
4870 const u8 *mac_addr, const u8 *pu8RxMic, const u8 *pu8TxMic, u8 mode, u8 u8Ciphermode, u8 u8Idx)
4871 {
4872 s32 s32Error = WILC_SUCCESS;
4873 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
4874 tstrHostIFmsg strHostIFmsg;
4875 u8 u8KeyLen = u8PtkKeylen;
4876 u32 i;
4877
4878 if (pstrWFIDrv == NULL)
4879 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
4880 if (pu8RxMic != NULL)
4881 u8KeyLen += RX_MIC_KEY_LEN;
4882 if (pu8TxMic != NULL)
4883 u8KeyLen += TX_MIC_KEY_LEN;
4884
4885 /* prepare the Key Message */
4886 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4887
4888
4889 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
4890 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WPAPtk;
4891 #ifdef WILC_AP_EXTERNAL_MLME
4892 if (mode == AP_MODE) {
4893 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY_AP;
4894 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4895 uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx = u8Idx;
4896 }
4897 #endif
4898 if (mode == STATION_MODE)
4899 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY;
4900
4901
4902 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4903 uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8PtkKeylen);
4904
4905
4906 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
4907 pu8Ptk, u8PtkKeylen);
4908
4909 if (pu8RxMic != NULL) {
4910
4911 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 16,
4912 pu8RxMic, RX_MIC_KEY_LEN);
4913 if (INFO) {
4914 for (i = 0; i < RX_MIC_KEY_LEN; i++)
4915 PRINT_INFO(CFG80211_DBG, "PairwiseRx[%d] = %x\n", i, pu8RxMic[i]);
4916 }
4917 }
4918 if (pu8TxMic != NULL) {
4919
4920 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 24,
4921 pu8TxMic, TX_MIC_KEY_LEN);
4922 if (INFO) {
4923 for (i = 0; i < TX_MIC_KEY_LEN; i++)
4924 PRINT_INFO(CFG80211_DBG, "PairwiseTx[%d] = %x\n", i, pu8TxMic[i]);
4925 }
4926 }
4927
4928 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4929 uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen = u8KeyLen;
4930
4931 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4932 uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = u8Ciphermode;
4933 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4934 uniHostIFkeyAttr.strHostIFwpaAttr.pu8macaddr = mac_addr;
4935 strHostIFmsg.drvHandler = hWFIDrv;
4936
4937 /* send the message */
4938 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
4939
4940 if (s32Error)
4941 PRINT_ER("Error in sending message queue: PTK Key\n");
4942
4943 /* ////////////// */
4944 down(&(pstrWFIDrv->hSemTestKeyBlock));
4945 /* WILC_Sleep(100); */
4946 /* /////// */
4947
4948 WILC_CATCH(s32Error)
4949 {
4950
4951 }
4952
4953 return s32Error;
4954 }
4955
4956 /**
4957 * @brief adds Rx GTk Key
4958 * @details
4959 * @param[in,out] handle to the wifi driver
4960 * @param[in] pu8RxGtk : contains temporal key | Rx Mic | Tx Mic
4961 * u8GtkKeylen :The total key length
4962 *
4963 * @return Error code indicating success/failure
4964 * @note
4965 * @author zsalah
4966 * @date 8 March 2012
4967 * @version 1.0
4968 */
4969 s32 host_int_add_rx_gtk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8RxGtk, u8 u8GtkKeylen,
4970 u8 u8KeyIdx, u32 u32KeyRSClen, const u8 *KeyRSC,
4971 const u8 *pu8RxMic, const u8 *pu8TxMic, u8 mode, u8 u8Ciphermode)
4972 {
4973 s32 s32Error = WILC_SUCCESS;
4974 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
4975 tstrHostIFmsg strHostIFmsg;
4976 u8 u8KeyLen = u8GtkKeylen;
4977
4978 if (pstrWFIDrv == NULL)
4979 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
4980 /* prepare the Key Message */
4981 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
4982
4983
4984 if (pu8RxMic != NULL)
4985 u8KeyLen += RX_MIC_KEY_LEN;
4986 if (pu8TxMic != NULL)
4987 u8KeyLen += TX_MIC_KEY_LEN;
4988 if (KeyRSC != NULL) {
4989 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
4990 uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq = (u8 *)WILC_MALLOC(u32KeyRSClen);
4991
4992 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq,
4993 KeyRSC, u32KeyRSClen);
4994 }
4995
4996
4997 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
4998 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WPARxGtk;
4999 strHostIFmsg.drvHandler = hWFIDrv;
5000
5001 #ifdef WILC_AP_EXTERNAL_MLME
5002 if (mode == AP_MODE) {
5003 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY_AP;
5004 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = u8Ciphermode;
5005 }
5006 #endif
5007 if (mode == STATION_MODE)
5008 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY;
5009
5010
5011 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
5012 uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8KeyLen);
5013
5014 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
5015 pu8RxGtk, u8GtkKeylen);
5016
5017 if (pu8RxMic != NULL) {
5018
5019 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 16,
5020 pu8RxMic, RX_MIC_KEY_LEN);
5021
5022 }
5023 if (pu8TxMic != NULL) {
5024
5025 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 24,
5026 pu8TxMic, TX_MIC_KEY_LEN);
5027
5028 }
5029
5030 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
5031 uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx = u8KeyIdx;
5032 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
5033 uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen = u8KeyLen;
5034
5035 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
5036 uniHostIFkeyAttr.strHostIFwpaAttr.u8seqlen = u32KeyRSClen;
5037
5038
5039
5040 /* send the message */
5041 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5042 if (s32Error)
5043 PRINT_ER("Error in sending message queue: RX GTK\n");
5044 /* ////////////// */
5045 down(&(pstrWFIDrv->hSemTestKeyBlock));
5046 /* WILC_Sleep(100); */
5047 /* /////// */
5048
5049 WILC_CATCH(s32Error)
5050 {
5051
5052 }
5053 return s32Error;
5054 }
5055
5056 /**
5057 * @brief host_int_set_pmkid_info
5058 * @details caches the pmkid valid only in BSS STA mode if External Supplicant
5059 * support is enabled. This Function sets the PMKID in firmware
5060 * when host drivr receives the corresponding request from NDIS.
5061 * The firmware then includes theset PMKID in the appropriate
5062 * management frames
5063 * @param[in,out] handle to the wifi driver
5064 * @param[in] message containing PMKID Info in the following format
5065 *|-----------------------------------------------------------------|
5066 *|NumEntries | BSSID[1] | PMKID[1] | ... | BSSID[K] | PMKID[K] |
5067 *|-----------|------------|----------|-------|----------|----------|
5068 | 1 | 6 | 16 | ... | 6 | 16 |
5069 ||-----------------------------------------------------------------|
5070 * @return Error code indicating success/failure
5071 * @note
5072 * @author zsalah
5073 * @date 8 March 2012
5074 * @version 1.0
5075 */
5076 s32 host_int_set_pmkid_info(WILC_WFIDrvHandle hWFIDrv, tstrHostIFpmkidAttr *pu8PmkidInfoArray)
5077 {
5078 s32 s32Error = WILC_SUCCESS;
5079 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5080 tstrHostIFmsg strHostIFmsg;
5081 u32 i;
5082
5083
5084 if (pstrWFIDrv == NULL)
5085 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5086
5087 /* prepare the Key Message */
5088 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5089
5090 strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY;
5091 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = PMKSA;
5092 strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY;
5093 strHostIFmsg.drvHandler = hWFIDrv;
5094
5095 for (i = 0; i < pu8PmkidInfoArray->numpmkid; i++) {
5096
5097 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].bssid, &pu8PmkidInfoArray->pmkidlist[i].bssid,
5098 ETH_ALEN);
5099
5100 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].pmkid, &pu8PmkidInfoArray->pmkidlist[i].pmkid,
5101 PMKID_LEN);
5102 }
5103
5104 /* send the message */
5105 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5106 if (s32Error)
5107 PRINT_ER(" Error in sending messagequeue: PMKID Info\n");
5108
5109 WILC_CATCH(s32Error)
5110 {
5111
5112 }
5113
5114 return s32Error;
5115 }
5116
5117 /**
5118 * @brief gets the cached the pmkid info
5119 * @details valid only in BSS STA mode if External Supplicant
5120 * support is enabled. This Function sets the PMKID in firmware
5121 * when host drivr receives the corresponding request from NDIS.
5122 * The firmware then includes theset PMKID in the appropriate
5123 * management frames
5124 * @param[in,out] handle to the wifi driver,
5125 * message containing PMKID Info in the following format
5126 *|-----------------------------------------------------------------|
5127 *|NumEntries | BSSID[1] | PMKID[1] | ... | BSSID[K] | PMKID[K] |
5128 *|-----------|------------|----------|-------|----------|----------|
5129 | 1 | 6 | 16 | ... | 6 | 16 |
5130 ||-----------------------------------------------------------------|
5131 * @param[in]
5132 * @return Error code indicating success/failure
5133 * @note
5134 * @author zsalah
5135 * @date 8 March 2012
5136 * @version 1.0
5137 */
5138 s32 host_int_get_pmkid_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PmkidInfoArray,
5139 u32 u32PmkidInfoLen)
5140 {
5141 s32 s32Error = WILC_SUCCESS;
5142 tstrWID strWID;
5143 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5144
5145 strWID.u16WIDid = (u16)WID_PMKID_INFO;
5146 strWID.enuWIDtype = WID_STR;
5147 strWID.s32ValueSize = u32PmkidInfoLen;
5148 strWID.ps8WidVal = pu8PmkidInfoArray;
5149
5150 return s32Error;
5151 }
5152
5153 /**
5154 * @brief sets the pass phrase
5155 * @details AP/STA mode. This function gives the pass phrase used to
5156 * generate the Pre-Shared Key when WPA/WPA2 is enabled
5157 * The length of the field can vary from 8 to 64 bytes,
5158 * the lower layer should get the
5159 * @param[in,out] handle to the wifi driver,
5160 * @param[in] String containing PSK
5161 * @return Error code indicating success/failure
5162 * @note
5163 * @author zsalah
5164 * @date 8 March 2012
5165 * @version 1.0
5166 */
5167 s32 host_int_set_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PassPhrase,
5168 u8 u8Psklength)
5169 {
5170 s32 s32Error = WILC_SUCCESS;
5171 tstrWID strWID;
5172 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5173
5174 /* u8 u8Psklength = WILC_strlen(pu8PassPhrase); */
5175 /*validating psk length*/
5176 if ((u8Psklength > 7) && (u8Psklength < 65)) {
5177 strWID.u16WIDid = (u16)WID_11I_PSK;
5178 strWID.enuWIDtype = WID_STR;
5179 strWID.ps8WidVal = pu8PassPhrase;
5180 strWID.s32ValueSize = u8Psklength;
5181 }
5182
5183 return s32Error;
5184 }
5185 /**
5186 * @brief host_int_get_MacAddress
5187 * @details gets mac address
5188 * @param[in,out] handle to the wifi driver,
5189 *
5190 * @return Error code indicating success/failure
5191 * @note
5192 * @author mdaftedar
5193 * @date 19 April 2012
5194 * @version 1.0
5195 */
5196 s32 host_int_get_MacAddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8MacAddress)
5197 {
5198 s32 s32Error = WILC_SUCCESS;
5199 tstrHostIFmsg strHostIFmsg;
5200
5201
5202 /* prepare the Message */
5203 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5204
5205 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_MAC_ADDRESS;
5206 strHostIFmsg.uniHostIFmsgBody.strHostIfGetMacAddress.u8MacAddress = pu8MacAddress;
5207 strHostIFmsg.drvHandler = hWFIDrv;
5208 /* send the message */
5209 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5210 if (s32Error) {
5211 PRINT_ER("Failed to send get mac address\n");
5212 return WILC_FAIL;
5213 }
5214
5215 down(&hWaitResponse);
5216 return s32Error;
5217 }
5218
5219 /**
5220 * @brief host_int_set_MacAddress
5221 * @details sets mac address
5222 * @param[in,out] handle to the wifi driver,
5223 *
5224 * @return Error code indicating success/failure
5225 * @note
5226 * @author mabubakr
5227 * @date 16 July 2012
5228 * @version 1.0
5229 */
5230 s32 host_int_set_MacAddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8MacAddress)
5231 {
5232 s32 s32Error = WILC_SUCCESS;
5233 tstrHostIFmsg strHostIFmsg;
5234
5235 PRINT_D(GENERIC_DBG, "mac addr = %x:%x:%x\n", pu8MacAddress[0], pu8MacAddress[1], pu8MacAddress[2]);
5236
5237 /* prepare setting mac address message */
5238 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5239 strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_MAC_ADDRESS;
5240 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIfSetMacAddress.u8MacAddress, pu8MacAddress, ETH_ALEN);
5241 strHostIFmsg.drvHandler = hWFIDrv;
5242
5243 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5244 if (s32Error) {
5245 PRINT_ER("Failed to send message queue: Set mac address\n");
5246 WILC_ERRORREPORT(s32Error, s32Error);
5247 }
5248 WILC_CATCH(s32Error)
5249 {
5250
5251 }
5252
5253 return s32Error;
5254
5255 }
5256
5257 /**
5258 * @brief host_int_get_RSNAConfigPSKPassPhrase
5259 * @details gets the pass phrase:AP/STA mode. This function gets the pass phrase used to
5260 * generate the Pre-Shared Key when WPA/WPA2 is enabled
5261 * The length of the field can vary from 8 to 64 bytes,
5262 * the lower layer should get the
5263 * @param[in,out] handle to the wifi driver,
5264 * String containing PSK
5265 * @return Error code indicating success/failure
5266 * @note
5267 * @author zsalah
5268 * @date 8 March 2012
5269 * @version 1.0
5270 */
5271 s32 host_int_get_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv,
5272 u8 *pu8PassPhrase, u8 u8Psklength)
5273 {
5274 s32 s32Error = WILC_SUCCESS;
5275 tstrWID strWID;
5276 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5277
5278 strWID.u16WIDid = (u16)WID_11I_PSK;
5279 strWID.enuWIDtype = WID_STR;
5280 strWID.s32ValueSize = u8Psklength;
5281 strWID.ps8WidVal = pu8PassPhrase;
5282
5283 return s32Error;
5284 }
5285
5286 /**
5287 * @brief host_int_get_site_survey_results
5288 * @details gets the site survey results
5289 * @param[in,out] handle to the wifi driver,
5290 * Message containing site survey results in the
5291 * following format
5292 *|---------------------------------------------------|
5293 | MsgLength | fragNo. | MsgBodyLength | MsgBody |
5294 ||-----------|-----------|---------------|-----------|
5295 | 1 | 1 | 1 | 1 |
5296 | ----------------------------------------- | ----------------
5297 |
5298 ||---------------------------------------|
5299 | Network1 | Netweork2 | ... | Network5 |
5300 ||---------------------------------------|
5301 | 44 | 44 | ... | 44 |
5302 | -------------------------- | ---------------------------------------
5303 |
5304 ||---------------------------------------------------------------------|
5305 | SSID | BSS Type | Channel | Security Status| BSSID | RSSI |Reserved |
5306 |
5307 |
5308 ||------|----------|---------|----------------|-------|------|---------|
5309 | 33 | 1 | 1 | 1 | 6 | 1 | 1 |
5310 ||---------------------------------------------------------------------|
5311 * @return Error code indicating success/failure
5312 * @note
5313 * @author zsalah
5314 * @date 8 March 2012
5315 * @version 1.0
5316 */
5317 #ifndef CONNECT_DIRECT
5318 s32 host_int_get_site_survey_results(WILC_WFIDrvHandle hWFIDrv,
5319 u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
5320 u32 u32MaxSiteSrvyFragLen)
5321 {
5322 s32 s32Error = WILC_SUCCESS;
5323 tstrWID astrWIDList[2];
5324 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5325
5326 astrWIDList[0].u16WIDid = (u16)WID_SITE_SURVEY_RESULTS;
5327 astrWIDList[0].enuWIDtype = WID_STR;
5328 astrWIDList[0].ps8WidVal = ppu8RcvdSiteSurveyResults[0];
5329 astrWIDList[0].s32ValueSize = u32MaxSiteSrvyFragLen;
5330
5331 astrWIDList[1].u16WIDid = (u16)WID_SITE_SURVEY_RESULTS;
5332 astrWIDList[1].enuWIDtype = WID_STR;
5333 astrWIDList[1].ps8WidVal = ppu8RcvdSiteSurveyResults[1];
5334 astrWIDList[1].s32ValueSize = u32MaxSiteSrvyFragLen;
5335
5336 s32Error = SendConfigPkt(GET_CFG, astrWIDList, 2, true, (u32)pstrWFIDrv);
5337
5338 /*get the value by searching the local copy*/
5339 if (s32Error) {
5340 PRINT_ER("Failed to send config packet to get survey results\n");
5341 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
5342 }
5343
5344 WILC_CATCH(s32Error)
5345 {
5346
5347 }
5348
5349 return s32Error;
5350 }
5351 #endif
5352
5353 /**
5354 * @brief sets a start scan request
5355 * @details
5356 * @param[in,out] handle to the wifi driver,
5357 * @param[in] Scan Source one of the following values
5358 * DEFAULT_SCAN 0
5359 * USER_SCAN BIT0
5360 * OBSS_PERIODIC_SCAN BIT1
5361 * OBSS_ONETIME_SCAN BIT2
5362 * @return Error code indicating success/failure
5363 * @note
5364 * @author zsalah
5365 * @date 8 March 2012
5366 * @version 1.0
5367 */
5368 s32 host_int_set_start_scan_req(WILC_WFIDrvHandle hWFIDrv, u8 scanSource)
5369 {
5370 s32 s32Error = WILC_SUCCESS;
5371 tstrWID strWID;
5372 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5373
5374 strWID.u16WIDid = (u16)WID_START_SCAN_REQ;
5375 strWID.enuWIDtype = WID_CHAR;
5376 strWID.ps8WidVal = (s8 *)&scanSource;
5377 strWID.s32ValueSize = sizeof(char);
5378
5379 return s32Error;
5380 }
5381
5382 /**
5383 * @brief host_int_get_start_scan_req
5384 * @details gets a start scan request
5385 * @param[in,out] handle to the wifi driver,
5386 * @param[in] Scan Source one of the following values
5387 * DEFAULT_SCAN 0
5388 * USER_SCAN BIT0
5389 * OBSS_PERIODIC_SCAN BIT1
5390 * OBSS_ONETIME_SCAN BIT2
5391 * @return Error code indicating success/failure
5392 * @note
5393 * @author zsalah
5394 * @date 8 March 2012
5395 * @version 1.0
5396 */
5397
5398 s32 host_int_get_start_scan_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8ScanSource)
5399 {
5400 s32 s32Error = WILC_SUCCESS;
5401 tstrWID strWID;
5402 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5403
5404 strWID.u16WIDid = (u16)WID_START_SCAN_REQ;
5405 strWID.enuWIDtype = WID_CHAR;
5406 strWID.ps8WidVal = (s8 *)pu8ScanSource;
5407 strWID.s32ValueSize = sizeof(char);
5408
5409 return s32Error;
5410 }
5411
5412 /**
5413 * @brief host_int_set_join_req
5414 * @details sets a join request
5415 * @param[in,out] handle to the wifi driver,
5416 * @param[in] Index of the bss descriptor
5417 * @return Error code indicating success/failure
5418 * @note
5419 * @author zsalah
5420 * @date 8 March 2012
5421 * @version 1.0
5422 */
5423 s32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8bssid,
5424 const u8 *pu8ssid, size_t ssidLen,
5425 const u8 *pu8IEs, size_t IEsLen,
5426 tWILCpfConnectResult pfConnectResult, void *pvUserArg,
5427 u8 u8security, AUTHTYPE_T tenuAuth_type,
5428 u8 u8channel,
5429 void *pJoinParams)
5430 {
5431 s32 s32Error = WILC_SUCCESS;
5432 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5433 tstrHostIFmsg strHostIFmsg;
5434 tenuScanConnTimer enuScanConnTimer;
5435
5436 if (pstrWFIDrv == NULL || pfConnectResult == NULL)
5437 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5438
5439 if (hWFIDrv == NULL) {
5440 PRINT_ER("Driver not initialized: gWFiDrvHandle = NULL\n");
5441 WILC_ERRORREPORT(s32Error, WILC_FAIL);
5442 }
5443
5444 if (pJoinParams == NULL) {
5445 PRINT_ER("Unable to Join - JoinParams is NULL\n");
5446 WILC_ERRORREPORT(s32Error, WILC_FAIL);
5447
5448 }
5449 /*
5450 * if(gWFiDrvHandle->strWILC_UsrScanReq.u32RcvdChCount == 0)
5451 * {
5452 * PRINT_ER("No scan results exist: Scanning should be done\n");
5453 * WILC_ERRORREPORT(s32Error, WILC_FAIL);
5454 * }
5455 */
5456 /* prepare the Connect Message */
5457 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5458
5459 strHostIFmsg.u16MsgId = HOST_IF_MSG_CONNECT;
5460
5461 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.u8security = u8security;
5462 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.tenuAuth_type = tenuAuth_type;
5463 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.u8channel = u8channel;
5464 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pfConnectResult = pfConnectResult;
5465 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pvUserArg = pvUserArg;
5466 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pJoinParams = pJoinParams;
5467 strHostIFmsg.drvHandler = hWFIDrv;
5468
5469 if (pu8bssid != NULL) {
5470 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid = (u8 *)WILC_MALLOC(6); /* will be deallocated by the receiving thread */
5471 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid,
5472 pu8bssid, 6);
5473 }
5474
5475 if (pu8ssid != NULL) {
5476 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.ssidLen = ssidLen;
5477 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid = (u8 *)WILC_MALLOC(ssidLen); /* will be deallocated by the receiving thread */
5478 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid,
5479
5480 pu8ssid, ssidLen);
5481 }
5482
5483 if (pu8IEs != NULL) {
5484 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.IEsLen = IEsLen;
5485 strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs = (u8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */
5486 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs,
5487 pu8IEs, IEsLen);
5488 }
5489 if (pstrWFIDrv->enuHostIFstate < HOST_IF_CONNECTING) {
5490 pstrWFIDrv->enuHostIFstate = HOST_IF_CONNECTING;
5491 } else
5492 PRINT_D(GENERIC_DBG, "Don't set state to 'connecting' as state is %d\n", pstrWFIDrv->enuHostIFstate);
5493
5494 /* send the message */
5495 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5496 if (s32Error) {
5497 PRINT_ER("Failed to send message queue: Set join request\n");
5498 WILC_ERRORREPORT(s32Error, WILC_FAIL);
5499 }
5500
5501 enuScanConnTimer = CONNECT_TIMER;
5502 WILC_TimerStart(&(pstrWFIDrv->hConnectTimer), HOST_IF_CONNECT_TIMEOUT, (void *) hWFIDrv, NULL);
5503
5504 WILC_CATCH(s32Error)
5505 {
5506
5507 }
5508
5509 return s32Error;
5510 }
5511
5512 /**
5513 * @brief Flush a join request parameters to FW, but actual connection
5514 * @details The function is called in situation where WILC is connected to AP and
5515 * required to switch to hybrid FW for P2P connection
5516 * @param[in] handle to the wifi driver,
5517 * @return Error code indicating success/failure
5518 * @note
5519 * @author Amr Abdel-Moghny
5520 * @date 19 DEC 2013
5521 * @version 8.0
5522 */
5523
5524 s32 host_int_flush_join_req(WILC_WFIDrvHandle hWFIDrv)
5525 {
5526 s32 s32Error = WILC_SUCCESS;
5527 tstrHostIFmsg strHostIFmsg;
5528
5529 if (!gu8FlushedJoinReq) {
5530 s32Error = WILC_FAIL;
5531 return s32Error;
5532 }
5533
5534
5535 if (hWFIDrv == NULL)
5536 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5537
5538
5539 strHostIFmsg.u16MsgId = HOST_IF_MSG_FLUSH_CONNECT;
5540 strHostIFmsg.drvHandler = hWFIDrv;
5541
5542 /* send the message */
5543 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5544 if (s32Error) {
5545 PRINT_ER("Failed to send message queue: Flush join request\n");
5546 WILC_ERRORREPORT(s32Error, WILC_FAIL);
5547 }
5548
5549 WILC_CATCH(s32Error)
5550 {
5551
5552 }
5553 return s32Error;
5554 }
5555
5556 /**
5557 * @brief host_int_disconnect
5558 * @details disconnects from the currently associated network
5559 * @param[in,out] handle to the wifi driver,
5560 * @param[in] Reason Code of the Disconnection
5561 * @return Error code indicating success/failure
5562 * @note
5563 * @author zsalah
5564 * @date 8 March 2012
5565 * @version 1.0
5566 */
5567 s32 host_int_disconnect(WILC_WFIDrvHandle hWFIDrv, u16 u16ReasonCode)
5568 {
5569 s32 s32Error = WILC_SUCCESS;
5570 tstrHostIFmsg strHostIFmsg;
5571 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5572
5573 if (pstrWFIDrv == NULL) {
5574 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5575 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5576 }
5577
5578 if (pstrWFIDrv == NULL) {
5579 PRINT_ER("gWFiDrvHandle = NULL\n");
5580 WILC_ERRORREPORT(s32Error, WILC_FAIL);
5581 }
5582
5583 /* prepare the Disconnect Message */
5584 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5585
5586 strHostIFmsg.u16MsgId = HOST_IF_MSG_DISCONNECT;
5587 strHostIFmsg.drvHandler = hWFIDrv;
5588
5589 /* send the message */
5590 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5591 if (s32Error)
5592 PRINT_ER("Failed to send message queue: disconnect\n");
5593 /* ////////////// */
5594 down(&(pstrWFIDrv->hSemTestDisconnectBlock));
5595 /* /////// */
5596
5597 WILC_CATCH(s32Error)
5598 {
5599
5600 }
5601
5602 return s32Error;
5603 }
5604
5605 /**
5606 * @brief host_int_disconnect_station
5607 * @details disconnects a sta
5608 * @param[in,out] handle to the wifi driver,
5609 * @param[in] Association Id of the station to be disconnected
5610 * @return Error code indicating success/failure
5611 * @note
5612 * @author zsalah
5613 * @date 8 March 2012
5614 * @version 1.0
5615 */
5616 s32 host_int_disconnect_station(WILC_WFIDrvHandle hWFIDrv, u8 assoc_id)
5617 {
5618 s32 s32Error = WILC_SUCCESS;
5619 tstrWID strWID;
5620 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5621
5622 strWID.u16WIDid = (u16)WID_DISCONNECT;
5623 strWID.enuWIDtype = WID_CHAR;
5624 strWID.ps8WidVal = (s8 *)&assoc_id;
5625 strWID.s32ValueSize = sizeof(char);
5626
5627 return s32Error;
5628 }
5629
5630 /**
5631 * @brief host_int_get_assoc_req_info
5632 * @details gets a Association request info
5633 * @param[in,out] handle to the wifi driver,
5634 * Message containg assoc. req info in the following format
5635 * ------------------------------------------------------------------------
5636 | Management Frame Format |
5637 ||-------------------------------------------------------------------|
5638 ||Frame Control|Duration|DA|SA|BSSID|Sequence Control|Frame Body|FCS |
5639 ||-------------|--------|--|--|-----|----------------|----------|----|
5640 | 2 |2 |6 |6 |6 | 2 |0 - 2312 | 4 |
5641 ||-------------------------------------------------------------------|
5642 | |
5643 | Association Request Frame - Frame Body |
5644 ||-------------------------------------------------------------------|
5645 | Capability Information | Listen Interval | SSID | Supported Rates |
5646 ||------------------------|-----------------|------|-----------------|
5647 | 2 | 2 | 2-34 | 3-10 |
5648 | ---------------------------------------------------------------------
5649 * @return Error code indicating success/failure
5650 * @note
5651 * @author zsalah
5652 * @date 8 March 2012
5653 * @version 1.0
5654 */
5655
5656 s32 host_int_get_assoc_req_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8AssocReqInfo,
5657 u32 u32AssocReqInfoLen)
5658 {
5659 s32 s32Error = WILC_SUCCESS;
5660 tstrWID strWID;
5661 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5662
5663 strWID.u16WIDid = (u16)WID_ASSOC_REQ_INFO;
5664 strWID.enuWIDtype = WID_STR;
5665 strWID.ps8WidVal = pu8AssocReqInfo;
5666 strWID.s32ValueSize = u32AssocReqInfoLen;
5667
5668
5669 return s32Error;
5670 }
5671
5672 /**
5673 * @brief gets a Association Response info
5674 * @details
5675 * @param[in,out] handle to the wifi driver,
5676 * Message containg assoc. resp info
5677 * @return Error code indicating success/failure
5678 * @note
5679 * @author zsalah
5680 * @date 8 March 2012
5681 * @version 1.0
5682 */
5683 s32 host_int_get_assoc_res_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8AssocRespInfo,
5684 u32 u32MaxAssocRespInfoLen, u32 *pu32RcvdAssocRespInfoLen)
5685 {
5686 s32 s32Error = WILC_SUCCESS;
5687 tstrWID strWID;
5688 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5689
5690 if (pstrWFIDrv == NULL) {
5691 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5692 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5693 }
5694
5695 strWID.u16WIDid = (u16)WID_ASSOC_RES_INFO;
5696 strWID.enuWIDtype = WID_STR;
5697 strWID.ps8WidVal = pu8AssocRespInfo;
5698 strWID.s32ValueSize = u32MaxAssocRespInfoLen;
5699
5700
5701 /* Sending Configuration packet */
5702 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
5703 if (s32Error) {
5704 PRINT_ER("Failed to send association response config packet\n");
5705 *pu32RcvdAssocRespInfoLen = 0;
5706 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
5707 } else {
5708 *pu32RcvdAssocRespInfoLen = strWID.s32ValueSize;
5709 }
5710
5711 WILC_CATCH(s32Error)
5712 {
5713
5714 }
5715 return s32Error;
5716 }
5717
5718 /**
5719 * @brief gets a Association Response info
5720 * @details Valid only in STA mode. This function gives the RSSI
5721 * values observed in all the channels at the time of scanning.
5722 * The length of the field is 1 greater that the total number of
5723 * channels supported. Byte 0 contains the number of channels while
5724 * each of Byte N contains the observed RSSI value for the channel index N.
5725 * @param[in,out] handle to the wifi driver,
5726 * array of scanned channels' RSSI
5727 * @return Error code indicating success/failure
5728 * @note
5729 * @author zsalah
5730 * @date 8 March 2012
5731 * @version 1.0
5732 */
5733 s32 host_int_get_rx_power_level(WILC_WFIDrvHandle hWFIDrv, u8 *pu8RxPowerLevel,
5734 u32 u32RxPowerLevelLen)
5735 {
5736 s32 s32Error = WILC_SUCCESS;
5737 tstrWID strWID;
5738 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5739
5740 strWID.u16WIDid = (u16)WID_RX_POWER_LEVEL;
5741 strWID.enuWIDtype = WID_STR;
5742 strWID.ps8WidVal = pu8RxPowerLevel;
5743 strWID.s32ValueSize = u32RxPowerLevelLen;
5744
5745
5746 return s32Error;
5747 }
5748
5749 /**
5750 * @brief sets a channel
5751 * @details
5752 * @param[in,out] handle to the wifi driver,
5753 * @param[in] Index of the channel to be set
5754 *|-------------------------------------------------------------------|
5755 | CHANNEL1 CHANNEL2 .... CHANNEL14 |
5756 | Input: 1 2 14 |
5757 ||-------------------------------------------------------------------|
5758 * @return Error code indicating success/failure
5759 * @note
5760 * @author zsalah
5761 * @date 8 March 2012
5762 * @version 1.0
5763 */
5764 s32 host_int_set_mac_chnl_num(WILC_WFIDrvHandle hWFIDrv, u8 u8ChNum)
5765 {
5766 s32 s32Error = WILC_SUCCESS;
5767 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5768 tstrHostIFmsg strHostIFmsg;
5769
5770 if (pstrWFIDrv == NULL)
5771 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5772
5773 /* prepare the set channel message */
5774 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5775 strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_CHANNEL;
5776 strHostIFmsg.uniHostIFmsgBody.strHostIFSetChan.u8SetChan = u8ChNum;
5777 strHostIFmsg.drvHandler = hWFIDrv;
5778
5779 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5780 if (s32Error)
5781 WILC_ERRORREPORT(s32Error, s32Error);
5782 WILC_CATCH(s32Error)
5783 {
5784
5785 }
5786
5787 return s32Error;
5788 }
5789
5790
5791 s32 host_int_wait_msg_queue_idle(void)
5792 {
5793 s32 s32Error = WILC_SUCCESS;
5794
5795 tstrHostIFmsg strHostIFmsg;
5796
5797 /* prepare the set driver handler message */
5798
5799 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5800 strHostIFmsg.u16MsgId = HOST_IF_MSG_Q_IDLE;
5801 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5802 if (s32Error)
5803 WILC_ERRORREPORT(s32Error, s32Error);
5804 WILC_CATCH(s32Error)
5805 {
5806
5807 }
5808
5809 /* wait untill MSG Q is empty */
5810 down(&hWaitResponse);
5811
5812 return s32Error;
5813
5814 }
5815
5816 s32 host_int_set_wfi_drv_handler(u32 u32address)
5817 {
5818 s32 s32Error = WILC_SUCCESS;
5819
5820 tstrHostIFmsg strHostIFmsg;
5821
5822
5823 /* prepare the set driver handler message */
5824
5825 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5826 strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_WFIDRV_HANDLER;
5827 strHostIFmsg.uniHostIFmsgBody.strHostIfSetDrvHandler.u32Address = u32address;
5828 /* strHostIFmsg.drvHandler=hWFIDrv; */
5829
5830 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5831 if (s32Error)
5832 WILC_ERRORREPORT(s32Error, s32Error);
5833 WILC_CATCH(s32Error)
5834 {
5835
5836 }
5837
5838 return s32Error;
5839 }
5840
5841
5842
5843 s32 host_int_set_operation_mode(WILC_WFIDrvHandle hWFIDrv, u32 u32mode)
5844 {
5845 s32 s32Error = WILC_SUCCESS;
5846
5847 tstrHostIFmsg strHostIFmsg;
5848
5849
5850 /* prepare the set driver handler message */
5851
5852 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5853 strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_OPERATION_MODE;
5854 strHostIFmsg.uniHostIFmsgBody.strHostIfSetOperationMode.u32Mode = u32mode;
5855 strHostIFmsg.drvHandler = hWFIDrv;
5856
5857 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5858 if (s32Error)
5859 WILC_ERRORREPORT(s32Error, s32Error);
5860 WILC_CATCH(s32Error)
5861 {
5862
5863 }
5864
5865 return s32Error;
5866 }
5867
5868 /**
5869 * @brief gets the current channel index
5870 * @details
5871 * @param[in,out] handle to the wifi driver,
5872 * current channel index
5873 *|-----------------------------------------------------------------------|
5874 | CHANNEL1 CHANNEL2 .... CHANNEL14 |
5875 | Input: 1 2 14 |
5876 ||-----------------------------------------------------------------------|
5877 * @return Error code indicating success/failure
5878 * @note
5879 * @author zsalah
5880 * @date 8 March 2012
5881 * @version 1.0
5882 */
5883 s32 host_int_get_host_chnl_num(WILC_WFIDrvHandle hWFIDrv, u8 *pu8ChNo)
5884 {
5885 s32 s32Error = WILC_SUCCESS;
5886 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5887 tstrHostIFmsg strHostIFmsg;
5888
5889 if (pstrWFIDrv == NULL) {
5890 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5891 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5892 }
5893
5894 /* prepare the Get Channel Message */
5895 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5896
5897 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_CHNL;
5898 strHostIFmsg.drvHandler = hWFIDrv;
5899
5900 /* send the message */
5901 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5902 if (s32Error)
5903 PRINT_ER("Failed to send get host channel param's message queue ");
5904 down(&(pstrWFIDrv->hSemGetCHNL));
5905 /* gu8Chnl = 11; */
5906
5907 *pu8ChNo = gu8Chnl;
5908
5909 WILC_CATCH(s32Error)
5910 {
5911 }
5912
5913 return s32Error;
5914
5915
5916 }
5917
5918
5919 /**
5920 * @brief host_int_test_set_int_wid
5921 * @details Test function for setting wids
5922 * @param[in,out] WILC_WFIDrvHandle hWFIDrv, u32 u32TestMemAddr
5923 * @return Error code indicating success/failure
5924 * @note
5925 * @author zsalah
5926 * @date 8 March 2012
5927 * @version 1.0
5928 */
5929 s32 host_int_test_set_int_wid(WILC_WFIDrvHandle hWFIDrv, u32 u32TestMemAddr)
5930 {
5931 s32 s32Error = WILC_SUCCESS;
5932 tstrWID strWID;
5933 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5934
5935
5936 if (pstrWFIDrv == NULL) {
5937 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5938 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5939 }
5940
5941 /*prepare configuration packet*/
5942 strWID.u16WIDid = (u16)WID_MEMORY_ADDRESS;
5943 strWID.enuWIDtype = WID_INT;
5944 strWID.ps8WidVal = (char *)&u32TestMemAddr;
5945 strWID.s32ValueSize = sizeof(u32);
5946
5947 /*Sending Cfg*/
5948 s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
5949 if (s32Error) {
5950 PRINT_ER("Test Function: Failed to set wid value\n");
5951 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
5952 } else {
5953 PRINT_D(HOSTINF_DBG, "Successfully set wid value\n");
5954
5955 }
5956
5957 WILC_CATCH(s32Error)
5958 {
5959
5960 }
5961 return s32Error;
5962 }
5963
5964 #ifdef WILC_AP_EXTERNAL_MLME
5965 /**
5966 * @brief host_int_get_inactive_time
5967 * @details
5968 * @param[in,out] handle to the wifi driver,
5969 * current sta macaddress, inactive_time
5970 * @return
5971 * @note
5972 * @author
5973 * @date
5974 * @version 1.0
5975 */
5976 s32 host_int_get_inactive_time(WILC_WFIDrvHandle hWFIDrv, const u8 *mac, u32 *pu32InactiveTime)
5977 {
5978 s32 s32Error = WILC_SUCCESS;
5979 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
5980 tstrHostIFmsg strHostIFmsg;
5981
5982 if (pstrWFIDrv == NULL) {
5983 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5984 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
5985 }
5986
5987 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
5988
5989
5990 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIfStaInactiveT.mac,
5991 mac, ETH_ALEN);
5992
5993 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_INACTIVETIME;
5994 strHostIFmsg.drvHandler = hWFIDrv;
5995
5996 /* send the message */
5997 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
5998 if (s32Error)
5999 PRINT_ER("Failed to send get host channel param's message queue ");
6000
6001 down(&(pstrWFIDrv->hSemInactiveTime));
6002
6003 *pu32InactiveTime = gu32InactiveTime;
6004
6005 WILC_CATCH(s32Error)
6006 {
6007 }
6008
6009 return s32Error;
6010 }
6011 #endif
6012 /**
6013 * @brief host_int_test_get_int_wid
6014 * @details Test function for getting wids
6015 * @param[in,out] WILC_WFIDrvHandle hWFIDrv, u32* pu32TestMemAddr
6016 * @return Error code indicating success/failure
6017 * @note
6018 * @author zsalah
6019 * @date 8 March 2012
6020 * @version 1.0
6021 */
6022 s32 host_int_test_get_int_wid(WILC_WFIDrvHandle hWFIDrv, u32 *pu32TestMemAddr)
6023 {
6024
6025 s32 s32Error = WILC_SUCCESS;
6026 tstrWID strWID;
6027 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6028
6029
6030 if (pstrWFIDrv == NULL) {
6031 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
6032 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
6033 }
6034
6035 strWID.u16WIDid = (u16)WID_MEMORY_ADDRESS;
6036 strWID.enuWIDtype = WID_INT;
6037 strWID.ps8WidVal = (s8 *)pu32TestMemAddr;
6038 strWID.s32ValueSize = sizeof(u32);
6039
6040 s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
6041 /*get the value by searching the local copy*/
6042 if (s32Error) {
6043 PRINT_ER("Test Function: Failed to get wid value\n");
6044 WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
6045 } else {
6046 PRINT_D(HOSTINF_DBG, "Successfully got wid value\n");
6047
6048 }
6049
6050 WILC_CATCH(s32Error)
6051 {
6052
6053 }
6054 return s32Error;
6055 }
6056
6057
6058 /**
6059 * @brief host_int_get_rssi
6060 * @details gets the currently maintained RSSI value for the station.
6061 * The received signal strength value in dB.
6062 * The range of valid values is -128 to 0.
6063 * @param[in,out] handle to the wifi driver,
6064 * rssi value in dB
6065 * @return Error code indicating success/failure
6066 * @note
6067 * @author zsalah
6068 * @date 8 March 2012
6069 * @version 1.0
6070 */
6071 s32 host_int_get_rssi(WILC_WFIDrvHandle hWFIDrv, s8 *ps8Rssi)
6072 {
6073 s32 s32Error = WILC_SUCCESS;
6074 tstrHostIFmsg strHostIFmsg;
6075 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6076
6077
6078 /* prepare the Get RSSI Message */
6079 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6080
6081 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_RSSI;
6082 strHostIFmsg.drvHandler = hWFIDrv;
6083
6084 /* send the message */
6085 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6086 if (s32Error) {
6087 PRINT_ER("Failed to send get host channel param's message queue ");
6088 return WILC_FAIL;
6089 }
6090
6091 down(&(pstrWFIDrv->hSemGetRSSI));
6092
6093
6094 if (ps8Rssi == NULL) {
6095 PRINT_ER("RSS pointer value is null");
6096 return WILC_FAIL;
6097 }
6098
6099
6100 *ps8Rssi = gs8Rssi;
6101
6102
6103 return s32Error;
6104 }
6105
6106 s32 host_int_get_link_speed(WILC_WFIDrvHandle hWFIDrv, s8 *ps8lnkspd)
6107 {
6108 tstrHostIFmsg strHostIFmsg;
6109 s32 s32Error = WILC_SUCCESS;
6110
6111 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6112
6113
6114
6115 /* prepare the Get LINKSPEED Message */
6116 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6117
6118 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_LINKSPEED;
6119 strHostIFmsg.drvHandler = hWFIDrv;
6120
6121 /* send the message */
6122 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6123 if (s32Error) {
6124 PRINT_ER("Failed to send GET_LINKSPEED to message queue ");
6125 return WILC_FAIL;
6126 }
6127
6128 down(&(pstrWFIDrv->hSemGetLINKSPEED));
6129
6130
6131 if (ps8lnkspd == NULL) {
6132 PRINT_ER("LINKSPEED pointer value is null");
6133 return WILC_FAIL;
6134 }
6135
6136
6137 *ps8lnkspd = gs8lnkspd;
6138
6139
6140 return s32Error;
6141 }
6142
6143 s32 host_int_get_statistics(WILC_WFIDrvHandle hWFIDrv, tstrStatistics *pstrStatistics)
6144 {
6145 s32 s32Error = WILC_SUCCESS;
6146 tstrHostIFmsg strHostIFmsg;
6147
6148
6149 /* prepare the Get RSSI Message */
6150 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6151
6152 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_STATISTICS;
6153 strHostIFmsg.uniHostIFmsgBody.pUserData = (char *)pstrStatistics;
6154 strHostIFmsg.drvHandler = hWFIDrv;
6155 /* send the message */
6156 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6157 if (s32Error) {
6158 PRINT_ER("Failed to send get host channel param's message queue ");
6159 return WILC_FAIL;
6160 }
6161
6162 down(&hWaitResponse);
6163 return s32Error;
6164 }
6165
6166
6167 /**
6168 * @brief host_int_scan
6169 * @details scans a set of channels
6170 * @param[in,out] handle to the wifi driver,
6171 * @param[in] Scan source
6172 * Scan Type PASSIVE_SCAN = 0,
6173 * ACTIVE_SCAN = 1
6174 * Channels Array
6175 * Channels Array length
6176 * Scan Callback function
6177 * @return Error code indicating success/failure
6178 * @note
6179 * @author zsalah
6180 * @date 8 March 2012
6181 * @version 1.0
6182 */
6183 s32 host_int_scan(WILC_WFIDrvHandle hWFIDrv, u8 u8ScanSource,
6184 u8 u8ScanType, u8 *pu8ChnlFreqList,
6185 u8 u8ChnlListLen, const u8 *pu8IEs,
6186 size_t IEsLen, tWILCpfScanResult ScanResult,
6187 void *pvUserArg, tstrHiddenNetwork *pstrHiddenNetwork)
6188 {
6189 s32 s32Error = WILC_SUCCESS;
6190 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6191 tstrHostIFmsg strHostIFmsg;
6192 tenuScanConnTimer enuScanConnTimer;
6193
6194 if (pstrWFIDrv == NULL || ScanResult == NULL)
6195 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
6196
6197
6198 /* prepare the Scan Message */
6199 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6200
6201 strHostIFmsg.u16MsgId = HOST_IF_MSG_SCAN;
6202
6203 if (pstrHiddenNetwork != NULL) {
6204 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.strHiddenNetwork.pstrHiddenNetworkInfo = pstrHiddenNetwork->pstrHiddenNetworkInfo;
6205 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.strHiddenNetwork.u8ssidnum = pstrHiddenNetwork->u8ssidnum;
6206
6207 } else
6208 PRINT_D(HOSTINF_DBG, "pstrHiddenNetwork IS EQUAL TO NULL\n");
6209
6210 strHostIFmsg.drvHandler = hWFIDrv;
6211 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ScanSource = u8ScanSource;
6212 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ScanType = u8ScanType;
6213 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pfScanResult = ScanResult;
6214 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pvUserArg = pvUserArg;
6215
6216 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ChnlListLen = u8ChnlListLen;
6217 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList = (u8 *)WILC_MALLOC(u8ChnlListLen); /* will be deallocated by the receiving thread */
6218 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList,
6219 pu8ChnlFreqList, u8ChnlListLen);
6220
6221 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.IEsLen = IEsLen;
6222 strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs = (u8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */
6223 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs,
6224 pu8IEs, IEsLen);
6225
6226 /* send the message */
6227 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6228 if (s32Error) {
6229 PRINT_ER("Error in sending message queue scanning parameters: Error(%d)\n", s32Error);
6230 WILC_ERRORREPORT(s32Error, WILC_FAIL);
6231 }
6232
6233 enuScanConnTimer = SCAN_TIMER;
6234 PRINT_D(HOSTINF_DBG, ">> Starting the SCAN timer\n");
6235 WILC_TimerStart(&(pstrWFIDrv->hScanTimer), HOST_IF_SCAN_TIMEOUT, (void *) hWFIDrv, NULL);
6236
6237
6238 WILC_CATCH(s32Error)
6239 {
6240
6241 }
6242 return s32Error;
6243
6244 }
6245 /**
6246 * @brief hif_set_cfg
6247 * @details sets configuration wids values
6248 * @param[in,out] handle to the wifi driver,
6249 * @param[in] WID, WID value
6250 * @return Error code indicating success/failure
6251 * @note
6252 * @author zsalah
6253 * @date 8 March 2012
6254 * @version 1.0
6255 */
6256 s32 hif_set_cfg(WILC_WFIDrvHandle hWFIDrv, tstrCfgParamVal *pstrCfgParamVal)
6257 {
6258
6259 s32 s32Error = WILC_SUCCESS;
6260 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6261
6262 tstrHostIFmsg strHostIFmsg;
6263
6264
6265 if (pstrWFIDrv == NULL)
6266 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
6267 /* prepare the WiphyParams Message */
6268 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6269 strHostIFmsg.u16MsgId = HOST_IF_MSG_CFG_PARAMS;
6270 strHostIFmsg.uniHostIFmsgBody.strHostIFCfgParamAttr.pstrCfgParamVal = *pstrCfgParamVal;
6271 strHostIFmsg.drvHandler = hWFIDrv;
6272
6273 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6274
6275 WILC_CATCH(s32Error)
6276 {
6277 }
6278
6279 return s32Error;
6280
6281 }
6282
6283
6284 /**
6285 * @brief hif_get_cfg
6286 * @details gets configuration wids values
6287 * @param[in,out] handle to the wifi driver,
6288 * WID value
6289 * @param[in] WID,
6290 * @return Error code indicating success/failure
6291 * @note
6292 * @author zsalah
6293 *
6294 * @date 8 March 2012
6295 * @version 1.0
6296 */
6297 s32 hif_get_cfg(WILC_WFIDrvHandle hWFIDrv, u16 u16WID, u16 *pu16WID_Value)
6298 {
6299 s32 s32Error = WILC_SUCCESS;
6300 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6301
6302 down(&(pstrWFIDrv->gtOsCfgValuesSem));
6303
6304 if (pstrWFIDrv == NULL) {
6305 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
6306 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
6307 }
6308 PRINT_D(HOSTINF_DBG, "Getting configuration parameters\n");
6309 switch (u16WID) {
6310
6311 case WID_BSS_TYPE:
6312 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.bss_type;
6313 break;
6314
6315 case WID_AUTH_TYPE:
6316 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.auth_type;
6317 break;
6318
6319 case WID_AUTH_TIMEOUT:
6320 *pu16WID_Value = pstrWFIDrv->strCfgValues.auth_timeout;
6321 break;
6322
6323 case WID_POWER_MANAGEMENT:
6324 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.power_mgmt_mode;
6325 break;
6326
6327 case WID_SHORT_RETRY_LIMIT:
6328 *pu16WID_Value = pstrWFIDrv->strCfgValues.short_retry_limit;
6329 break;
6330
6331 case WID_LONG_RETRY_LIMIT:
6332 *pu16WID_Value = pstrWFIDrv->strCfgValues.long_retry_limit;
6333 break;
6334
6335 case WID_FRAG_THRESHOLD:
6336 *pu16WID_Value = pstrWFIDrv->strCfgValues.frag_threshold;
6337 break;
6338
6339 case WID_RTS_THRESHOLD:
6340 *pu16WID_Value = pstrWFIDrv->strCfgValues.rts_threshold;
6341 break;
6342
6343 case WID_PREAMBLE:
6344 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.preamble_type;
6345 break;
6346
6347 case WID_SHORT_SLOT_ALLOWED:
6348 *pu16WID_Value = (u16) pstrWFIDrv->strCfgValues.short_slot_allowed;
6349 break;
6350
6351 case WID_11N_TXOP_PROT_DISABLE:
6352 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.txop_prot_disabled;
6353 break;
6354
6355 case WID_BEACON_INTERVAL:
6356 *pu16WID_Value = pstrWFIDrv->strCfgValues.beacon_interval;
6357 break;
6358
6359 case WID_DTIM_PERIOD:
6360 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.dtim_period;
6361 break;
6362
6363 case WID_SITE_SURVEY:
6364 *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.site_survey_enabled;
6365 break;
6366
6367 case WID_SITE_SURVEY_SCAN_TIME:
6368 *pu16WID_Value = pstrWFIDrv->strCfgValues.site_survey_scan_time;
6369 break;
6370
6371 case WID_ACTIVE_SCAN_TIME:
6372 *pu16WID_Value = pstrWFIDrv->strCfgValues.active_scan_time;
6373 break;
6374
6375 case WID_PASSIVE_SCAN_TIME:
6376 *pu16WID_Value = pstrWFIDrv->strCfgValues.passive_scan_time;
6377 break;
6378
6379 case WID_CURRENT_TX_RATE:
6380 *pu16WID_Value = pstrWFIDrv->strCfgValues.curr_tx_rate;
6381 break;
6382
6383 default:
6384 break;
6385 }
6386
6387 up(&(pstrWFIDrv->gtOsCfgValuesSem));
6388
6389 WILC_CATCH(s32Error)
6390 {
6391 }
6392 return s32Error;
6393
6394 }
6395
6396 /*****************************************************************************/
6397 /* Notification Functions */
6398 /*****************************************************************************/
6399 /**
6400 * @brief notifies host with join and leave requests
6401 * @details This function prepares an Information frame having the
6402 * information about a joining/leaving station.
6403 * @param[in,out] handle to the wifi driver,
6404 * @param[in] 6 byte Sta Adress
6405 * Join or leave flag:
6406 * Join = 1,
6407 * Leave =0
6408 * @return Error code indicating success/failure
6409 * @note
6410 * @author zsalah
6411 * @date 8 March 2012
6412 * @version 1.0
6413 */
6414 void host_int_send_join_leave_info_to_host
6415 (u16 assocId, u8 *stationAddr, bool joining)
6416 {
6417 }
6418 /**
6419 * @brief notifies host with stations found in scan
6420 * @details sends the beacon/probe response from scan
6421 * @param[in,out] handle to the wifi driver,
6422 * @param[in] Sta Address,
6423 * Frame length,
6424 * Rssi of the Station found
6425 * @return Error code indicating success/failure
6426 * @note
6427 * @author zsalah
6428 * @date 8 March 2012
6429 * @version 1.0
6430 */
6431
6432 void GetPeriodicRSSI(void *pvArg)
6433 {
6434 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)pvArg;
6435
6436 if (pstrWFIDrv == NULL) {
6437 PRINT_ER("Driver handler is NULL\n");
6438 return;
6439 }
6440
6441 if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) {
6442 s32 s32Error = WILC_SUCCESS;
6443 tstrHostIFmsg strHostIFmsg;
6444
6445 /* prepare the Get RSSI Message */
6446 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6447
6448 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_RSSI;
6449 strHostIFmsg.drvHandler = pstrWFIDrv;
6450
6451 /* send the message */
6452 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6453 if (s32Error) {
6454 PRINT_ER("Failed to send get host channel param's message queue ");
6455 return;
6456 }
6457 }
6458 WILC_TimerStart(&(g_hPeriodicRSSI), 5000, (void *)pstrWFIDrv, NULL);
6459 }
6460
6461
6462 void host_int_send_network_info_to_host
6463 (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi)
6464 {
6465 }
6466 /**
6467 * @brief host_int_init
6468 * @details host interface initialization function
6469 * @param[in,out] handle to the wifi driver,
6470 * @note
6471 * @author zsalah
6472 * @date 8 March 2012
6473 * @version 1.0
6474 */
6475 static u32 u32Intialized;
6476 static u32 msgQ_created;
6477 static u32 clients_count;
6478
6479 s32 host_int_init(WILC_WFIDrvHandle *phWFIDrv)
6480 {
6481 s32 s32Error = WILC_SUCCESS;
6482 tstrWILC_WFIDrv *pstrWFIDrv;
6483
6484 /*if(u32Intialized == 1)
6485 * {
6486 * PRINT_D(HOSTINF_DBG,"Host interface is previously initialized\n");
6487 * *phWFIDrv = (WILC_WFIDrvHandle)gWFiDrvHandle; //Will be adjusted later for P2P
6488 * return 0;
6489 * } */
6490 PRINT_D(HOSTINF_DBG, "Initializing host interface for client %d\n", clients_count + 1);
6491
6492 gbScanWhileConnected = false;
6493
6494 sema_init(&hWaitResponse, 0);
6495
6496
6497
6498 /*Allocate host interface private structure*/
6499 pstrWFIDrv = (tstrWILC_WFIDrv *)WILC_MALLOC(sizeof(tstrWILC_WFIDrv));
6500 if (pstrWFIDrv == NULL) {
6501 /* WILC_ERRORREPORT(s32Error,WILC_NO_MEM); */
6502 s32Error = WILC_NO_MEM;
6503 PRINT_ER("Failed to allocate memory\n");
6504 goto _fail_timer_2;
6505 }
6506 WILC_memset(pstrWFIDrv, 0, sizeof(tstrWILC_WFIDrv));
6507 /*return driver handle to user*/
6508 *phWFIDrv = (WILC_WFIDrvHandle)pstrWFIDrv;
6509 /*save into globl handle*/
6510
6511 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
6512
6513 g_obtainingIP = false;
6514 #endif
6515
6516 PRINT_D(HOSTINF_DBG, "Global handle pointer value=%p\n", pstrWFIDrv);
6517 /* /////////////////////////////////////// */
6518 if (clients_count == 0) {
6519 sema_init(&hSemHostIFthrdEnd, 0);
6520 sema_init(&hSemDeinitDrvHandle, 0);
6521 /*BugID_5348*/
6522 sema_init(&hSemHostIntDeinit, 1);
6523 }
6524
6525 sema_init(&(pstrWFIDrv->hSemTestKeyBlock), 0);
6526 sema_init(&(pstrWFIDrv->hSemTestDisconnectBlock), 0);
6527 sema_init(&(pstrWFIDrv->hSemGetRSSI), 0);
6528 sema_init(&(pstrWFIDrv->hSemGetLINKSPEED), 0);
6529 sema_init(&(pstrWFIDrv->hSemGetCHNL), 0);
6530 sema_init(&(pstrWFIDrv->hSemInactiveTime), 0);
6531
6532 /* /////////////////////////////////////// */
6533
6534
6535
6536 PRINT_D(HOSTINF_DBG, "INIT: CLIENT COUNT %d\n", clients_count);
6537
6538 if (clients_count == 0) {
6539
6540 s32Error = WILC_MsgQueueCreate(&gMsgQHostIF, NULL);
6541
6542
6543 if (s32Error < 0) {
6544 PRINT_ER("Failed to creat MQ\n");
6545 goto _fail_;
6546 }
6547 msgQ_created = 1;
6548 HostIFthreadHandler = kthread_run(hostIFthread, NULL, "WILC_kthread");
6549 if (IS_ERR(HostIFthreadHandler)) {
6550 PRINT_ER("Failed to creat Thread\n");
6551 s32Error = WILC_FAIL;
6552 goto _fail_mq_;
6553 }
6554 s32Error = WILC_TimerCreate(&(g_hPeriodicRSSI), GetPeriodicRSSI, NULL);
6555 if (s32Error < 0) {
6556 PRINT_ER("Failed to creat Timer\n");
6557 goto _fail_timer_1;
6558 }
6559 WILC_TimerStart(&(g_hPeriodicRSSI), 5000, (void *)pstrWFIDrv, NULL);
6560
6561 }
6562
6563
6564 s32Error = WILC_TimerCreate(&(pstrWFIDrv->hScanTimer), TimerCB_Scan, NULL);
6565 if (s32Error < 0) {
6566 PRINT_ER("Failed to creat Timer\n");
6567 goto _fail_thread_;
6568 }
6569
6570 s32Error = WILC_TimerCreate(&(pstrWFIDrv->hConnectTimer), TimerCB_Connect, NULL);
6571 if (s32Error < 0) {
6572 PRINT_ER("Failed to creat Timer\n");
6573 goto _fail_timer_1;
6574 }
6575
6576
6577 #ifdef WILC_P2P
6578 /*Remain on channel timer*/
6579 s32Error = WILC_TimerCreate(&(pstrWFIDrv->hRemainOnChannel), ListenTimerCB, NULL);
6580 if (s32Error < 0) {
6581 PRINT_ER("Failed to creat Remain-on-channel Timer\n");
6582 goto _fail_timer_3;
6583 }
6584 #endif
6585
6586 sema_init(&(pstrWFIDrv->gtOsCfgValuesSem), 1);
6587 down(&(pstrWFIDrv->gtOsCfgValuesSem));
6588
6589
6590
6591 #ifdef SIMULATION
6592 TransportInit();
6593 #endif
6594
6595 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
6596 /* gWFiDrvHandle->bPendingConnRequest = false; */
6597
6598 /*Initialize CFG WIDS Defualt Values*/
6599
6600 pstrWFIDrv->strCfgValues.site_survey_enabled = SITE_SURVEY_OFF;
6601 pstrWFIDrv->strCfgValues.scan_source = DEFAULT_SCAN;
6602 pstrWFIDrv->strCfgValues.active_scan_time = ACTIVE_SCAN_TIME;
6603 pstrWFIDrv->strCfgValues.passive_scan_time = PASSIVE_SCAN_TIME;
6604 pstrWFIDrv->strCfgValues.curr_tx_rate = AUTORATE;
6605
6606
6607 #ifdef WILC_P2P
6608
6609 pstrWFIDrv->u64P2p_MgmtTimeout = 0;
6610
6611 #endif
6612
6613 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",
6614
6615 pstrWFIDrv->strCfgValues.site_survey_enabled, pstrWFIDrv->strCfgValues.scan_source,
6616 pstrWFIDrv->strCfgValues.active_scan_time, pstrWFIDrv->strCfgValues.passive_scan_time,
6617 pstrWFIDrv->strCfgValues.curr_tx_rate);
6618
6619
6620 up(&(pstrWFIDrv->gtOsCfgValuesSem));
6621
6622 /*TODO Code to setup simulation to be removed later*/
6623 /*Intialize configurator module*/
6624 s32Error = CoreConfiguratorInit();
6625 if (s32Error < 0) {
6626 PRINT_ER("Failed to initialize core configurator\n");
6627 goto _fail_mem_;
6628 }
6629
6630 #ifdef SIMULATION
6631 /*Initialize Simulaor*/
6632 CoreConfigSimulatorInit();
6633 #endif
6634
6635 u32Intialized = 1;
6636 clients_count++; /* increase number of created entities */
6637
6638 return s32Error;
6639
6640
6641 _fail_mem_:
6642 if (pstrWFIDrv != NULL)
6643 WILC_FREE(pstrWFIDrv);
6644 #ifdef WILC_P2P
6645 _fail_timer_3:
6646 WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), NULL);
6647 #endif
6648 _fail_timer_2:
6649 up(&(pstrWFIDrv->gtOsCfgValuesSem));
6650 WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), NULL);
6651 _fail_timer_1:
6652 WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), NULL);
6653 _fail_thread_:
6654 kthread_stop(HostIFthreadHandler);
6655 _fail_mq_:
6656 WILC_MsgQueueDestroy(&gMsgQHostIF, NULL);
6657 _fail_:
6658 return s32Error;
6659
6660
6661 }
6662 /**
6663 * @brief host_int_deinit
6664 * @details host interface initialization function
6665 * @param[in,out] handle to the wifi driver,
6666 * @note
6667 * @author zsalah
6668 * @date 8 March 2012
6669 * @version 1.0
6670 */
6671
6672 s32 host_int_deinit(WILC_WFIDrvHandle hWFIDrv)
6673 {
6674 s32 s32Error = WILC_SUCCESS;
6675 tstrHostIFmsg strHostIFmsg;
6676
6677
6678 /*obtain driver handle*/
6679 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6680 /*if(u32Intialized == 0)
6681 * {
6682 * PRINT_ER("Host Interface is not initialized\n");
6683 * return 0;
6684 * }*/
6685
6686 /*BugID_5348*/
6687
6688 if (pstrWFIDrv == NULL) {
6689 PRINT_ER("pstrWFIDrv = NULL\n");
6690 return 0;
6691 }
6692
6693 down(&hSemHostIntDeinit);
6694
6695 terminated_handle = pstrWFIDrv;
6696 PRINT_D(HOSTINF_DBG, "De-initializing host interface for client %d\n", clients_count);
6697
6698 /*BugID_5348*/
6699 /*Destroy all timers before acquiring hSemDeinitDrvHandle*/
6700 /*to guarantee handling all messages befor proceeding*/
6701 if (WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), NULL)) {
6702 PRINT_D(HOSTINF_DBG, ">> Scan timer is active\n");
6703 /* msleep(HOST_IF_SCAN_TIMEOUT+1000); */
6704 }
6705
6706 if (WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), NULL)) {
6707 PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
6708 /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
6709 }
6710
6711
6712 if (WILC_TimerDestroy(&(g_hPeriodicRSSI), NULL)) {
6713 PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
6714 /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
6715 }
6716
6717 #ifdef WILC_P2P
6718 /*Destroy Remain-onchannel Timer*/
6719 WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), NULL);
6720 #endif
6721
6722 host_int_set_wfi_drv_handler((u32)NULL);
6723 down(&hSemDeinitDrvHandle);
6724
6725
6726 /*Calling the CFG80211 scan done function with the abort flag set to true*/
6727 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
6728 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
6729 pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
6730
6731 pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL;
6732 }
6733 /*deinit configurator and simulator*/
6734 #ifdef SIMULATION
6735 CoreConfigSimulatorDeInit();
6736 #endif
6737 CoreConfiguratorDeInit();
6738 #ifdef SIMULATION
6739 TransportDeInit();
6740 #endif
6741
6742 pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
6743
6744 gbScanWhileConnected = false;
6745
6746 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6747
6748 if (clients_count == 1) {
6749 if (WILC_TimerDestroy(&g_hPeriodicRSSI, NULL)) {
6750 PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
6751 /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
6752 }
6753 strHostIFmsg.u16MsgId = HOST_IF_MSG_EXIT;
6754 strHostIFmsg.drvHandler = hWFIDrv;
6755
6756
6757 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6758 if (s32Error != WILC_SUCCESS)
6759 PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", s32Error);
6760
6761 down(&hSemHostIFthrdEnd);
6762
6763
6764
6765 WILC_MsgQueueDestroy(&gMsgQHostIF, NULL);
6766 msgQ_created = 0;
6767 }
6768
6769 down(&(pstrWFIDrv->gtOsCfgValuesSem));
6770
6771 /*Setting the gloabl driver handler with NULL*/
6772 u32Intialized = 0;
6773 /* gWFiDrvHandle = NULL; */
6774 if (pstrWFIDrv != NULL) {
6775 WILC_FREE(pstrWFIDrv);
6776 /* pstrWFIDrv=NULL; */
6777
6778 }
6779
6780 clients_count--; /* Decrease number of created entities */
6781 terminated_handle = NULL;
6782 up(&hSemHostIntDeinit);
6783 return s32Error;
6784 }
6785
6786
6787 /**
6788 * @brief NetworkInfoReceived
6789 * @details function to to be called when network info packet is received
6790 * @param[in] pu8Buffer the received packet
6791 * @param[in] u32Length length of the received packet
6792 * @return none
6793 * @note
6794 * @author
6795 * @date 1 Mar 2012
6796 * @version 1.0
6797 */
6798 void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length)
6799 {
6800 s32 s32Error = WILC_SUCCESS;
6801 tstrHostIFmsg strHostIFmsg;
6802 u32 drvHandler;
6803 tstrWILC_WFIDrv *pstrWFIDrv = NULL;
6804
6805 drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
6806 pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
6807
6808
6809
6810
6811 if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) {
6812 PRINT_ER("NetworkInfo received but driver not init[%p]\n", pstrWFIDrv);
6813 return;
6814 }
6815
6816 /* prepare the Asynchronous Network Info message */
6817 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6818
6819 strHostIFmsg.u16MsgId = HOST_IF_MSG_RCVD_NTWRK_INFO;
6820 strHostIFmsg.drvHandler = pstrWFIDrv;
6821
6822 strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.u32Length = u32Length;
6823 strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer = (u8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */
6824 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer,
6825 pu8Buffer, u32Length);
6826
6827 /* send the message */
6828 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6829 if (s32Error)
6830 PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", s32Error);
6831
6832
6833 return;
6834 }
6835
6836 /**
6837 * @brief GnrlAsyncInfoReceived
6838 * @details function to be called when general Asynchronous info packet is received
6839 * @param[in] pu8Buffer the received packet
6840 * @param[in] u32Length length of the received packet
6841 * @return none
6842 * @note
6843 * @author
6844 * @date 15 Mar 2012
6845 * @version 1.0
6846 */
6847 void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length)
6848 {
6849 s32 s32Error = WILC_SUCCESS;
6850 tstrHostIFmsg strHostIFmsg;
6851 u32 drvHandler;
6852 tstrWILC_WFIDrv *pstrWFIDrv = NULL;
6853
6854 /*BugID_5348*/
6855 down(&hSemHostIntDeinit);
6856
6857 drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
6858 pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
6859 PRINT_D(HOSTINF_DBG, "General asynchronous info packet received\n");
6860
6861
6862 if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) {
6863 PRINT_D(HOSTINF_DBG, "Wifi driver handler is equal to NULL\n");
6864 /*BugID_5348*/
6865 up(&hSemHostIntDeinit);
6866 return;
6867 }
6868
6869 if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == NULL) {
6870 /* received mac status is not needed when there is no current Connect Request */
6871 PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
6872 /*BugID_5348*/
6873 up(&hSemHostIntDeinit);
6874 return;
6875 }
6876
6877 /* prepare the General Asynchronous Info message */
6878 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6879
6880
6881 strHostIFmsg.u16MsgId = HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO;
6882 strHostIFmsg.drvHandler = pstrWFIDrv;
6883
6884
6885 strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.u32Length = u32Length;
6886 strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer = (u8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */
6887 WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer,
6888 pu8Buffer, u32Length);
6889
6890 /* send the message */
6891 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6892 if (s32Error)
6893 PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", s32Error);
6894
6895 /*BugID_5348*/
6896 up(&hSemHostIntDeinit);
6897 return;
6898 }
6899
6900 /**
6901 * @brief host_int_ScanCompleteReceived
6902 * @details Setting scan complete received notifcation in message queue
6903 * @param[in] u8* pu8Buffer, u32 u32Length
6904 * @return Error code.
6905 * @author
6906 * @date
6907 * @version 1.0
6908 */
6909 void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length)
6910 {
6911 s32 s32Error = WILC_SUCCESS;
6912 tstrHostIFmsg strHostIFmsg;
6913 u32 drvHandler;
6914 tstrWILC_WFIDrv *pstrWFIDrv = NULL;
6915
6916 drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
6917 pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
6918
6919
6920 PRINT_D(GENERIC_DBG, "Scan notification received %p\n", pstrWFIDrv);
6921
6922 if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle)
6923 return;
6924
6925 /*if there is an ongoing scan request*/
6926 if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
6927 /* prepare theScan Done message */
6928 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6929
6930 strHostIFmsg.u16MsgId = HOST_IF_MSG_RCVD_SCAN_COMPLETE;
6931 strHostIFmsg.drvHandler = pstrWFIDrv;
6932
6933
6934 /* will be deallocated by the receiving thread */
6935 /*no need to send message body*/
6936
6937 /*strHostIFmsg.uniHostIFmsgBody.strScanComplete.u32Length = u32Length;
6938 * strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer = (u8*)WILC_MALLOC(u32Length);
6939 * WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer,
6940 * pu8Buffer, u32Length); */
6941
6942 /* send the message */
6943 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6944 if (s32Error)
6945 PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", s32Error);
6946 }
6947
6948
6949 return;
6950
6951 }
6952
6953 #ifdef WILC_P2P
6954 /**
6955 * @brief host_int_remain_on_channel
6956 * @details
6957 * @param[in] Handle to wifi driver
6958 * Duration to remain on channel
6959 * Channel to remain on
6960 * Pointer to fn to be called on receive frames in listen state
6961 * Pointer to remain-on-channel expired fn
6962 * Priv
6963 * @return Error code.
6964 * @author
6965 * @date
6966 * @version 1.0
6967 */
6968 s32 host_int_remain_on_channel(WILC_WFIDrvHandle hWFIDrv, u32 u32SessionID, u32 u32duration, u16 chan, tWILCpfRemainOnChanExpired RemainOnChanExpired, tWILCpfRemainOnChanReady RemainOnChanReady, void *pvUserArg)
6969 {
6970 s32 s32Error = WILC_SUCCESS;
6971 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
6972 tstrHostIFmsg strHostIFmsg;
6973
6974 if (pstrWFIDrv == NULL)
6975 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
6976
6977 /* prepare the remainonchan Message */
6978 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
6979
6980 /* prepare the WiphyParams Message */
6981 strHostIFmsg.u16MsgId = HOST_IF_MSG_REMAIN_ON_CHAN;
6982 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u16Channel = chan;
6983 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.pRemainOnChanExpired = RemainOnChanExpired;
6984 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.pRemainOnChanReady = RemainOnChanReady;
6985 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.pVoid = pvUserArg;
6986 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32duration = u32duration;
6987 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = u32SessionID;
6988 strHostIFmsg.drvHandler = hWFIDrv;
6989
6990 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
6991 if (s32Error)
6992 WILC_ERRORREPORT(s32Error, s32Error);
6993 WILC_CATCH(s32Error)
6994 {
6995
6996 }
6997
6998 return s32Error;
6999 }
7000
7001 /**
7002 * @brief host_int_ListenStateExpired
7003 * @details
7004 * @param[in] Handle to wifi driver
7005 * Duration to remain on channel
7006 * Channel to remain on
7007 * Pointer to fn to be called on receive frames in listen state
7008 * Pointer to remain-on-channel expired fn
7009 * Priv
7010 * @return Error code.
7011 * @author
7012 * @date
7013 * @version 1.0
7014 */
7015 s32 host_int_ListenStateExpired(WILC_WFIDrvHandle hWFIDrv, u32 u32SessionID)
7016 {
7017 s32 s32Error = WILC_SUCCESS;
7018 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7019 tstrHostIFmsg strHostIFmsg;
7020
7021 if (pstrWFIDrv == NULL)
7022 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7023
7024 /*Stopping remain-on-channel timer*/
7025 WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), NULL);
7026
7027 /* prepare the timer fire Message */
7028 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7029 strHostIFmsg.u16MsgId = HOST_IF_MSG_LISTEN_TIMER_FIRED;
7030 strHostIFmsg.drvHandler = hWFIDrv;
7031 strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = u32SessionID;
7032
7033 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7034 if (s32Error)
7035 WILC_ERRORREPORT(s32Error, s32Error);
7036 WILC_CATCH(s32Error)
7037 {
7038
7039 }
7040 return s32Error;
7041 }
7042
7043 /**
7044 * @brief host_int_frame_register
7045 * @details
7046 * @param[in] Handle to wifi driver
7047 * @return Error code.
7048 * @author
7049 * @date
7050 * @version 1.0*/
7051 s32 host_int_frame_register(WILC_WFIDrvHandle hWFIDrv, u16 u16FrameType, bool bReg)
7052 {
7053 s32 s32Error = WILC_SUCCESS;
7054 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7055 tstrHostIFmsg strHostIFmsg;
7056
7057 if (pstrWFIDrv == NULL)
7058 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7059
7060 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7061
7062 /* prepare the WiphyParams Message */
7063 strHostIFmsg.u16MsgId = HOST_IF_MSG_REGISTER_FRAME;
7064 switch (u16FrameType) {
7065 case ACTION:
7066 PRINT_D(HOSTINF_DBG, "ACTION\n");
7067 strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.u8Regid = ACTION_FRM_IDX;
7068 break;
7069
7070 case PROBE_REQ:
7071 PRINT_D(HOSTINF_DBG, "PROBE REQ\n");
7072 strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.u8Regid = PROBE_REQ_IDX;
7073 break;
7074
7075 default:
7076 PRINT_D(HOSTINF_DBG, "Not valid frame type\n");
7077 break;
7078 }
7079 strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.u16FrameType = u16FrameType;
7080 strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.bReg = bReg;
7081 strHostIFmsg.drvHandler = hWFIDrv;
7082
7083 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7084 if (s32Error)
7085 WILC_ERRORREPORT(s32Error, s32Error);
7086 WILC_CATCH(s32Error)
7087 {
7088
7089 }
7090
7091 return s32Error;
7092
7093
7094 }
7095 #endif
7096
7097 #ifdef WILC_AP_EXTERNAL_MLME
7098 /**
7099 * @brief host_int_add_beacon
7100 * @details Setting add beacon params in message queue
7101 * @param[in] WILC_WFIDrvHandle hWFIDrv, u32 u32Interval,
7102 * u32 u32DTIMPeriod,u32 u32HeadLen, u8* pu8Head,
7103 * u32 u32TailLen, u8* pu8Tail
7104 * @return Error code.
7105 * @author
7106 * @date
7107 * @version 1.0
7108 */
7109 s32 host_int_add_beacon(WILC_WFIDrvHandle hWFIDrv, u32 u32Interval,
7110 u32 u32DTIMPeriod,
7111 u32 u32HeadLen, u8 *pu8Head,
7112 u32 u32TailLen, u8 *pu8Tail)
7113 {
7114 s32 s32Error = WILC_SUCCESS;
7115 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7116 tstrHostIFmsg strHostIFmsg;
7117 tstrHostIFSetBeacon *pstrSetBeaconParam = &strHostIFmsg.uniHostIFmsgBody.strHostIFSetBeacon;
7118
7119 if (pstrWFIDrv == NULL)
7120 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7121
7122 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7123
7124 PRINT_D(HOSTINF_DBG, "Setting adding beacon message queue params\n");
7125
7126
7127 /* prepare the WiphyParams Message */
7128 strHostIFmsg.u16MsgId = HOST_IF_MSG_ADD_BEACON;
7129 strHostIFmsg.drvHandler = hWFIDrv;
7130 pstrSetBeaconParam->u32Interval = u32Interval;
7131 pstrSetBeaconParam->u32DTIMPeriod = u32DTIMPeriod;
7132 pstrSetBeaconParam->u32HeadLen = u32HeadLen;
7133 pstrSetBeaconParam->pu8Head = (u8 *)WILC_MALLOC(u32HeadLen);
7134 if (pstrSetBeaconParam->pu8Head == NULL)
7135 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
7136 WILC_memcpy(pstrSetBeaconParam->pu8Head, pu8Head, u32HeadLen);
7137 pstrSetBeaconParam->u32TailLen = u32TailLen;
7138
7139 /* Bug 4599 : if tail length = 0 skip allocating & copying */
7140 if (u32TailLen > 0) {
7141 pstrSetBeaconParam->pu8Tail = (u8 *)WILC_MALLOC(u32TailLen);
7142 if (pstrSetBeaconParam->pu8Tail == NULL)
7143 WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
7144 WILC_memcpy(pstrSetBeaconParam->pu8Tail, pu8Tail, u32TailLen);
7145 } else {
7146 pstrSetBeaconParam->pu8Tail = NULL;
7147 }
7148
7149 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7150 if (s32Error)
7151 WILC_ERRORREPORT(s32Error, s32Error);
7152
7153 WILC_CATCH(s32Error)
7154 {
7155 if (pstrSetBeaconParam->pu8Head != NULL)
7156 WILC_FREE(pstrSetBeaconParam->pu8Head);
7157
7158 if (pstrSetBeaconParam->pu8Tail != NULL)
7159 WILC_FREE(pstrSetBeaconParam->pu8Tail);
7160 }
7161
7162 return s32Error;
7163
7164 }
7165
7166
7167 /**
7168 * @brief host_int_del_beacon
7169 * @details Setting add beacon params in message queue
7170 * @param[in] WILC_WFIDrvHandle hWFIDrv
7171 * @return Error code.
7172 * @author
7173 * @date
7174 * @version 1.0
7175 */
7176 s32 host_int_del_beacon(WILC_WFIDrvHandle hWFIDrv)
7177 {
7178 s32 s32Error = WILC_SUCCESS;
7179 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7180 tstrHostIFmsg strHostIFmsg;
7181
7182 if (pstrWFIDrv == NULL)
7183 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7184
7185 /* prepare the WiphyParams Message */
7186 strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_BEACON;
7187 strHostIFmsg.drvHandler = hWFIDrv;
7188 PRINT_D(HOSTINF_DBG, "Setting deleting beacon message queue params\n");
7189
7190 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7191 WILC_ERRORCHECK(s32Error);
7192
7193 WILC_CATCH(s32Error)
7194 {
7195 }
7196 return s32Error;
7197 }
7198
7199
7200 /**
7201 * @brief host_int_add_station
7202 * @details Setting add station params in message queue
7203 * @param[in] WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam* pstrStaParams
7204 * @return Error code.
7205 * @author
7206 * @date
7207 * @version 1.0
7208 */
7209 s32 host_int_add_station(WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam *pstrStaParams)
7210 {
7211 s32 s32Error = WILC_SUCCESS;
7212 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7213 tstrHostIFmsg strHostIFmsg;
7214 tstrWILC_AddStaParam *pstrAddStationMsg = &strHostIFmsg.uniHostIFmsgBody.strAddStaParam;
7215
7216
7217 if (pstrWFIDrv == NULL)
7218 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7219
7220 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7221
7222 PRINT_D(HOSTINF_DBG, "Setting adding station message queue params\n");
7223
7224
7225 /* prepare the WiphyParams Message */
7226 strHostIFmsg.u16MsgId = HOST_IF_MSG_ADD_STATION;
7227 strHostIFmsg.drvHandler = hWFIDrv;
7228
7229 WILC_memcpy(pstrAddStationMsg, pstrStaParams, sizeof(tstrWILC_AddStaParam));
7230 if (pstrAddStationMsg->u8NumRates > 0) {
7231 u8 *rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates);
7232
7233 WILC_NULLCHECK(s32Error, rates);
7234
7235 WILC_memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
7236 pstrAddStationMsg->pu8Rates = rates;
7237 }
7238
7239
7240 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7241 if (s32Error)
7242 WILC_ERRORREPORT(s32Error, s32Error);
7243
7244 WILC_CATCH(s32Error)
7245 {
7246 }
7247 return s32Error;
7248 }
7249
7250 /**
7251 * @brief host_int_del_station
7252 * @details Setting delete station params in message queue
7253 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8MacAddr
7254 * @return Error code.
7255 * @author
7256 * @date
7257 * @version 1.0
7258 */
7259 s32 host_int_del_station(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8MacAddr)
7260 {
7261 s32 s32Error = WILC_SUCCESS;
7262 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7263 tstrHostIFmsg strHostIFmsg;
7264 tstrHostIFDelSta *pstrDelStationMsg = &strHostIFmsg.uniHostIFmsgBody.strDelStaParam;
7265
7266 if (pstrWFIDrv == NULL)
7267 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7268
7269 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7270
7271 PRINT_D(HOSTINF_DBG, "Setting deleting station message queue params\n");
7272
7273
7274
7275 /* prepare the WiphyParams Message */
7276 strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_STATION;
7277 strHostIFmsg.drvHandler = hWFIDrv;
7278
7279 /*BugID_4795: Handling situation of deleting all stations*/
7280 if (pu8MacAddr == NULL)
7281 WILC_memset(pstrDelStationMsg->au8MacAddr, 255, ETH_ALEN);
7282 else
7283 WILC_memcpy(pstrDelStationMsg->au8MacAddr, pu8MacAddr, ETH_ALEN);
7284
7285 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7286 if (s32Error)
7287 WILC_ERRORREPORT(s32Error, s32Error);
7288
7289 WILC_CATCH(s32Error)
7290 {
7291 }
7292 return s32Error;
7293 }
7294 /**
7295 * @brief host_int_del_allstation
7296 * @details Setting del station params in message queue
7297 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN]s
7298 * @return Error code.
7299 * @author
7300 * @date
7301 * @version 1.0
7302 */
7303 s32 host_int_del_allstation(WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN])
7304 {
7305 s32 s32Error = WILC_SUCCESS;
7306 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7307 tstrHostIFmsg strHostIFmsg;
7308 tstrHostIFDelAllSta *pstrDelAllStationMsg = &strHostIFmsg.uniHostIFmsgBody.strHostIFDelAllSta;
7309 u8 au8Zero_Buff[ETH_ALEN] = {0};
7310 u32 i;
7311 u8 u8AssocNumb = 0;
7312
7313
7314 if (pstrWFIDrv == NULL)
7315 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7316
7317 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7318
7319 PRINT_D(HOSTINF_DBG, "Setting deauthenticating station message queue params\n");
7320
7321 /* prepare the WiphyParams Message */
7322 strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_ALL_STA;
7323 strHostIFmsg.drvHandler = hWFIDrv;
7324
7325 /* Handling situation of deauthenticing all associated stations*/
7326 for (i = 0; i < MAX_NUM_STA; i++) {
7327 if (memcmp(pu8MacAddr[i], au8Zero_Buff, ETH_ALEN)) {
7328 WILC_memcpy(pstrDelAllStationMsg->au8Sta_DelAllSta[i], pu8MacAddr[i], ETH_ALEN);
7329 PRINT_D(CFG80211_DBG, "BSSID = %x%x%x%x%x%x\n", pstrDelAllStationMsg->au8Sta_DelAllSta[i][0], pstrDelAllStationMsg->au8Sta_DelAllSta[i][1], pstrDelAllStationMsg->au8Sta_DelAllSta[i][2], pstrDelAllStationMsg->au8Sta_DelAllSta[i][3], pstrDelAllStationMsg->au8Sta_DelAllSta[i][4],
7330 pstrDelAllStationMsg->au8Sta_DelAllSta[i][5]);
7331 u8AssocNumb++;
7332 }
7333 }
7334 if (!u8AssocNumb) {
7335 PRINT_D(CFG80211_DBG, "NO ASSOCIATED STAS\n");
7336 return s32Error;
7337 }
7338
7339 pstrDelAllStationMsg->u8Num_AssocSta = u8AssocNumb;
7340 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7341
7342
7343 if (s32Error)
7344 WILC_ERRORREPORT(s32Error, s32Error);
7345
7346 WILC_CATCH(s32Error)
7347 {
7348
7349 }
7350 down(&hWaitResponse);
7351
7352 return s32Error;
7353
7354 }
7355
7356 /**
7357 * @brief host_int_edit_station
7358 * @details Setting edit station params in message queue
7359 * @param[in] WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam* pstrStaParams
7360 * @return Error code.
7361 * @author
7362 * @date
7363 * @version 1.0
7364 */
7365 s32 host_int_edit_station(WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam *pstrStaParams)
7366 {
7367 s32 s32Error = WILC_SUCCESS;
7368 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7369 tstrHostIFmsg strHostIFmsg;
7370 tstrWILC_AddStaParam *pstrAddStationMsg = &strHostIFmsg.uniHostIFmsgBody.strAddStaParam;
7371
7372 if (pstrWFIDrv == NULL)
7373 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7374
7375 PRINT_D(HOSTINF_DBG, "Setting editing station message queue params\n");
7376
7377 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7378
7379
7380 /* prepare the WiphyParams Message */
7381 strHostIFmsg.u16MsgId = HOST_IF_MSG_EDIT_STATION;
7382 strHostIFmsg.drvHandler = hWFIDrv;
7383
7384 WILC_memcpy(pstrAddStationMsg, pstrStaParams, sizeof(tstrWILC_AddStaParam));
7385 if (pstrAddStationMsg->u8NumRates > 0) {
7386 u8 *rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates);
7387
7388 WILC_NULLCHECK(s32Error, rates);
7389 WILC_memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
7390 pstrAddStationMsg->pu8Rates = rates;
7391 }
7392
7393 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7394 if (s32Error)
7395 WILC_ERRORREPORT(s32Error, s32Error);
7396 WILC_CATCH(s32Error)
7397 {
7398 }
7399 return s32Error;
7400 }
7401 #endif /*WILC_AP_EXTERNAL_MLME*/
7402 uint32_t wilc_get_chipid(uint8_t);
7403
7404 s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32Timeout)
7405 {
7406 s32 s32Error = WILC_SUCCESS;
7407 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7408 tstrHostIFmsg strHostIFmsg;
7409 tstrHostIfPowerMgmtParam *pstrPowerMgmtParam = &strHostIFmsg.uniHostIFmsgBody.strPowerMgmtparam;
7410
7411 PRINT_INFO(HOSTINF_DBG, "\n\n>> Setting PS to %d <<\n\n", bIsEnabled);
7412
7413 if (pstrWFIDrv == NULL)
7414 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7415
7416 PRINT_D(HOSTINF_DBG, "Setting Power management message queue params\n");
7417
7418 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7419
7420
7421 /* prepare the WiphyParams Message */
7422 strHostIFmsg.u16MsgId = HOST_IF_MSG_POWER_MGMT;
7423 strHostIFmsg.drvHandler = hWFIDrv;
7424
7425 pstrPowerMgmtParam->bIsEnabled = bIsEnabled;
7426 pstrPowerMgmtParam->u32Timeout = u32Timeout;
7427
7428
7429 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7430 if (s32Error)
7431 WILC_ERRORREPORT(s32Error, s32Error);
7432 WILC_CATCH(s32Error)
7433 {
7434 }
7435 return s32Error;
7436 }
7437
7438 s32 host_int_setup_multicast_filter(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32count)
7439 {
7440 s32 s32Error = WILC_SUCCESS;
7441
7442 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7443 tstrHostIFmsg strHostIFmsg;
7444 tstrHostIFSetMulti *pstrMulticastFilterParam = &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMulti;
7445
7446
7447 if (pstrWFIDrv == NULL)
7448 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7449
7450 PRINT_D(HOSTINF_DBG, "Setting Multicast Filter params\n");
7451
7452 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7453
7454
7455 /* prepare the WiphyParams Message */
7456 strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_MULTICAST_FILTER;
7457 strHostIFmsg.drvHandler = hWFIDrv;
7458
7459 pstrMulticastFilterParam->bIsEnabled = bIsEnabled;
7460 pstrMulticastFilterParam->u32count = u32count;
7461
7462 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7463 if (s32Error)
7464 WILC_ERRORREPORT(s32Error, s32Error);
7465 WILC_CATCH(s32Error)
7466 {
7467 }
7468 return s32Error;
7469 }
7470
7471
7472
7473 /*Bug4218: Parsing Join Param*/
7474 #ifdef WILC_PARSE_SCAN_IN_HOST
7475
7476 /*Bug4218: Parsing Join Param*/
7477 /**
7478 * @brief host_int_ParseJoinBssParam
7479 * @details Parse Needed Join Parameters and save it in a new JoinBssParam entry
7480 * @param[in] tstrNetworkInfo* ptstrNetworkInfo
7481 * @return
7482 * @author zsalah
7483 * @date
7484 * @version 1.0**/
7485 static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo)
7486 {
7487 tstrJoinBssParam *pNewJoinBssParam = NULL;
7488 u8 *pu8IEs;
7489 u16 u16IEsLen;
7490 u16 index = 0;
7491 u8 suppRatesNo = 0;
7492 u8 extSuppRatesNo;
7493 u16 jumpOffset;
7494 u8 pcipherCount;
7495 u8 authCount;
7496 u8 pcipherTotalCount = 0;
7497 u8 authTotalCount = 0;
7498 u8 i, j;
7499
7500 pu8IEs = ptstrNetworkInfo->pu8IEs;
7501 u16IEsLen = ptstrNetworkInfo->u16IEsLen;
7502
7503 pNewJoinBssParam = WILC_MALLOC(sizeof(tstrJoinBssParam));
7504 if (pNewJoinBssParam != NULL) {
7505 WILC_memset(pNewJoinBssParam, 0, sizeof(tstrJoinBssParam));
7506 pNewJoinBssParam->dtim_period = ptstrNetworkInfo->u8DtimPeriod;
7507 pNewJoinBssParam->beacon_period = ptstrNetworkInfo->u16BeaconPeriod;
7508 pNewJoinBssParam->cap_info = ptstrNetworkInfo->u16CapInfo;
7509 WILC_memcpy(pNewJoinBssParam->au8bssid, ptstrNetworkInfo->au8bssid, 6);
7510 /*for(i=0; i<6;i++)
7511 * PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->au8bssid[i]);*/
7512 WILC_memcpy((u8 *)pNewJoinBssParam->ssid, ptstrNetworkInfo->au8ssid, ptstrNetworkInfo->u8SsidLen + 1);
7513 pNewJoinBssParam->ssidLen = ptstrNetworkInfo->u8SsidLen;
7514 WILC_memset(pNewJoinBssParam->rsn_pcip_policy, 0xFF, 3);
7515 WILC_memset(pNewJoinBssParam->rsn_auth_policy, 0xFF, 3);
7516 /*for(i=0; i<pNewJoinBssParam->ssidLen;i++)
7517 * PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->ssid[i]);*/
7518
7519 /* parse supported rates: */
7520 while (index < u16IEsLen) {
7521 /* supportedRates IE */
7522 if (pu8IEs[index] == SUPP_RATES_IE) {
7523 /* PRINT_D(HOSTINF_DBG, "Supported Rates\n"); */
7524 suppRatesNo = pu8IEs[index + 1];
7525 pNewJoinBssParam->supp_rates[0] = suppRatesNo;
7526 index += 2; /* skipping ID and length bytes; */
7527
7528 for (i = 0; i < suppRatesNo; i++) {
7529 pNewJoinBssParam->supp_rates[i + 1] = pu8IEs[index + i];
7530 /* PRINT_D(HOSTINF_DBG,"%0x ",pNewJoinBssParam->supp_rates[i+1]); */
7531 }
7532 index += suppRatesNo;
7533 continue;
7534 }
7535 /* Ext SupportedRates IE */
7536 else if (pu8IEs[index] == EXT_SUPP_RATES_IE) {
7537 /* PRINT_D(HOSTINF_DBG, "Extended Supported Rates\n"); */
7538 /* checking if no of ext. supp and supp rates < max limit */
7539 extSuppRatesNo = pu8IEs[index + 1];
7540 if (extSuppRatesNo > (MAX_RATES_SUPPORTED - suppRatesNo))
7541 pNewJoinBssParam->supp_rates[0] = MAX_RATES_SUPPORTED;
7542 else
7543 pNewJoinBssParam->supp_rates[0] += extSuppRatesNo;
7544 index += 2;
7545 /* pNewJoinBssParam.supp_rates[0] contains now old number not the ext. no */
7546 for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++) {
7547 pNewJoinBssParam->supp_rates[suppRatesNo + i + 1] = pu8IEs[index + i];
7548 /* PRINT_D(HOSTINF_DBG,"%0x ",pNewJoinBssParam->supp_rates[suppRatesNo+i+1]); */
7549 }
7550 index += extSuppRatesNo;
7551 continue;
7552 }
7553 /* HT Cap. IE */
7554 else if (pu8IEs[index] == HT_CAPABILITY_IE) {
7555 /* if IE found set the flag */
7556 pNewJoinBssParam->ht_capable = true;
7557 index += pu8IEs[index + 1] + 2; /* ID,Length bytes and IE body */
7558 /* PRINT_D(HOSTINF_DBG,"HT_CAPABALE\n"); */
7559 continue;
7560 } else if ((pu8IEs[index] == WMM_IE) && /* WMM Element ID */
7561 (pu8IEs[index + 2] == 0x00) && (pu8IEs[index + 3] == 0x50) &&
7562 (pu8IEs[index + 4] == 0xF2) && /* OUI */
7563 (pu8IEs[index + 5] == 0x02) && /* OUI Type */
7564 ((pu8IEs[index + 6] == 0x00) || (pu8IEs[index + 6] == 0x01)) && /* OUI Sub Type */
7565 (pu8IEs[index + 7] == 0x01)) {
7566 /* Presence of WMM Info/Param element indicates WMM capability */
7567 pNewJoinBssParam->wmm_cap = true;
7568
7569 /* Check if Bit 7 is set indicating U-APSD capability */
7570 if (pu8IEs[index + 8] & (1 << 7))
7571 pNewJoinBssParam->uapsd_cap = true;
7572 index += pu8IEs[index + 1] + 2;
7573 continue;
7574 }
7575 #ifdef WILC_P2P
7576 else if ((pu8IEs[index] == P2P_IE) && /* P2P Element ID */
7577 (pu8IEs[index + 2] == 0x50) && (pu8IEs[index + 3] == 0x6f) &&
7578 (pu8IEs[index + 4] == 0x9a) && /* OUI */
7579 (pu8IEs[index + 5] == 0x09) && (pu8IEs[index + 6] == 0x0c)) { /* OUI Type */
7580 u16 u16P2P_count;
7581
7582 pNewJoinBssParam->tsf = ptstrNetworkInfo->u32Tsf;
7583 pNewJoinBssParam->u8NoaEnbaled = 1;
7584 pNewJoinBssParam->u8Index = pu8IEs[index + 9];
7585
7586 /* Check if Bit 7 is set indicating Opss capability */
7587 if (pu8IEs[index + 10] & (1 << 7)) {
7588 pNewJoinBssParam->u8OppEnable = 1;
7589 pNewJoinBssParam->u8CtWindow = pu8IEs[index + 10];
7590 } else
7591 pNewJoinBssParam->u8OppEnable = 0;
7592 /* HOSTINF_DBG */
7593 PRINT_D(GENERIC_DBG, "P2P Dump\n");
7594 for (i = 0; i < pu8IEs[index + 7]; i++)
7595 PRINT_D(GENERIC_DBG, " %x\n", pu8IEs[index + 9 + i]);
7596
7597 pNewJoinBssParam->u8Count = pu8IEs[index + 11];
7598 u16P2P_count = index + 12;
7599
7600 WILC_memcpy(pNewJoinBssParam->au8Duration, pu8IEs + u16P2P_count, 4);
7601 u16P2P_count += 4;
7602
7603 WILC_memcpy(pNewJoinBssParam->au8Interval, pu8IEs + u16P2P_count, 4);
7604 u16P2P_count += 4;
7605
7606 WILC_memcpy(pNewJoinBssParam->au8StartTime, pu8IEs + u16P2P_count, 4);
7607
7608 index += pu8IEs[index + 1] + 2;
7609 continue;
7610
7611 }
7612 #endif
7613 else if ((pu8IEs[index] == RSN_IE) ||
7614 ((pu8IEs[index] == WPA_IE) && (pu8IEs[index + 2] == 0x00) &&
7615 (pu8IEs[index + 3] == 0x50) && (pu8IEs[index + 4] == 0xF2) &&
7616 (pu8IEs[index + 5] == 0x01))) {
7617 u16 rsnIndex = index;
7618 /*PRINT_D(HOSTINF_DBG,"RSN IE Length:%d\n",pu8IEs[rsnIndex+1]);
7619 * for(i=0; i<pu8IEs[rsnIndex+1]; i++)
7620 * {
7621 * PRINT_D(HOSTINF_DBG,"%0x ",pu8IEs[rsnIndex+2+i]);
7622 * }*/
7623 if (pu8IEs[rsnIndex] == RSN_IE) {
7624 pNewJoinBssParam->mode_802_11i = 2;
7625 /* PRINT_D(HOSTINF_DBG,"\nRSN_IE\n"); */
7626 } else { /* check if rsn was previously parsed */
7627 if (pNewJoinBssParam->mode_802_11i == 0)
7628 pNewJoinBssParam->mode_802_11i = 1;
7629 /* PRINT_D(HOSTINF_DBG,"\nWPA_IE\n"); */
7630 rsnIndex += 4;
7631 }
7632 rsnIndex += 7; /* skipping id, length, version(2B) and first 3 bytes of gcipher */
7633 pNewJoinBssParam->rsn_grp_policy = pu8IEs[rsnIndex];
7634 rsnIndex++;
7635 /* PRINT_D(HOSTINF_DBG,"Group Policy: %0x\n",pNewJoinBssParam->rsn_grp_policy); */
7636 /* initialize policies with invalid values */
7637
7638 jumpOffset = pu8IEs[rsnIndex] * 4; /* total no.of bytes of pcipher field (count*4) */
7639
7640 /*parsing pairwise cipher*/
7641
7642 /* saving 3 pcipher max. */
7643 pcipherCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
7644 rsnIndex += 2; /* jump 2 bytes of pcipher count */
7645
7646 /* PRINT_D(HOSTINF_DBG,"\npcipher:%d\n",pcipherCount); */
7647 for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++) {
7648 /* each count corresponds to 4 bytes, only last byte is saved */
7649 pNewJoinBssParam->rsn_pcip_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
7650 /* PRINT_D(HOSTINF_DBG,"PAIR policy = [%0x,%0x]\n",pNewJoinBssParam->rsn_pcip_policy[i],i); */
7651 }
7652 pcipherTotalCount += pcipherCount;
7653 rsnIndex += jumpOffset;
7654
7655 jumpOffset = pu8IEs[rsnIndex] * 4;
7656
7657 /*parsing AKM suite (auth_policy)*/
7658 /* saving 3 auth policies max. */
7659 authCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
7660 rsnIndex += 2; /* jump 2 bytes of pcipher count */
7661
7662 for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++) {
7663 /* each count corresponds to 4 bytes, only last byte is saved */
7664 pNewJoinBssParam->rsn_auth_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
7665 }
7666 authTotalCount += authCount;
7667 rsnIndex += jumpOffset;
7668 /*pasring rsn cap. only if rsn IE*/
7669 if (pu8IEs[index] == RSN_IE) {
7670 pNewJoinBssParam->rsn_cap[0] = pu8IEs[rsnIndex];
7671 pNewJoinBssParam->rsn_cap[1] = pu8IEs[rsnIndex + 1];
7672 rsnIndex += 2;
7673 }
7674 pNewJoinBssParam->rsn_found = true;
7675 index += pu8IEs[index + 1] + 2; /* ID,Length bytes and IE body */
7676 continue;
7677 } else
7678 index += pu8IEs[index + 1] + 2; /* ID,Length bytes and IE body */
7679
7680 }
7681
7682
7683 }
7684
7685 return (void *)pNewJoinBssParam;
7686
7687 }
7688
7689 void host_int_freeJoinParams(void *pJoinParams)
7690 {
7691 if ((tstrJoinBssParam *)pJoinParams != NULL)
7692 WILC_FREE((tstrJoinBssParam *)pJoinParams);
7693 else
7694 PRINT_ER("Unable to FREE null pointer\n");
7695 }
7696 #endif /*WILC_PARSE_SCAN_IN_HOST*/
7697
7698
7699 /**
7700 * @brief host_int_addBASession
7701 * @details Open a block Ack session with the given parameters
7702 * @param[in] tstrNetworkInfo* ptstrNetworkInfo
7703 * @return
7704 * @author anoureldin
7705 * @date
7706 * @version 1.0**/
7707
7708 static int host_int_addBASession(WILC_WFIDrvHandle hWFIDrv, char *pBSSID, char TID, short int BufferSize,
7709 short int SessionTimeout, void *drvHandler)
7710 {
7711 s32 s32Error = WILC_SUCCESS;
7712 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7713 tstrHostIFmsg strHostIFmsg;
7714 tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo;
7715
7716 if (pstrWFIDrv == NULL)
7717 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7718
7719 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7720
7721 /* prepare the WiphyParams Message */
7722 strHostIFmsg.u16MsgId = HOST_IF_MSG_ADD_BA_SESSION;
7723
7724 memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN);
7725 pBASessionInfo->u8Ted = TID;
7726 pBASessionInfo->u16BufferSize = BufferSize;
7727 pBASessionInfo->u16SessionTimeout = SessionTimeout;
7728 strHostIFmsg.drvHandler = hWFIDrv;
7729
7730 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7731 if (s32Error)
7732 WILC_ERRORREPORT(s32Error, s32Error);
7733 WILC_CATCH(s32Error)
7734 {
7735
7736 }
7737
7738 return s32Error;
7739 }
7740
7741
7742 s32 host_int_delBASession(WILC_WFIDrvHandle hWFIDrv, char *pBSSID, char TID)
7743 {
7744 s32 s32Error = WILC_SUCCESS;
7745 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7746 tstrHostIFmsg strHostIFmsg;
7747 tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo;
7748
7749 if (pstrWFIDrv == NULL)
7750 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7751
7752 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7753
7754 /* prepare the WiphyParams Message */
7755 strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_BA_SESSION;
7756
7757 memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN);
7758 pBASessionInfo->u8Ted = TID;
7759 strHostIFmsg.drvHandler = hWFIDrv;
7760
7761 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7762 if (s32Error)
7763 WILC_ERRORREPORT(s32Error, s32Error);
7764 WILC_CATCH(s32Error)
7765 {
7766
7767 }
7768
7769 /*BugID_5222*/
7770 down(&hWaitResponse);
7771
7772 return s32Error;
7773 }
7774
7775 s32 host_int_del_All_Rx_BASession(WILC_WFIDrvHandle hWFIDrv, char *pBSSID, char TID)
7776 {
7777 s32 s32Error = WILC_SUCCESS;
7778 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7779 tstrHostIFmsg strHostIFmsg;
7780 tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo;
7781
7782 if (pstrWFIDrv == NULL)
7783 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7784
7785 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7786
7787 /* prepare the WiphyParams Message */
7788 strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS;
7789
7790 memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN);
7791 pBASessionInfo->u8Ted = TID;
7792 strHostIFmsg.drvHandler = hWFIDrv;
7793
7794 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7795 if (s32Error)
7796 WILC_ERRORREPORT(s32Error, s32Error);
7797 WILC_CATCH(s32Error)
7798 {
7799
7800 }
7801
7802 /*BugID_5222*/
7803 down(&hWaitResponse);
7804
7805 return s32Error;
7806 }
7807
7808 /**
7809 * @brief host_int_setup_ipaddress
7810 * @details setup IP in firmware
7811 * @param[in] Handle to wifi driver
7812 * @return Error code.
7813 * @author Abdelrahman Sobhy
7814 * @date
7815 * @version 1.0*/
7816 s32 host_int_setup_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *u16ipadd, u8 idx)
7817 {
7818 s32 s32Error = WILC_SUCCESS;
7819 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7820 tstrHostIFmsg strHostIFmsg;
7821
7822 /* TODO: Enable This feature on softap firmware */
7823 return 0;
7824
7825 if (pstrWFIDrv == NULL)
7826 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7827
7828 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7829
7830 /* prepare the WiphyParams Message */
7831 strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_IPADDRESS;
7832
7833 strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr = u16ipadd;
7834 strHostIFmsg.drvHandler = hWFIDrv;
7835 strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx = idx;
7836
7837 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7838 if (s32Error)
7839 WILC_ERRORREPORT(s32Error, s32Error);
7840 WILC_CATCH(s32Error)
7841 {
7842
7843 }
7844
7845 return s32Error;
7846
7847
7848 }
7849
7850 /**
7851 * @brief host_int_get_ipaddress
7852 * @details Get IP from firmware
7853 * @param[in] Handle to wifi driver
7854 * @return Error code.
7855 * @author Abdelrahman Sobhy
7856 * @date
7857 * @version 1.0*/
7858 s32 host_int_get_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *u16ipadd, u8 idx)
7859 {
7860 s32 s32Error = WILC_SUCCESS;
7861 tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
7862 tstrHostIFmsg strHostIFmsg;
7863
7864 if (pstrWFIDrv == NULL)
7865 WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
7866
7867 WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
7868
7869 /* prepare the WiphyParams Message */
7870 strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_IPADDRESS;
7871
7872 strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr = u16ipadd;
7873 strHostIFmsg.drvHandler = hWFIDrv;
7874 strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx = idx;
7875
7876 s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
7877 if (s32Error)
7878 WILC_ERRORREPORT(s32Error, s32Error);
7879 WILC_CATCH(s32Error)
7880 {
7881
7882 }
7883
7884 return s32Error;
7885
7886
7887 }
Linux kernel - Deliverables
This page took 0.409881 seconds and 6 git commands to generate.