1 #include "host_interface.h"
2 #include "coreconfigurator.h"
4 extern s32
TransportInit(void);
5 extern s32
TransportDeInit(void);
8 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
9 extern WILC_TimerHandle hDuringIpTimer
;
13 extern u8 g_wilc_initialized
;
14 /*****************************************************************************/
16 /*****************************************************************************/
18 /* Message types of the Host IF Message Queue*/
19 #define HOST_IF_MSG_SCAN 0
20 #define HOST_IF_MSG_CONNECT 1
21 #define HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO 2
22 #define HOST_IF_MSG_KEY 3
23 #define HOST_IF_MSG_RCVD_NTWRK_INFO 4
24 #define HOST_IF_MSG_RCVD_SCAN_COMPLETE 5
25 #define HOST_IF_MSG_CFG_PARAMS 6
26 #define HOST_IF_MSG_SET_CHANNEL 7
27 #define HOST_IF_MSG_DISCONNECT 8
28 #define HOST_IF_MSG_GET_RSSI 9
29 #define HOST_IF_MSG_GET_CHNL 10
30 #define HOST_IF_MSG_ADD_BEACON 11
31 #define HOST_IF_MSG_DEL_BEACON 12
32 #define HOST_IF_MSG_ADD_STATION 13
33 #define HOST_IF_MSG_DEL_STATION 14
34 #define HOST_IF_MSG_EDIT_STATION 15
35 #define HOST_IF_MSG_SCAN_TIMER_FIRED 16
36 #define HOST_IF_MSG_CONNECT_TIMER_FIRED 17
37 #define HOST_IF_MSG_POWER_MGMT 18
38 #define HOST_IF_MSG_GET_INACTIVETIME 19
39 #define HOST_IF_MSG_REMAIN_ON_CHAN 20
40 #define HOST_IF_MSG_REGISTER_FRAME 21
41 #define HOST_IF_MSG_LISTEN_TIMER_FIRED 22
42 #define HOST_IF_MSG_GET_LINKSPEED 23
43 #define HOST_IF_MSG_SET_WFIDRV_HANDLER 24
44 #define HOST_IF_MSG_SET_MAC_ADDRESS 25
45 #define HOST_IF_MSG_GET_MAC_ADDRESS 26
46 #define HOST_IF_MSG_SET_OPERATION_MODE 27
47 #define HOST_IF_MSG_SET_IPADDRESS 28
48 #define HOST_IF_MSG_GET_IPADDRESS 29
49 #define HOST_IF_MSG_FLUSH_CONNECT 30
50 #define HOST_IF_MSG_GET_STATISTICS 31
51 #define HOST_IF_MSG_SET_MULTICAST_FILTER 32
52 #define HOST_IF_MSG_ADD_BA_SESSION 33
53 #define HOST_IF_MSG_DEL_BA_SESSION 34
54 #define HOST_IF_MSG_Q_IDLE 35
55 #define HOST_IF_MSG_DEL_ALL_STA 36
56 #define HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS 34
57 #define HOST_IF_MSG_EXIT 100
59 #define HOST_IF_SCAN_TIMEOUT 4000
60 #define HOST_IF_CONNECT_TIMEOUT 9500
62 #define BA_SESSION_DEFAULT_BUFFER_SIZE 16
63 #define BA_SESSION_DEFAULT_TIMEOUT 1000
64 #define BLOCK_ACK_REQ_SIZE 0x14
65 /*****************************************************************************/
66 /* Type Definitions */
67 /*****************************************************************************/
70 * @struct tstrHostIFCfgParamAttr
71 * @brief Structure to hold Host IF CFG Params Attributes
75 * @author Mai Daftedar
79 typedef struct _tstrHostIFCfgParamAttr
{
80 tstrCfgParamVal pstrCfgParamVal
;
82 } tstrHostIFCfgParamAttr
;
85 * @struct tstrHostIFwpaAttr
86 * @brief Structure to hold Host IF Scan Attributes
90 * @author Mai Daftedar
94 typedef struct _tstrHostIFwpaAttr
{
106 * @struct tstrHostIFwepAttr
107 * @brief Structure to hold Host IF Scan Attributes
111 * @author Mai Daftedar
112 * @date 25 March 2012
115 typedef struct _tstrHostIFwepAttr
{
120 AUTHTYPE_T tenuAuth_type
;
125 * @struct tuniHostIFkeyAttr
126 * @brief Structure to hold Host IF Scan Attributes
130 * @author Mai Daftedar
131 * @date 25 March 2012
134 typedef union _tuniHostIFkeyAttr
{
135 tstrHostIFwepAttr strHostIFwepAttr
;
136 tstrHostIFwpaAttr strHostIFwpaAttr
;
137 tstrHostIFpmkidAttr strHostIFpmkidAttr
;
141 * @struct tstrHostIFkeyAttr
142 * @brief Structure to hold Host IF Scan Attributes
146 * @author Mai Daftedar
147 * @date 25 March 2012
150 typedef struct _tstrHostIFkeyAttr
{
151 tenuKeyType enuKeyType
;
153 tuniHostIFkeyAttr uniHostIFkeyAttr
;
160 * @struct tstrHostIFscanAttr
161 * @brief Structure to hold Host IF Scan Attributes
165 * @author Mostafa Abu Bakr
166 * @date 25 March 2012
169 typedef struct _tstrHostIFscanAttr
{
176 tWILCpfScanResult pfScanResult
;
179 tstrHiddenNetwork strHiddenNetwork
;
181 } tstrHostIFscanAttr
;
184 * @struct tstrHostIFconnectAttr
185 * @brief Structure to hold Host IF Connect Attributes
189 * @author Mostafa Abu Bakr
190 * @date 25 March 2012
193 typedef struct _tstrHostIFconnectAttr
{
200 tWILCpfConnectResult pfConnectResult
;
202 AUTHTYPE_T tenuAuth_type
;
205 } tstrHostIFconnectAttr
;
208 * @struct tstrRcvdGnrlAsyncInfo
209 * @brief Structure to hold Received General Asynchronous info
213 * @author Mostafa Abu Bakr
214 * @date 25 March 2012
217 typedef struct _tstrRcvdGnrlAsyncInfo
{
220 } tstrRcvdGnrlAsyncInfo
;
223 * @struct tstrHostIFSetChan
224 * @brief Set Channel message body
228 * @author Mai Daftedar
229 * @date 25 March 2012
232 typedef struct _tstrHostIFSetChan
{
237 * @struct tstrHostIFSetChan
238 * @brief Get Channel message body
242 * @author Mai Daftedar
246 typedef struct _tstrHostIFGetChan
{
250 /*bug3819: Add Scan acomplete notification to host*/
252 * @struct tstrScanComplete
253 * @brief hold received Async. Scan Complete message body
258 * @date 25 March 2012
261 /*typedef struct _tstrScanComplete
265 * } tstrScanComplete;*/
268 * @struct tstrHostIFSetBeacon
269 * @brief Set Beacon message body
273 * @author Adham Abozaeid
277 typedef struct _tstrHostIFSetBeacon
{
278 u32 u32Interval
; /*!< Beacon Interval. Period between two successive beacons on air */
279 u32 u32DTIMPeriod
; /*!< DTIM Period. Indicates how many Beacon frames
280 * (including the current frame) appear before the next DTIM */
281 u32 u32HeadLen
; /*!< Length of the head buffer in bytes */
282 u8
*pu8Head
; /*!< Pointer to the beacon's head buffer. Beacon's head is the part
283 * from the beacon's start till the TIM element, NOT including the TIM */
284 u32 u32TailLen
; /*!< Length of the tail buffer in bytes */
285 u8
*pu8Tail
; /*!< Pointer to the beacon's tail buffer. Beacon's tail starts just
286 * after the TIM inormation element */
287 } tstrHostIFSetBeacon
;
292 * @struct tstrHostIFDelBeacon
293 * @brief Del Beacon message body
297 * @author Adham Abozaeid
301 typedef struct _tstrHostIFDelBeacon
{
303 } tstrHostIFDelBeacon
;
306 * @struct tstrHostIFSetMulti
307 * @brief set Multicast filter Address
311 * @author Abdelrahman Sobhy
312 * @date 30 August 2013
313 * @version 1.0 Description
319 } tstrHostIFSetMulti
;
322 * @struct tstrHostIFDelAllSta
323 * @brief Deauth station message body
327 * @author Mai Daftedar
328 * @date 09 April 2014
329 * @version 1.0 Description
333 u8 au8Sta_DelAllSta
[MAX_NUM_STA
][ETH_ALEN
];
335 } tstrHostIFDelAllSta
;
338 * @struct tstrHostIFDelSta
339 * @brief Delete station message body
343 * @author Adham Abozaeid
345 * @version 1.0 Description
349 u8 au8MacAddr
[ETH_ALEN
];
353 * @struct tstrTimerCb
354 * @brief Timer callback message body
358 * @author Mostafa Abu Bakr
359 * @date 25 March 2012
362 typedef struct _tstrTimerCb
{
363 void *pvUsrArg
; /*!< Private data passed at timer start */
367 * @struct tstrHostIfPowerMgmtParam
368 * @brief Power management message body
372 * @author Adham Abozaeid
373 * @date 24 November 2012
380 } tstrHostIfPowerMgmtParam
;
383 * @struct tstrHostIFSetIPAddr
384 * @brief set IP Address message body
388 * @author Abdelrahman Sobhy
389 * @date 30 August 2013
390 * @version 1.0 Description
396 } tstrHostIFSetIPAddr
;
399 * @struct tstrHostIfStaInactiveT
400 * @brief Get station message body
404 * @author Mai Daftedar
405 * @date 16 April 2013
411 } tstrHostIfStaInactiveT
;
414 * @union tuniHostIFmsgBody
415 * @brief Message body for the Host Interface message_q
419 * @author Mostafa Abu Bakr
420 * @date 25 March 2012
423 typedef union _tuniHostIFmsgBody
{
424 tstrHostIFscanAttr strHostIFscanAttr
; /*!< Host IF Scan Request Attributes message body */
425 tstrHostIFconnectAttr strHostIFconnectAttr
; /*!< Host IF Connect Request Attributes message body */
426 tstrRcvdNetworkInfo strRcvdNetworkInfo
; /*!< Received Asynchronous Network Info message body */
427 tstrRcvdGnrlAsyncInfo strRcvdGnrlAsyncInfo
; /*!< Received General Asynchronous Info message body */
428 tstrHostIFkeyAttr strHostIFkeyAttr
; /*!<>*/
429 tstrHostIFCfgParamAttr strHostIFCfgParamAttr
; /*! <CFG Parameter message Body> */
430 tstrHostIFSetChan strHostIFSetChan
;
431 tstrHostIFGetChan strHostIFGetChan
;
432 tstrHostIFSetBeacon strHostIFSetBeacon
; /*!< Set beacon message body */
433 tstrHostIFDelBeacon strHostIFDelBeacon
; /*!< Del beacon message body */
434 tstrWILC_AddStaParam strAddStaParam
; /*!< Add station message body */
435 tstrHostIFDelSta strDelStaParam
; /*!< Del Station message body */
436 tstrWILC_AddStaParam strEditStaParam
; /*!< Edit station message body */
437 /* tstrScanComplete strScanComplete; / *Received Async. Scan Complete message body* / */
438 tstrTimerCb strTimerCb
; /*!< Timer callback message body */
439 tstrHostIfPowerMgmtParam strPowerMgmtparam
; /*!< Power Management message body */
440 tstrHostIfStaInactiveT strHostIfStaInactiveT
;
441 tstrHostIFSetIPAddr strHostIfSetIP
;
442 tstrHostIfSetDrvHandler strHostIfSetDrvHandler
;
443 tstrHostIFSetMulti strHostIfSetMulti
;
444 tstrHostIfSetOperationMode strHostIfSetOperationMode
;
445 tstrHostIfSetMacAddress strHostIfSetMacAddress
;
446 tstrHostIfGetMacAddress strHostIfGetMacAddress
;
447 tstrHostIfBASessionInfo strHostIfBASessionInfo
;
449 tstrHostIfRemainOnChan strHostIfRemainOnChan
;
450 tstrHostIfRegisterFrame strHostIfRegisterFrame
;
453 tstrHostIFDelAllSta strHostIFDelAllSta
;
457 * @struct tstrHostIFmsg
458 * @brief Host Interface message
462 * @author Mostafa Abu Bakr
463 * @date 25 March 2012
466 typedef struct _tstrHostIFmsg
{
467 u16 u16MsgId
; /*!< Message ID */
468 tuniHostIFmsgBody uniHostIFmsgBody
; /*!< Message body */
469 tstrWILC_WFIDrv
*drvHandler
;
472 #ifdef CONNECT_DIRECT
473 typedef struct _tstrWidJoinReqExt
{
474 char SSID
[MAX_SSID_LEN
];
480 /*Bug4218: Parsing Join Param*/
481 #ifdef WILC_PARSE_SCAN_IN_HOST
482 /*Struct containg joinParam of each AP*/
483 typedef struct _tstrJoinBssParam
{
489 char ssid
[MAX_SSID_LEN
];
491 u8 supp_rates
[MAX_RATES_SUPPORTED
+ 1];
498 u8 rsn_pcip_policy
[3];
499 u8 rsn_auth_policy
[3];
501 struct _tstrJoinParam
*nextJoinBss
;
514 /*Bug4218: Parsing Join Param*/
515 /*a linked list table containing needed join parameters entries for each AP found in most recent scan*/
516 typedef struct _tstrBssTable
{
518 tstrJoinBssParam
*head
;
519 tstrJoinBssParam
*tail
;
521 #endif /*WILC_PARSE_SCAN_IN_HOST*/
526 SCAN_CONNECT_TIMER_FORCE_32BIT
= 0xFFFFFFFF
529 /*****************************************************************************/
531 /* Global Variabls */
533 /*****************************************************************************/
536 tstrWILC_WFIDrv
*terminated_handle
;
537 tstrWILC_WFIDrv
*gWFiDrvHandle
;
538 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
539 bool g_obtainingIP
= false;
542 static struct task_struct
*HostIFthreadHandler
;
543 static WILC_MsgQueueHandle gMsgQHostIF
;
544 static struct semaphore hSemHostIFthrdEnd
;
546 struct semaphore hSemDeinitDrvHandle
;
547 static struct semaphore hWaitResponse
;
548 struct semaphore hSemHostIntDeinit
;
549 WILC_TimerHandle g_hPeriodicRSSI
;
553 u8 gau8MulticastMacAddrList
[WILC_MULTICAST_TABLE_SIZE
][ETH_ALEN
];
555 #ifndef CONNECT_DIRECT
556 static u8 gapu8RcvdSurveyResults
[2][MAX_SURVEY_RESULT_FRAG_SIZE
];
559 static u8 gapu8RcvdAssocResp
[MAX_ASSOC_RESP_FRAME_SIZE
];
561 bool gbScanWhileConnected
= false;
566 static u8 gs8SetIP
[2][4];
567 static u8 gs8GetIP
[2][4];
568 #ifdef WILC_AP_EXTERNAL_MLME
569 static u32 gu32InactiveTime
;
572 static u32 gu32WidConnRstHack
;
575 u8
*gu8FlushedJoinReq
;
576 u8
*gu8FlushedInfoElemAsoc
;
577 u8 gu8Flushed11iMode
;
578 u8 gu8FlushedAuthType
;
579 u32 gu32FlushedJoinReqSize
;
580 u32 gu32FlushedInfoElemAsocSize
;
581 u32 gu8FlushedJoinReqDrvHandler
;
582 #define REAL_JOIN_REQ 0
583 #define FLUSHED_JOIN_REQ 1
584 #define FLUSHED_BYTE_POS 79 /* Position the byte indicating flushing in the flushed request */
586 /*Bug4218: Parsing Join Param*/
587 #ifdef WILC_PARSE_SCAN_IN_HOST
588 /*Bug4218: Parsing Join Param*/
589 static void *host_int_ParseJoinBssParam(tstrNetworkInfo
*ptstrNetworkInfo
);
590 #endif /*WILC_PARSE_SCAN_IN_HOST*/
592 extern void chip_sleep_manually(u32 u32SleepTime
);
593 extern int linux_wlan_get_num_conn_ifcs(void);
596 * @brief Handle_SetChannel
597 * @details Sending config packet to firmware to set channel
598 * @param[in] tstrHostIFSetChan* pstrHostIFSetChan
599 * @return Error code.
604 static s32
Handle_SetChannel(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFSetChan
*pstrHostIFSetChan
)
607 s32 s32Error
= WILC_SUCCESS
;
609 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
611 /*prepare configuration packet*/
612 strWID
.u16WIDid
= (u16
)WID_CURRENT_CHANNEL
;
613 strWID
.enuWIDtype
= WID_CHAR
;
614 strWID
.ps8WidVal
= (char *)&(pstrHostIFSetChan
->u8SetChan
);
615 strWID
.s32ValueSize
= sizeof(char);
617 PRINT_D(HOSTINF_DBG
, "Setting channel\n");
619 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
621 PRINT_ER("Failed to set channel\n");
622 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
632 * @brief Handle_SetWfiDrvHandler
633 * @details Sending config packet to firmware to set driver handler
634 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
635 * @return Error code.
640 static s32
Handle_SetWfiDrvHandler(tstrHostIfSetDrvHandler
*pstrHostIfSetDrvHandler
)
643 s32 s32Error
= WILC_SUCCESS
;
645 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)((pstrHostIfSetDrvHandler
->u32Address
));
648 /*prepare configuration packet*/
649 strWID
.u16WIDid
= (u16
)WID_SET_DRV_HANDLER
;
650 strWID
.enuWIDtype
= WID_INT
;
651 strWID
.ps8WidVal
= (s8
*)&(pstrHostIfSetDrvHandler
->u32Address
);
652 strWID
.s32ValueSize
= sizeof(u32
);
656 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
659 if ((pstrHostIfSetDrvHandler
->u32Address
) == (u32
)NULL
)
660 up(&hSemDeinitDrvHandle
);
664 PRINT_ER("Failed to set driver handler\n");
665 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
676 * @brief Handle_SetWfiAPDrvHandler
677 * @details Sending config packet to firmware to set driver handler
678 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
679 * @return Error code.
684 static s32
Handle_SetOperationMode(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfSetOperationMode
*pstrHostIfSetOperationMode
)
687 s32 s32Error
= WILC_SUCCESS
;
689 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
692 /*prepare configuration packet*/
693 strWID
.u16WIDid
= (u16
)WID_SET_OPERATION_MODE
;
694 strWID
.enuWIDtype
= WID_INT
;
695 strWID
.ps8WidVal
= (s8
*)&(pstrHostIfSetOperationMode
->u32Mode
);
696 strWID
.s32ValueSize
= sizeof(u32
);
699 PRINT_INFO(HOSTINF_DBG
, "pstrWFIDrv= %p\n", pstrWFIDrv
);
701 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
704 if ((pstrHostIfSetOperationMode
->u32Mode
) == (u32
)NULL
)
705 up(&hSemDeinitDrvHandle
);
709 PRINT_ER("Failed to set driver handler\n");
710 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
721 * @brief host_int_set_IPAddress
722 * @details Setting IP address params in message queue
723 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr
724 * @return Error code.
729 s32
Handle_set_IPAddress(tstrWILC_WFIDrv
*drvHandler
, u8
*pu8IPAddr
, u8 idx
)
732 s32 s32Error
= WILC_SUCCESS
;
734 char firmwareIPAddress
[4] = {0};
735 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
737 if (pu8IPAddr
[0] < 192)
740 PRINT_INFO(HOSTINF_DBG
, "Indx = %d, Handling set IP = %pI4\n", idx
, pu8IPAddr
);
742 memcpy(gs8SetIP
[idx
], pu8IPAddr
, IP_ALEN
);
744 /*prepare configuration packet*/
745 strWID
.u16WIDid
= (u16
)WID_IP_ADDRESS
;
746 strWID
.enuWIDtype
= WID_STR
;
747 strWID
.ps8WidVal
= (u8
*)pu8IPAddr
;
748 strWID
.s32ValueSize
= IP_ALEN
;
750 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
754 host_int_get_ipaddress(drvHandler
, firmwareIPAddress
, idx
);
757 PRINT_D(HOSTINF_DBG
, "Failed to set IP address\n");
758 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
760 PRINT_INFO(HOSTINF_DBG
, "IP address set\n");
773 * @brief Handle_get_IPAddress
774 * @details Setting IP address params in message queue
775 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr
776 * @return Error code.
781 s32
Handle_get_IPAddress(tstrWILC_WFIDrv
*drvHandler
, u8
*pu8IPAddr
, u8 idx
)
784 s32 s32Error
= WILC_SUCCESS
;
786 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
788 /*prepare configuration packet*/
789 strWID
.u16WIDid
= (u16
)WID_IP_ADDRESS
;
790 strWID
.enuWIDtype
= WID_STR
;
791 strWID
.ps8WidVal
= (u8
*)WILC_MALLOC(IP_ALEN
);
792 strWID
.s32ValueSize
= IP_ALEN
;
794 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
796 PRINT_INFO(HOSTINF_DBG
, "%pI4\n", strWID
.ps8WidVal
);
798 memcpy(gs8GetIP
[idx
], strWID
.ps8WidVal
, IP_ALEN
);
800 /*get the value by searching the local copy*/
801 kfree(strWID
.ps8WidVal
);
803 if (memcmp(gs8GetIP
[idx
], gs8SetIP
[idx
], IP_ALEN
) != 0)
804 host_int_setup_ipaddress(pstrWFIDrv
, gs8SetIP
[idx
], idx
);
806 if (s32Error
!= WILC_SUCCESS
) {
807 PRINT_ER("Failed to get IP address\n");
808 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
810 PRINT_INFO(HOSTINF_DBG
, "IP address retrieved:: u8IfIdx = %d\n", idx
);
811 PRINT_INFO(HOSTINF_DBG
, "%pI4\n", gs8GetIP
[idx
]);
812 PRINT_INFO(HOSTINF_DBG
, "\n");
826 * @brief Handle_SetMacAddress
827 * @details Setting mac address
828 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
829 * @return Error code.
830 * @author Amr Abdel-Moghny
831 * @date November 2013
834 static s32
Handle_SetMacAddress(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfSetMacAddress
*pstrHostIfSetMacAddress
)
837 s32 s32Error
= WILC_SUCCESS
;
839 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
840 u8
*mac_buf
= (u8
*)WILC_MALLOC(ETH_ALEN
);
842 if (mac_buf
== NULL
) {
843 PRINT_ER("No buffer to send mac address\n");
846 memcpy(mac_buf
, pstrHostIfSetMacAddress
->u8MacAddress
, ETH_ALEN
);
848 /*prepare configuration packet*/
849 strWID
.u16WIDid
= (u16
)WID_MAC_ADDR
;
850 strWID
.enuWIDtype
= WID_STR
;
851 strWID
.ps8WidVal
= mac_buf
;
852 strWID
.s32ValueSize
= ETH_ALEN
;
853 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]);
855 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
857 PRINT_ER("Failed to set mac address\n");
858 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
872 * @brief Handle_GetMacAddress
873 * @details Getting mac address
874 * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler
875 * @return Error code.
876 * @author Amr Abdel-Moghny
880 static s32
Handle_GetMacAddress(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfGetMacAddress
*pstrHostIfGetMacAddress
)
883 s32 s32Error
= WILC_SUCCESS
;
886 /*prepare configuration packet*/
887 strWID
.u16WIDid
= (u16
)WID_MAC_ADDR
;
888 strWID
.enuWIDtype
= WID_STR
;
889 strWID
.ps8WidVal
= pstrHostIfGetMacAddress
->u8MacAddress
;
890 strWID
.s32ValueSize
= ETH_ALEN
;
893 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, false, (u32
)drvHandler
);
895 PRINT_ER("Failed to get mac address\n");
896 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
909 * @brief Handle_CfgParam
910 * @details Sending config packet to firmware to set CFG params
911 * @param[in] tstrHostIFCfgParamAttr* strHostIFCfgParamAttr
912 * @return Error code.
917 static s32
Handle_CfgParam(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFCfgParamAttr
*strHostIFCfgParamAttr
)
919 s32 s32Error
= WILC_SUCCESS
;
920 tstrWID strWIDList
[32];
922 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
925 down(&(pstrWFIDrv
->gtOsCfgValuesSem
));
928 PRINT_D(HOSTINF_DBG
, "Setting CFG params\n");
930 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& BSS_TYPE
) {
931 /*----------------------------------------------------------*/
932 /*Input Value: INFRASTRUCTURE = 1, */
933 /* INDEPENDENT= 2, */
935 /*----------------------------------------------------------*/
936 /* validate input then copy>> need to check value 4 and 5 */
937 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.bss_type
< 6) {
938 strWIDList
[u8WidCnt
].u16WIDid
= WID_BSS_TYPE
;
939 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.bss_type
;
940 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
941 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
942 pstrWFIDrv
->strCfgValues
.bss_type
= (u8
)strHostIFCfgParamAttr
->pstrCfgParamVal
.bss_type
;
944 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
948 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& AUTH_TYPE
) {
949 /*------------------------------------------------------*/
950 /*Input Values: OPEN_SYSTEM = 0, */
951 /* SHARED_KEY = 1, */
953 /*------------------------------------------------------*/
954 /*validate Possible values*/
955 if ((strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_type
) == 1 || (strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_type
) == 2 || (strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_type
) == 5) {
956 strWIDList
[u8WidCnt
].u16WIDid
= WID_AUTH_TYPE
;
957 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_type
;
958 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
959 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
960 pstrWFIDrv
->strCfgValues
.auth_type
= (u8
)strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_type
;
962 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
966 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& AUTHEN_TIMEOUT
) {
967 /* range is 1 to 65535. */
968 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_timeout
> 0 && strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_timeout
< 65536) {
969 strWIDList
[u8WidCnt
].u16WIDid
= WID_AUTH_TIMEOUT
;
970 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_timeout
;
971 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
972 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
973 pstrWFIDrv
->strCfgValues
.auth_timeout
= strHostIFCfgParamAttr
->pstrCfgParamVal
.auth_timeout
;
975 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
979 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& POWER_MANAGEMENT
) {
980 /*-----------------------------------------------------------*/
981 /*Input Values: NO_POWERSAVE = 0, */
982 /* MIN_FAST_PS = 1, */
983 /* MAX_FAST_PS = 2, */
984 /* MIN_PSPOLL_PS = 3, */
985 /* MAX_PSPOLL_PS = 4 */
986 /*----------------------------------------------------------*/
987 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.power_mgmt_mode
< 5) {
988 strWIDList
[u8WidCnt
].u16WIDid
= WID_POWER_MANAGEMENT
;
989 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.power_mgmt_mode
;
990 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
991 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
992 pstrWFIDrv
->strCfgValues
.power_mgmt_mode
= (u8
)strHostIFCfgParamAttr
->pstrCfgParamVal
.power_mgmt_mode
;
994 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
998 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& RETRY_SHORT
) {
999 /* range from 1 to 256 */
1000 if ((strHostIFCfgParamAttr
->pstrCfgParamVal
.short_retry_limit
> 0) && (strHostIFCfgParamAttr
->pstrCfgParamVal
.short_retry_limit
< 256)) {
1001 strWIDList
[u8WidCnt
].u16WIDid
= WID_SHORT_RETRY_LIMIT
;
1002 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.short_retry_limit
;
1003 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1004 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1005 pstrWFIDrv
->strCfgValues
.short_retry_limit
= strHostIFCfgParamAttr
->pstrCfgParamVal
.short_retry_limit
;
1007 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1011 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& RETRY_LONG
) {
1012 /* range from 1 to 256 */
1013 if ((strHostIFCfgParamAttr
->pstrCfgParamVal
.long_retry_limit
> 0) && (strHostIFCfgParamAttr
->pstrCfgParamVal
.long_retry_limit
< 256)) {
1014 strWIDList
[u8WidCnt
].u16WIDid
= WID_LONG_RETRY_LIMIT
;
1015 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.long_retry_limit
;
1017 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1018 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1019 pstrWFIDrv
->strCfgValues
.long_retry_limit
= strHostIFCfgParamAttr
->pstrCfgParamVal
.long_retry_limit
;
1021 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1025 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& FRAG_THRESHOLD
) {
1027 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.frag_threshold
> 255 && strHostIFCfgParamAttr
->pstrCfgParamVal
.frag_threshold
< 7937) {
1028 strWIDList
[u8WidCnt
].u16WIDid
= WID_FRAG_THRESHOLD
;
1029 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.frag_threshold
;
1030 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1031 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1032 pstrWFIDrv
->strCfgValues
.frag_threshold
= strHostIFCfgParamAttr
->pstrCfgParamVal
.frag_threshold
;
1034 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1038 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& RTS_THRESHOLD
) {
1039 /* range 256 to 65535 */
1040 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.rts_threshold
> 255 && strHostIFCfgParamAttr
->pstrCfgParamVal
.rts_threshold
< 65536) {
1041 strWIDList
[u8WidCnt
].u16WIDid
= WID_RTS_THRESHOLD
;
1042 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.rts_threshold
;
1043 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1044 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1045 pstrWFIDrv
->strCfgValues
.rts_threshold
= strHostIFCfgParamAttr
->pstrCfgParamVal
.rts_threshold
;
1047 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1051 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& PREAMBLE
) {
1052 /*-----------------------------------------------------*/
1053 /*Input Values: Short= 0, */
1056 /*------------------------------------------------------*/
1057 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.preamble_type
< 3) {
1058 strWIDList
[u8WidCnt
].u16WIDid
= WID_PREAMBLE
;
1059 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.preamble_type
;
1060 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
1061 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
1062 pstrWFIDrv
->strCfgValues
.preamble_type
= strHostIFCfgParamAttr
->pstrCfgParamVal
.preamble_type
;
1064 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1068 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& SHORT_SLOT_ALLOWED
) {
1069 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.short_slot_allowed
< 2) {
1070 strWIDList
[u8WidCnt
].u16WIDid
= WID_SHORT_SLOT_ALLOWED
;
1071 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.short_slot_allowed
;
1072 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
1073 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
1074 pstrWFIDrv
->strCfgValues
.short_slot_allowed
= (u8
)strHostIFCfgParamAttr
->pstrCfgParamVal
.short_slot_allowed
;
1076 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1080 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& TXOP_PROT_DISABLE
) {
1081 /*Description: used to Disable RTS-CTS protection for TXOP burst*/
1082 /*transmission when the acknowledgement policy is No-Ack or Block-Ack */
1083 /* this information is useful for external supplicant */
1084 /*Input Values: 1 for enable and 0 for disable. */
1085 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.txop_prot_disabled
< 2) {
1086 strWIDList
[u8WidCnt
].u16WIDid
= WID_11N_TXOP_PROT_DISABLE
;
1087 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.txop_prot_disabled
;
1088 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
1089 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
1090 pstrWFIDrv
->strCfgValues
.txop_prot_disabled
= (u8
)strHostIFCfgParamAttr
->pstrCfgParamVal
.txop_prot_disabled
;
1092 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1096 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& BEACON_INTERVAL
) {
1097 /* range is 1 to 65535. */
1098 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.beacon_interval
> 0 && strHostIFCfgParamAttr
->pstrCfgParamVal
.beacon_interval
< 65536) {
1099 strWIDList
[u8WidCnt
].u16WIDid
= WID_BEACON_INTERVAL
;
1100 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.beacon_interval
;
1101 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1102 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1103 pstrWFIDrv
->strCfgValues
.beacon_interval
= strHostIFCfgParamAttr
->pstrCfgParamVal
.beacon_interval
;
1105 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1109 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& DTIM_PERIOD
) {
1110 /* range is 1 to 255. */
1111 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.dtim_period
> 0 && strHostIFCfgParamAttr
->pstrCfgParamVal
.dtim_period
< 256) {
1112 strWIDList
[u8WidCnt
].u16WIDid
= WID_DTIM_PERIOD
;
1113 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.dtim_period
;
1114 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
1115 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
1116 pstrWFIDrv
->strCfgValues
.dtim_period
= strHostIFCfgParamAttr
->pstrCfgParamVal
.dtim_period
;
1118 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1122 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& SITE_SURVEY
) {
1123 /*----------------------------------------------------------------------*/
1124 /*Input Values: SITE_SURVEY_1CH = 0, i.e.: currently set channel */
1125 /* SITE_SURVEY_ALL_CH = 1, */
1126 /* SITE_SURVEY_OFF = 2 */
1127 /*----------------------------------------------------------------------*/
1128 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_enabled
< 3) {
1129 strWIDList
[u8WidCnt
].u16WIDid
= WID_SITE_SURVEY
;
1130 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_enabled
;
1131 strWIDList
[u8WidCnt
].enuWIDtype
= WID_CHAR
;
1132 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(char);
1133 pstrWFIDrv
->strCfgValues
.site_survey_enabled
= (u8
)strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_enabled
;
1135 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1139 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& SITE_SURVEY_SCAN_TIME
) {
1140 /* range is 1 to 65535. */
1141 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_scan_time
> 0 && strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_scan_time
< 65536) {
1142 strWIDList
[u8WidCnt
].u16WIDid
= WID_SITE_SURVEY_SCAN_TIME
;
1143 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_scan_time
;
1144 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1145 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1146 pstrWFIDrv
->strCfgValues
.site_survey_scan_time
= strHostIFCfgParamAttr
->pstrCfgParamVal
.site_survey_scan_time
;
1148 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1152 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& ACTIVE_SCANTIME
) {
1153 /* range is 1 to 65535. */
1154 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.active_scan_time
> 0 && strHostIFCfgParamAttr
->pstrCfgParamVal
.active_scan_time
< 65536) {
1155 strWIDList
[u8WidCnt
].u16WIDid
= WID_ACTIVE_SCAN_TIME
;
1156 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.active_scan_time
;
1157 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1158 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1159 pstrWFIDrv
->strCfgValues
.active_scan_time
= strHostIFCfgParamAttr
->pstrCfgParamVal
.active_scan_time
;
1161 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1165 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& PASSIVE_SCANTIME
) {
1166 /* range is 1 to 65535. */
1167 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.passive_scan_time
> 0 && strHostIFCfgParamAttr
->pstrCfgParamVal
.passive_scan_time
< 65536) {
1168 strWIDList
[u8WidCnt
].u16WIDid
= WID_PASSIVE_SCAN_TIME
;
1169 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&strHostIFCfgParamAttr
->pstrCfgParamVal
.passive_scan_time
;
1170 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1171 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1172 pstrWFIDrv
->strCfgValues
.passive_scan_time
= strHostIFCfgParamAttr
->pstrCfgParamVal
.passive_scan_time
;
1174 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1178 if (strHostIFCfgParamAttr
->pstrCfgParamVal
.u32SetCfgFlag
& CURRENT_TX_RATE
) {
1179 CURRENT_TX_RATE_T curr_tx_rate
= strHostIFCfgParamAttr
->pstrCfgParamVal
.curr_tx_rate
;
1180 /*----------------------------------------------------------------------*/
1181 /*Rates: 1 2 5.5 11 6 9 12 18 24 36 48 54 Auto */
1182 /*InputValues: 1 2 3 4 5 6 7 8 9 10 11 12 0 */
1183 /*----------------------------------------------------------------------*/
1185 if (curr_tx_rate
== AUTORATE
|| curr_tx_rate
== MBPS_1
1186 || curr_tx_rate
== MBPS_2
|| curr_tx_rate
== MBPS_5_5
1187 || curr_tx_rate
== MBPS_11
|| curr_tx_rate
== MBPS_6
1188 || curr_tx_rate
== MBPS_9
|| curr_tx_rate
== MBPS_12
1189 || curr_tx_rate
== MBPS_18
|| curr_tx_rate
== MBPS_24
1190 || curr_tx_rate
== MBPS_36
|| curr_tx_rate
== MBPS_48
|| curr_tx_rate
== MBPS_54
) {
1191 strWIDList
[u8WidCnt
].u16WIDid
= WID_CURRENT_TX_RATE
;
1192 strWIDList
[u8WidCnt
].ps8WidVal
= (s8
*)&curr_tx_rate
;
1193 strWIDList
[u8WidCnt
].enuWIDtype
= WID_SHORT
;
1194 strWIDList
[u8WidCnt
].s32ValueSize
= sizeof(u16
);
1195 pstrWFIDrv
->strCfgValues
.curr_tx_rate
= (u8
)curr_tx_rate
;
1197 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
1201 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, u8WidCnt
, false, (u32
)pstrWFIDrv
);
1204 PRINT_ER("Error in setting CFG params\n");
1206 WILC_CATCH(s32Error
)
1209 up(&(pstrWFIDrv
->gtOsCfgValuesSem
));
1215 * @brief Handle_wait_msg_q_empty
1216 * @details this should be the last msg and then the msg Q becomes idle
1217 * @param[in] tstrHostIFscanAttr* pstrHostIFscanAttr
1218 * @return Error code.
1223 static s32
Handle_wait_msg_q_empty(void)
1225 s32 s32Error
= WILC_SUCCESS
;
1227 g_wilc_initialized
= 0;
1233 * @brief Handle_Scan
1234 * @details Sending config packet to firmware to set the scan params
1235 * @param[in] tstrHostIFscanAttr* pstrHostIFscanAttr
1236 * @return Error code.
1241 static s32
Handle_Scan(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFscanAttr
*pstrHostIFscanAttr
)
1243 s32 s32Error
= WILC_SUCCESS
;
1244 tstrWID strWIDList
[5];
1245 u32 u32WidsCount
= 0;
1249 u8
*pu8HdnNtwrksWidVal
= NULL
;
1250 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*) drvHandler
;
1252 PRINT_D(HOSTINF_DBG
, "Setting SCAN params\n");
1253 PRINT_D(HOSTINF_DBG
, "Scanning: In [%d] state\n", pstrWFIDrv
->enuHostIFstate
);
1255 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
= pstrHostIFscanAttr
->pfScanResult
;
1256 pstrWFIDrv
->strWILC_UsrScanReq
.u32UserScanPvoid
= pstrHostIFscanAttr
->pvUserArg
;
1261 if ((pstrWFIDrv
->enuHostIFstate
>= HOST_IF_SCANNING
) && (pstrWFIDrv
->enuHostIFstate
< HOST_IF_CONNECTED
)) {
1262 /* here we either in HOST_IF_SCANNING, HOST_IF_WAITING_CONN_REQ or HOST_IF_WAITING_CONN_RESP */
1263 PRINT_D(GENERIC_DBG
, "Don't scan we are already in [%d] state\n", pstrWFIDrv
->enuHostIFstate
);
1264 WILC_ERRORREPORT(s32Error
, WILC_BUSY
);
1267 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
1268 if (g_obtainingIP
|| connecting
) {
1269 PRINT_D(GENERIC_DBG
, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
1270 WILC_ERRORREPORT(s32Error
, WILC_BUSY
);
1274 PRINT_D(HOSTINF_DBG
, "Setting SCAN params\n");
1277 pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
= 0;
1280 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_SSID_PROBE_REQ
;
1281 strWIDList
[u32WidsCount
].enuWIDtype
= WID_STR
;
1283 for (i
= 0; i
< pstrHostIFscanAttr
->strHiddenNetwork
.u8ssidnum
; i
++)
1284 valuesize
+= ((pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
[i
].u8ssidlen
) + 1);
1285 pu8HdnNtwrksWidVal
= WILC_MALLOC(valuesize
+ 1);
1286 strWIDList
[u32WidsCount
].ps8WidVal
= pu8HdnNtwrksWidVal
;
1287 if (strWIDList
[u32WidsCount
].ps8WidVal
!= NULL
) {
1288 pu8Buffer
= strWIDList
[u32WidsCount
].ps8WidVal
;
1290 *pu8Buffer
++ = pstrHostIFscanAttr
->strHiddenNetwork
.u8ssidnum
;
1292 PRINT_D(HOSTINF_DBG
, "In Handle_ProbeRequest number of ssid %d\n", pstrHostIFscanAttr
->strHiddenNetwork
.u8ssidnum
);
1294 for (i
= 0; i
< pstrHostIFscanAttr
->strHiddenNetwork
.u8ssidnum
; i
++) {
1295 *pu8Buffer
++ = pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
[i
].u8ssidlen
;
1296 memcpy(pu8Buffer
, pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
[i
].pu8ssid
, pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
[i
].u8ssidlen
);
1297 pu8Buffer
+= pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
[i
].u8ssidlen
;
1302 strWIDList
[u32WidsCount
].s32ValueSize
= (s32
)(valuesize
+ 1);
1306 /*filling cfg param array*/
1308 /* if((pstrHostIFscanAttr->pu8IEs != NULL) && (pstrHostIFscanAttr->IEsLen != 0)) */
1310 /* IEs to be inserted in Probe Request */
1311 strWIDList
[u32WidsCount
].u16WIDid
= WID_INFO_ELEMENT_PROBE
;
1312 strWIDList
[u32WidsCount
].enuWIDtype
= WID_BIN_DATA
;
1313 strWIDList
[u32WidsCount
].ps8WidVal
= pstrHostIFscanAttr
->pu8IEs
;
1314 strWIDList
[u32WidsCount
].s32ValueSize
= pstrHostIFscanAttr
->IEsLen
;
1319 strWIDList
[u32WidsCount
].u16WIDid
= WID_SCAN_TYPE
;
1320 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1321 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1322 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrHostIFscanAttr
->u8ScanType
));
1325 /*list of channels to be scanned*/
1326 strWIDList
[u32WidsCount
].u16WIDid
= WID_SCAN_CHANNEL_LIST
;
1327 strWIDList
[u32WidsCount
].enuWIDtype
= WID_BIN_DATA
;
1329 /* Bug 4648: Convert channel numbers to start from 0 not 1. */
1330 if (pstrHostIFscanAttr
->pu8ChnlFreqList
!= NULL
&& pstrHostIFscanAttr
->u8ChnlListLen
> 0) {
1333 for (i
= 0; i
< pstrHostIFscanAttr
->u8ChnlListLen
; i
++) {
1334 if (pstrHostIFscanAttr
->pu8ChnlFreqList
[i
] > 0)
1335 pstrHostIFscanAttr
->pu8ChnlFreqList
[i
] = pstrHostIFscanAttr
->pu8ChnlFreqList
[i
] - 1;
1339 strWIDList
[u32WidsCount
].ps8WidVal
= pstrHostIFscanAttr
->pu8ChnlFreqList
;
1340 strWIDList
[u32WidsCount
].s32ValueSize
= pstrHostIFscanAttr
->u8ChnlListLen
;
1344 strWIDList
[u32WidsCount
].u16WIDid
= WID_START_SCAN_REQ
;
1345 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1346 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1347 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrHostIFscanAttr
->u8ScanSource
));
1350 /*keep the state as is , no need to change it*/
1351 /* gWFiDrvHandle->enuHostIFstate = HOST_IF_SCANNING; */
1353 if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_CONNECTED
)
1354 gbScanWhileConnected
= true;
1355 else if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_IDLE
)
1356 gbScanWhileConnected
= false;
1358 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, u32WidsCount
, false, (u32
)pstrWFIDrv
);
1361 PRINT_ER("Failed to send scan paramters config packet\n");
1362 WILC_ERRORREPORT(s32Error
, s32Error
);
1364 PRINT_D(HOSTINF_DBG
, "Successfully sent SCAN params config packet\n");
1367 WILC_CATCH(s32Error
)
1369 WILC_TimerStop(&(pstrWFIDrv
->hScanTimer
), NULL
);
1370 /*if there is an ongoing scan request*/
1371 Handle_ScanDone(drvHandler
, SCAN_EVENT_ABORTED
);
1374 /* Deallocate pstrHostIFscanAttr->u8ChnlListLen which was prevoisuly allocated by the sending thread */
1375 if (pstrHostIFscanAttr
->pu8ChnlFreqList
!= NULL
) {
1376 kfree(pstrHostIFscanAttr
->pu8ChnlFreqList
);
1377 pstrHostIFscanAttr
->pu8ChnlFreqList
= NULL
;
1380 /* Deallocate pstrHostIFscanAttr->pu8IEs which was previously allocated by the sending thread */
1381 if (pstrHostIFscanAttr
->pu8IEs
!= NULL
) {
1382 kfree(pstrHostIFscanAttr
->pu8IEs
);
1383 pstrHostIFscanAttr
->pu8IEs
= NULL
;
1385 if (pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
!= NULL
) {
1386 kfree(pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
);
1387 pstrHostIFscanAttr
->strHiddenNetwork
.pstrHiddenNetworkInfo
= NULL
;
1390 /* Deallocate pstrHostIFscanAttr->u8ChnlListLen which was prevoisuly allocated by the sending thread */
1391 if (pstrHostIFscanAttr
->pu8ChnlFreqList
!= NULL
) {
1392 kfree(pstrHostIFscanAttr
->pu8ChnlFreqList
);
1393 pstrHostIFscanAttr
->pu8ChnlFreqList
= NULL
;
1396 if (pu8HdnNtwrksWidVal
!= NULL
)
1397 kfree(pu8HdnNtwrksWidVal
);
1403 * @brief Handle_ScanDone
1404 * @details Call scan notification callback function
1406 * @return Error code.
1411 static s32
Handle_ScanDone(tstrWILC_WFIDrv
*drvHandler
, tenuScanEvent enuEvent
)
1413 s32 s32Error
= WILC_SUCCESS
;
1415 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
1418 u8 u8abort_running_scan
;
1422 PRINT_D(HOSTINF_DBG
, "in Handle_ScanDone()\n");
1425 /*Ask FW to abort the running scan, if any*/
1426 if (enuEvent
== SCAN_EVENT_ABORTED
) {
1427 PRINT_D(GENERIC_DBG
, "Abort running scan\n");
1428 u8abort_running_scan
= 1;
1429 strWID
.u16WIDid
= (u16
)WID_ABORT_RUNNING_SCAN
;
1430 strWID
.enuWIDtype
= WID_CHAR
;
1431 strWID
.ps8WidVal
= (s8
*)&u8abort_running_scan
;
1432 strWID
.s32ValueSize
= sizeof(char);
1435 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
1436 if (s32Error
!= WILC_SUCCESS
) {
1437 PRINT_ER("Failed to set abort running scan\n");
1438 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
1440 WILC_CATCH(s32Error
)
1445 if (pstrWFIDrv
== NULL
) {
1446 PRINT_ER("Driver handler is NULL\n");
1450 /*if there is an ongoing scan request*/
1451 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
1452 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult(enuEvent
, NULL
,
1453 pstrWFIDrv
->strWILC_UsrScanReq
.u32UserScanPvoid
, NULL
);
1454 /*delete current scan request*/
1455 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
= NULL
;
1462 * @brief Handle_Connect
1463 * @details Sending config packet to firmware to starting connection
1464 * @param[in] tstrHostIFconnectAttr* pstrHostIFconnectAttr
1465 * @return Error code.
1470 u8 u8ConnectedSSID
[6] = {0};
1471 static s32
Handle_Connect(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFconnectAttr
*pstrHostIFconnectAttr
)
1473 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*) drvHandler
;
1474 s32 s32Error
= WILC_SUCCESS
;
1475 tstrWID strWIDList
[8];
1476 u32 u32WidsCount
= 0, dummyval
= 0;
1477 /* char passphrase[] = "12345678"; */
1478 #ifndef CONNECT_DIRECT
1479 s32 s32Err
= WILC_SUCCESS
;
1481 u8 u8bssDscListIndex
;
1482 wid_site_survey_reslts_s
*pstrSurveyResults
= NULL
;
1484 u8
*pu8CurrByte
= NULL
;
1485 /*Bug4218: Parsing Join Param*/
1486 #ifdef WILC_PARSE_SCAN_IN_HOST
1487 tstrJoinBssParam
*ptstrJoinBssParam
;
1488 #endif /*WILC_PARSE_SCAN_IN_HOST*/
1492 PRINT_D(GENERIC_DBG
, "Handling connect request\n");
1494 #ifndef CONNECT_DIRECT
1495 memset(gapu8RcvdSurveyResults
[0], 0, MAX_SURVEY_RESULT_FRAG_SIZE
);
1496 memset(gapu8RcvdSurveyResults
[1], 0, MAX_SURVEY_RESULT_FRAG_SIZE
);
1499 PRINT_D(HOSTINF_DBG
, "Getting site survey results\n");
1500 s32Err
= host_int_get_site_survey_results(pstrWFIDrv
,
1501 gapu8RcvdSurveyResults
,
1502 MAX_SURVEY_RESULT_FRAG_SIZE
);
1504 PRINT_ER("Failed to get site survey results\n");
1505 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
1508 s32Err
= ParseSurveyResults(gapu8RcvdSurveyResults
, &pstrSurveyResults
,
1509 &pstrWFIDrv
->u32SurveyResultsCount
);
1512 if (s32Err
== WILC_SUCCESS
) {
1513 /* use the parsed info in pstrSurveyResults, then deallocate it */
1514 PRINT_D(HOSTINF_DBG
, "Copying site survey results in global structure, then deallocate\n");
1515 for (i
= 0; i
< pstrWFIDrv
->u32SurveyResultsCount
; i
++) {
1516 memcpy(&pstrWFIDrv
->astrSurveyResults
[i
], &pstrSurveyResults
[i
],
1517 sizeof(wid_site_survey_reslts_s
));
1520 DeallocateSurveyResults(pstrSurveyResults
);
1522 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
1523 PRINT_ER("ParseSurveyResults() Error(%d)\n", s32Err
);
1527 for (i
= 0; i
< pstrWFIDrv
->u32SurveyResultsCount
; i
++) {
1528 if (memcmp(pstrWFIDrv
->astrSurveyResults
[i
].SSID
,
1529 pstrHostIFconnectAttr
->pu8ssid
,
1530 pstrHostIFconnectAttr
->ssidLen
) == 0) {
1531 PRINT_INFO(HOSTINF_DBG
, "Network with required SSID is found %s\n", pstrHostIFconnectAttr
->pu8ssid
);
1532 if (pstrHostIFconnectAttr
->pu8bssid
== NULL
) {
1533 /* BSSID is not passed from the user, so decision of matching
1534 * is done by SSID only */
1535 PRINT_INFO(HOSTINF_DBG
, "BSSID is not passed from the user\n");
1538 /* BSSID is also passed from the user, so decision of matching
1539 * should consider also this passed BSSID */
1541 if (memcmp(pstrWFIDrv
->astrSurveyResults
[i
].BSSID
,
1542 pstrHostIFconnectAttr
->pu8bssid
,
1544 PRINT_INFO(HOSTINF_DBG
, "BSSID is passed from the user and matched\n");
1551 if (i
< pstrWFIDrv
->u32SurveyResultsCount
) {
1552 u8bssDscListIndex
= i
;
1554 PRINT_INFO(HOSTINF_DBG
, "Connecting to network of Bss Idx%d and SSID %s and channel%d\n",
1555 u8bssDscListIndex
, pstrWFIDrv
->astrSurveyResults
[u8bssDscListIndex
].SSID
,
1556 pstrWFIDrv
->astrSurveyResults
[u8bssDscListIndex
].Channel
);
1558 PRINT_INFO(HOSTINF_DBG
, "Saving connection parameters in global structure\n");
1560 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
) {
1561 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
= (u8
*)WILC_MALLOC(6);
1562 memcpy(pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
, pstrHostIFconnectAttr
->pu8bssid
, 6);
1565 pstrWFIDrv
->strWILC_UsrConnReq
.ssidLen
= pstrHostIFconnectAttr
->ssidLen
;
1566 if (pstrHostIFconnectAttr
->pu8ssid
!= NULL
) {
1567 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
= (u8
*)WILC_MALLOC(pstrHostIFconnectAttr
->ssidLen
+ 1);
1568 memcpy(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
, pstrHostIFconnectAttr
->pu8ssid
,
1569 pstrHostIFconnectAttr
->ssidLen
);
1570 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
[pstrHostIFconnectAttr
->ssidLen
] = '\0';
1573 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
= pstrHostIFconnectAttr
->IEsLen
;
1574 if (pstrHostIFconnectAttr
->pu8IEs
!= NULL
) {
1575 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
= (u8
*)WILC_MALLOC(pstrHostIFconnectAttr
->IEsLen
);
1576 memcpy(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
, pstrHostIFconnectAttr
->pu8IEs
,
1577 pstrHostIFconnectAttr
->IEsLen
);
1580 pstrWFIDrv
->strWILC_UsrConnReq
.u8security
= pstrHostIFconnectAttr
->u8security
;
1581 pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
= pstrHostIFconnectAttr
->tenuAuth_type
;
1582 pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
= pstrHostIFconnectAttr
->pfConnectResult
;
1583 pstrWFIDrv
->strWILC_UsrConnReq
.u32UserConnectPvoid
= pstrHostIFconnectAttr
->pvUserArg
;
1586 /* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */
1587 /* (gWFiDrvHandle->strWILC_UsrConnReq.ConnReqIEsLen != 0)) */
1589 /* IEs to be inserted in Association Request */
1590 strWIDList
[u32WidsCount
].u16WIDid
= WID_INFO_ELEMENT_ASSOCIATE
;
1591 strWIDList
[u32WidsCount
].enuWIDtype
= WID_BIN_DATA
;
1592 strWIDList
[u32WidsCount
].ps8WidVal
= pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
;
1593 strWIDList
[u32WidsCount
].s32ValueSize
= pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
;
1596 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_11I_MODE
;
1597 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1598 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1599 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrWFIDrv
->strWILC_UsrConnReq
.u8security
));
1602 PRINT_INFO(HOSTINF_DBG
, "Encrypt Mode = %x\n", pstrWFIDrv
->strWILC_UsrConnReq
.u8security
);
1604 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_AUTH_TYPE
;
1605 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1606 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1607 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
);
1610 PRINT_INFO(HOSTINF_DBG
, "Authentication Type = %x\n", pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
);
1612 * strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
1613 * strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1614 * strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
1615 * strWIDList[u32WidsCount].ps8WidVal = (s8*)(passphrase);
1619 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_JOIN_REQ
;
1620 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1621 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1622 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)&u8bssDscListIndex
;
1625 /* A temporary workaround to avoid handling the misleading MAC_DISCONNECTED raised from the
1626 * firmware at chip reset when processing the WIDs of the Connect Request.
1627 * (This workaround should be removed in the future when the Chip reset of the Connect WIDs is disabled) */
1628 /* ////////////////////// */
1629 gu32WidConnRstHack
= 0;
1630 /* ////////////////////// */
1632 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, u32WidsCount
, false, (u32
)pstrWFIDrv
);
1634 PRINT_ER("Handle_Connect()] failed to send config packet\n");
1635 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
1637 pstrWFIDrv
->enuHostIFstate
= HOST_IF_WAITING_CONN_RESP
;
1641 PRINT_ER("Required BSSID not found\n");
1642 WILC_ERRORREPORT(s32Error
, WILC_NOT_FOUND
);
1647 /* if we try to connect to an already connected AP then discard the request */
1649 if (memcmp(pstrHostIFconnectAttr
->pu8bssid
, u8ConnectedSSID
, ETH_ALEN
) == 0) {
1651 s32Error
= WILC_SUCCESS
;
1652 PRINT_ER("Trying to connect to an already connected AP, Discard connect request\n");
1656 PRINT_INFO(HOSTINF_DBG
, "Saving connection parameters in global structure\n");
1658 /*Bug4218: Parsing Join Param*/
1659 #ifdef WILC_PARSE_SCAN_IN_HOST
1660 ptstrJoinBssParam
= (tstrJoinBssParam
*)pstrHostIFconnectAttr
->pJoinParams
;
1661 if (ptstrJoinBssParam
== NULL
) {
1662 PRINT_ER("Required BSSID not found\n");
1663 WILC_ERRORREPORT(s32Error
, WILC_NOT_FOUND
);
1665 #endif /*WILC_PARSE_SCAN_IN_HOST*/
1667 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
) {
1668 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
= (u8
*)WILC_MALLOC(6);
1669 memcpy(pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
, pstrHostIFconnectAttr
->pu8bssid
, 6);
1672 pstrWFIDrv
->strWILC_UsrConnReq
.ssidLen
= pstrHostIFconnectAttr
->ssidLen
;
1673 if (pstrHostIFconnectAttr
->pu8ssid
!= NULL
) {
1674 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
= (u8
*)WILC_MALLOC(pstrHostIFconnectAttr
->ssidLen
+ 1);
1675 memcpy(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
, pstrHostIFconnectAttr
->pu8ssid
,
1676 pstrHostIFconnectAttr
->ssidLen
);
1677 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
[pstrHostIFconnectAttr
->ssidLen
] = '\0';
1680 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
= pstrHostIFconnectAttr
->IEsLen
;
1681 if (pstrHostIFconnectAttr
->pu8IEs
!= NULL
) {
1682 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
= (u8
*)WILC_MALLOC(pstrHostIFconnectAttr
->IEsLen
);
1683 memcpy(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
, pstrHostIFconnectAttr
->pu8IEs
,
1684 pstrHostIFconnectAttr
->IEsLen
);
1687 pstrWFIDrv
->strWILC_UsrConnReq
.u8security
= pstrHostIFconnectAttr
->u8security
;
1688 pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
= pstrHostIFconnectAttr
->tenuAuth_type
;
1689 pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
= pstrHostIFconnectAttr
->pfConnectResult
;
1690 pstrWFIDrv
->strWILC_UsrConnReq
.u32UserConnectPvoid
= pstrHostIFconnectAttr
->pvUserArg
;
1692 strWIDList
[u32WidsCount
].u16WIDid
= WID_SUCCESS_FRAME_COUNT
;
1693 strWIDList
[u32WidsCount
].enuWIDtype
= WID_INT
;
1694 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(u32
);
1695 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(dummyval
));
1698 strWIDList
[u32WidsCount
].u16WIDid
= WID_RECEIVED_FRAGMENT_COUNT
;
1699 strWIDList
[u32WidsCount
].enuWIDtype
= WID_INT
;
1700 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(u32
);
1701 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(dummyval
));
1704 strWIDList
[u32WidsCount
].u16WIDid
= WID_FAILED_COUNT
;
1705 strWIDList
[u32WidsCount
].enuWIDtype
= WID_INT
;
1706 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(u32
);
1707 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(dummyval
));
1710 /* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */
1711 /* (gWFiDrvHandle->strWILC_UsrConnReq.ConnReqIEsLen != 0)) */
1713 /* IEs to be inserted in Association Request */
1714 strWIDList
[u32WidsCount
].u16WIDid
= WID_INFO_ELEMENT_ASSOCIATE
;
1715 strWIDList
[u32WidsCount
].enuWIDtype
= WID_BIN_DATA
;
1716 strWIDList
[u32WidsCount
].ps8WidVal
= pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
;
1717 strWIDList
[u32WidsCount
].s32ValueSize
= pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
;
1721 if (memcmp("DIRECT-", pstrHostIFconnectAttr
->pu8ssid
, 7)) {
1723 gu32FlushedInfoElemAsocSize
= pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
;
1724 gu8FlushedInfoElemAsoc
= WILC_MALLOC(gu32FlushedInfoElemAsocSize
);
1725 memcpy(gu8FlushedInfoElemAsoc
, pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
,
1726 gu32FlushedInfoElemAsocSize
);
1729 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_11I_MODE
;
1730 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1731 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1732 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrWFIDrv
->strWILC_UsrConnReq
.u8security
));
1736 if (memcmp("DIRECT-", pstrHostIFconnectAttr
->pu8ssid
, 7))
1737 gu8Flushed11iMode
= pstrWFIDrv
->strWILC_UsrConnReq
.u8security
;
1739 PRINT_INFO(HOSTINF_DBG
, "Encrypt Mode = %x\n", pstrWFIDrv
->strWILC_UsrConnReq
.u8security
);
1742 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_AUTH_TYPE
;
1743 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
1744 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
1745 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
);
1749 if (memcmp("DIRECT-", pstrHostIFconnectAttr
->pu8ssid
, 7))
1750 gu8FlushedAuthType
= (u8
)pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
;
1752 PRINT_INFO(HOSTINF_DBG
, "Authentication Type = %x\n", pstrWFIDrv
->strWILC_UsrConnReq
.tenuAuth_type
);
1754 * strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
1755 * strWIDList[u32WidsCount].enuWIDtype = WID_STR;
1756 * strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
1757 * strWIDList[u32WidsCount].ps8WidVal = (s8*)(passphrase);
1761 PRINT_D(HOSTINF_DBG
, "Connecting to network of SSID %s on channel %d\n",
1762 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
, pstrHostIFconnectAttr
->u8channel
);
1765 #ifndef WILC_PARSE_SCAN_IN_HOST
1766 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_JOIN_REQ_EXTENDED
;
1767 strWIDList
[u32WidsCount
].enuWIDtype
= WID_STR
;
1768 strWIDList
[u32WidsCount
].s32ValueSize
= MAX_SSID_LEN
+ 7;
1769 strWIDList
[u32WidsCount
].ps8WidVal
= WILC_MALLOC(strWIDList
[u32WidsCount
].s32ValueSize
);
1771 if (strWIDList
[u32WidsCount
].ps8WidVal
== NULL
)
1772 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
1774 pu8CurrByte
= strWIDList
[u32WidsCount
].ps8WidVal
;
1776 if (pstrHostIFconnectAttr
->pu8ssid
!= NULL
) {
1777 memcpy(pu8CurrByte
, pstrHostIFconnectAttr
->pu8ssid
, pstrHostIFconnectAttr
->ssidLen
);
1778 pu8CurrByte
[pstrHostIFconnectAttr
->ssidLen
] = '\0';
1780 pu8CurrByte
+= MAX_SSID_LEN
;
1781 if ((pstrHostIFconnectAttr
->u8channel
>= 1) && (pstrHostIFconnectAttr
->u8channel
<= 14)) {
1782 *(pu8CurrByte
++) = pstrHostIFconnectAttr
->u8channel
;
1784 PRINT_ER("Channel out of range\n");
1785 *(pu8CurrByte
++) = 0xFF;
1787 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
)
1788 memcpy(pu8CurrByte
, pstrHostIFconnectAttr
->pu8bssid
, 6);
1791 /* keep the buffer at the start of the allocated pointer to use it with the free*/
1792 pu8CurrByte
= strWIDList
[u32WidsCount
].ps8WidVal
;
1796 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_JOIN_REQ_EXTENDED
;
1797 strWIDList
[u32WidsCount
].enuWIDtype
= WID_STR
;
1799 /*Sending NoA attributes during connection*/
1800 strWIDList
[u32WidsCount
].s32ValueSize
= 112; /* 79; */
1801 strWIDList
[u32WidsCount
].ps8WidVal
= WILC_MALLOC(strWIDList
[u32WidsCount
].s32ValueSize
);
1804 if (memcmp("DIRECT-", pstrHostIFconnectAttr
->pu8ssid
, 7)) {
1805 gu32FlushedJoinReqSize
= strWIDList
[u32WidsCount
].s32ValueSize
;
1806 gu8FlushedJoinReq
= WILC_MALLOC(gu32FlushedJoinReqSize
);
1808 if (strWIDList
[u32WidsCount
].ps8WidVal
== NULL
)
1809 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
1811 pu8CurrByte
= strWIDList
[u32WidsCount
].ps8WidVal
;
1814 if (pstrHostIFconnectAttr
->pu8ssid
!= NULL
) {
1815 memcpy(pu8CurrByte
, pstrHostIFconnectAttr
->pu8ssid
, pstrHostIFconnectAttr
->ssidLen
);
1816 pu8CurrByte
[pstrHostIFconnectAttr
->ssidLen
] = '\0';
1818 pu8CurrByte
+= MAX_SSID_LEN
;
1821 *(pu8CurrByte
++) = INFRASTRUCTURE
;
1823 if ((pstrHostIFconnectAttr
->u8channel
>= 1) && (pstrHostIFconnectAttr
->u8channel
<= 14)) {
1824 *(pu8CurrByte
++) = pstrHostIFconnectAttr
->u8channel
;
1826 PRINT_ER("Channel out of range\n");
1827 *(pu8CurrByte
++) = 0xFF;
1830 *(pu8CurrByte
++) = (ptstrJoinBssParam
->cap_info
) & 0xFF;
1831 *(pu8CurrByte
++) = ((ptstrJoinBssParam
->cap_info
) >> 8) & 0xFF;
1832 PRINT_D(HOSTINF_DBG
, "* Cap Info %0x*\n", (*(pu8CurrByte
- 2) | ((*(pu8CurrByte
- 1)) << 8)));
1835 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
)
1836 memcpy(pu8CurrByte
, pstrHostIFconnectAttr
->pu8bssid
, 6);
1840 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
)
1841 memcpy(pu8CurrByte
, pstrHostIFconnectAttr
->pu8bssid
, 6);
1845 *(pu8CurrByte
++) = (ptstrJoinBssParam
->beacon_period
) & 0xFF;
1846 *(pu8CurrByte
++) = ((ptstrJoinBssParam
->beacon_period
) >> 8) & 0xFF;
1847 PRINT_D(HOSTINF_DBG
, "* Beacon Period %d*\n", (*(pu8CurrByte
- 2) | ((*(pu8CurrByte
- 1)) << 8)));
1849 *(pu8CurrByte
++) = ptstrJoinBssParam
->dtim_period
;
1850 PRINT_D(HOSTINF_DBG
, "* DTIM Period %d*\n", (*(pu8CurrByte
- 1)));
1851 /* Supported rates*/
1852 memcpy(pu8CurrByte
, ptstrJoinBssParam
->supp_rates
, MAX_RATES_SUPPORTED
+ 1);
1853 pu8CurrByte
+= (MAX_RATES_SUPPORTED
+ 1);
1856 *(pu8CurrByte
++) = ptstrJoinBssParam
->wmm_cap
;
1857 PRINT_D(HOSTINF_DBG
, "* wmm cap%d*\n", (*(pu8CurrByte
- 1)));
1859 *(pu8CurrByte
++) = ptstrJoinBssParam
->uapsd_cap
;
1862 *(pu8CurrByte
++) = ptstrJoinBssParam
->ht_capable
;
1863 /* copy this information to the user request */
1864 pstrWFIDrv
->strWILC_UsrConnReq
.IsHTCapable
= ptstrJoinBssParam
->ht_capable
;
1867 *(pu8CurrByte
++) = ptstrJoinBssParam
->rsn_found
;
1868 PRINT_D(HOSTINF_DBG
, "* rsn found %d*\n", *(pu8CurrByte
- 1));
1869 /* rsn group policy*/
1870 *(pu8CurrByte
++) = ptstrJoinBssParam
->rsn_grp_policy
;
1871 PRINT_D(HOSTINF_DBG
, "* rsn group policy %0x*\n", (*(pu8CurrByte
- 1)));
1873 *(pu8CurrByte
++) = ptstrJoinBssParam
->mode_802_11i
;
1874 PRINT_D(HOSTINF_DBG
, "* mode_802_11i %d*\n", (*(pu8CurrByte
- 1)));
1875 /* rsn pcip policy*/
1876 memcpy(pu8CurrByte
, ptstrJoinBssParam
->rsn_pcip_policy
, sizeof(ptstrJoinBssParam
->rsn_pcip_policy
));
1877 pu8CurrByte
+= sizeof(ptstrJoinBssParam
->rsn_pcip_policy
);
1879 /* rsn auth policy*/
1880 memcpy(pu8CurrByte
, ptstrJoinBssParam
->rsn_auth_policy
, sizeof(ptstrJoinBssParam
->rsn_auth_policy
));
1881 pu8CurrByte
+= sizeof(ptstrJoinBssParam
->rsn_auth_policy
);
1883 /* rsn auth policy*/
1884 memcpy(pu8CurrByte
, ptstrJoinBssParam
->rsn_cap
, sizeof(ptstrJoinBssParam
->rsn_cap
));
1885 pu8CurrByte
+= sizeof(ptstrJoinBssParam
->rsn_cap
);
1888 *(pu8CurrByte
++) = REAL_JOIN_REQ
;
1891 *(pu8CurrByte
++) = ptstrJoinBssParam
->u8NoaEnbaled
;
1892 if (ptstrJoinBssParam
->u8NoaEnbaled
) {
1893 PRINT_D(HOSTINF_DBG
, "NOA present\n");
1895 *(pu8CurrByte
++) = (ptstrJoinBssParam
->tsf
) & 0xFF;
1896 *(pu8CurrByte
++) = ((ptstrJoinBssParam
->tsf
) >> 8) & 0xFF;
1897 *(pu8CurrByte
++) = ((ptstrJoinBssParam
->tsf
) >> 16) & 0xFF;
1898 *(pu8CurrByte
++) = ((ptstrJoinBssParam
->tsf
) >> 24) & 0xFF;
1900 *(pu8CurrByte
++) = ptstrJoinBssParam
->u8Index
;
1902 *(pu8CurrByte
++) = ptstrJoinBssParam
->u8OppEnable
;
1904 if (ptstrJoinBssParam
->u8OppEnable
)
1905 *(pu8CurrByte
++) = ptstrJoinBssParam
->u8CtWindow
;
1907 *(pu8CurrByte
++) = ptstrJoinBssParam
->u8Count
;
1909 memcpy(pu8CurrByte
, ptstrJoinBssParam
->au8Duration
, sizeof(ptstrJoinBssParam
->au8Duration
));
1911 pu8CurrByte
+= sizeof(ptstrJoinBssParam
->au8Duration
);
1913 memcpy(pu8CurrByte
, ptstrJoinBssParam
->au8Interval
, sizeof(ptstrJoinBssParam
->au8Interval
));
1915 pu8CurrByte
+= sizeof(ptstrJoinBssParam
->au8Interval
);
1917 memcpy(pu8CurrByte
, ptstrJoinBssParam
->au8StartTime
, sizeof(ptstrJoinBssParam
->au8StartTime
));
1919 pu8CurrByte
+= sizeof(ptstrJoinBssParam
->au8StartTime
);
1922 PRINT_D(HOSTINF_DBG
, "NOA not present\n");
1926 /* keep the buffer at the start of the allocated pointer to use it with the free*/
1927 pu8CurrByte
= strWIDList
[u32WidsCount
].ps8WidVal
;
1930 #endif /* #ifdef WILC_PARSE_SCAN_IN_HOST*/
1933 /* A temporary workaround to avoid handling the misleading MAC_DISCONNECTED raised from the
1934 * firmware at chip reset when processing the WIDs of the Connect Request.
1935 * (This workaround should be removed in the future when the Chip reset of the Connect WIDs is disabled) */
1936 /* ////////////////////// */
1937 gu32WidConnRstHack
= 0;
1938 /* ////////////////////// */
1941 if (memcmp("DIRECT-", pstrHostIFconnectAttr
->pu8ssid
, 7)) {
1942 memcpy(gu8FlushedJoinReq
, pu8CurrByte
, gu32FlushedJoinReqSize
);
1943 gu8FlushedJoinReqDrvHandler
= (u32
)pstrWFIDrv
;
1946 PRINT_D(GENERIC_DBG
, "send HOST_IF_WAITING_CONN_RESP\n");
1948 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
) {
1949 memcpy(u8ConnectedSSID
, pstrHostIFconnectAttr
->pu8bssid
, ETH_ALEN
);
1951 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]));
1952 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]));
1955 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, u32WidsCount
, false, (u32
)pstrWFIDrv
);
1957 PRINT_ER("Handle_Connect()] failed to send config packet\n");
1958 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
1960 PRINT_D(GENERIC_DBG
, "set HOST_IF_WAITING_CONN_RESP\n");
1961 pstrWFIDrv
->enuHostIFstate
= HOST_IF_WAITING_CONN_RESP
;
1965 WILC_CATCH(s32Error
)
1967 tstrConnectInfo strConnectInfo
;
1969 WILC_TimerStop(&(pstrWFIDrv
->hConnectTimer
), NULL
);
1971 PRINT_D(HOSTINF_DBG
, "could not start connecting to the required network\n");
1973 memset(&strConnectInfo
, 0, sizeof(tstrConnectInfo
));
1975 if (pstrHostIFconnectAttr
->pfConnectResult
!= NULL
) {
1976 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
)
1977 memcpy(strConnectInfo
.au8bssid
, pstrHostIFconnectAttr
->pu8bssid
, 6);
1979 if (pstrHostIFconnectAttr
->pu8IEs
!= NULL
) {
1980 strConnectInfo
.ReqIEsLen
= pstrHostIFconnectAttr
->IEsLen
;
1981 strConnectInfo
.pu8ReqIEs
= (u8
*)WILC_MALLOC(pstrHostIFconnectAttr
->IEsLen
);
1982 memcpy(strConnectInfo
.pu8ReqIEs
,
1983 pstrHostIFconnectAttr
->pu8IEs
,
1984 pstrHostIFconnectAttr
->IEsLen
);
1987 pstrHostIFconnectAttr
->pfConnectResult(CONN_DISCONN_EVENT_CONN_RESP
,
1991 pstrHostIFconnectAttr
->pvUserArg
);
1992 /*Change state to idle*/
1993 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
1995 if (strConnectInfo
.pu8ReqIEs
!= NULL
) {
1996 kfree(strConnectInfo
.pu8ReqIEs
);
1997 strConnectInfo
.pu8ReqIEs
= NULL
;
2001 PRINT_ER("Connect callback function pointer is NULL\n");
2005 PRINT_D(HOSTINF_DBG
, "Deallocating connection parameters\n");
2006 /* Deallocate pstrHostIFconnectAttr->pu8bssid which was prevoisuly allocated by the sending thread */
2007 if (pstrHostIFconnectAttr
->pu8bssid
!= NULL
) {
2008 kfree(pstrHostIFconnectAttr
->pu8bssid
);
2009 pstrHostIFconnectAttr
->pu8bssid
= NULL
;
2012 /* Deallocate pstrHostIFconnectAttr->pu8ssid which was prevoisuly allocated by the sending thread */
2013 if (pstrHostIFconnectAttr
->pu8ssid
!= NULL
) {
2014 kfree(pstrHostIFconnectAttr
->pu8ssid
);
2015 pstrHostIFconnectAttr
->pu8ssid
= NULL
;
2018 /* Deallocate pstrHostIFconnectAttr->pu8IEs which was prevoisuly allocated by the sending thread */
2019 if (pstrHostIFconnectAttr
->pu8IEs
!= NULL
) {
2020 kfree(pstrHostIFconnectAttr
->pu8IEs
);
2021 pstrHostIFconnectAttr
->pu8IEs
= NULL
;
2024 if (pu8CurrByte
!= NULL
)
2030 * @brief Handle_FlushConnect
2031 * @details Sending config packet to firmware to flush an old connection
2032 * after switching FW from station one to hybrid one
2033 * @param[in] void * drvHandler
2034 * @return Error code.
2035 * @author Amr Abdel-Moghny
2040 static s32
Handle_FlushConnect(tstrWILC_WFIDrv
*drvHandler
)
2042 s32 s32Error
= WILC_SUCCESS
;
2043 tstrWID strWIDList
[5];
2044 u32 u32WidsCount
= 0;
2045 u8
*pu8CurrByte
= NULL
;
2048 /* IEs to be inserted in Association Request */
2049 strWIDList
[u32WidsCount
].u16WIDid
= WID_INFO_ELEMENT_ASSOCIATE
;
2050 strWIDList
[u32WidsCount
].enuWIDtype
= WID_BIN_DATA
;
2051 strWIDList
[u32WidsCount
].ps8WidVal
= gu8FlushedInfoElemAsoc
;
2052 strWIDList
[u32WidsCount
].s32ValueSize
= gu32FlushedInfoElemAsocSize
;
2055 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_11I_MODE
;
2056 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
2057 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
2058 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(gu8Flushed11iMode
));
2063 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_AUTH_TYPE
;
2064 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
2065 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
2066 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&gu8FlushedAuthType
);
2070 #ifdef WILC_PARSE_SCAN_IN_HOST
2071 strWIDList
[u32WidsCount
].u16WIDid
= (u16
)WID_JOIN_REQ_EXTENDED
;
2072 strWIDList
[u32WidsCount
].enuWIDtype
= WID_STR
;
2073 strWIDList
[u32WidsCount
].s32ValueSize
= gu32FlushedJoinReqSize
;
2074 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)gu8FlushedJoinReq
;
2075 pu8CurrByte
= strWIDList
[u32WidsCount
].ps8WidVal
;
2077 pu8CurrByte
+= FLUSHED_BYTE_POS
;
2078 *(pu8CurrByte
) = FLUSHED_JOIN_REQ
;
2084 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, u32WidsCount
, false, gu8FlushedJoinReqDrvHandler
);
2086 PRINT_ER("Handle_Flush_Connect()] failed to send config packet\n");
2087 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
2090 WILC_CATCH(s32Error
)
2099 * @brief Handle_ConnectTimeout
2100 * @details Call connect notification callback function indicating connection failure
2102 * @return Error code.
2107 static s32
Handle_ConnectTimeout(tstrWILC_WFIDrv
*drvHandler
)
2109 s32 s32Error
= WILC_SUCCESS
;
2110 tstrConnectInfo strConnectInfo
;
2112 u16 u16DummyReasonCode
= 0;
2113 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*) drvHandler
;
2115 if (pstrWFIDrv
== NULL
) {
2116 PRINT_ER("Driver handler is NULL\n");
2120 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
2122 gbScanWhileConnected
= false;
2125 memset(&strConnectInfo
, 0, sizeof(tstrConnectInfo
));
2128 /* First, we will notify the upper layer with the Connection failure {through the Connect Callback function},
2129 * then we will notify our firmware also with the Connection failure {through sending to it Cfg packet carrying
2130 * WID_DISCONNECT} */
2131 if (pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
!= NULL
) {
2132 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
!= NULL
) {
2133 memcpy(strConnectInfo
.au8bssid
,
2134 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
, 6);
2137 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
!= NULL
) {
2138 strConnectInfo
.ReqIEsLen
= pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
;
2139 strConnectInfo
.pu8ReqIEs
= (u8
*)WILC_MALLOC(pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
);
2140 memcpy(strConnectInfo
.pu8ReqIEs
,
2141 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
,
2142 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
);
2145 pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP
,
2149 pstrWFIDrv
->strWILC_UsrConnReq
.u32UserConnectPvoid
);
2151 /* Deallocation of strConnectInfo.pu8ReqIEs */
2152 if (strConnectInfo
.pu8ReqIEs
!= NULL
) {
2153 kfree(strConnectInfo
.pu8ReqIEs
);
2154 strConnectInfo
.pu8ReqIEs
= NULL
;
2157 PRINT_ER("Connect callback function pointer is NULL\n");
2160 /* Here we will notify our firmware also with the Connection failure {through sending to it Cfg packet carrying
2161 * WID_DISCONNECT} */
2162 strWID
.u16WIDid
= (u16
)WID_DISCONNECT
;
2163 strWID
.enuWIDtype
= WID_CHAR
;
2164 strWID
.ps8WidVal
= (s8
*)&u16DummyReasonCode
;
2165 strWID
.s32ValueSize
= sizeof(char);
2167 PRINT_D(HOSTINF_DBG
, "Sending disconnect request\n");
2169 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
2171 PRINT_ER("Failed to send dissconect config packet\n");
2173 /* Deallocation of the Saved Connect Request in the global Handle */
2174 pstrWFIDrv
->strWILC_UsrConnReq
.ssidLen
= 0;
2175 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
!= NULL
) {
2176 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
);
2177 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
= NULL
;
2180 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
!= NULL
) {
2181 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
);
2182 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
= NULL
;
2185 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
= 0;
2186 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
!= NULL
) {
2187 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
);
2188 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
= NULL
;
2191 memset(u8ConnectedSSID
, 0, ETH_ALEN
);
2193 /*Freeing flushed join request params on connect timeout*/
2194 if (gu8FlushedJoinReq
!= NULL
&& gu8FlushedJoinReqDrvHandler
== (u32
)drvHandler
) {
2195 kfree(gu8FlushedJoinReq
);
2196 gu8FlushedJoinReq
= NULL
;
2198 if (gu8FlushedInfoElemAsoc
!= NULL
&& gu8FlushedJoinReqDrvHandler
== (u32
)drvHandler
) {
2199 kfree(gu8FlushedInfoElemAsoc
);
2200 gu8FlushedInfoElemAsoc
= NULL
;
2207 * @brief Handle_RcvdNtwrkInfo
2208 * @details Handling received network information
2209 * @param[in] tstrRcvdNetworkInfo* pstrRcvdNetworkInfo
2210 * @return Error code.
2215 static s32
Handle_RcvdNtwrkInfo(tstrWILC_WFIDrv
*drvHandler
, tstrRcvdNetworkInfo
*pstrRcvdNetworkInfo
)
2218 bool bNewNtwrkFound
;
2222 s32 s32Error
= WILC_SUCCESS
;
2223 tstrNetworkInfo
*pstrNetworkInfo
= NULL
;
2224 void *pJoinParams
= NULL
;
2226 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
2230 bNewNtwrkFound
= true;
2231 PRINT_INFO(HOSTINF_DBG
, "Handling received network info\n");
2233 /*if there is a an ongoing scan request*/
2234 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
2235 PRINT_D(HOSTINF_DBG
, "State: Scanning, parsing network information received\n");
2236 ParseNetworkInfo(pstrRcvdNetworkInfo
->pu8Buffer
, &pstrNetworkInfo
);
2237 if ((pstrNetworkInfo
== NULL
)
2238 || (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
== NULL
)) {
2239 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
2242 /* check whether this network is discovered before */
2243 for (i
= 0; i
< pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
; i
++) {
2245 if ((pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[i
].au8bssid
!= NULL
) &&
2246 (pstrNetworkInfo
->au8bssid
!= NULL
)) {
2247 if (memcmp(pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[i
].au8bssid
,
2248 pstrNetworkInfo
->au8bssid
, 6) == 0) {
2249 if (pstrNetworkInfo
->s8rssi
<= pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[i
].s8rssi
) {
2250 /*we have already found this network with better rssi, so keep the old cached one and don't
2251 * send anything to the upper layer */
2252 PRINT_D(HOSTINF_DBG
, "Network previously discovered\n");
2255 /* here the same already found network is found again but with a better rssi, so just update
2256 * the rssi for this cached network and send this updated network to the upper layer but
2257 * don't add a new record for it */
2258 pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[i
].s8rssi
= pstrNetworkInfo
->s8rssi
;
2259 bNewNtwrkFound
= false;
2266 if (bNewNtwrkFound
== true) {
2267 /* here it is confirmed that it is a new discovered network,
2268 * so add its record then call the User CallBack function */
2270 PRINT_D(HOSTINF_DBG
, "New network found\n");
2272 if (pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
< MAX_NUM_SCANNED_NETWORKS
) {
2273 pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
].s8rssi
= pstrNetworkInfo
->s8rssi
;
2275 if ((pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
].au8bssid
!= NULL
)
2276 && (pstrNetworkInfo
->au8bssid
!= NULL
)) {
2277 memcpy(pstrWFIDrv
->strWILC_UsrScanReq
.astrFoundNetworkInfo
[pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
].au8bssid
,
2278 pstrNetworkInfo
->au8bssid
, 6);
2280 pstrWFIDrv
->strWILC_UsrScanReq
.u32RcvdChCount
++;
2282 pstrNetworkInfo
->bNewNetwork
= true;
2283 /*Bug4218: Parsing Join Param*/
2284 /* add new BSS to JoinBssTable */
2285 #ifdef WILC_PARSE_SCAN_IN_HOST
2286 pJoinParams
= host_int_ParseJoinBssParam(pstrNetworkInfo
);
2287 #endif /*WILC_PARSE_SCAN_IN_HOST*/
2289 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND
, pstrNetworkInfo
,
2290 pstrWFIDrv
->strWILC_UsrScanReq
.u32UserScanPvoid
,
2296 PRINT_WRN(HOSTINF_DBG
, "Discovered networks exceeded max. limit\n");
2299 pstrNetworkInfo
->bNewNetwork
= false;
2300 /* just call the User CallBack function to send the same discovered network with its updated RSSI */
2301 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND
, pstrNetworkInfo
,
2302 pstrWFIDrv
->strWILC_UsrScanReq
.u32UserScanPvoid
, NULL
);
2307 WILC_CATCH(s32Error
)
2313 /* Deallocate pstrRcvdNetworkInfo->pu8Buffer which was prevoisuly allocated by the sending thread */
2314 if (pstrRcvdNetworkInfo
->pu8Buffer
!= NULL
) {
2315 kfree(pstrRcvdNetworkInfo
->pu8Buffer
);
2316 pstrRcvdNetworkInfo
->pu8Buffer
= NULL
;
2319 /*free structure allocated*/
2320 if (pstrNetworkInfo
!= NULL
) {
2321 DeallocateNetworkInfo(pstrNetworkInfo
);
2322 pstrNetworkInfo
= NULL
;
2329 * @brief Handle_RcvdGnrlAsyncInfo
2330 * @details Handling received asynchrous general network information
2331 * @param[in] tstrRcvdGnrlAsyncInfo* pstrRcvdGnrlAsyncInfo
2332 * @return Error code.
2337 static s32
Handle_RcvdGnrlAsyncInfo(tstrWILC_WFIDrv
*drvHandler
, tstrRcvdGnrlAsyncInfo
*pstrRcvdGnrlAsyncInfo
)
2339 /* TODO: mostafa: till now, this function just handles only the received mac status msg, */
2340 /* which carries only 1 WID which have WID ID = WID_STATUS */
2341 s32 s32Error
= WILC_SUCCESS
;
2345 u16 u16WidID
= (u16
)WID_NIL
;
2348 u8 u8MacStatusReasonCode
;
2349 u8 u8MacStatusAdditionalInfo
;
2350 tstrConnectInfo strConnectInfo
;
2351 tstrDisconnectNotifInfo strDisconnectNotifInfo
;
2352 s32 s32Err
= WILC_SUCCESS
;
2353 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*) drvHandler
;
2355 if (pstrWFIDrv
== NULL
)
2356 PRINT_ER("Driver handler is NULL\n");
2357 PRINT_D(GENERIC_DBG
, "Current State = %d,Received state = %d\n", pstrWFIDrv
->enuHostIFstate
,
2358 pstrRcvdGnrlAsyncInfo
->pu8Buffer
[7]);
2360 if ((pstrWFIDrv
->enuHostIFstate
== HOST_IF_WAITING_CONN_RESP
) ||
2361 (pstrWFIDrv
->enuHostIFstate
== HOST_IF_CONNECTED
) ||
2362 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
2363 if ((pstrRcvdGnrlAsyncInfo
->pu8Buffer
== NULL
) ||
2364 (pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
== NULL
)) {
2365 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
2368 u8MsgType
= pstrRcvdGnrlAsyncInfo
->pu8Buffer
[0];
2370 /* Check whether the received message type is 'I' */
2371 if ('I' != u8MsgType
) {
2372 PRINT_ER("Received Message format incorrect.\n");
2373 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
2376 /* Extract message ID */
2377 u8MsgID
= pstrRcvdGnrlAsyncInfo
->pu8Buffer
[1];
2379 /* Extract message Length */
2380 u16MsgLen
= MAKE_WORD16(pstrRcvdGnrlAsyncInfo
->pu8Buffer
[2], pstrRcvdGnrlAsyncInfo
->pu8Buffer
[3]);
2382 /* Extract WID ID [expected to be = WID_STATUS] */
2383 u16WidID
= MAKE_WORD16(pstrRcvdGnrlAsyncInfo
->pu8Buffer
[4], pstrRcvdGnrlAsyncInfo
->pu8Buffer
[5]);
2385 /* Extract WID Length [expected to be = 1] */
2386 u8WidLen
= pstrRcvdGnrlAsyncInfo
->pu8Buffer
[6];
2388 /* get the WID value [expected to be one of two values: either MAC_CONNECTED = (1) or MAC_DISCONNECTED = (0)] */
2389 u8MacStatus
= pstrRcvdGnrlAsyncInfo
->pu8Buffer
[7];
2390 u8MacStatusReasonCode
= pstrRcvdGnrlAsyncInfo
->pu8Buffer
[8];
2391 u8MacStatusAdditionalInfo
= pstrRcvdGnrlAsyncInfo
->pu8Buffer
[9];
2392 PRINT_INFO(HOSTINF_DBG
, "Recieved MAC status = %d with Reason = %d , Info = %d\n", u8MacStatus
, u8MacStatusReasonCode
, u8MacStatusAdditionalInfo
);
2393 if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_WAITING_CONN_RESP
) {
2394 /* our station had sent Association Request frame, so here it will get the Association Response frame then parse it */
2395 u32 u32RcvdAssocRespInfoLen
;
2396 tstrConnectRespInfo
*pstrConnectRespInfo
= NULL
;
2398 PRINT_D(HOSTINF_DBG
, "Recieved MAC status = %d with Reason = %d , Code = %d\n", u8MacStatus
, u8MacStatusReasonCode
, u8MacStatusAdditionalInfo
);
2400 memset(&strConnectInfo
, 0, sizeof(tstrConnectInfo
));
2402 if (u8MacStatus
== MAC_CONNECTED
) {
2403 memset(gapu8RcvdAssocResp
, 0, MAX_ASSOC_RESP_FRAME_SIZE
);
2405 host_int_get_assoc_res_info(pstrWFIDrv
,
2407 MAX_ASSOC_RESP_FRAME_SIZE
,
2408 &u32RcvdAssocRespInfoLen
);
2410 PRINT_INFO(HOSTINF_DBG
, "Received association response with length = %d\n", u32RcvdAssocRespInfoLen
);
2412 if (u32RcvdAssocRespInfoLen
!= 0) {
2414 PRINT_D(HOSTINF_DBG
, "Parsing association response\n");
2415 s32Err
= ParseAssocRespInfo(gapu8RcvdAssocResp
, u32RcvdAssocRespInfoLen
,
2416 &pstrConnectRespInfo
);
2418 PRINT_ER("ParseAssocRespInfo() returned error %d\n", s32Err
);
2420 /* use the necessary parsed Info from the Received Association Response */
2421 strConnectInfo
.u16ConnectStatus
= pstrConnectRespInfo
->u16ConnectStatus
;
2423 if (strConnectInfo
.u16ConnectStatus
== SUCCESSFUL_STATUSCODE
) {
2424 PRINT_INFO(HOSTINF_DBG
, "Association response received : Successful connection status\n");
2425 if (pstrConnectRespInfo
->pu8RespIEs
!= NULL
) {
2426 strConnectInfo
.u16RespIEsLen
= pstrConnectRespInfo
->u16RespIEsLen
;
2429 strConnectInfo
.pu8RespIEs
= (u8
*)WILC_MALLOC(pstrConnectRespInfo
->u16RespIEsLen
);
2430 memcpy(strConnectInfo
.pu8RespIEs
, pstrConnectRespInfo
->pu8RespIEs
,
2431 pstrConnectRespInfo
->u16RespIEsLen
);
2435 /* deallocate the Assoc. Resp. parsed structure as it is not needed anymore */
2436 if (pstrConnectRespInfo
!= NULL
) {
2437 DeallocateAssocRespInfo(pstrConnectRespInfo
);
2438 pstrConnectRespInfo
= NULL
;
2444 /* The station has just received mac status and it also received assoc. response which
2445 * it was waiting for.
2446 * So check first the matching between the received mac status and the received status code in Asoc Resp */
2447 if ((u8MacStatus
== MAC_CONNECTED
) &&
2448 (strConnectInfo
.u16ConnectStatus
!= SUCCESSFUL_STATUSCODE
)) {
2449 PRINT_ER("Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE\n");
2450 memset(u8ConnectedSSID
, 0, ETH_ALEN
);
2452 } else if (u8MacStatus
== MAC_DISCONNECTED
) {
2453 PRINT_ER("Received MAC status is MAC_DISCONNECTED\n");
2454 memset(u8ConnectedSSID
, 0, ETH_ALEN
);
2457 /* TODO: mostafa: correct BSSID should be retrieved from actual BSSID received from AP */
2458 /* through a structure of type tstrConnectRespInfo */
2459 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
!= NULL
) {
2460 PRINT_D(HOSTINF_DBG
, "Retrieving actual BSSID from AP\n");
2461 memcpy(strConnectInfo
.au8bssid
, pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
, 6);
2463 if ((u8MacStatus
== MAC_CONNECTED
) &&
2464 (strConnectInfo
.u16ConnectStatus
== SUCCESSFUL_STATUSCODE
)) {
2465 memcpy(pstrWFIDrv
->au8AssociatedBSSID
,
2466 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
, ETH_ALEN
);
2471 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
!= NULL
) {
2472 strConnectInfo
.ReqIEsLen
= pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
;
2473 strConnectInfo
.pu8ReqIEs
= (u8
*)WILC_MALLOC(pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
);
2474 memcpy(strConnectInfo
.pu8ReqIEs
,
2475 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
,
2476 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
);
2480 WILC_TimerStop(&(pstrWFIDrv
->hConnectTimer
), NULL
);
2481 pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP
,
2485 pstrWFIDrv
->strWILC_UsrConnReq
.u32UserConnectPvoid
);
2488 /* if received mac status is MAC_CONNECTED and
2489 * received status code in Asoc Resp is SUCCESSFUL_STATUSCODE, change state to CONNECTED
2490 * else change state to IDLE */
2491 if ((u8MacStatus
== MAC_CONNECTED
) &&
2492 (strConnectInfo
.u16ConnectStatus
== SUCCESSFUL_STATUSCODE
)) {
2493 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
2495 host_int_set_power_mgmt(pstrWFIDrv
, 0, 0);
2498 PRINT_D(HOSTINF_DBG
, "MAC status : CONNECTED and Connect Status : Successful\n");
2499 pstrWFIDrv
->enuHostIFstate
= HOST_IF_CONNECTED
;
2501 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
2502 PRINT_D(GENERIC_DBG
, "Obtaining an IP, Disable Scan\n");
2503 g_obtainingIP
= true;
2504 WILC_TimerStart(&hDuringIpTimer
, 10000, NULL
, NULL
);
2507 #ifdef WILC_PARSE_SCAN_IN_HOST
2508 /* open a BA session if possible */
2509 /* if(pstrWFIDrv->strWILC_UsrConnReq.IsHTCapable) */
2513 /* host_int_addBASession(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid,0, */
2514 /* BA_SESSION_DEFAULT_BUFFER_SIZE,BA_SESSION_DEFAULT_TIMEOUT); */
2516 PRINT_D(HOSTINF_DBG
, "MAC status : %d and Connect Status : %d\n", u8MacStatus
, strConnectInfo
.u16ConnectStatus
);
2517 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
2518 gbScanWhileConnected
= false;
2522 if (strConnectInfo
.pu8RespIEs
!= NULL
) {
2523 kfree(strConnectInfo
.pu8RespIEs
);
2524 strConnectInfo
.pu8RespIEs
= NULL
;
2527 if (strConnectInfo
.pu8ReqIEs
!= NULL
) {
2528 kfree(strConnectInfo
.pu8ReqIEs
);
2529 strConnectInfo
.pu8ReqIEs
= NULL
;
2533 pstrWFIDrv
->strWILC_UsrConnReq
.ssidLen
= 0;
2534 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
!= NULL
) {
2535 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
);
2536 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
= NULL
;
2539 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
!= NULL
) {
2540 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
);
2541 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
= NULL
;
2544 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
= 0;
2545 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
!= NULL
) {
2546 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
);
2547 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
= NULL
;
2550 } else if ((u8MacStatus
== MAC_DISCONNECTED
) &&
2551 (pstrWFIDrv
->enuHostIFstate
== HOST_IF_CONNECTED
)) {
2552 /* Disassociation or Deauthentication frame has been received */
2553 PRINT_D(HOSTINF_DBG
, "Received MAC_DISCONNECTED from the FW\n");
2555 memset(&strDisconnectNotifInfo
, 0, sizeof(tstrDisconnectNotifInfo
));
2557 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
2558 PRINT_D(HOSTINF_DBG
, "\n\n<< Abort the running OBSS Scan >>\n\n");
2559 WILC_TimerStop(&(pstrWFIDrv
->hScanTimer
), NULL
);
2560 Handle_ScanDone((void *)pstrWFIDrv
, SCAN_EVENT_ABORTED
);
2563 strDisconnectNotifInfo
.u16reason
= 0;
2564 strDisconnectNotifInfo
.ie
= NULL
;
2565 strDisconnectNotifInfo
.ie_len
= 0;
2567 if (pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
!= NULL
) {
2568 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
2570 g_obtainingIP
= false;
2571 host_int_set_power_mgmt(pstrWFIDrv
, 0, 0);
2574 pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF
,
2577 &strDisconnectNotifInfo
,
2578 pstrWFIDrv
->strWILC_UsrConnReq
.u32UserConnectPvoid
);
2581 PRINT_ER("Connect result callback function is NULL\n");
2584 memset(pstrWFIDrv
->au8AssociatedBSSID
, 0, ETH_ALEN
);
2589 /* if Information Elements were retrieved from the Received deauth/disassoc frame, then they
2590 * should be deallocated here */
2592 * if(strDisconnectNotifInfo.ie != NULL)
2594 * kfree(strDisconnectNotifInfo.ie);
2595 * strDisconnectNotifInfo.ie = NULL;
2599 pstrWFIDrv
->strWILC_UsrConnReq
.ssidLen
= 0;
2600 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
!= NULL
) {
2601 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
);
2602 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
= NULL
;
2605 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
!= NULL
) {
2606 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
);
2607 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
= NULL
;
2610 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
= 0;
2611 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
!= NULL
) {
2612 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
);
2613 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
= NULL
;
2617 /*Freeing flushed join request params on receiving*/
2618 /*MAC_DISCONNECTED while connected*/
2619 if (gu8FlushedJoinReq
!= NULL
&& gu8FlushedJoinReqDrvHandler
== (u32
)drvHandler
) {
2620 kfree(gu8FlushedJoinReq
);
2621 gu8FlushedJoinReq
= NULL
;
2623 if (gu8FlushedInfoElemAsoc
!= NULL
&& gu8FlushedJoinReqDrvHandler
== (u32
)drvHandler
) {
2624 kfree(gu8FlushedInfoElemAsoc
);
2625 gu8FlushedInfoElemAsoc
= NULL
;
2628 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
2629 gbScanWhileConnected
= false;
2631 } else if ((u8MacStatus
== MAC_DISCONNECTED
) &&
2632 (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
!= NULL
)) {
2633 PRINT_D(HOSTINF_DBG
, "Received MAC_DISCONNECTED from the FW while scanning\n");
2634 PRINT_D(HOSTINF_DBG
, "\n\n<< Abort the running Scan >>\n\n");
2635 /*Abort the running scan*/
2636 WILC_TimerStop(&(pstrWFIDrv
->hScanTimer
), NULL
);
2637 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
)
2638 Handle_ScanDone(pstrWFIDrv
, SCAN_EVENT_ABORTED
);
2644 WILC_CATCH(s32Error
)
2649 /* Deallocate pstrRcvdGnrlAsyncInfo->pu8Buffer which was prevoisuly allocated by the sending thread */
2650 if (pstrRcvdGnrlAsyncInfo
->pu8Buffer
!= NULL
) {
2651 kfree(pstrRcvdGnrlAsyncInfo
->pu8Buffer
);
2652 pstrRcvdGnrlAsyncInfo
->pu8Buffer
= NULL
;
2660 * @details Sending config packet to firmware to set key
2661 * @param[in] tstrHostIFkeyAttr* pstrHostIFkeyAttr
2662 * @return Error code.
2667 static int Handle_Key(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFkeyAttr
*pstrHostIFkeyAttr
)
2669 s32 s32Error
= WILC_SUCCESS
;
2671 #ifdef WILC_AP_EXTERNAL_MLME
2672 tstrWID strWIDList
[5];
2678 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
2681 switch (pstrHostIFkeyAttr
->enuKeyType
) {
2686 #ifdef WILC_AP_EXTERNAL_MLME
2687 if (pstrHostIFkeyAttr
->u8KeyAction
& ADDKEY_AP
) {
2689 PRINT_D(HOSTINF_DBG
, "Handling WEP key\n");
2690 PRINT_D(GENERIC_DBG
, "ID Hostint is %d\n", (pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
));
2691 strWIDList
[0].u16WIDid
= (u16
)WID_11I_MODE
;
2692 strWIDList
[0].enuWIDtype
= WID_CHAR
;
2693 strWIDList
[0].s32ValueSize
= sizeof(char);
2694 strWIDList
[0].ps8WidVal
= (s8
*)(&(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8mode
));
2696 strWIDList
[1].u16WIDid
= WID_AUTH_TYPE
;
2697 strWIDList
[1].enuWIDtype
= WID_CHAR
;
2698 strWIDList
[1].s32ValueSize
= sizeof(char);
2699 strWIDList
[1].ps8WidVal
= (s8
*)(&(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.tenuAuth_type
));
2701 strWIDList
[2].u16WIDid
= (u16
)WID_KEY_ID
;
2702 strWIDList
[2].enuWIDtype
= WID_CHAR
;
2704 strWIDList
[2].ps8WidVal
= (s8
*)(&(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
));
2705 strWIDList
[2].s32ValueSize
= sizeof(char);
2708 pu8keybuf
= (u8
*)WILC_MALLOC(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
);
2711 if (pu8keybuf
== NULL
) {
2712 PRINT_ER("No buffer to send Key\n");
2716 memcpy(pu8keybuf
, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
,
2717 pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
);
2720 kfree(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
);
2722 strWIDList
[3].u16WIDid
= (u16
)WID_WEP_KEY_VALUE
;
2723 strWIDList
[3].enuWIDtype
= WID_STR
;
2724 strWIDList
[3].s32ValueSize
= pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
;
2725 strWIDList
[3].ps8WidVal
= (s8
*)pu8keybuf
;
2728 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, 4, true, (u32
)pstrWFIDrv
);
2735 if (pstrHostIFkeyAttr
->u8KeyAction
& ADDKEY
) {
2736 PRINT_D(HOSTINF_DBG
, "Handling WEP key\n");
2737 pu8keybuf
= (u8
*)WILC_MALLOC(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
+ 2);
2738 if (pu8keybuf
== NULL
) {
2739 PRINT_ER("No buffer to send Key\n");
2742 pu8keybuf
[0] = pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
;
2744 memcpy(pu8keybuf
+ 1, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
, 1);
2746 memcpy(pu8keybuf
+ 2, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
,
2747 pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
);
2749 kfree(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
);
2751 strWID
.u16WIDid
= (u16
)WID_ADD_WEP_KEY
;
2752 strWID
.enuWIDtype
= WID_STR
;
2753 strWID
.ps8WidVal
= (s8
*)pu8keybuf
;
2754 strWID
.s32ValueSize
= pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
+ 2;
2756 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
2758 } else if (pstrHostIFkeyAttr
->u8KeyAction
& REMOVEKEY
) {
2760 PRINT_D(HOSTINF_DBG
, "Removing key\n");
2761 strWID
.u16WIDid
= (u16
)WID_REMOVE_WEP_KEY
;
2762 strWID
.enuWIDtype
= WID_STR
;
2764 s8idxarray
[0] = (s8
)pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
;
2765 strWID
.ps8WidVal
= s8idxarray
;
2766 strWID
.s32ValueSize
= 1;
2768 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
2770 strWID
.u16WIDid
= (u16
)WID_KEY_ID
;
2771 strWID
.enuWIDtype
= WID_CHAR
;
2772 strWID
.ps8WidVal
= (s8
*)(&(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
));
2773 strWID
.s32ValueSize
= sizeof(char);
2775 PRINT_D(HOSTINF_DBG
, "Setting default key index\n");
2777 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
2779 up(&(pstrWFIDrv
->hSemTestKeyBlock
));
2783 #ifdef WILC_AP_EXTERNAL_MLME
2784 if (pstrHostIFkeyAttr
->u8KeyAction
& ADDKEY_AP
) {
2785 pu8keybuf
= (u8
*)WILC_MALLOC(RX_MIC_KEY_MSG_LEN
);
2786 if (pu8keybuf
== NULL
) {
2787 PRINT_ER("No buffer to send RxGTK Key\n");
2789 goto _WPARxGtk_end_case_
;
2792 memset(pu8keybuf
, 0, RX_MIC_KEY_MSG_LEN
);
2795 /*|----------------------------------------------------------------------------|
2796 * |Sta Address | Key RSC | KeyID | Key Length | Temporal Key | Rx Michael Key |
2797 * |------------|---------|-------|------------|---------------|----------------|
2798 | 6 bytes | 8 byte |1 byte | 1 byte | 16 bytes | 8 bytes |*/
2802 if (pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8seq
!= NULL
)
2803 memcpy(pu8keybuf
+ 6, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8seq
, 8);
2806 memcpy(pu8keybuf
+ 14, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8keyidx
, 1);
2808 memcpy(pu8keybuf
+ 15, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
, 1);
2810 memcpy(pu8keybuf
+ 16, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
,
2811 pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
);
2812 /* pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = 0X51; */
2813 strWIDList
[0].u16WIDid
= (u16
)WID_11I_MODE
;
2814 strWIDList
[0].enuWIDtype
= WID_CHAR
;
2815 strWIDList
[0].s32ValueSize
= sizeof(char);
2816 strWIDList
[0].ps8WidVal
= (s8
*)(&(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Ciphermode
));
2818 strWIDList
[1].u16WIDid
= (u16
)WID_ADD_RX_GTK
;
2819 strWIDList
[1].enuWIDtype
= WID_STR
;
2820 strWIDList
[1].ps8WidVal
= (s8
*)pu8keybuf
;
2821 strWIDList
[1].s32ValueSize
= RX_MIC_KEY_MSG_LEN
;
2823 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, 2, true, (u32
)pstrWFIDrv
);
2827 /* ////////////////////////// */
2828 up(&(pstrWFIDrv
->hSemTestKeyBlock
));
2829 /* ///////////////////////// */
2833 if (pstrHostIFkeyAttr
->u8KeyAction
& ADDKEY
) {
2834 PRINT_D(HOSTINF_DBG
, "Handling group key(Rx) function\n");
2836 pu8keybuf
= (u8
*)WILC_MALLOC(RX_MIC_KEY_MSG_LEN
);
2837 if (pu8keybuf
== NULL
) {
2838 PRINT_ER("No buffer to send RxGTK Key\n");
2840 goto _WPARxGtk_end_case_
;
2843 memset(pu8keybuf
, 0, RX_MIC_KEY_MSG_LEN
);
2846 /*|----------------------------------------------------------------------------|
2847 * |Sta Address | Key RSC | KeyID | Key Length | Temporal Key | Rx Michael Key |
2848 * |------------|---------|-------|------------|---------------|----------------|
2849 | 6 bytes | 8 byte |1 byte | 1 byte | 16 bytes | 8 bytes |*/
2851 if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_CONNECTED
)
2852 memcpy(pu8keybuf
, pstrWFIDrv
->au8AssociatedBSSID
, ETH_ALEN
);
2854 PRINT_ER("Couldn't handle WPARxGtk while enuHostIFstate is not HOST_IF_CONNECTED\n");
2856 memcpy(pu8keybuf
+ 6, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8seq
, 8);
2858 memcpy(pu8keybuf
+ 14, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8keyidx
, 1);
2860 memcpy(pu8keybuf
+ 15, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
, 1);
2861 memcpy(pu8keybuf
+ 16, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
,
2862 pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
);
2864 strWID
.u16WIDid
= (u16
)WID_ADD_RX_GTK
;
2865 strWID
.enuWIDtype
= WID_STR
;
2866 strWID
.ps8WidVal
= (s8
*)pu8keybuf
;
2867 strWID
.s32ValueSize
= RX_MIC_KEY_MSG_LEN
;
2869 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
2873 /* ////////////////////////// */
2874 up(&(pstrWFIDrv
->hSemTestKeyBlock
));
2875 /* ///////////////////////// */
2877 _WPARxGtk_end_case_
:
2878 kfree(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
);
2879 kfree(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8seq
);
2886 #ifdef WILC_AP_EXTERNAL_MLME
2887 if (pstrHostIFkeyAttr
->u8KeyAction
& ADDKEY_AP
) {
2890 pu8keybuf
= (u8
*)WILC_MALLOC(PTK_KEY_MSG_LEN
+ 1);
2894 if (pu8keybuf
== NULL
) {
2895 PRINT_ER("No buffer to send PTK Key\n");
2897 goto _WPAPtk_end_case_
;
2901 /*|-----------------------------------------------------------------------------|
2902 * |Station address | keyidx |Key Length |Temporal Key | Rx Michael Key |Tx Michael Key |
2903 * |----------------|------------ |--------------|----------------|---------------|
2904 | 6 bytes | 1 byte | 1byte | 16 bytes | 8 bytes | 8 bytes |
2905 |-----------------------------------------------------------------------------|*/
2907 memcpy(pu8keybuf
, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8macaddr
, 6); /*1 bytes Key Length */
2909 memcpy(pu8keybuf
+ 6, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8keyidx
, 1);
2910 memcpy(pu8keybuf
+ 7, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
, 1);
2912 memcpy(pu8keybuf
+ 8, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
,
2913 pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
);
2916 strWIDList
[0].u16WIDid
= (u16
)WID_11I_MODE
;
2917 strWIDList
[0].enuWIDtype
= WID_CHAR
;
2918 strWIDList
[0].s32ValueSize
= sizeof(char);
2919 strWIDList
[0].ps8WidVal
= (s8
*)(&(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Ciphermode
));
2921 strWIDList
[1].u16WIDid
= (u16
)WID_ADD_PTK
;
2922 strWIDList
[1].enuWIDtype
= WID_STR
;
2923 strWIDList
[1].ps8WidVal
= (s8
*)pu8keybuf
;
2924 strWIDList
[1].s32ValueSize
= PTK_KEY_MSG_LEN
+ 1;
2926 s32Error
= SendConfigPkt(SET_CFG
, strWIDList
, 2, true, (u32
)pstrWFIDrv
);
2929 /* ////////////////////////// */
2930 up(&(pstrWFIDrv
->hSemTestKeyBlock
));
2931 /* ///////////////////////// */
2934 if (pstrHostIFkeyAttr
->u8KeyAction
& ADDKEY
) {
2937 pu8keybuf
= (u8
*)WILC_MALLOC(PTK_KEY_MSG_LEN
);
2941 if (pu8keybuf
== NULL
) {
2942 PRINT_ER("No buffer to send PTK Key\n");
2944 goto _WPAPtk_end_case_
;
2948 /*|-----------------------------------------------------------------------------|
2949 * |Station address | Key Length | Temporal Key | Rx Michael Key |Tx Michael Key |
2950 * |----------------|------------|--------------|----------------|---------------|
2951 | 6 bytes | 1byte | 16 bytes | 8 bytes | 8 bytes |
2952 |-----------------------------------------------------------------------------|*/
2954 memcpy(pu8keybuf
, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8macaddr
, 6); /*1 bytes Key Length */
2956 memcpy(pu8keybuf
+ 6, &pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
, 1);
2958 memcpy(pu8keybuf
+ 7, pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
,
2959 pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
);
2962 strWID
.u16WIDid
= (u16
)WID_ADD_PTK
;
2963 strWID
.enuWIDtype
= WID_STR
;
2964 strWID
.ps8WidVal
= (s8
*)pu8keybuf
;
2965 strWID
.s32ValueSize
= PTK_KEY_MSG_LEN
;
2967 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
2970 /* ////////////////////////// */
2971 up(&(pstrWFIDrv
->hSemTestKeyBlock
));
2972 /* ///////////////////////// */
2976 kfree(pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
);
2985 PRINT_D(HOSTINF_DBG
, "Handling PMKSA key\n");
2987 pu8keybuf
= (u8
*)WILC_MALLOC((pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFpmkidAttr
.numpmkid
* PMKSA_KEY_LEN
) + 1);
2988 if (pu8keybuf
== NULL
) {
2989 PRINT_ER("No buffer to send PMKSA Key\n");
2993 pu8keybuf
[0] = pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFpmkidAttr
.numpmkid
;
2995 for (i
= 0; i
< pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFpmkidAttr
.numpmkid
; i
++) {
2997 memcpy(pu8keybuf
+ ((PMKSA_KEY_LEN
* i
) + 1), pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFpmkidAttr
.pmkidlist
[i
].bssid
, ETH_ALEN
);
2998 memcpy(pu8keybuf
+ ((PMKSA_KEY_LEN
* i
) + ETH_ALEN
+ 1), pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFpmkidAttr
.pmkidlist
[i
].pmkid
, PMKID_LEN
);
3001 strWID
.u16WIDid
= (u16
)WID_PMKID_INFO
;
3002 strWID
.enuWIDtype
= WID_STR
;
3003 strWID
.ps8WidVal
= (s8
*)pu8keybuf
;
3004 strWID
.s32ValueSize
= (pstrHostIFkeyAttr
->uniHostIFkeyAttr
.strHostIFpmkidAttr
.numpmkid
* PMKSA_KEY_LEN
) + 1;
3006 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3013 PRINT_ER("Failed to send key config packet\n");
3021 * @brief Handle_Disconnect
3022 * @details Sending config packet to firmware to disconnect
3029 static void Handle_Disconnect(tstrWILC_WFIDrv
*drvHandler
)
3033 s32 s32Error
= WILC_SUCCESS
;
3034 u16 u16DummyReasonCode
= 0;
3035 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3038 strWID
.u16WIDid
= (u16
)WID_DISCONNECT
;
3039 strWID
.enuWIDtype
= WID_CHAR
;
3040 strWID
.ps8WidVal
= (s8
*)&u16DummyReasonCode
;
3041 strWID
.s32ValueSize
= sizeof(char);
3045 PRINT_D(HOSTINF_DBG
, "Sending disconnect request\n");
3047 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
3049 g_obtainingIP
= false;
3050 host_int_set_power_mgmt(pstrWFIDrv
, 0, 0);
3053 memset(u8ConnectedSSID
, 0, ETH_ALEN
);
3055 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
3058 PRINT_ER("Failed to send dissconect config packet\n");
3059 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3061 tstrDisconnectNotifInfo strDisconnectNotifInfo
;
3063 memset(&strDisconnectNotifInfo
, 0, sizeof(tstrDisconnectNotifInfo
));
3065 strDisconnectNotifInfo
.u16reason
= 0;
3066 strDisconnectNotifInfo
.ie
= NULL
;
3067 strDisconnectNotifInfo
.ie_len
= 0;
3069 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
3070 WILC_TimerStop(&(pstrWFIDrv
->hScanTimer
), NULL
);
3071 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult(SCAN_EVENT_ABORTED
, NULL
,
3072 pstrWFIDrv
->strWILC_UsrScanReq
.u32UserScanPvoid
, NULL
);
3074 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
= NULL
;
3077 if (pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
!= NULL
) {
3080 /*Stop connect timer, if connection in progress*/
3081 if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_WAITING_CONN_RESP
) {
3082 PRINT_D(HOSTINF_DBG
, "Upper layer requested termination of connection\n");
3083 WILC_TimerStop(&(pstrWFIDrv
->hConnectTimer
), NULL
);
3086 pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF
, NULL
,
3087 0, &strDisconnectNotifInfo
, pstrWFIDrv
->strWILC_UsrConnReq
.u32UserConnectPvoid
);
3089 PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL\n");
3092 gbScanWhileConnected
= false;
3094 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
3096 memset(pstrWFIDrv
->au8AssociatedBSSID
, 0, ETH_ALEN
);
3100 pstrWFIDrv
->strWILC_UsrConnReq
.ssidLen
= 0;
3101 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
!= NULL
) {
3102 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
);
3103 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ssid
= NULL
;
3106 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
!= NULL
) {
3107 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
);
3108 pstrWFIDrv
->strWILC_UsrConnReq
.pu8bssid
= NULL
;
3111 pstrWFIDrv
->strWILC_UsrConnReq
.ConnReqIEsLen
= 0;
3112 if (pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
!= NULL
) {
3113 kfree(pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
);
3114 pstrWFIDrv
->strWILC_UsrConnReq
.pu8ConnReqIEs
= NULL
;
3119 if (gu8FlushedJoinReq
!= NULL
&& gu8FlushedJoinReqDrvHandler
== (u32
)drvHandler
) {
3120 kfree(gu8FlushedJoinReq
);
3121 gu8FlushedJoinReq
= NULL
;
3123 if (gu8FlushedInfoElemAsoc
!= NULL
&& gu8FlushedJoinReqDrvHandler
== (u32
)drvHandler
) {
3124 kfree(gu8FlushedInfoElemAsoc
);
3125 gu8FlushedInfoElemAsoc
= NULL
;
3130 WILC_CATCH(s32Error
)
3135 /* ////////////////////////// */
3136 up(&(pstrWFIDrv
->hSemTestDisconnectBlock
));
3137 /* ///////////////////////// */
3142 void resolve_disconnect_aberration(tstrWILC_WFIDrv
*drvHandler
)
3144 tstrWILC_WFIDrv
*pstrWFIDrv
;
3146 pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3147 if (pstrWFIDrv
== NULL
)
3149 if ((pstrWFIDrv
->enuHostIFstate
== HOST_IF_WAITING_CONN_RESP
) || (pstrWFIDrv
->enuHostIFstate
== HOST_IF_CONNECTING
)) {
3150 PRINT_D(HOSTINF_DBG
, "\n\n<< correcting Supplicant state machine >>\n\n");
3151 host_int_disconnect(pstrWFIDrv
, 1);
3154 static s32
Switch_Log_Terminal(tstrWILC_WFIDrv
*drvHandler
)
3158 s32 s32Error
= WILC_SUCCESS
;
3160 static char dummy
= 9;
3161 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3163 strWID
.u16WIDid
= (u16
)WID_LOGTerminal_Switch
;
3164 strWID
.enuWIDtype
= WID_CHAR
;
3165 strWID
.ps8WidVal
= &dummy
;
3166 strWID
.s32ValueSize
= sizeof(char);
3168 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3172 PRINT_D(HOSTINF_DBG
, "Failed to switch log terminal\n");
3173 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
3175 PRINT_INFO(HOSTINF_DBG
, "MAC address set ::\n");
3180 WILC_CATCH(s32Error
)
3189 * @brief Handle_GetChnl
3190 * @details Sending config packet to get channel
3198 static s32
Handle_GetChnl(tstrWILC_WFIDrv
*drvHandler
)
3201 s32 s32Error
= WILC_SUCCESS
;
3203 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
3204 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3206 strWID
.u16WIDid
= (u16
)WID_CURRENT_CHANNEL
;
3207 strWID
.enuWIDtype
= WID_CHAR
;
3208 strWID
.ps8WidVal
= (s8
*)&gu8Chnl
;
3209 strWID
.s32ValueSize
= sizeof(char);
3211 PRINT_D(HOSTINF_DBG
, "Getting channel value\n");
3213 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3214 /*get the value by searching the local copy*/
3216 PRINT_ER("Failed to get channel number\n");
3217 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3221 WILC_CATCH(s32Error
)
3225 up(&(pstrWFIDrv
->hSemGetCHNL
));
3235 * @brief Handle_GetRssi
3236 * @details Sending config packet to get RSSI
3243 static void Handle_GetRssi(tstrWILC_WFIDrv
*drvHandler
)
3245 s32 s32Error
= WILC_SUCCESS
;
3247 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3249 strWID
.u16WIDid
= (u16
)WID_RSSI
;
3250 strWID
.enuWIDtype
= WID_CHAR
;
3251 strWID
.ps8WidVal
= &gs8Rssi
;
3252 strWID
.s32ValueSize
= sizeof(char);
3255 PRINT_D(HOSTINF_DBG
, "Getting RSSI value\n");
3257 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3259 PRINT_ER("Failed to get RSSI value\n");
3260 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3263 WILC_CATCH(s32Error
)
3267 up(&(pstrWFIDrv
->hSemGetRSSI
));
3273 static void Handle_GetLinkspeed(tstrWILC_WFIDrv
*drvHandler
)
3275 s32 s32Error
= WILC_SUCCESS
;
3277 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3281 strWID
.u16WIDid
= (u16
)WID_LINKSPEED
;
3282 strWID
.enuWIDtype
= WID_CHAR
;
3283 strWID
.ps8WidVal
= &gs8lnkspd
;
3284 strWID
.s32ValueSize
= sizeof(char);
3286 PRINT_D(HOSTINF_DBG
, "Getting LINKSPEED value\n");
3288 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3290 PRINT_ER("Failed to get LINKSPEED value\n");
3291 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3294 WILC_CATCH(s32Error
)
3298 up(&(pstrWFIDrv
->hSemGetLINKSPEED
));
3303 s32
Handle_GetStatistics(tstrWILC_WFIDrv
*drvHandler
, tstrStatistics
*pstrStatistics
)
3305 tstrWID strWIDList
[5];
3306 uint32_t u32WidsCount
= 0, s32Error
= 0;
3308 strWIDList
[u32WidsCount
].u16WIDid
= WID_LINKSPEED
;
3309 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
3310 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
3311 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrStatistics
->u8LinkSpeed
));
3314 strWIDList
[u32WidsCount
].u16WIDid
= WID_RSSI
;
3315 strWIDList
[u32WidsCount
].enuWIDtype
= WID_CHAR
;
3316 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(char);
3317 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrStatistics
->s8RSSI
));
3320 strWIDList
[u32WidsCount
].u16WIDid
= WID_SUCCESS_FRAME_COUNT
;
3321 strWIDList
[u32WidsCount
].enuWIDtype
= WID_INT
;
3322 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(u32
);
3323 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrStatistics
->u32TxCount
));
3326 strWIDList
[u32WidsCount
].u16WIDid
= WID_RECEIVED_FRAGMENT_COUNT
;
3327 strWIDList
[u32WidsCount
].enuWIDtype
= WID_INT
;
3328 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(u32
);
3329 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrStatistics
->u32RxCount
));
3332 strWIDList
[u32WidsCount
].u16WIDid
= WID_FAILED_COUNT
;
3333 strWIDList
[u32WidsCount
].enuWIDtype
= WID_INT
;
3334 strWIDList
[u32WidsCount
].s32ValueSize
= sizeof(u32
);
3335 strWIDList
[u32WidsCount
].ps8WidVal
= (s8
*)(&(pstrStatistics
->u32TxFailureCount
));
3338 s32Error
= SendConfigPkt(GET_CFG
, strWIDList
, u32WidsCount
, false, (u32
)drvHandler
);
3341 PRINT_ER("Failed to send scan paramters config packet\n");
3342 /* WILC_ERRORREPORT(s32Error, s32Error); */
3350 #ifdef WILC_AP_EXTERNAL_MLME
3354 * @brief Handle_Get_InActiveTime
3355 * @details Sending config packet to set mac adddress for station and
3364 static s32
Handle_Get_InActiveTime(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfStaInactiveT
*strHostIfStaInactiveT
)
3367 s32 s32Error
= WILC_SUCCESS
;
3370 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3373 strWID
.u16WIDid
= (u16
)WID_SET_STA_MAC_INACTIVE_TIME
;
3374 strWID
.enuWIDtype
= WID_STR
;
3375 strWID
.s32ValueSize
= ETH_ALEN
;
3376 strWID
.ps8WidVal
= (u8
*)WILC_MALLOC(strWID
.s32ValueSize
);
3379 stamac
= strWID
.ps8WidVal
;
3380 memcpy(stamac
, strHostIfStaInactiveT
->mac
, ETH_ALEN
);
3383 PRINT_D(CFG80211_DBG
, "SETING STA inactive time\n");
3386 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3387 /*get the value by searching the local copy*/
3389 PRINT_ER("Failed to SET incative time\n");
3390 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3394 strWID
.u16WIDid
= (u16
)WID_GET_INACTIVE_TIME
;
3395 strWID
.enuWIDtype
= WID_INT
;
3396 strWID
.ps8WidVal
= (s8
*)&gu32InactiveTime
;
3397 strWID
.s32ValueSize
= sizeof(u32
);
3400 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3401 /*get the value by searching the local copy*/
3403 PRINT_ER("Failed to get incative time\n");
3404 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3408 PRINT_D(CFG80211_DBG
, "Getting inactive time : %d\n", gu32InactiveTime
);
3410 up(&(pstrWFIDrv
->hSemInactiveTime
));
3411 WILC_CATCH(s32Error
)
3425 * @brief Handle_AddBeacon
3426 * @details Sending config packet to add beacon
3427 * @param[in] tstrHostIFSetBeacon* pstrSetBeaconParam
3433 static void Handle_AddBeacon(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFSetBeacon
*pstrSetBeaconParam
)
3435 s32 s32Error
= WILC_SUCCESS
;
3438 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3440 PRINT_D(HOSTINF_DBG
, "Adding BEACON\n");
3442 strWID
.u16WIDid
= (u16
)WID_ADD_BEACON
;
3443 strWID
.enuWIDtype
= WID_BIN
;
3444 strWID
.s32ValueSize
= pstrSetBeaconParam
->u32HeadLen
+ pstrSetBeaconParam
->u32TailLen
+ 16;
3445 strWID
.ps8WidVal
= WILC_MALLOC(strWID
.s32ValueSize
);
3446 if (strWID
.ps8WidVal
== NULL
)
3447 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3449 pu8CurrByte
= strWID
.ps8WidVal
;
3450 *pu8CurrByte
++ = (pstrSetBeaconParam
->u32Interval
& 0xFF);
3451 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32Interval
>> 8) & 0xFF);
3452 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32Interval
>> 16) & 0xFF);
3453 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32Interval
>> 24) & 0xFF);
3455 *pu8CurrByte
++ = (pstrSetBeaconParam
->u32DTIMPeriod
& 0xFF);
3456 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32DTIMPeriod
>> 8) & 0xFF);
3457 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32DTIMPeriod
>> 16) & 0xFF);
3458 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32DTIMPeriod
>> 24) & 0xFF);
3460 *pu8CurrByte
++ = (pstrSetBeaconParam
->u32HeadLen
& 0xFF);
3461 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32HeadLen
>> 8) & 0xFF);
3462 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32HeadLen
>> 16) & 0xFF);
3463 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32HeadLen
>> 24) & 0xFF);
3465 memcpy(pu8CurrByte
, pstrSetBeaconParam
->pu8Head
, pstrSetBeaconParam
->u32HeadLen
);
3466 pu8CurrByte
+= pstrSetBeaconParam
->u32HeadLen
;
3468 *pu8CurrByte
++ = (pstrSetBeaconParam
->u32TailLen
& 0xFF);
3469 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32TailLen
>> 8) & 0xFF);
3470 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32TailLen
>> 16) & 0xFF);
3471 *pu8CurrByte
++ = ((pstrSetBeaconParam
->u32TailLen
>> 24) & 0xFF);
3473 /* Bug 4599 : if tail length = 0 skip copying */
3474 if (pstrSetBeaconParam
->pu8Tail
> 0)
3475 memcpy(pu8CurrByte
, pstrSetBeaconParam
->pu8Tail
, pstrSetBeaconParam
->u32TailLen
);
3476 pu8CurrByte
+= pstrSetBeaconParam
->u32TailLen
;
3481 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
3483 PRINT_ER("Failed to send add beacon config packet\n");
3484 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3487 WILC_CATCH(s32Error
)
3490 kfree(strWID
.ps8WidVal
);
3491 kfree(pstrSetBeaconParam
->pu8Head
);
3492 kfree(pstrSetBeaconParam
->pu8Tail
);
3497 * @brief Handle_AddBeacon
3498 * @details Sending config packet to delete beacon
3499 * @param[in] tstrHostIFDelBeacon* pstrDelBeacon
3505 static void Handle_DelBeacon(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFDelBeacon
*pstrDelBeacon
)
3507 s32 s32Error
= WILC_SUCCESS
;
3510 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3512 strWID
.u16WIDid
= (u16
)WID_DEL_BEACON
;
3513 strWID
.enuWIDtype
= WID_CHAR
;
3514 strWID
.s32ValueSize
= sizeof(char);
3515 strWID
.ps8WidVal
= &gu8DelBcn
;
3517 if (strWID
.ps8WidVal
== NULL
)
3518 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3520 pu8CurrByte
= strWID
.ps8WidVal
;
3522 PRINT_D(HOSTINF_DBG
, "Deleting BEACON\n");
3523 /* TODO: build del beacon message*/
3526 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
3529 PRINT_ER("Failed to send delete beacon config packet\n");
3530 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3533 WILC_CATCH(s32Error
)
3540 * @brief WILC_HostIf_PackStaParam
3541 * @details Handling packing of the station params in a buffer
3542 * @param[in] u8* pu8Buffer, tstrWILC_AddStaParam* pstrStationParam
3548 static u32
WILC_HostIf_PackStaParam(u8
*pu8Buffer
, tstrWILC_AddStaParam
*pstrStationParam
)
3552 pu8CurrByte
= pu8Buffer
;
3554 PRINT_D(HOSTINF_DBG
, "Packing STA params\n");
3555 memcpy(pu8CurrByte
, pstrStationParam
->au8BSSID
, ETH_ALEN
);
3556 pu8CurrByte
+= ETH_ALEN
;
3558 *pu8CurrByte
++ = pstrStationParam
->u16AssocID
& 0xFF;
3559 *pu8CurrByte
++ = (pstrStationParam
->u16AssocID
>> 8) & 0xFF;
3561 *pu8CurrByte
++ = pstrStationParam
->u8NumRates
;
3562 if (pstrStationParam
->u8NumRates
> 0)
3563 memcpy(pu8CurrByte
, pstrStationParam
->pu8Rates
, pstrStationParam
->u8NumRates
);
3564 pu8CurrByte
+= pstrStationParam
->u8NumRates
;
3566 *pu8CurrByte
++ = pstrStationParam
->bIsHTSupported
;
3567 *pu8CurrByte
++ = pstrStationParam
->u16HTCapInfo
& 0xFF;
3568 *pu8CurrByte
++ = (pstrStationParam
->u16HTCapInfo
>> 8) & 0xFF;
3570 *pu8CurrByte
++ = pstrStationParam
->u8AmpduParams
;
3571 memcpy(pu8CurrByte
, pstrStationParam
->au8SuppMCsSet
, WILC_SUPP_MCS_SET_SIZE
);
3572 pu8CurrByte
+= WILC_SUPP_MCS_SET_SIZE
;
3574 *pu8CurrByte
++ = pstrStationParam
->u16HTExtParams
& 0xFF;
3575 *pu8CurrByte
++ = (pstrStationParam
->u16HTExtParams
>> 8) & 0xFF;
3577 *pu8CurrByte
++ = pstrStationParam
->u32TxBeamformingCap
& 0xFF;
3578 *pu8CurrByte
++ = (pstrStationParam
->u32TxBeamformingCap
>> 8) & 0xFF;
3579 *pu8CurrByte
++ = (pstrStationParam
->u32TxBeamformingCap
>> 16) & 0xFF;
3580 *pu8CurrByte
++ = (pstrStationParam
->u32TxBeamformingCap
>> 24) & 0xFF;
3582 *pu8CurrByte
++ = pstrStationParam
->u8ASELCap
;
3584 *pu8CurrByte
++ = pstrStationParam
->u16FlagsMask
& 0xFF;
3585 *pu8CurrByte
++ = (pstrStationParam
->u16FlagsMask
>> 8) & 0xFF;
3587 *pu8CurrByte
++ = pstrStationParam
->u16FlagsSet
& 0xFF;
3588 *pu8CurrByte
++ = (pstrStationParam
->u16FlagsSet
>> 8) & 0xFF;
3590 return pu8CurrByte
- pu8Buffer
;
3594 * @brief Handle_AddStation
3595 * @details Sending config packet to add station
3596 * @param[in] tstrWILC_AddStaParam* pstrStationParam
3602 static void Handle_AddStation(tstrWILC_WFIDrv
*drvHandler
, tstrWILC_AddStaParam
*pstrStationParam
)
3604 s32 s32Error
= WILC_SUCCESS
;
3607 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3609 PRINT_D(HOSTINF_DBG
, "Handling add station\n");
3610 strWID
.u16WIDid
= (u16
)WID_ADD_STA
;
3611 strWID
.enuWIDtype
= WID_BIN
;
3612 strWID
.s32ValueSize
= WILC_ADD_STA_LENGTH
+ pstrStationParam
->u8NumRates
;
3614 strWID
.ps8WidVal
= WILC_MALLOC(strWID
.s32ValueSize
);
3615 if (strWID
.ps8WidVal
== NULL
)
3616 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3618 pu8CurrByte
= strWID
.ps8WidVal
;
3619 pu8CurrByte
+= WILC_HostIf_PackStaParam(pu8CurrByte
, pstrStationParam
);
3622 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
3623 if (s32Error
!= WILC_SUCCESS
) {
3625 PRINT_ER("Failed to send add station config packet\n");
3626 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3629 WILC_CATCH(s32Error
)
3632 kfree(pstrStationParam
->pu8Rates
);
3633 kfree(strWID
.ps8WidVal
);
3637 * @brief Handle_DelAllSta
3638 * @details Sending config packet to delete station
3639 * @param[in] tstrHostIFDelSta* pstrDelStaParam
3645 static void Handle_DelAllSta(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFDelAllSta
*pstrDelAllStaParam
)
3647 s32 s32Error
= WILC_SUCCESS
;
3651 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3653 u8 au8Zero_Buff
[6] = {0};
3655 strWID
.u16WIDid
= (u16
)WID_DEL_ALL_STA
;
3656 strWID
.enuWIDtype
= WID_STR
;
3657 strWID
.s32ValueSize
= (pstrDelAllStaParam
->u8Num_AssocSta
* ETH_ALEN
) + 1;
3659 PRINT_D(HOSTINF_DBG
, "Handling delete station\n");
3661 strWID
.ps8WidVal
= WILC_MALLOC((pstrDelAllStaParam
->u8Num_AssocSta
* ETH_ALEN
) + 1);
3662 if (strWID
.ps8WidVal
== NULL
)
3663 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3665 pu8CurrByte
= strWID
.ps8WidVal
;
3667 *(pu8CurrByte
++) = pstrDelAllStaParam
->u8Num_AssocSta
;
3669 for (i
= 0; i
< MAX_NUM_STA
; i
++) {
3670 if (memcmp(pstrDelAllStaParam
->au8Sta_DelAllSta
[i
], au8Zero_Buff
, ETH_ALEN
))
3671 memcpy(pu8CurrByte
, pstrDelAllStaParam
->au8Sta_DelAllSta
[i
], ETH_ALEN
);
3675 pu8CurrByte
+= ETH_ALEN
;
3679 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3682 PRINT_ER("Failed to send add station config packet\n");
3683 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3686 WILC_CATCH(s32Error
)
3689 kfree(strWID
.ps8WidVal
);
3696 * @brief Handle_DelStation
3697 * @details Sending config packet to delete station
3698 * @param[in] tstrHostIFDelSta* pstrDelStaParam
3704 static void Handle_DelStation(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFDelSta
*pstrDelStaParam
)
3706 s32 s32Error
= WILC_SUCCESS
;
3709 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3711 strWID
.u16WIDid
= (u16
)WID_REMOVE_STA
;
3712 strWID
.enuWIDtype
= WID_BIN
;
3713 strWID
.s32ValueSize
= ETH_ALEN
;
3715 PRINT_D(HOSTINF_DBG
, "Handling delete station\n");
3717 strWID
.ps8WidVal
= WILC_MALLOC(strWID
.s32ValueSize
);
3718 if (strWID
.ps8WidVal
== NULL
)
3719 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3721 pu8CurrByte
= strWID
.ps8WidVal
;
3723 memcpy(pu8CurrByte
, pstrDelStaParam
->au8MacAddr
, ETH_ALEN
);
3726 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
3729 PRINT_ER("Failed to send add station config packet\n");
3730 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3733 WILC_CATCH(s32Error
)
3736 kfree(strWID
.ps8WidVal
);
3741 * @brief Handle_EditStation
3742 * @details Sending config packet to edit station
3743 * @param[in] tstrWILC_AddStaParam* pstrStationParam
3749 static void Handle_EditStation(tstrWILC_WFIDrv
*drvHandler
, tstrWILC_AddStaParam
*pstrStationParam
)
3751 s32 s32Error
= WILC_SUCCESS
;
3754 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3756 strWID
.u16WIDid
= (u16
)WID_EDIT_STA
;
3757 strWID
.enuWIDtype
= WID_BIN
;
3758 strWID
.s32ValueSize
= WILC_ADD_STA_LENGTH
+ pstrStationParam
->u8NumRates
;
3760 PRINT_D(HOSTINF_DBG
, "Handling edit station\n");
3761 strWID
.ps8WidVal
= WILC_MALLOC(strWID
.s32ValueSize
);
3762 if (strWID
.ps8WidVal
== NULL
)
3763 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3765 pu8CurrByte
= strWID
.ps8WidVal
;
3766 pu8CurrByte
+= WILC_HostIf_PackStaParam(pu8CurrByte
, pstrStationParam
);
3769 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)pstrWFIDrv
);
3772 PRINT_ER("Failed to send edit station config packet\n");
3773 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
3776 WILC_CATCH(s32Error
)
3779 kfree(pstrStationParam
->pu8Rates
);
3780 kfree(strWID
.ps8WidVal
);
3782 #endif /*WILC_AP_EXTERNAL_MLME*/
3786 * @brief Handle_RemainOnChan
3787 * @details Sending config packet to edit station
3788 * @param[in] tstrWILC_AddStaParam* pstrStationParam
3794 static int Handle_RemainOnChan(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfRemainOnChan
*pstrHostIfRemainOnChan
)
3796 s32 s32Error
= WILC_SUCCESS
;
3797 u8 u8remain_on_chan_flag
;
3799 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*) drvHandler
;
3801 /*If it's a pendig remain-on-channel, don't overwrite gWFiDrvHandle values (since incoming msg is garbbage)*/
3802 if (!pstrWFIDrv
->u8RemainOnChan_pendingreq
) {
3803 pstrWFIDrv
->strHostIfRemainOnChan
.pVoid
= pstrHostIfRemainOnChan
->pVoid
;
3804 pstrWFIDrv
->strHostIfRemainOnChan
.pRemainOnChanExpired
= pstrHostIfRemainOnChan
->pRemainOnChanExpired
;
3805 pstrWFIDrv
->strHostIfRemainOnChan
.pRemainOnChanReady
= pstrHostIfRemainOnChan
->pRemainOnChanReady
;
3806 pstrWFIDrv
->strHostIfRemainOnChan
.u16Channel
= pstrHostIfRemainOnChan
->u16Channel
;
3807 pstrWFIDrv
->strHostIfRemainOnChan
.u32ListenSessionID
= pstrHostIfRemainOnChan
->u32ListenSessionID
;
3809 /*Set the channel to use it as a wid val*/
3810 pstrHostIfRemainOnChan
->u16Channel
= pstrWFIDrv
->strHostIfRemainOnChan
.u16Channel
;
3813 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
!= NULL
) {
3814 PRINT_INFO(GENERIC_DBG
, "Required to remain on chan while scanning return\n");
3815 pstrWFIDrv
->u8RemainOnChan_pendingreq
= 1;
3816 WILC_ERRORREPORT(s32Error
, WILC_BUSY
);
3818 if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_WAITING_CONN_RESP
) {
3819 PRINT_INFO(GENERIC_DBG
, "Required to remain on chan while connecting return\n");
3820 WILC_ERRORREPORT(s32Error
, WILC_BUSY
);
3823 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
3824 if (g_obtainingIP
|| connecting
) {
3825 PRINT_D(GENERIC_DBG
, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
3826 WILC_ERRORREPORT(s32Error
, WILC_BUSY
);
3830 PRINT_D(HOSTINF_DBG
, "Setting channel :%d\n", pstrHostIfRemainOnChan
->u16Channel
);
3832 u8remain_on_chan_flag
= true;
3833 strWID
.u16WIDid
= (u16
)WID_REMAIN_ON_CHAN
;
3834 strWID
.enuWIDtype
= WID_STR
;
3835 strWID
.s32ValueSize
= 2;
3836 strWID
.ps8WidVal
= (s8
*)WILC_MALLOC(strWID
.s32ValueSize
);
3838 if (strWID
.ps8WidVal
== NULL
)
3839 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3841 strWID
.ps8WidVal
[0] = u8remain_on_chan_flag
;
3842 strWID
.ps8WidVal
[1] = (s8
)pstrHostIfRemainOnChan
->u16Channel
;
3845 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3846 if (s32Error
!= WILC_SUCCESS
)
3847 PRINT_ER("Failed to set remain on channel\n");
3851 P2P_LISTEN_STATE
= 1;
3852 WILC_TimerStart(&(pstrWFIDrv
->hRemainOnChannel
), pstrHostIfRemainOnChan
->u32duration
, (void *)pstrWFIDrv
, NULL
);
3854 /*Calling CFG ready_on_channel*/
3855 if (pstrWFIDrv
->strHostIfRemainOnChan
.pRemainOnChanReady
)
3856 pstrWFIDrv
->strHostIfRemainOnChan
.pRemainOnChanReady(pstrWFIDrv
->strHostIfRemainOnChan
.pVoid
);
3858 if (pstrWFIDrv
->u8RemainOnChan_pendingreq
)
3859 pstrWFIDrv
->u8RemainOnChan_pendingreq
= 0;
3865 * @brief Handle_RegisterFrame
3873 static int Handle_RegisterFrame(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfRegisterFrame
*pstrHostIfRegisterFrame
)
3875 s32 s32Error
= WILC_SUCCESS
;
3878 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
3880 PRINT_D(HOSTINF_DBG
, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame
->bReg
, pstrHostIfRegisterFrame
->u16FrameType
);
3882 /*prepare configuration packet*/
3883 strWID
.u16WIDid
= (u16
)WID_REGISTER_FRAME
;
3884 strWID
.enuWIDtype
= WID_STR
;
3885 strWID
.ps8WidVal
= WILC_MALLOC(sizeof(u16
) + 2);
3886 if (strWID
.ps8WidVal
== NULL
)
3887 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
3889 pu8CurrByte
= strWID
.ps8WidVal
;
3891 *pu8CurrByte
++ = pstrHostIfRegisterFrame
->bReg
;
3892 *pu8CurrByte
++ = pstrHostIfRegisterFrame
->u8Regid
;
3893 memcpy(pu8CurrByte
, &(pstrHostIfRegisterFrame
->u16FrameType
), sizeof(u16
));
3896 strWID
.s32ValueSize
= sizeof(u16
) + 2;
3900 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3902 PRINT_ER("Failed to frame register config packet\n");
3903 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
3907 WILC_CATCH(s32Error
)
3916 * @brief Handle_ListenStateExpired
3917 * @details Handle of listen state expiration
3919 * @return Error code.
3924 #define FALSE_FRMWR_CHANNEL 100
3925 static u32
Handle_ListenStateExpired(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfRemainOnChan
*pstrHostIfRemainOnChan
)
3927 u8 u8remain_on_chan_flag
;
3929 s32 s32Error
= WILC_SUCCESS
;
3930 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*) drvHandler
;
3932 PRINT_D(HOSTINF_DBG
, "CANCEL REMAIN ON CHAN\n");
3935 /*Make sure we are already in listen state*/
3936 /*This is to handle duplicate expiry messages (listen timer fired and supplicant called cancel_remain_on_channel())*/
3937 if (P2P_LISTEN_STATE
) {
3938 u8remain_on_chan_flag
= false;
3939 strWID
.u16WIDid
= (u16
)WID_REMAIN_ON_CHAN
;
3940 strWID
.enuWIDtype
= WID_STR
;
3941 strWID
.s32ValueSize
= 2;
3942 strWID
.ps8WidVal
= WILC_MALLOC(strWID
.s32ValueSize
);
3944 if (strWID
.ps8WidVal
== NULL
)
3945 PRINT_ER("Failed to allocate memory\n");
3947 strWID
.ps8WidVal
[0] = u8remain_on_chan_flag
;
3948 strWID
.ps8WidVal
[1] = FALSE_FRMWR_CHANNEL
;
3951 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
3952 if (s32Error
!= WILC_SUCCESS
) {
3953 PRINT_ER("Failed to set remain on channel\n");
3957 if (pstrWFIDrv
->strHostIfRemainOnChan
.pRemainOnChanExpired
) {
3958 pstrWFIDrv
->strHostIfRemainOnChan
.pRemainOnChanExpired(pstrWFIDrv
->strHostIfRemainOnChan
.pVoid
3959 , pstrHostIfRemainOnChan
->u32ListenSessionID
);
3961 P2P_LISTEN_STATE
= 0;
3963 PRINT_D(GENERIC_DBG
, "Not in listen state\n");
3964 s32Error
= WILC_FAIL
;
3973 * @brief ListenTimerCB
3974 * @details Callback function of remain-on-channel timer
3976 * @return Error code.
3981 static void ListenTimerCB(void *pvArg
)
3983 s32 s32Error
= WILC_SUCCESS
;
3984 tstrHostIFmsg strHostIFmsg
;
3985 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)pvArg
;
3986 /*Stopping remain-on-channel timer*/
3987 WILC_TimerStop(&(pstrWFIDrv
->hRemainOnChannel
), NULL
);
3989 /* prepare the Timer Callback message */
3990 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
3991 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_LISTEN_TIMER_FIRED
;
3992 strHostIFmsg
.drvHandler
= pstrWFIDrv
;
3993 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.u32ListenSessionID
= pstrWFIDrv
->strHostIfRemainOnChan
.u32ListenSessionID
;
3995 /* send the message */
3996 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
3998 WILC_ERRORREPORT(s32Error
, s32Error
);
3999 WILC_CATCH(s32Error
)
4008 * @brief Handle_EditStation
4009 * @details Sending config packet to edit station
4010 * @param[in] tstrWILC_AddStaParam* pstrStationParam
4016 static void Handle_PowerManagement(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfPowerMgmtParam
*strPowerMgmtParam
)
4018 s32 s32Error
= WILC_SUCCESS
;
4021 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
4023 strWID
.u16WIDid
= (u16
)WID_POWER_MANAGEMENT
;
4025 if (strPowerMgmtParam
->bIsEnabled
== true)
4026 s8PowerMode
= MIN_FAST_PS
;
4028 s8PowerMode
= NO_POWERSAVE
;
4029 PRINT_D(HOSTINF_DBG
, "Handling power mgmt to %d\n", s8PowerMode
);
4030 strWID
.ps8WidVal
= &s8PowerMode
;
4031 strWID
.s32ValueSize
= sizeof(char);
4033 PRINT_D(HOSTINF_DBG
, "Handling Power Management\n");
4036 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
4038 PRINT_ER("Failed to send power management config packet\n");
4039 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
4042 WILC_CATCH(s32Error
)
4049 * @brief Handle_SetMulticastFilter
4050 * @details Set Multicast filter in firmware
4051 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4057 static void Handle_SetMulticastFilter(tstrWILC_WFIDrv
*drvHandler
, tstrHostIFSetMulti
*strHostIfSetMulti
)
4059 s32 s32Error
= WILC_SUCCESS
;
4063 PRINT_D(HOSTINF_DBG
, "Setup Multicast Filter\n");
4065 strWID
.u16WIDid
= (u16
)WID_SETUP_MULTICAST_FILTER
;
4066 strWID
.enuWIDtype
= WID_BIN
;
4067 strWID
.s32ValueSize
= sizeof(tstrHostIFSetMulti
) + ((strHostIfSetMulti
->u32count
) * ETH_ALEN
);
4068 strWID
.ps8WidVal
= WILC_MALLOC(strWID
.s32ValueSize
);
4069 if (strWID
.ps8WidVal
== NULL
)
4070 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
4072 pu8CurrByte
= strWID
.ps8WidVal
;
4073 *pu8CurrByte
++ = (strHostIfSetMulti
->bIsEnabled
& 0xFF);
4074 *pu8CurrByte
++ = ((strHostIfSetMulti
->bIsEnabled
>> 8) & 0xFF);
4075 *pu8CurrByte
++ = ((strHostIfSetMulti
->bIsEnabled
>> 16) & 0xFF);
4076 *pu8CurrByte
++ = ((strHostIfSetMulti
->bIsEnabled
>> 24) & 0xFF);
4078 *pu8CurrByte
++ = (strHostIfSetMulti
->u32count
& 0xFF);
4079 *pu8CurrByte
++ = ((strHostIfSetMulti
->u32count
>> 8) & 0xFF);
4080 *pu8CurrByte
++ = ((strHostIfSetMulti
->u32count
>> 16) & 0xFF);
4081 *pu8CurrByte
++ = ((strHostIfSetMulti
->u32count
>> 24) & 0xFF);
4083 if ((strHostIfSetMulti
->u32count
) > 0)
4084 memcpy(pu8CurrByte
, gau8MulticastMacAddrList
, ((strHostIfSetMulti
->u32count
) * ETH_ALEN
));
4087 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, false, (u32
)drvHandler
);
4089 PRINT_ER("Failed to send setup multicast config packet\n");
4090 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
4093 WILC_CATCH(s32Error
)
4096 kfree(strWID
.ps8WidVal
);
4103 * @brief Handle_AddBASession
4104 * @details Add block ack session
4105 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4107 * @author Amr Abdel-Moghny
4111 static s32
Handle_AddBASession(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfBASessionInfo
*strHostIfBASessionInfo
)
4113 s32 s32Error
= WILC_SUCCESS
;
4115 int AddbaTimeout
= 100;
4117 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
4119 PRINT_D(HOSTINF_DBG
, "Opening Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\nBufferSize == %d\nSessionTimeOut = %d\n",
4120 strHostIfBASessionInfo
->au8Bssid
[0],
4121 strHostIfBASessionInfo
->au8Bssid
[1],
4122 strHostIfBASessionInfo
->au8Bssid
[2],
4123 strHostIfBASessionInfo
->u16BufferSize
,
4124 strHostIfBASessionInfo
->u16SessionTimeout
,
4125 strHostIfBASessionInfo
->u8Ted
);
4127 strWID
.u16WIDid
= (u16
)WID_11E_P_ACTION_REQ
;
4128 strWID
.enuWIDtype
= WID_STR
;
4129 strWID
.ps8WidVal
= (u8
*)WILC_MALLOC(BLOCK_ACK_REQ_SIZE
);
4130 strWID
.s32ValueSize
= BLOCK_ACK_REQ_SIZE
;
4131 ptr
= strWID
.ps8WidVal
;
4132 /* *ptr++ = 0x14; */
4136 memcpy(ptr
, strHostIfBASessionInfo
->au8Bssid
, ETH_ALEN
);
4138 *ptr
++ = strHostIfBASessionInfo
->u8Ted
;
4142 *ptr
++ = (strHostIfBASessionInfo
->u16BufferSize
& 0xFF);
4143 *ptr
++ = ((strHostIfBASessionInfo
->u16BufferSize
>> 16) & 0xFF);
4145 *ptr
++ = (strHostIfBASessionInfo
->u16SessionTimeout
& 0xFF);
4146 *ptr
++ = ((strHostIfBASessionInfo
->u16SessionTimeout
>> 16) & 0xFF);
4148 *ptr
++ = (AddbaTimeout
& 0xFF);
4149 *ptr
++ = ((AddbaTimeout
>> 16) & 0xFF);
4150 /* Group Buffer Max Frames*/
4152 /* Group Buffer Timeout */
4155 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
4157 PRINT_D(HOSTINF_DBG
, "Couldn't open BA Session\n");
4160 strWID
.u16WIDid
= (u16
)WID_11E_P_ACTION_REQ
;
4161 strWID
.enuWIDtype
= WID_STR
;
4162 strWID
.s32ValueSize
= 15;
4163 ptr
= strWID
.ps8WidVal
;
4164 /* *ptr++ = 0x14; */
4168 memcpy(ptr
, strHostIfBASessionInfo
->au8Bssid
, ETH_ALEN
);
4171 *ptr
++ = strHostIfBASessionInfo
->u8Ted
;
4175 *ptr
++ = (strHostIfBASessionInfo
->u16BufferSize
& 0xFF);
4176 *ptr
++ = ((strHostIfBASessionInfo
->u16SessionTimeout
>> 16) & 0xFF);
4179 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
4181 if (strWID
.ps8WidVal
!= NULL
)
4182 kfree(strWID
.ps8WidVal
);
4191 * @brief Handle_DelBASession
4192 * @details Delete block ack session
4193 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4195 * @author Amr Abdel-Moghny
4199 static s32
Handle_DelBASession(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfBASessionInfo
*strHostIfBASessionInfo
)
4201 s32 s32Error
= WILC_SUCCESS
;
4204 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
4206 PRINT_D(GENERIC_DBG
, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
4207 strHostIfBASessionInfo
->au8Bssid
[0],
4208 strHostIfBASessionInfo
->au8Bssid
[1],
4209 strHostIfBASessionInfo
->au8Bssid
[2],
4210 strHostIfBASessionInfo
->u8Ted
);
4212 strWID
.u16WIDid
= (u16
)WID_11E_P_ACTION_REQ
;
4213 strWID
.enuWIDtype
= WID_STR
;
4214 strWID
.ps8WidVal
= (u8
*)WILC_MALLOC(BLOCK_ACK_REQ_SIZE
);
4215 strWID
.s32ValueSize
= BLOCK_ACK_REQ_SIZE
;
4216 ptr
= strWID
.ps8WidVal
;
4217 /* *ptr++ = 0x14; */
4221 memcpy(ptr
, strHostIfBASessionInfo
->au8Bssid
, ETH_ALEN
);
4223 *ptr
++ = strHostIfBASessionInfo
->u8Ted
;
4224 /* BA direction = recipent*/
4227 *ptr
++ = 32; /* Unspecific QOS reason */
4229 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
4231 PRINT_D(HOSTINF_DBG
, "Couldn't delete BA Session\n");
4234 strWID
.u16WIDid
= (u16
)WID_11E_P_ACTION_REQ
;
4235 strWID
.enuWIDtype
= WID_STR
;
4236 strWID
.s32ValueSize
= 15;
4237 ptr
= strWID
.ps8WidVal
;
4238 /* *ptr++ = 0x14; */
4242 memcpy(ptr
, strHostIfBASessionInfo
->au8Bssid
, ETH_ALEN
);
4245 *ptr
++ = strHostIfBASessionInfo
->u8Ted
;
4247 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
4249 if (strWID
.ps8WidVal
!= NULL
)
4250 kfree(strWID
.ps8WidVal
);
4261 * @brief Handle_DelAllRxBASessions
4262 * @details Delete all Rx BA sessions
4263 * @param[in] tstrHostIFSetMulti* strHostIfSetMulti
4265 * @author Abdelrahman Sobhy
4269 static s32
Handle_DelAllRxBASessions(tstrWILC_WFIDrv
*drvHandler
, tstrHostIfBASessionInfo
*strHostIfBASessionInfo
)
4271 s32 s32Error
= WILC_SUCCESS
;
4274 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
4276 PRINT_D(GENERIC_DBG
, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
4277 strHostIfBASessionInfo
->au8Bssid
[0],
4278 strHostIfBASessionInfo
->au8Bssid
[1],
4279 strHostIfBASessionInfo
->au8Bssid
[2],
4280 strHostIfBASessionInfo
->u8Ted
);
4282 strWID
.u16WIDid
= (u16
)WID_DEL_ALL_RX_BA
;
4283 strWID
.enuWIDtype
= WID_STR
;
4284 strWID
.ps8WidVal
= (u8
*)WILC_MALLOC(BLOCK_ACK_REQ_SIZE
);
4285 strWID
.s32ValueSize
= BLOCK_ACK_REQ_SIZE
;
4286 ptr
= strWID
.ps8WidVal
;
4290 memcpy(ptr
, strHostIfBASessionInfo
->au8Bssid
, ETH_ALEN
);
4292 *ptr
++ = strHostIfBASessionInfo
->u8Ted
;
4293 /* BA direction = recipent*/
4296 *ptr
++ = 32; /* Unspecific QOS reason */
4298 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
4300 PRINT_D(HOSTINF_DBG
, "Couldn't delete BA Session\n");
4303 if (strWID
.ps8WidVal
!= NULL
)
4304 kfree(strWID
.ps8WidVal
);
4314 * @brief hostIFthread
4315 * @details Main thread to handle message queue requests
4316 * @param[in] void* pvArg
4322 static int hostIFthread(void *pvArg
)
4325 tstrHostIFmsg strHostIFmsg
;
4326 tstrWILC_WFIDrv
*pstrWFIDrv
;
4328 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4331 WILC_MsgQueueRecv(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), &u32Ret
, NULL
);
4332 pstrWFIDrv
= (tstrWILC_WFIDrv
*)strHostIFmsg
.drvHandler
;
4333 if (strHostIFmsg
.u16MsgId
== HOST_IF_MSG_EXIT
) {
4334 PRINT_D(GENERIC_DBG
, "THREAD: Exiting HostIfThread\n");
4339 /*Re-Queue HIF message*/
4340 if ((!g_wilc_initialized
)) {
4341 PRINT_D(GENERIC_DBG
, "--WAIT--");
4343 WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4347 if (strHostIFmsg
.u16MsgId
== HOST_IF_MSG_CONNECT
&& pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
!= NULL
) {
4348 PRINT_D(HOSTINF_DBG
, "Requeue connect request till scan done received\n");
4349 WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4354 switch (strHostIFmsg
.u16MsgId
) {
4355 case HOST_IF_MSG_Q_IDLE
:
4356 Handle_wait_msg_q_empty();
4359 case HOST_IF_MSG_SCAN
:
4360 Handle_Scan(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
);
4363 case HOST_IF_MSG_CONNECT
:
4364 Handle_Connect(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
);
4368 case HOST_IF_MSG_FLUSH_CONNECT
:
4369 Handle_FlushConnect(strHostIFmsg
.drvHandler
);
4372 case HOST_IF_MSG_RCVD_NTWRK_INFO
:
4373 Handle_RcvdNtwrkInfo(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strRcvdNetworkInfo
);
4376 case HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO
:
4377 Handle_RcvdGnrlAsyncInfo(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strRcvdGnrlAsyncInfo
);
4380 case HOST_IF_MSG_KEY
:
4381 Handle_Key(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
);
4384 case HOST_IF_MSG_CFG_PARAMS
:
4386 Handle_CfgParam(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFCfgParamAttr
);
4389 case HOST_IF_MSG_SET_CHANNEL
:
4390 Handle_SetChannel(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFSetChan
);
4393 case HOST_IF_MSG_DISCONNECT
:
4394 Handle_Disconnect(strHostIFmsg
.drvHandler
);
4397 case HOST_IF_MSG_RCVD_SCAN_COMPLETE
:
4398 WILC_TimerStop(&(pstrWFIDrv
->hScanTimer
), NULL
);
4399 PRINT_D(HOSTINF_DBG
, "scan completed successfully\n");
4402 /*Allow chip sleep, only if both interfaces are not connected*/
4403 if (!linux_wlan_get_num_conn_ifcs())
4404 chip_sleep_manually(INFINITE_SLEEP_TIME
);
4406 Handle_ScanDone(strHostIFmsg
.drvHandler
, SCAN_EVENT_DONE
);
4409 if (pstrWFIDrv
->u8RemainOnChan_pendingreq
)
4410 Handle_RemainOnChan(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
);
4415 case HOST_IF_MSG_GET_RSSI
:
4416 Handle_GetRssi(strHostIFmsg
.drvHandler
);
4419 case HOST_IF_MSG_GET_LINKSPEED
:
4420 Handle_GetLinkspeed(strHostIFmsg
.drvHandler
);
4423 case HOST_IF_MSG_GET_STATISTICS
:
4424 Handle_GetStatistics(strHostIFmsg
.drvHandler
, (tstrStatistics
*)strHostIFmsg
.uniHostIFmsgBody
.pUserData
);
4427 case HOST_IF_MSG_GET_CHNL
:
4428 Handle_GetChnl(strHostIFmsg
.drvHandler
);
4431 #ifdef WILC_AP_EXTERNAL_MLME
4432 case HOST_IF_MSG_ADD_BEACON
:
4433 Handle_AddBeacon(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFSetBeacon
);
4436 case HOST_IF_MSG_DEL_BEACON
:
4437 Handle_DelBeacon(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFDelBeacon
);
4440 case HOST_IF_MSG_ADD_STATION
:
4441 Handle_AddStation(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strAddStaParam
);
4444 case HOST_IF_MSG_DEL_STATION
:
4445 Handle_DelStation(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strDelStaParam
);
4448 case HOST_IF_MSG_EDIT_STATION
:
4449 Handle_EditStation(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strEditStaParam
);
4452 case HOST_IF_MSG_GET_INACTIVETIME
:
4453 Handle_Get_InActiveTime(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfStaInactiveT
);
4456 #endif /*WILC_AP_EXTERNAL_MLME*/
4457 case HOST_IF_MSG_SCAN_TIMER_FIRED
:
4458 PRINT_D(HOSTINF_DBG
, "Scan Timeout\n");
4460 Handle_ScanDone(strHostIFmsg
.drvHandler
, SCAN_EVENT_ABORTED
);
4463 case HOST_IF_MSG_CONNECT_TIMER_FIRED
:
4464 PRINT_D(HOSTINF_DBG
, "Connect Timeout\n");
4465 Handle_ConnectTimeout(strHostIFmsg
.drvHandler
);
4468 case HOST_IF_MSG_POWER_MGMT
:
4469 Handle_PowerManagement(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strPowerMgmtparam
);
4472 case HOST_IF_MSG_SET_WFIDRV_HANDLER
:
4473 Handle_SetWfiDrvHandler(&strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetDrvHandler
);
4476 case HOST_IF_MSG_SET_OPERATION_MODE
:
4477 Handle_SetOperationMode(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetOperationMode
);
4480 case HOST_IF_MSG_SET_IPADDRESS
:
4481 PRINT_D(HOSTINF_DBG
, "HOST_IF_MSG_SET_IPADDRESS\n");
4482 Handle_set_IPAddress(strHostIFmsg
.drvHandler
, strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.au8IPAddr
, strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.idx
);
4485 case HOST_IF_MSG_GET_IPADDRESS
:
4486 PRINT_D(HOSTINF_DBG
, "HOST_IF_MSG_SET_IPADDRESS\n");
4487 Handle_get_IPAddress(strHostIFmsg
.drvHandler
, strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.au8IPAddr
, strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.idx
);
4491 case HOST_IF_MSG_SET_MAC_ADDRESS
:
4492 Handle_SetMacAddress(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetMacAddress
);
4496 case HOST_IF_MSG_GET_MAC_ADDRESS
:
4497 Handle_GetMacAddress(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfGetMacAddress
);
4501 case HOST_IF_MSG_REMAIN_ON_CHAN
:
4502 PRINT_D(HOSTINF_DBG
, "HOST_IF_MSG_REMAIN_ON_CHAN\n");
4503 Handle_RemainOnChan(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
);
4506 case HOST_IF_MSG_REGISTER_FRAME
:
4507 PRINT_D(HOSTINF_DBG
, "HOST_IF_MSG_REGISTER_FRAME\n");
4508 Handle_RegisterFrame(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfRegisterFrame
);
4511 case HOST_IF_MSG_LISTEN_TIMER_FIRED
:
4512 Handle_ListenStateExpired(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
);
4516 case HOST_IF_MSG_SET_MULTICAST_FILTER
:
4517 PRINT_D(HOSTINF_DBG
, "HOST_IF_MSG_SET_MULTICAST_FILTER\n");
4518 Handle_SetMulticastFilter(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetMulti
);
4522 case HOST_IF_MSG_ADD_BA_SESSION
:
4523 Handle_AddBASession(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfBASessionInfo
);
4526 case HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS
:
4527 Handle_DelAllRxBASessions(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIfBASessionInfo
);
4530 case HOST_IF_MSG_DEL_ALL_STA
:
4531 Handle_DelAllSta(strHostIFmsg
.drvHandler
, &strHostIFmsg
.uniHostIFmsgBody
.strHostIFDelAllSta
);
4535 PRINT_ER("[Host Interface] undefined Received Msg ID\n");
4540 PRINT_D(HOSTINF_DBG
, "Releasing thread exit semaphore\n");
4541 up(&hSemHostIFthrdEnd
);
4545 static void TimerCB_Scan(void *pvArg
)
4547 tstrHostIFmsg strHostIFmsg
;
4549 /* prepare the Timer Callback message */
4550 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4551 strHostIFmsg
.drvHandler
= pvArg
;
4552 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SCAN_TIMER_FIRED
;
4554 /* send the message */
4555 WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4558 static void TimerCB_Connect(void *pvArg
)
4560 tstrHostIFmsg strHostIFmsg
;
4562 /* prepare the Timer Callback message */
4563 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4564 strHostIFmsg
.drvHandler
= pvArg
;
4565 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_CONNECT_TIMER_FIRED
;
4567 /* send the message */
4568 WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4573 * @brief removes wpa/wpa2 keys
4574 * @details only in BSS STA mode if External Supplicant support is enabled.
4575 * removes all WPA/WPA2 station key entries from MAC hardware.
4576 * @param[in,out] handle to the wifi driver
4577 * @param[in] 6 bytes of Station Adress in the station entry table
4578 * @return Error code indicating success/failure
4581 * @date 8 March 2012
4584 /* Check implementation in core adding 9 bytes to the input! */
4585 s32
host_int_remove_key(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*pu8StaAddress
)
4587 s32 s32Error
= WILC_SUCCESS
;
4589 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
4591 strWID
.u16WIDid
= (u16
)WID_REMOVE_KEY
;
4592 strWID
.enuWIDtype
= WID_STR
;
4593 strWID
.ps8WidVal
= (s8
*)pu8StaAddress
;
4594 strWID
.s32ValueSize
= 6;
4601 * @brief removes WEP key
4602 * @details valid only in BSS STA mode if External Supplicant support is enabled.
4603 * remove a WEP key entry from MAC HW.
4604 * The BSS Station automatically finds the index of the entry using its
4605 * BSS ID and removes that entry from the MAC hardware.
4606 * @param[in,out] handle to the wifi driver
4607 * @param[in] 6 bytes of Station Adress in the station entry table
4608 * @return Error code indicating success/failure
4609 * @note NO need for the STA add since it is not used for processing
4611 * @date 8 March 2012
4614 s32
host_int_remove_wep_key(tstrWILC_WFIDrv
*hWFIDrv
, u8 u8keyIdx
)
4616 s32 s32Error
= WILC_SUCCESS
;
4617 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
4618 tstrHostIFmsg strHostIFmsg
;
4621 if (pstrWFIDrv
== NULL
)
4622 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
4624 /* prepare the Remove Wep Key Message */
4625 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4628 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
4629 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= WEP
;
4630 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= REMOVEKEY
;
4631 strHostIFmsg
.drvHandler
= hWFIDrv
;
4635 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4636 uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
= u8keyIdx
;
4638 /* send the message */
4639 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4641 PRINT_ER("Error in sending message queue : Request to remove WEP key\n");
4642 down(&(pstrWFIDrv
->hSemTestKeyBlock
));
4644 WILC_CATCH(s32Error
)
4652 * @brief sets WEP default key
4653 * @details Sets the index of the WEP encryption key in use,
4655 * @param[in,out] handle to the wifi driver
4656 * @param[in] key index ( 0, 1, 2, 3)
4657 * @return Error code indicating success/failure
4660 * @date 8 March 2012
4663 s32
host_int_set_WEPDefaultKeyID(tstrWILC_WFIDrv
*hWFIDrv
, u8 u8Index
)
4665 s32 s32Error
= WILC_SUCCESS
;
4666 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
4667 tstrHostIFmsg strHostIFmsg
;
4670 if (pstrWFIDrv
== NULL
)
4671 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
4673 /* prepare the Key Message */
4674 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4677 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
4678 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= WEP
;
4679 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= DEFAULTKEY
;
4680 strHostIFmsg
.drvHandler
= hWFIDrv
;
4683 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4684 uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
= u8Index
;
4686 /* send the message */
4687 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4689 PRINT_ER("Error in sending message queue : Default key index\n");
4690 down(&(pstrWFIDrv
->hSemTestKeyBlock
));
4692 WILC_CATCH(s32Error
)
4701 * @brief sets WEP deafault key
4702 * @details valid only in BSS STA mode if External Supplicant support is enabled.
4703 * sets WEP key entry into MAC hardware when it receives the
4704 * corresponding request from NDIS.
4705 * @param[in,out] handle to the wifi driver
4706 * @param[in] message containing WEP Key in the following format
4707 *|---------------------------------------|
4708 *|Key ID Value | Key Length | Key |
4709 *|-------------|------------|------------|
4710 | 1byte | 1byte | Key Length |
4711 ||---------------------------------------|
4713 * @return Error code indicating success/failure
4716 * @date 8 March 2012
4719 s32
host_int_add_wep_key_bss_sta(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*pu8WepKey
, u8 u8WepKeylen
, u8 u8Keyidx
)
4722 s32 s32Error
= WILC_SUCCESS
;
4723 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
4724 tstrHostIFmsg strHostIFmsg
;
4726 if (pstrWFIDrv
== NULL
)
4727 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
4730 /* prepare the Key Message */
4731 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4734 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
4735 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= WEP
;
4736 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY
;
4737 strHostIFmsg
.drvHandler
= hWFIDrv
;
4740 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4741 uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
= (u8
*)WILC_MALLOC(u8WepKeylen
);
4743 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
,
4744 pu8WepKey
, u8WepKeylen
);
4747 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4748 uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
= (u8WepKeylen
);
4750 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4751 uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
= u8Keyidx
;
4753 /* send the message */
4754 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4756 PRINT_ER("Error in sending message queue :WEP Key\n");
4757 down(&(pstrWFIDrv
->hSemTestKeyBlock
));
4759 WILC_CATCH(s32Error
)
4767 #ifdef WILC_AP_EXTERNAL_MLME
4770 * @brief host_int_add_wep_key_bss_ap
4771 * @details valid only in BSS AP mode if External Supplicant support is enabled.
4772 * sets WEP key entry into MAC hardware when it receives the
4774 * corresponding request from NDIS.
4775 * @param[in,out] handle to the wifi driver
4778 * @return Error code indicating success/failure
4784 s32
host_int_add_wep_key_bss_ap(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*pu8WepKey
, u8 u8WepKeylen
, u8 u8Keyidx
, u8 u8mode
, AUTHTYPE_T tenuAuth_type
)
4787 s32 s32Error
= WILC_SUCCESS
;
4788 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
4789 tstrHostIFmsg strHostIFmsg
;
4792 if (pstrWFIDrv
== NULL
)
4793 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
4796 /* prepare the Key Message */
4797 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4800 for (i
= 0; i
< u8WepKeylen
; i
++)
4801 PRINT_INFO(HOSTAPD_DBG
, "KEY is %x\n", pu8WepKey
[i
]);
4803 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
4804 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= WEP
;
4805 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY_AP
;
4806 strHostIFmsg
.drvHandler
= hWFIDrv
;
4809 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4810 uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
= (u8
*)WILC_MALLOC((u8WepKeylen
));
4813 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwepAttr
.pu8WepKey
,
4814 pu8WepKey
, (u8WepKeylen
));
4817 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4818 uniHostIFkeyAttr
.strHostIFwepAttr
.u8WepKeylen
= (u8WepKeylen
);
4820 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4821 uniHostIFkeyAttr
.strHostIFwepAttr
.u8Wepidx
= u8Keyidx
;
4823 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4824 uniHostIFkeyAttr
.strHostIFwepAttr
.u8mode
= u8mode
;
4826 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4827 uniHostIFkeyAttr
.strHostIFwepAttr
.tenuAuth_type
= tenuAuth_type
;
4828 /* send the message */
4829 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4832 PRINT_ER("Error in sending message queue :WEP Key\n");
4833 down(&(pstrWFIDrv
->hSemTestKeyBlock
));
4835 WILC_CATCH(s32Error
)
4844 * @brief adds ptk Key
4846 * @param[in,out] handle to the wifi driver
4847 * @param[in] message containing PTK Key in the following format
4848 *|-----------------------------------------------------------------------------|
4849 *|Station address | Key Length | Temporal Key | Rx Michael Key |Tx Michael Key |
4850 *|----------------|------------|--------------|----------------|---------------|
4851 | 6 bytes | 1byte | 16 bytes | 8 bytes | 8 bytes |
4852 ||-----------------------------------------------------------------------------|
4853 * @return Error code indicating success/failure
4856 * @date 8 March 2012
4859 s32
host_int_add_ptk(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*pu8Ptk
, u8 u8PtkKeylen
,
4860 const u8
*mac_addr
, const u8
*pu8RxMic
, const u8
*pu8TxMic
, u8 mode
, u8 u8Ciphermode
, u8 u8Idx
)
4862 s32 s32Error
= WILC_SUCCESS
;
4863 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
4864 tstrHostIFmsg strHostIFmsg
;
4865 u8 u8KeyLen
= u8PtkKeylen
;
4868 if (pstrWFIDrv
== NULL
)
4869 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
4870 if (pu8RxMic
!= NULL
)
4871 u8KeyLen
+= RX_MIC_KEY_LEN
;
4872 if (pu8TxMic
!= NULL
)
4873 u8KeyLen
+= TX_MIC_KEY_LEN
;
4875 /* prepare the Key Message */
4876 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4879 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
4880 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= WPAPtk
;
4881 #ifdef WILC_AP_EXTERNAL_MLME
4882 if (mode
== AP_MODE
) {
4883 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY_AP
;
4884 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4885 uniHostIFkeyAttr
.strHostIFwpaAttr
.u8keyidx
= u8Idx
;
4888 if (mode
== STATION_MODE
)
4889 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY
;
4892 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4893 uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
= (u8
*)WILC_MALLOC(u8PtkKeylen
);
4896 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
,
4897 pu8Ptk
, u8PtkKeylen
);
4899 if (pu8RxMic
!= NULL
) {
4901 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
+ 16,
4902 pu8RxMic
, RX_MIC_KEY_LEN
);
4904 for (i
= 0; i
< RX_MIC_KEY_LEN
; i
++)
4905 PRINT_INFO(CFG80211_DBG
, "PairwiseRx[%d] = %x\n", i
, pu8RxMic
[i
]);
4908 if (pu8TxMic
!= NULL
) {
4910 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
+ 24,
4911 pu8TxMic
, TX_MIC_KEY_LEN
);
4913 for (i
= 0; i
< TX_MIC_KEY_LEN
; i
++)
4914 PRINT_INFO(CFG80211_DBG
, "PairwiseTx[%d] = %x\n", i
, pu8TxMic
[i
]);
4918 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4919 uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
= u8KeyLen
;
4921 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4922 uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Ciphermode
= u8Ciphermode
;
4923 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4924 uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8macaddr
= mac_addr
;
4925 strHostIFmsg
.drvHandler
= hWFIDrv
;
4927 /* send the message */
4928 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
4931 PRINT_ER("Error in sending message queue: PTK Key\n");
4933 /* ////////////// */
4934 down(&(pstrWFIDrv
->hSemTestKeyBlock
));
4937 WILC_CATCH(s32Error
)
4946 * @brief adds Rx GTk Key
4948 * @param[in,out] handle to the wifi driver
4949 * @param[in] pu8RxGtk : contains temporal key | Rx Mic | Tx Mic
4950 * u8GtkKeylen :The total key length
4952 * @return Error code indicating success/failure
4955 * @date 8 March 2012
4958 s32
host_int_add_rx_gtk(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*pu8RxGtk
, u8 u8GtkKeylen
,
4959 u8 u8KeyIdx
, u32 u32KeyRSClen
, const u8
*KeyRSC
,
4960 const u8
*pu8RxMic
, const u8
*pu8TxMic
, u8 mode
, u8 u8Ciphermode
)
4962 s32 s32Error
= WILC_SUCCESS
;
4963 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
4964 tstrHostIFmsg strHostIFmsg
;
4965 u8 u8KeyLen
= u8GtkKeylen
;
4967 if (pstrWFIDrv
== NULL
)
4968 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
4969 /* prepare the Key Message */
4970 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
4973 if (pu8RxMic
!= NULL
)
4974 u8KeyLen
+= RX_MIC_KEY_LEN
;
4975 if (pu8TxMic
!= NULL
)
4976 u8KeyLen
+= TX_MIC_KEY_LEN
;
4977 if (KeyRSC
!= NULL
) {
4978 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
4979 uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8seq
= (u8
*)WILC_MALLOC(u32KeyRSClen
);
4981 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8seq
,
4982 KeyRSC
, u32KeyRSClen
);
4986 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
4987 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= WPARxGtk
;
4988 strHostIFmsg
.drvHandler
= hWFIDrv
;
4990 #ifdef WILC_AP_EXTERNAL_MLME
4991 if (mode
== AP_MODE
) {
4992 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY_AP
;
4993 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Ciphermode
= u8Ciphermode
;
4996 if (mode
== STATION_MODE
)
4997 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY
;
5000 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
5001 uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
= (u8
*)WILC_MALLOC(u8KeyLen
);
5003 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
,
5004 pu8RxGtk
, u8GtkKeylen
);
5006 if (pu8RxMic
!= NULL
) {
5008 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
+ 16,
5009 pu8RxMic
, RX_MIC_KEY_LEN
);
5012 if (pu8TxMic
!= NULL
) {
5014 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFwpaAttr
.pu8key
+ 24,
5015 pu8TxMic
, TX_MIC_KEY_LEN
);
5019 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
5020 uniHostIFkeyAttr
.strHostIFwpaAttr
.u8keyidx
= u8KeyIdx
;
5021 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
5022 uniHostIFkeyAttr
.strHostIFwpaAttr
.u8Keylen
= u8KeyLen
;
5024 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.
5025 uniHostIFkeyAttr
.strHostIFwpaAttr
.u8seqlen
= u32KeyRSClen
;
5029 /* send the message */
5030 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5032 PRINT_ER("Error in sending message queue: RX GTK\n");
5033 /* ////////////// */
5034 down(&(pstrWFIDrv
->hSemTestKeyBlock
));
5037 WILC_CATCH(s32Error
)
5045 * @brief host_int_set_pmkid_info
5046 * @details caches the pmkid valid only in BSS STA mode if External Supplicant
5047 * support is enabled. This Function sets the PMKID in firmware
5048 * when host drivr receives the corresponding request from NDIS.
5049 * The firmware then includes theset PMKID in the appropriate
5051 * @param[in,out] handle to the wifi driver
5052 * @param[in] message containing PMKID Info in the following format
5053 *|-----------------------------------------------------------------|
5054 *|NumEntries | BSSID[1] | PMKID[1] | ... | BSSID[K] | PMKID[K] |
5055 *|-----------|------------|----------|-------|----------|----------|
5056 | 1 | 6 | 16 | ... | 6 | 16 |
5057 ||-----------------------------------------------------------------|
5058 * @return Error code indicating success/failure
5061 * @date 8 March 2012
5064 s32
host_int_set_pmkid_info(tstrWILC_WFIDrv
*hWFIDrv
, tstrHostIFpmkidAttr
*pu8PmkidInfoArray
)
5066 s32 s32Error
= WILC_SUCCESS
;
5067 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5068 tstrHostIFmsg strHostIFmsg
;
5072 if (pstrWFIDrv
== NULL
)
5073 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5075 /* prepare the Key Message */
5076 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5078 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_KEY
;
5079 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.enuKeyType
= PMKSA
;
5080 strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.u8KeyAction
= ADDKEY
;
5081 strHostIFmsg
.drvHandler
= hWFIDrv
;
5083 for (i
= 0; i
< pu8PmkidInfoArray
->numpmkid
; i
++) {
5085 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFpmkidAttr
.pmkidlist
[i
].bssid
, &pu8PmkidInfoArray
->pmkidlist
[i
].bssid
,
5088 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFkeyAttr
.uniHostIFkeyAttr
.strHostIFpmkidAttr
.pmkidlist
[i
].pmkid
, &pu8PmkidInfoArray
->pmkidlist
[i
].pmkid
,
5092 /* send the message */
5093 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5095 PRINT_ER(" Error in sending messagequeue: PMKID Info\n");
5097 WILC_CATCH(s32Error
)
5106 * @brief gets the cached the pmkid info
5107 * @details valid only in BSS STA mode if External Supplicant
5108 * support is enabled. This Function sets the PMKID in firmware
5109 * when host drivr receives the corresponding request from NDIS.
5110 * The firmware then includes theset PMKID in the appropriate
5112 * @param[in,out] handle to the wifi driver,
5113 * message containing PMKID Info in the following format
5114 *|-----------------------------------------------------------------|
5115 *|NumEntries | BSSID[1] | PMKID[1] | ... | BSSID[K] | PMKID[K] |
5116 *|-----------|------------|----------|-------|----------|----------|
5117 | 1 | 6 | 16 | ... | 6 | 16 |
5118 ||-----------------------------------------------------------------|
5120 * @return Error code indicating success/failure
5123 * @date 8 March 2012
5126 s32
host_int_get_pmkid_info(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8PmkidInfoArray
,
5127 u32 u32PmkidInfoLen
)
5129 s32 s32Error
= WILC_SUCCESS
;
5131 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5133 strWID
.u16WIDid
= (u16
)WID_PMKID_INFO
;
5134 strWID
.enuWIDtype
= WID_STR
;
5135 strWID
.s32ValueSize
= u32PmkidInfoLen
;
5136 strWID
.ps8WidVal
= pu8PmkidInfoArray
;
5142 * @brief sets the pass phrase
5143 * @details AP/STA mode. This function gives the pass phrase used to
5144 * generate the Pre-Shared Key when WPA/WPA2 is enabled
5145 * The length of the field can vary from 8 to 64 bytes,
5146 * the lower layer should get the
5147 * @param[in,out] handle to the wifi driver,
5148 * @param[in] String containing PSK
5149 * @return Error code indicating success/failure
5152 * @date 8 March 2012
5155 s32
host_int_set_RSNAConfigPSKPassPhrase(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8PassPhrase
,
5158 s32 s32Error
= WILC_SUCCESS
;
5161 /*validating psk length*/
5162 if ((u8Psklength
> 7) && (u8Psklength
< 65)) {
5163 strWID
.u16WIDid
= (u16
)WID_11I_PSK
;
5164 strWID
.enuWIDtype
= WID_STR
;
5165 strWID
.ps8WidVal
= pu8PassPhrase
;
5166 strWID
.s32ValueSize
= u8Psklength
;
5172 * @brief host_int_get_MacAddress
5173 * @details gets mac address
5174 * @param[in,out] handle to the wifi driver,
5176 * @return Error code indicating success/failure
5179 * @date 19 April 2012
5182 s32
host_int_get_MacAddress(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8MacAddress
)
5184 s32 s32Error
= WILC_SUCCESS
;
5185 tstrHostIFmsg strHostIFmsg
;
5188 /* prepare the Message */
5189 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5191 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_MAC_ADDRESS
;
5192 strHostIFmsg
.uniHostIFmsgBody
.strHostIfGetMacAddress
.u8MacAddress
= pu8MacAddress
;
5193 strHostIFmsg
.drvHandler
= hWFIDrv
;
5194 /* send the message */
5195 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5197 PRINT_ER("Failed to send get mac address\n");
5201 down(&hWaitResponse
);
5206 * @brief host_int_set_MacAddress
5207 * @details sets mac address
5208 * @param[in,out] handle to the wifi driver,
5210 * @return Error code indicating success/failure
5213 * @date 16 July 2012
5216 s32
host_int_set_MacAddress(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8MacAddress
)
5218 s32 s32Error
= WILC_SUCCESS
;
5219 tstrHostIFmsg strHostIFmsg
;
5221 PRINT_D(GENERIC_DBG
, "mac addr = %x:%x:%x\n", pu8MacAddress
[0], pu8MacAddress
[1], pu8MacAddress
[2]);
5223 /* prepare setting mac address message */
5224 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5225 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SET_MAC_ADDRESS
;
5226 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetMacAddress
.u8MacAddress
, pu8MacAddress
, ETH_ALEN
);
5227 strHostIFmsg
.drvHandler
= hWFIDrv
;
5229 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5231 PRINT_ER("Failed to send message queue: Set mac address\n");
5232 WILC_ERRORREPORT(s32Error
, s32Error
);
5234 WILC_CATCH(s32Error
)
5244 * @brief host_int_get_RSNAConfigPSKPassPhrase
5245 * @details gets the pass phrase:AP/STA mode. This function gets the pass phrase used to
5246 * generate the Pre-Shared Key when WPA/WPA2 is enabled
5247 * The length of the field can vary from 8 to 64 bytes,
5248 * the lower layer should get the
5249 * @param[in,out] handle to the wifi driver,
5250 * String containing PSK
5251 * @return Error code indicating success/failure
5254 * @date 8 March 2012
5257 s32
host_int_get_RSNAConfigPSKPassPhrase(tstrWILC_WFIDrv
*hWFIDrv
,
5258 u8
*pu8PassPhrase
, u8 u8Psklength
)
5260 s32 s32Error
= WILC_SUCCESS
;
5262 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5264 strWID
.u16WIDid
= (u16
)WID_11I_PSK
;
5265 strWID
.enuWIDtype
= WID_STR
;
5266 strWID
.s32ValueSize
= u8Psklength
;
5267 strWID
.ps8WidVal
= pu8PassPhrase
;
5273 * @brief host_int_get_site_survey_results
5274 * @details gets the site survey results
5275 * @param[in,out] handle to the wifi driver,
5276 * Message containing site survey results in the
5278 *|---------------------------------------------------|
5279 | MsgLength | fragNo. | MsgBodyLength | MsgBody |
5280 ||-----------|-----------|---------------|-----------|
5282 | ----------------------------------------- | ----------------
5284 ||---------------------------------------|
5285 | Network1 | Netweork2 | ... | Network5 |
5286 ||---------------------------------------|
5287 | 44 | 44 | ... | 44 |
5288 | -------------------------- | ---------------------------------------
5290 ||---------------------------------------------------------------------|
5291 | SSID | BSS Type | Channel | Security Status| BSSID | RSSI |Reserved |
5294 ||------|----------|---------|----------------|-------|------|---------|
5295 | 33 | 1 | 1 | 1 | 6 | 1 | 1 |
5296 ||---------------------------------------------------------------------|
5297 * @return Error code indicating success/failure
5300 * @date 8 March 2012
5303 #ifndef CONNECT_DIRECT
5304 s32
host_int_get_site_survey_results(tstrWILC_WFIDrv
*hWFIDrv
,
5305 u8 ppu8RcvdSiteSurveyResults
[][MAX_SURVEY_RESULT_FRAG_SIZE
],
5306 u32 u32MaxSiteSrvyFragLen
)
5308 s32 s32Error
= WILC_SUCCESS
;
5309 tstrWID astrWIDList
[2];
5310 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5312 astrWIDList
[0].u16WIDid
= (u16
)WID_SITE_SURVEY_RESULTS
;
5313 astrWIDList
[0].enuWIDtype
= WID_STR
;
5314 astrWIDList
[0].ps8WidVal
= ppu8RcvdSiteSurveyResults
[0];
5315 astrWIDList
[0].s32ValueSize
= u32MaxSiteSrvyFragLen
;
5317 astrWIDList
[1].u16WIDid
= (u16
)WID_SITE_SURVEY_RESULTS
;
5318 astrWIDList
[1].enuWIDtype
= WID_STR
;
5319 astrWIDList
[1].ps8WidVal
= ppu8RcvdSiteSurveyResults
[1];
5320 astrWIDList
[1].s32ValueSize
= u32MaxSiteSrvyFragLen
;
5322 s32Error
= SendConfigPkt(GET_CFG
, astrWIDList
, 2, true, (u32
)pstrWFIDrv
);
5324 /*get the value by searching the local copy*/
5326 PRINT_ER("Failed to send config packet to get survey results\n");
5327 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
5330 WILC_CATCH(s32Error
)
5340 * @brief sets a start scan request
5342 * @param[in,out] handle to the wifi driver,
5343 * @param[in] Scan Source one of the following values
5346 * OBSS_PERIODIC_SCAN BIT1
5347 * OBSS_ONETIME_SCAN BIT2
5348 * @return Error code indicating success/failure
5351 * @date 8 March 2012
5354 s32
host_int_set_start_scan_req(tstrWILC_WFIDrv
*hWFIDrv
, u8 scanSource
)
5356 s32 s32Error
= WILC_SUCCESS
;
5358 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5360 strWID
.u16WIDid
= (u16
)WID_START_SCAN_REQ
;
5361 strWID
.enuWIDtype
= WID_CHAR
;
5362 strWID
.ps8WidVal
= (s8
*)&scanSource
;
5363 strWID
.s32ValueSize
= sizeof(char);
5369 * @brief host_int_get_start_scan_req
5370 * @details gets a start scan request
5371 * @param[in,out] handle to the wifi driver,
5372 * @param[in] Scan Source one of the following values
5375 * OBSS_PERIODIC_SCAN BIT1
5376 * OBSS_ONETIME_SCAN BIT2
5377 * @return Error code indicating success/failure
5380 * @date 8 March 2012
5384 s32
host_int_get_start_scan_req(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8ScanSource
)
5386 s32 s32Error
= WILC_SUCCESS
;
5388 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5390 strWID
.u16WIDid
= (u16
)WID_START_SCAN_REQ
;
5391 strWID
.enuWIDtype
= WID_CHAR
;
5392 strWID
.ps8WidVal
= (s8
*)pu8ScanSource
;
5393 strWID
.s32ValueSize
= sizeof(char);
5399 * @brief host_int_set_join_req
5400 * @details sets a join request
5401 * @param[in,out] handle to the wifi driver,
5402 * @param[in] Index of the bss descriptor
5403 * @return Error code indicating success/failure
5406 * @date 8 March 2012
5409 s32
host_int_set_join_req(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8bssid
,
5410 const u8
*pu8ssid
, size_t ssidLen
,
5411 const u8
*pu8IEs
, size_t IEsLen
,
5412 tWILCpfConnectResult pfConnectResult
, void *pvUserArg
,
5413 u8 u8security
, AUTHTYPE_T tenuAuth_type
,
5417 s32 s32Error
= WILC_SUCCESS
;
5418 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5419 tstrHostIFmsg strHostIFmsg
;
5420 tenuScanConnTimer enuScanConnTimer
;
5422 if (pstrWFIDrv
== NULL
|| pfConnectResult
== NULL
)
5423 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5425 if (hWFIDrv
== NULL
) {
5426 PRINT_ER("Driver not initialized: gWFiDrvHandle = NULL\n");
5427 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
5430 if (pJoinParams
== NULL
) {
5431 PRINT_ER("Unable to Join - JoinParams is NULL\n");
5432 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
5436 * if(gWFiDrvHandle->strWILC_UsrScanReq.u32RcvdChCount == 0)
5438 * PRINT_ER("No scan results exist: Scanning should be done\n");
5439 * WILC_ERRORREPORT(s32Error, WILC_FAIL);
5442 /* prepare the Connect Message */
5443 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5445 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_CONNECT
;
5447 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.u8security
= u8security
;
5448 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.tenuAuth_type
= tenuAuth_type
;
5449 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.u8channel
= u8channel
;
5450 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pfConnectResult
= pfConnectResult
;
5451 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pvUserArg
= pvUserArg
;
5452 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pJoinParams
= pJoinParams
;
5453 strHostIFmsg
.drvHandler
= hWFIDrv
;
5455 if (pu8bssid
!= NULL
) {
5456 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pu8bssid
= (u8
*)WILC_MALLOC(6); /* will be deallocated by the receiving thread */
5457 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pu8bssid
,
5461 if (pu8ssid
!= NULL
) {
5462 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.ssidLen
= ssidLen
;
5463 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pu8ssid
= (u8
*)WILC_MALLOC(ssidLen
); /* will be deallocated by the receiving thread */
5464 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pu8ssid
,
5469 if (pu8IEs
!= NULL
) {
5470 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.IEsLen
= IEsLen
;
5471 strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pu8IEs
= (u8
*)WILC_MALLOC(IEsLen
); /* will be deallocated by the receiving thread */
5472 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFconnectAttr
.pu8IEs
,
5475 if (pstrWFIDrv
->enuHostIFstate
< HOST_IF_CONNECTING
)
5476 pstrWFIDrv
->enuHostIFstate
= HOST_IF_CONNECTING
;
5478 PRINT_D(GENERIC_DBG
, "Don't set state to 'connecting' as state is %d\n", pstrWFIDrv
->enuHostIFstate
);
5480 /* send the message */
5481 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5483 PRINT_ER("Failed to send message queue: Set join request\n");
5484 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
5487 enuScanConnTimer
= CONNECT_TIMER
;
5488 WILC_TimerStart(&(pstrWFIDrv
->hConnectTimer
), HOST_IF_CONNECT_TIMEOUT
, (void *) hWFIDrv
, NULL
);
5490 WILC_CATCH(s32Error
)
5499 * @brief Flush a join request parameters to FW, but actual connection
5500 * @details The function is called in situation where WILC is connected to AP and
5501 * required to switch to hybrid FW for P2P connection
5502 * @param[in] handle to the wifi driver,
5503 * @return Error code indicating success/failure
5505 * @author Amr Abdel-Moghny
5510 s32
host_int_flush_join_req(tstrWILC_WFIDrv
*hWFIDrv
)
5512 s32 s32Error
= WILC_SUCCESS
;
5513 tstrHostIFmsg strHostIFmsg
;
5515 if (!gu8FlushedJoinReq
) {
5516 s32Error
= WILC_FAIL
;
5521 if (hWFIDrv
== NULL
)
5522 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5525 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_FLUSH_CONNECT
;
5526 strHostIFmsg
.drvHandler
= hWFIDrv
;
5528 /* send the message */
5529 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5531 PRINT_ER("Failed to send message queue: Flush join request\n");
5532 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
5535 WILC_CATCH(s32Error
)
5543 * @brief host_int_disconnect
5544 * @details disconnects from the currently associated network
5545 * @param[in,out] handle to the wifi driver,
5546 * @param[in] Reason Code of the Disconnection
5547 * @return Error code indicating success/failure
5550 * @date 8 March 2012
5553 s32
host_int_disconnect(tstrWILC_WFIDrv
*hWFIDrv
, u16 u16ReasonCode
)
5555 s32 s32Error
= WILC_SUCCESS
;
5556 tstrHostIFmsg strHostIFmsg
;
5557 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5559 if (pstrWFIDrv
== NULL
) {
5560 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5561 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5564 if (pstrWFIDrv
== NULL
) {
5565 PRINT_ER("gWFiDrvHandle = NULL\n");
5566 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
5569 /* prepare the Disconnect Message */
5570 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5572 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_DISCONNECT
;
5573 strHostIFmsg
.drvHandler
= hWFIDrv
;
5575 /* send the message */
5576 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5578 PRINT_ER("Failed to send message queue: disconnect\n");
5579 /* ////////////// */
5580 down(&(pstrWFIDrv
->hSemTestDisconnectBlock
));
5583 WILC_CATCH(s32Error
)
5592 * @brief host_int_disconnect_station
5593 * @details disconnects a sta
5594 * @param[in,out] handle to the wifi driver,
5595 * @param[in] Association Id of the station to be disconnected
5596 * @return Error code indicating success/failure
5599 * @date 8 March 2012
5602 s32
host_int_disconnect_station(tstrWILC_WFIDrv
*hWFIDrv
, u8 assoc_id
)
5604 s32 s32Error
= WILC_SUCCESS
;
5606 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5608 strWID
.u16WIDid
= (u16
)WID_DISCONNECT
;
5609 strWID
.enuWIDtype
= WID_CHAR
;
5610 strWID
.ps8WidVal
= (s8
*)&assoc_id
;
5611 strWID
.s32ValueSize
= sizeof(char);
5617 * @brief host_int_get_assoc_req_info
5618 * @details gets a Association request info
5619 * @param[in,out] handle to the wifi driver,
5620 * Message containg assoc. req info in the following format
5621 * ------------------------------------------------------------------------
5622 | Management Frame Format |
5623 ||-------------------------------------------------------------------|
5624 ||Frame Control|Duration|DA|SA|BSSID|Sequence Control|Frame Body|FCS |
5625 ||-------------|--------|--|--|-----|----------------|----------|----|
5626 | 2 |2 |6 |6 |6 | 2 |0 - 2312 | 4 |
5627 ||-------------------------------------------------------------------|
5629 | Association Request Frame - Frame Body |
5630 ||-------------------------------------------------------------------|
5631 | Capability Information | Listen Interval | SSID | Supported Rates |
5632 ||------------------------|-----------------|------|-----------------|
5633 | 2 | 2 | 2-34 | 3-10 |
5634 | ---------------------------------------------------------------------
5635 * @return Error code indicating success/failure
5638 * @date 8 March 2012
5642 s32
host_int_get_assoc_req_info(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8AssocReqInfo
,
5643 u32 u32AssocReqInfoLen
)
5645 s32 s32Error
= WILC_SUCCESS
;
5647 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5649 strWID
.u16WIDid
= (u16
)WID_ASSOC_REQ_INFO
;
5650 strWID
.enuWIDtype
= WID_STR
;
5651 strWID
.ps8WidVal
= pu8AssocReqInfo
;
5652 strWID
.s32ValueSize
= u32AssocReqInfoLen
;
5659 * @brief gets a Association Response info
5661 * @param[in,out] handle to the wifi driver,
5662 * Message containg assoc. resp info
5663 * @return Error code indicating success/failure
5666 * @date 8 March 2012
5669 s32
host_int_get_assoc_res_info(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8AssocRespInfo
,
5670 u32 u32MaxAssocRespInfoLen
, u32
*pu32RcvdAssocRespInfoLen
)
5672 s32 s32Error
= WILC_SUCCESS
;
5674 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5676 if (pstrWFIDrv
== NULL
) {
5677 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5678 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5681 strWID
.u16WIDid
= (u16
)WID_ASSOC_RES_INFO
;
5682 strWID
.enuWIDtype
= WID_STR
;
5683 strWID
.ps8WidVal
= pu8AssocRespInfo
;
5684 strWID
.s32ValueSize
= u32MaxAssocRespInfoLen
;
5687 /* Sending Configuration packet */
5688 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
5690 PRINT_ER("Failed to send association response config packet\n");
5691 *pu32RcvdAssocRespInfoLen
= 0;
5692 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
5694 *pu32RcvdAssocRespInfoLen
= strWID
.s32ValueSize
;
5697 WILC_CATCH(s32Error
)
5705 * @brief gets a Association Response info
5706 * @details Valid only in STA mode. This function gives the RSSI
5707 * values observed in all the channels at the time of scanning.
5708 * The length of the field is 1 greater that the total number of
5709 * channels supported. Byte 0 contains the number of channels while
5710 * each of Byte N contains the observed RSSI value for the channel index N.
5711 * @param[in,out] handle to the wifi driver,
5712 * array of scanned channels' RSSI
5713 * @return Error code indicating success/failure
5716 * @date 8 March 2012
5719 s32
host_int_get_rx_power_level(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8RxPowerLevel
,
5720 u32 u32RxPowerLevelLen
)
5722 s32 s32Error
= WILC_SUCCESS
;
5724 /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
5726 strWID
.u16WIDid
= (u16
)WID_RX_POWER_LEVEL
;
5727 strWID
.enuWIDtype
= WID_STR
;
5728 strWID
.ps8WidVal
= pu8RxPowerLevel
;
5729 strWID
.s32ValueSize
= u32RxPowerLevelLen
;
5736 * @brief sets a channel
5738 * @param[in,out] handle to the wifi driver,
5739 * @param[in] Index of the channel to be set
5740 *|-------------------------------------------------------------------|
5741 | CHANNEL1 CHANNEL2 .... CHANNEL14 |
5743 ||-------------------------------------------------------------------|
5744 * @return Error code indicating success/failure
5747 * @date 8 March 2012
5750 s32
host_int_set_mac_chnl_num(tstrWILC_WFIDrv
*hWFIDrv
, u8 u8ChNum
)
5752 s32 s32Error
= WILC_SUCCESS
;
5753 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5754 tstrHostIFmsg strHostIFmsg
;
5756 if (pstrWFIDrv
== NULL
)
5757 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5759 /* prepare the set channel message */
5760 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5761 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SET_CHANNEL
;
5762 strHostIFmsg
.uniHostIFmsgBody
.strHostIFSetChan
.u8SetChan
= u8ChNum
;
5763 strHostIFmsg
.drvHandler
= hWFIDrv
;
5765 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5767 WILC_ERRORREPORT(s32Error
, s32Error
);
5768 WILC_CATCH(s32Error
)
5777 s32
host_int_wait_msg_queue_idle(void)
5779 s32 s32Error
= WILC_SUCCESS
;
5781 tstrHostIFmsg strHostIFmsg
;
5783 /* prepare the set driver handler message */
5785 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5786 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_Q_IDLE
;
5787 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5789 WILC_ERRORREPORT(s32Error
, s32Error
);
5790 WILC_CATCH(s32Error
)
5795 /* wait untill MSG Q is empty */
5796 down(&hWaitResponse
);
5802 s32
host_int_set_wfi_drv_handler(tstrWILC_WFIDrv
*u32address
)
5804 s32 s32Error
= WILC_SUCCESS
;
5806 tstrHostIFmsg strHostIFmsg
;
5809 /* prepare the set driver handler message */
5811 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5812 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SET_WFIDRV_HANDLER
;
5813 strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetDrvHandler
.u32Address
= u32address
;
5814 /* strHostIFmsg.drvHandler=hWFIDrv; */
5816 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5818 WILC_ERRORREPORT(s32Error
, s32Error
);
5819 WILC_CATCH(s32Error
)
5829 s32
host_int_set_operation_mode(tstrWILC_WFIDrv
*hWFIDrv
, u32 u32mode
)
5831 s32 s32Error
= WILC_SUCCESS
;
5833 tstrHostIFmsg strHostIFmsg
;
5836 /* prepare the set driver handler message */
5838 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5839 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SET_OPERATION_MODE
;
5840 strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetOperationMode
.u32Mode
= u32mode
;
5841 strHostIFmsg
.drvHandler
= hWFIDrv
;
5843 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5845 WILC_ERRORREPORT(s32Error
, s32Error
);
5846 WILC_CATCH(s32Error
)
5855 * @brief gets the current channel index
5857 * @param[in,out] handle to the wifi driver,
5858 * current channel index
5859 *|-----------------------------------------------------------------------|
5860 | CHANNEL1 CHANNEL2 .... CHANNEL14 |
5862 ||-----------------------------------------------------------------------|
5863 * @return Error code indicating success/failure
5866 * @date 8 March 2012
5869 s32
host_int_get_host_chnl_num(tstrWILC_WFIDrv
*hWFIDrv
, u8
*pu8ChNo
)
5871 s32 s32Error
= WILC_SUCCESS
;
5872 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5873 tstrHostIFmsg strHostIFmsg
;
5875 if (pstrWFIDrv
== NULL
) {
5876 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5877 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5880 /* prepare the Get Channel Message */
5881 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5883 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_CHNL
;
5884 strHostIFmsg
.drvHandler
= hWFIDrv
;
5886 /* send the message */
5887 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5889 PRINT_ER("Failed to send get host channel param's message queue ");
5890 down(&(pstrWFIDrv
->hSemGetCHNL
));
5895 WILC_CATCH(s32Error
)
5906 * @brief host_int_test_set_int_wid
5907 * @details Test function for setting wids
5908 * @param[in,out] WILC_WFIDrvHandle hWFIDrv, u32 u32TestMemAddr
5909 * @return Error code indicating success/failure
5912 * @date 8 March 2012
5915 s32
host_int_test_set_int_wid(tstrWILC_WFIDrv
*hWFIDrv
, u32 u32TestMemAddr
)
5917 s32 s32Error
= WILC_SUCCESS
;
5919 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5922 if (pstrWFIDrv
== NULL
) {
5923 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5924 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5927 /*prepare configuration packet*/
5928 strWID
.u16WIDid
= (u16
)WID_MEMORY_ADDRESS
;
5929 strWID
.enuWIDtype
= WID_INT
;
5930 strWID
.ps8WidVal
= (char *)&u32TestMemAddr
;
5931 strWID
.s32ValueSize
= sizeof(u32
);
5934 s32Error
= SendConfigPkt(SET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
5936 PRINT_ER("Test Function: Failed to set wid value\n");
5937 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
5939 PRINT_D(HOSTINF_DBG
, "Successfully set wid value\n");
5943 WILC_CATCH(s32Error
)
5950 #ifdef WILC_AP_EXTERNAL_MLME
5952 * @brief host_int_get_inactive_time
5954 * @param[in,out] handle to the wifi driver,
5955 * current sta macaddress, inactive_time
5962 s32
host_int_get_inactive_time(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*mac
, u32
*pu32InactiveTime
)
5964 s32 s32Error
= WILC_SUCCESS
;
5965 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
5966 tstrHostIFmsg strHostIFmsg
;
5968 if (pstrWFIDrv
== NULL
) {
5969 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
5970 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
5973 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
5976 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIfStaInactiveT
.mac
,
5979 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_INACTIVETIME
;
5980 strHostIFmsg
.drvHandler
= hWFIDrv
;
5982 /* send the message */
5983 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
5985 PRINT_ER("Failed to send get host channel param's message queue ");
5987 down(&(pstrWFIDrv
->hSemInactiveTime
));
5989 *pu32InactiveTime
= gu32InactiveTime
;
5991 WILC_CATCH(s32Error
)
5999 * @brief host_int_test_get_int_wid
6000 * @details Test function for getting wids
6001 * @param[in,out] WILC_WFIDrvHandle hWFIDrv, u32* pu32TestMemAddr
6002 * @return Error code indicating success/failure
6005 * @date 8 March 2012
6008 s32
host_int_test_get_int_wid(tstrWILC_WFIDrv
*hWFIDrv
, u32
*pu32TestMemAddr
)
6011 s32 s32Error
= WILC_SUCCESS
;
6013 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6016 if (pstrWFIDrv
== NULL
) {
6017 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
6018 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
6021 strWID
.u16WIDid
= (u16
)WID_MEMORY_ADDRESS
;
6022 strWID
.enuWIDtype
= WID_INT
;
6023 strWID
.ps8WidVal
= (s8
*)pu32TestMemAddr
;
6024 strWID
.s32ValueSize
= sizeof(u32
);
6026 s32Error
= SendConfigPkt(GET_CFG
, &strWID
, 1, true, (u32
)pstrWFIDrv
);
6027 /*get the value by searching the local copy*/
6029 PRINT_ER("Test Function: Failed to get wid value\n");
6030 WILC_ERRORREPORT(s32Error
, WILC_INVALID_STATE
);
6032 PRINT_D(HOSTINF_DBG
, "Successfully got wid value\n");
6036 WILC_CATCH(s32Error
)
6045 * @brief host_int_get_rssi
6046 * @details gets the currently maintained RSSI value for the station.
6047 * The received signal strength value in dB.
6048 * The range of valid values is -128 to 0.
6049 * @param[in,out] handle to the wifi driver,
6051 * @return Error code indicating success/failure
6054 * @date 8 March 2012
6057 s32
host_int_get_rssi(tstrWILC_WFIDrv
*hWFIDrv
, s8
*ps8Rssi
)
6059 s32 s32Error
= WILC_SUCCESS
;
6060 tstrHostIFmsg strHostIFmsg
;
6061 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6064 /* prepare the Get RSSI Message */
6065 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6067 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_RSSI
;
6068 strHostIFmsg
.drvHandler
= hWFIDrv
;
6070 /* send the message */
6071 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6073 PRINT_ER("Failed to send get host channel param's message queue ");
6077 down(&(pstrWFIDrv
->hSemGetRSSI
));
6080 if (ps8Rssi
== NULL
) {
6081 PRINT_ER("RSS pointer value is null");
6092 s32
host_int_get_link_speed(tstrWILC_WFIDrv
*hWFIDrv
, s8
*ps8lnkspd
)
6094 tstrHostIFmsg strHostIFmsg
;
6095 s32 s32Error
= WILC_SUCCESS
;
6097 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6101 /* prepare the Get LINKSPEED Message */
6102 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6104 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_LINKSPEED
;
6105 strHostIFmsg
.drvHandler
= hWFIDrv
;
6107 /* send the message */
6108 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6110 PRINT_ER("Failed to send GET_LINKSPEED to message queue ");
6114 down(&(pstrWFIDrv
->hSemGetLINKSPEED
));
6117 if (ps8lnkspd
== NULL
) {
6118 PRINT_ER("LINKSPEED pointer value is null");
6123 *ps8lnkspd
= gs8lnkspd
;
6129 s32
host_int_get_statistics(tstrWILC_WFIDrv
*hWFIDrv
, tstrStatistics
*pstrStatistics
)
6131 s32 s32Error
= WILC_SUCCESS
;
6132 tstrHostIFmsg strHostIFmsg
;
6135 /* prepare the Get RSSI Message */
6136 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6138 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_STATISTICS
;
6139 strHostIFmsg
.uniHostIFmsgBody
.pUserData
= (char *)pstrStatistics
;
6140 strHostIFmsg
.drvHandler
= hWFIDrv
;
6141 /* send the message */
6142 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6144 PRINT_ER("Failed to send get host channel param's message queue ");
6148 down(&hWaitResponse
);
6154 * @brief host_int_scan
6155 * @details scans a set of channels
6156 * @param[in,out] handle to the wifi driver,
6157 * @param[in] Scan source
6158 * Scan Type PASSIVE_SCAN = 0,
6161 * Channels Array length
6162 * Scan Callback function
6163 * @return Error code indicating success/failure
6166 * @date 8 March 2012
6169 s32
host_int_scan(tstrWILC_WFIDrv
*hWFIDrv
, u8 u8ScanSource
,
6170 u8 u8ScanType
, u8
*pu8ChnlFreqList
,
6171 u8 u8ChnlListLen
, const u8
*pu8IEs
,
6172 size_t IEsLen
, tWILCpfScanResult ScanResult
,
6173 void *pvUserArg
, tstrHiddenNetwork
*pstrHiddenNetwork
)
6175 s32 s32Error
= WILC_SUCCESS
;
6176 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6177 tstrHostIFmsg strHostIFmsg
;
6178 tenuScanConnTimer enuScanConnTimer
;
6180 if (pstrWFIDrv
== NULL
|| ScanResult
== NULL
)
6181 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
6184 /* prepare the Scan Message */
6185 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6187 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SCAN
;
6189 if (pstrHiddenNetwork
!= NULL
) {
6190 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.strHiddenNetwork
.pstrHiddenNetworkInfo
= pstrHiddenNetwork
->pstrHiddenNetworkInfo
;
6191 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.strHiddenNetwork
.u8ssidnum
= pstrHiddenNetwork
->u8ssidnum
;
6194 PRINT_D(HOSTINF_DBG
, "pstrHiddenNetwork IS EQUAL TO NULL\n");
6196 strHostIFmsg
.drvHandler
= hWFIDrv
;
6197 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.u8ScanSource
= u8ScanSource
;
6198 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.u8ScanType
= u8ScanType
;
6199 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.pfScanResult
= ScanResult
;
6200 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.pvUserArg
= pvUserArg
;
6202 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.u8ChnlListLen
= u8ChnlListLen
;
6203 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.pu8ChnlFreqList
= (u8
*)WILC_MALLOC(u8ChnlListLen
); /* will be deallocated by the receiving thread */
6204 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.pu8ChnlFreqList
,
6205 pu8ChnlFreqList
, u8ChnlListLen
);
6207 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.IEsLen
= IEsLen
;
6208 strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.pu8IEs
= (u8
*)WILC_MALLOC(IEsLen
); /* will be deallocated by the receiving thread */
6209 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strHostIFscanAttr
.pu8IEs
,
6212 /* send the message */
6213 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6215 PRINT_ER("Error in sending message queue scanning parameters: Error(%d)\n", s32Error
);
6216 WILC_ERRORREPORT(s32Error
, WILC_FAIL
);
6219 enuScanConnTimer
= SCAN_TIMER
;
6220 PRINT_D(HOSTINF_DBG
, ">> Starting the SCAN timer\n");
6221 WILC_TimerStart(&(pstrWFIDrv
->hScanTimer
), HOST_IF_SCAN_TIMEOUT
, (void *) hWFIDrv
, NULL
);
6224 WILC_CATCH(s32Error
)
6232 * @brief hif_set_cfg
6233 * @details sets configuration wids values
6234 * @param[in,out] handle to the wifi driver,
6235 * @param[in] WID, WID value
6236 * @return Error code indicating success/failure
6239 * @date 8 March 2012
6242 s32
hif_set_cfg(tstrWILC_WFIDrv
*hWFIDrv
, tstrCfgParamVal
*pstrCfgParamVal
)
6245 s32 s32Error
= WILC_SUCCESS
;
6246 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6248 tstrHostIFmsg strHostIFmsg
;
6251 if (pstrWFIDrv
== NULL
)
6252 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
6253 /* prepare the WiphyParams Message */
6254 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6255 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_CFG_PARAMS
;
6256 strHostIFmsg
.uniHostIFmsgBody
.strHostIFCfgParamAttr
.pstrCfgParamVal
= *pstrCfgParamVal
;
6257 strHostIFmsg
.drvHandler
= hWFIDrv
;
6259 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6261 WILC_CATCH(s32Error
)
6271 * @brief hif_get_cfg
6272 * @details gets configuration wids values
6273 * @param[in,out] handle to the wifi driver,
6276 * @return Error code indicating success/failure
6280 * @date 8 March 2012
6283 s32
hif_get_cfg(tstrWILC_WFIDrv
*hWFIDrv
, u16 u16WID
, u16
*pu16WID_Value
)
6285 s32 s32Error
= WILC_SUCCESS
;
6286 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6288 down(&(pstrWFIDrv
->gtOsCfgValuesSem
));
6290 if (pstrWFIDrv
== NULL
) {
6291 PRINT_ER("Driver not initialized: pstrWFIDrv = NULL\n");
6292 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
6294 PRINT_D(HOSTINF_DBG
, "Getting configuration parameters\n");
6298 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.bss_type
;
6302 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.auth_type
;
6305 case WID_AUTH_TIMEOUT
:
6306 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.auth_timeout
;
6309 case WID_POWER_MANAGEMENT
:
6310 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.power_mgmt_mode
;
6313 case WID_SHORT_RETRY_LIMIT
:
6314 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.short_retry_limit
;
6317 case WID_LONG_RETRY_LIMIT
:
6318 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.long_retry_limit
;
6321 case WID_FRAG_THRESHOLD
:
6322 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.frag_threshold
;
6325 case WID_RTS_THRESHOLD
:
6326 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.rts_threshold
;
6330 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.preamble_type
;
6333 case WID_SHORT_SLOT_ALLOWED
:
6334 *pu16WID_Value
= (u16
) pstrWFIDrv
->strCfgValues
.short_slot_allowed
;
6337 case WID_11N_TXOP_PROT_DISABLE
:
6338 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.txop_prot_disabled
;
6341 case WID_BEACON_INTERVAL
:
6342 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.beacon_interval
;
6345 case WID_DTIM_PERIOD
:
6346 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.dtim_period
;
6349 case WID_SITE_SURVEY
:
6350 *pu16WID_Value
= (u16
)pstrWFIDrv
->strCfgValues
.site_survey_enabled
;
6353 case WID_SITE_SURVEY_SCAN_TIME
:
6354 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.site_survey_scan_time
;
6357 case WID_ACTIVE_SCAN_TIME
:
6358 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.active_scan_time
;
6361 case WID_PASSIVE_SCAN_TIME
:
6362 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.passive_scan_time
;
6365 case WID_CURRENT_TX_RATE
:
6366 *pu16WID_Value
= pstrWFIDrv
->strCfgValues
.curr_tx_rate
;
6373 up(&(pstrWFIDrv
->gtOsCfgValuesSem
));
6375 WILC_CATCH(s32Error
)
6382 /*****************************************************************************/
6383 /* Notification Functions */
6384 /*****************************************************************************/
6386 * @brief notifies host with join and leave requests
6387 * @details This function prepares an Information frame having the
6388 * information about a joining/leaving station.
6389 * @param[in,out] handle to the wifi driver,
6390 * @param[in] 6 byte Sta Adress
6391 * Join or leave flag:
6394 * @return Error code indicating success/failure
6397 * @date 8 March 2012
6400 void host_int_send_join_leave_info_to_host
6401 (u16 assocId
, u8
*stationAddr
, bool joining
)
6405 * @brief notifies host with stations found in scan
6406 * @details sends the beacon/probe response from scan
6407 * @param[in,out] handle to the wifi driver,
6408 * @param[in] Sta Address,
6410 * Rssi of the Station found
6411 * @return Error code indicating success/failure
6414 * @date 8 March 2012
6418 void GetPeriodicRSSI(void *pvArg
)
6420 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)pvArg
;
6422 if (pstrWFIDrv
== NULL
) {
6423 PRINT_ER("Driver handler is NULL\n");
6427 if (pstrWFIDrv
->enuHostIFstate
== HOST_IF_CONNECTED
) {
6428 s32 s32Error
= WILC_SUCCESS
;
6429 tstrHostIFmsg strHostIFmsg
;
6431 /* prepare the Get RSSI Message */
6432 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6434 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_RSSI
;
6435 strHostIFmsg
.drvHandler
= pstrWFIDrv
;
6437 /* send the message */
6438 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6440 PRINT_ER("Failed to send get host channel param's message queue ");
6444 WILC_TimerStart(&(g_hPeriodicRSSI
), 5000, (void *)pstrWFIDrv
, NULL
);
6448 void host_int_send_network_info_to_host
6449 (u8
*macStartAddress
, u16 u16RxFrameLen
, s8 s8Rssi
)
6453 * @brief host_int_init
6454 * @details host interface initialization function
6455 * @param[in,out] handle to the wifi driver,
6458 * @date 8 March 2012
6461 static u32 u32Intialized
;
6462 static u32 msgQ_created
;
6463 static u32 clients_count
;
6465 s32
host_int_init(tstrWILC_WFIDrv
**phWFIDrv
)
6467 s32 s32Error
= WILC_SUCCESS
;
6468 tstrWILC_WFIDrv
*pstrWFIDrv
;
6470 /*if(u32Intialized == 1)
6472 * PRINT_D(HOSTINF_DBG,"Host interface is previously initialized\n");
6473 * *phWFIDrv = (WILC_WFIDrvHandle)gWFiDrvHandle; //Will be adjusted later for P2P
6476 PRINT_D(HOSTINF_DBG
, "Initializing host interface for client %d\n", clients_count
+ 1);
6478 gbScanWhileConnected
= false;
6480 sema_init(&hWaitResponse
, 0);
6484 /*Allocate host interface private structure*/
6485 pstrWFIDrv
= (tstrWILC_WFIDrv
*)WILC_MALLOC(sizeof(tstrWILC_WFIDrv
));
6486 if (pstrWFIDrv
== NULL
) {
6487 /* WILC_ERRORREPORT(s32Error,WILC_NO_MEM); */
6488 s32Error
= WILC_NO_MEM
;
6489 PRINT_ER("Failed to allocate memory\n");
6492 memset(pstrWFIDrv
, 0, sizeof(tstrWILC_WFIDrv
));
6493 /*return driver handle to user*/
6494 *phWFIDrv
= pstrWFIDrv
;
6495 /*save into globl handle*/
6497 #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
6499 g_obtainingIP
= false;
6502 PRINT_D(HOSTINF_DBG
, "Global handle pointer value=%p\n", pstrWFIDrv
);
6503 /* /////////////////////////////////////// */
6504 if (clients_count
== 0) {
6505 sema_init(&hSemHostIFthrdEnd
, 0);
6506 sema_init(&hSemDeinitDrvHandle
, 0);
6508 sema_init(&hSemHostIntDeinit
, 1);
6511 sema_init(&(pstrWFIDrv
->hSemTestKeyBlock
), 0);
6512 sema_init(&(pstrWFIDrv
->hSemTestDisconnectBlock
), 0);
6513 sema_init(&(pstrWFIDrv
->hSemGetRSSI
), 0);
6514 sema_init(&(pstrWFIDrv
->hSemGetLINKSPEED
), 0);
6515 sema_init(&(pstrWFIDrv
->hSemGetCHNL
), 0);
6516 sema_init(&(pstrWFIDrv
->hSemInactiveTime
), 0);
6518 /* /////////////////////////////////////// */
6522 PRINT_D(HOSTINF_DBG
, "INIT: CLIENT COUNT %d\n", clients_count
);
6524 if (clients_count
== 0) {
6526 s32Error
= WILC_MsgQueueCreate(&gMsgQHostIF
, NULL
);
6530 PRINT_ER("Failed to creat MQ\n");
6534 HostIFthreadHandler
= kthread_run(hostIFthread
, NULL
, "WILC_kthread");
6535 if (IS_ERR(HostIFthreadHandler
)) {
6536 PRINT_ER("Failed to creat Thread\n");
6537 s32Error
= WILC_FAIL
;
6540 s32Error
= WILC_TimerCreate(&(g_hPeriodicRSSI
), GetPeriodicRSSI
, NULL
);
6542 PRINT_ER("Failed to creat Timer\n");
6545 WILC_TimerStart(&(g_hPeriodicRSSI
), 5000, (void *)pstrWFIDrv
, NULL
);
6550 s32Error
= WILC_TimerCreate(&(pstrWFIDrv
->hScanTimer
), TimerCB_Scan
, NULL
);
6552 PRINT_ER("Failed to creat Timer\n");
6556 s32Error
= WILC_TimerCreate(&(pstrWFIDrv
->hConnectTimer
), TimerCB_Connect
, NULL
);
6558 PRINT_ER("Failed to creat Timer\n");
6564 /*Remain on channel timer*/
6565 s32Error
= WILC_TimerCreate(&(pstrWFIDrv
->hRemainOnChannel
), ListenTimerCB
, NULL
);
6567 PRINT_ER("Failed to creat Remain-on-channel Timer\n");
6572 sema_init(&(pstrWFIDrv
->gtOsCfgValuesSem
), 1);
6573 down(&(pstrWFIDrv
->gtOsCfgValuesSem
));
6575 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
6576 /* gWFiDrvHandle->bPendingConnRequest = false; */
6578 /*Initialize CFG WIDS Defualt Values*/
6580 pstrWFIDrv
->strCfgValues
.site_survey_enabled
= SITE_SURVEY_OFF
;
6581 pstrWFIDrv
->strCfgValues
.scan_source
= DEFAULT_SCAN
;
6582 pstrWFIDrv
->strCfgValues
.active_scan_time
= ACTIVE_SCAN_TIME
;
6583 pstrWFIDrv
->strCfgValues
.passive_scan_time
= PASSIVE_SCAN_TIME
;
6584 pstrWFIDrv
->strCfgValues
.curr_tx_rate
= AUTORATE
;
6589 pstrWFIDrv
->u64P2p_MgmtTimeout
= 0;
6593 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",
6595 pstrWFIDrv
->strCfgValues
.site_survey_enabled
, pstrWFIDrv
->strCfgValues
.scan_source
,
6596 pstrWFIDrv
->strCfgValues
.active_scan_time
, pstrWFIDrv
->strCfgValues
.passive_scan_time
,
6597 pstrWFIDrv
->strCfgValues
.curr_tx_rate
);
6600 up(&(pstrWFIDrv
->gtOsCfgValuesSem
));
6602 /*TODO Code to setup simulation to be removed later*/
6603 /*Intialize configurator module*/
6604 s32Error
= CoreConfiguratorInit();
6606 PRINT_ER("Failed to initialize core configurator\n");
6611 clients_count
++; /* increase number of created entities */
6617 if (pstrWFIDrv
!= NULL
)
6621 WILC_TimerDestroy(&(pstrWFIDrv
->hRemainOnChannel
), NULL
);
6624 up(&(pstrWFIDrv
->gtOsCfgValuesSem
));
6625 WILC_TimerDestroy(&(pstrWFIDrv
->hConnectTimer
), NULL
);
6627 WILC_TimerDestroy(&(pstrWFIDrv
->hScanTimer
), NULL
);
6629 kthread_stop(HostIFthreadHandler
);
6631 WILC_MsgQueueDestroy(&gMsgQHostIF
, NULL
);
6638 * @brief host_int_deinit
6639 * @details host interface initialization function
6640 * @param[in,out] handle to the wifi driver,
6643 * @date 8 March 2012
6647 s32
host_int_deinit(tstrWILC_WFIDrv
*hWFIDrv
)
6649 s32 s32Error
= WILC_SUCCESS
;
6650 tstrHostIFmsg strHostIFmsg
;
6653 /*obtain driver handle*/
6654 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6655 /*if(u32Intialized == 0)
6657 * PRINT_ER("Host Interface is not initialized\n");
6663 if (pstrWFIDrv
== NULL
) {
6664 PRINT_ER("pstrWFIDrv = NULL\n");
6668 down(&hSemHostIntDeinit
);
6670 terminated_handle
= pstrWFIDrv
;
6671 PRINT_D(HOSTINF_DBG
, "De-initializing host interface for client %d\n", clients_count
);
6674 /*Destroy all timers before acquiring hSemDeinitDrvHandle*/
6675 /*to guarantee handling all messages befor proceeding*/
6676 if (WILC_TimerDestroy(&(pstrWFIDrv
->hScanTimer
), NULL
)) {
6677 PRINT_D(HOSTINF_DBG
, ">> Scan timer is active\n");
6678 /* msleep(HOST_IF_SCAN_TIMEOUT+1000); */
6681 if (WILC_TimerDestroy(&(pstrWFIDrv
->hConnectTimer
), NULL
)) {
6682 PRINT_D(HOSTINF_DBG
, ">> Connect timer is active\n");
6683 /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
6687 if (WILC_TimerDestroy(&(g_hPeriodicRSSI
), NULL
)) {
6688 PRINT_D(HOSTINF_DBG
, ">> Connect timer is active\n");
6689 /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
6693 /*Destroy Remain-onchannel Timer*/
6694 WILC_TimerDestroy(&(pstrWFIDrv
->hRemainOnChannel
), NULL
);
6697 host_int_set_wfi_drv_handler(NULL
);
6698 down(&hSemDeinitDrvHandle
);
6701 /*Calling the CFG80211 scan done function with the abort flag set to true*/
6702 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
6703 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult(SCAN_EVENT_ABORTED
, NULL
,
6704 pstrWFIDrv
->strWILC_UsrScanReq
.u32UserScanPvoid
, NULL
);
6706 pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
= NULL
;
6708 /*deinit configurator and simulator*/
6709 CoreConfiguratorDeInit();
6711 pstrWFIDrv
->enuHostIFstate
= HOST_IF_IDLE
;
6713 gbScanWhileConnected
= false;
6715 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6717 if (clients_count
== 1) {
6718 if (WILC_TimerDestroy(&g_hPeriodicRSSI
, NULL
)) {
6719 PRINT_D(HOSTINF_DBG
, ">> Connect timer is active\n");
6720 /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
6722 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_EXIT
;
6723 strHostIFmsg
.drvHandler
= hWFIDrv
;
6726 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6727 if (s32Error
!= WILC_SUCCESS
)
6728 PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", s32Error
);
6730 down(&hSemHostIFthrdEnd
);
6734 WILC_MsgQueueDestroy(&gMsgQHostIF
, NULL
);
6738 down(&(pstrWFIDrv
->gtOsCfgValuesSem
));
6740 /*Setting the gloabl driver handler with NULL*/
6742 /* gWFiDrvHandle = NULL; */
6743 if (pstrWFIDrv
!= NULL
) {
6745 /* pstrWFIDrv=NULL; */
6749 clients_count
--; /* Decrease number of created entities */
6750 terminated_handle
= NULL
;
6751 up(&hSemHostIntDeinit
);
6757 * @brief NetworkInfoReceived
6758 * @details function to to be called when network info packet is received
6759 * @param[in] pu8Buffer the received packet
6760 * @param[in] u32Length length of the received packet
6767 void NetworkInfoReceived(u8
*pu8Buffer
, u32 u32Length
)
6769 s32 s32Error
= WILC_SUCCESS
;
6770 tstrHostIFmsg strHostIFmsg
;
6772 tstrWILC_WFIDrv
*pstrWFIDrv
= NULL
;
6774 drvHandler
= ((pu8Buffer
[u32Length
- 4]) | (pu8Buffer
[u32Length
- 3] << 8) | (pu8Buffer
[u32Length
- 2] << 16) | (pu8Buffer
[u32Length
- 1] << 24));
6775 pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
6780 if (pstrWFIDrv
== NULL
|| pstrWFIDrv
== terminated_handle
) {
6781 PRINT_ER("NetworkInfo received but driver not init[%p]\n", pstrWFIDrv
);
6785 /* prepare the Asynchronous Network Info message */
6786 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6788 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_RCVD_NTWRK_INFO
;
6789 strHostIFmsg
.drvHandler
= pstrWFIDrv
;
6791 strHostIFmsg
.uniHostIFmsgBody
.strRcvdNetworkInfo
.u32Length
= u32Length
;
6792 strHostIFmsg
.uniHostIFmsgBody
.strRcvdNetworkInfo
.pu8Buffer
= (u8
*)WILC_MALLOC(u32Length
); /* will be deallocated by the receiving thread */
6793 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strRcvdNetworkInfo
.pu8Buffer
,
6794 pu8Buffer
, u32Length
);
6796 /* send the message */
6797 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6799 PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", s32Error
);
6806 * @brief GnrlAsyncInfoReceived
6807 * @details function to be called when general Asynchronous info packet is received
6808 * @param[in] pu8Buffer the received packet
6809 * @param[in] u32Length length of the received packet
6816 void GnrlAsyncInfoReceived(u8
*pu8Buffer
, u32 u32Length
)
6818 s32 s32Error
= WILC_SUCCESS
;
6819 tstrHostIFmsg strHostIFmsg
;
6821 tstrWILC_WFIDrv
*pstrWFIDrv
= NULL
;
6824 down(&hSemHostIntDeinit
);
6826 drvHandler
= ((pu8Buffer
[u32Length
- 4]) | (pu8Buffer
[u32Length
- 3] << 8) | (pu8Buffer
[u32Length
- 2] << 16) | (pu8Buffer
[u32Length
- 1] << 24));
6827 pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
6828 PRINT_D(HOSTINF_DBG
, "General asynchronous info packet received\n");
6831 if (pstrWFIDrv
== NULL
|| pstrWFIDrv
== terminated_handle
) {
6832 PRINT_D(HOSTINF_DBG
, "Wifi driver handler is equal to NULL\n");
6834 up(&hSemHostIntDeinit
);
6838 if (pstrWFIDrv
->strWILC_UsrConnReq
.pfUserConnectResult
== NULL
) {
6839 /* received mac status is not needed when there is no current Connect Request */
6840 PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
6842 up(&hSemHostIntDeinit
);
6846 /* prepare the General Asynchronous Info message */
6847 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6850 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO
;
6851 strHostIFmsg
.drvHandler
= pstrWFIDrv
;
6854 strHostIFmsg
.uniHostIFmsgBody
.strRcvdGnrlAsyncInfo
.u32Length
= u32Length
;
6855 strHostIFmsg
.uniHostIFmsgBody
.strRcvdGnrlAsyncInfo
.pu8Buffer
= (u8
*)WILC_MALLOC(u32Length
); /* will be deallocated by the receiving thread */
6856 memcpy(strHostIFmsg
.uniHostIFmsgBody
.strRcvdGnrlAsyncInfo
.pu8Buffer
,
6857 pu8Buffer
, u32Length
);
6859 /* send the message */
6860 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6862 PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", s32Error
);
6865 up(&hSemHostIntDeinit
);
6870 * @brief host_int_ScanCompleteReceived
6871 * @details Setting scan complete received notifcation in message queue
6872 * @param[in] u8* pu8Buffer, u32 u32Length
6873 * @return Error code.
6878 void host_int_ScanCompleteReceived(u8
*pu8Buffer
, u32 u32Length
)
6880 s32 s32Error
= WILC_SUCCESS
;
6881 tstrHostIFmsg strHostIFmsg
;
6883 tstrWILC_WFIDrv
*pstrWFIDrv
= NULL
;
6885 drvHandler
= ((pu8Buffer
[u32Length
- 4]) | (pu8Buffer
[u32Length
- 3] << 8) | (pu8Buffer
[u32Length
- 2] << 16) | (pu8Buffer
[u32Length
- 1] << 24));
6886 pstrWFIDrv
= (tstrWILC_WFIDrv
*)drvHandler
;
6889 PRINT_D(GENERIC_DBG
, "Scan notification received %p\n", pstrWFIDrv
);
6891 if (pstrWFIDrv
== NULL
|| pstrWFIDrv
== terminated_handle
)
6894 /*if there is an ongoing scan request*/
6895 if (pstrWFIDrv
->strWILC_UsrScanReq
.pfUserScanResult
) {
6896 /* prepare theScan Done message */
6897 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6899 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_RCVD_SCAN_COMPLETE
;
6900 strHostIFmsg
.drvHandler
= pstrWFIDrv
;
6903 /* will be deallocated by the receiving thread */
6904 /*no need to send message body*/
6906 /*strHostIFmsg.uniHostIFmsgBody.strScanComplete.u32Length = u32Length;
6907 * strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer = (u8*)WILC_MALLOC(u32Length);
6908 * memcpy(strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer,
6909 * pu8Buffer, u32Length); */
6911 /* send the message */
6912 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6914 PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", s32Error
);
6924 * @brief host_int_remain_on_channel
6926 * @param[in] Handle to wifi driver
6927 * Duration to remain on channel
6928 * Channel to remain on
6929 * Pointer to fn to be called on receive frames in listen state
6930 * Pointer to remain-on-channel expired fn
6932 * @return Error code.
6937 s32
host_int_remain_on_channel(tstrWILC_WFIDrv
*hWFIDrv
, u32 u32SessionID
, u32 u32duration
, u16 chan
, tWILCpfRemainOnChanExpired RemainOnChanExpired
, tWILCpfRemainOnChanReady RemainOnChanReady
, void *pvUserArg
)
6939 s32 s32Error
= WILC_SUCCESS
;
6940 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6941 tstrHostIFmsg strHostIFmsg
;
6943 if (pstrWFIDrv
== NULL
)
6944 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
6946 /* prepare the remainonchan Message */
6947 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6949 /* prepare the WiphyParams Message */
6950 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_REMAIN_ON_CHAN
;
6951 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.u16Channel
= chan
;
6952 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.pRemainOnChanExpired
= RemainOnChanExpired
;
6953 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.pRemainOnChanReady
= RemainOnChanReady
;
6954 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.pVoid
= pvUserArg
;
6955 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.u32duration
= u32duration
;
6956 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.u32ListenSessionID
= u32SessionID
;
6957 strHostIFmsg
.drvHandler
= hWFIDrv
;
6959 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
6961 WILC_ERRORREPORT(s32Error
, s32Error
);
6962 WILC_CATCH(s32Error
)
6971 * @brief host_int_ListenStateExpired
6973 * @param[in] Handle to wifi driver
6974 * Duration to remain on channel
6975 * Channel to remain on
6976 * Pointer to fn to be called on receive frames in listen state
6977 * Pointer to remain-on-channel expired fn
6979 * @return Error code.
6984 s32
host_int_ListenStateExpired(tstrWILC_WFIDrv
*hWFIDrv
, u32 u32SessionID
)
6986 s32 s32Error
= WILC_SUCCESS
;
6987 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
6988 tstrHostIFmsg strHostIFmsg
;
6990 if (pstrWFIDrv
== NULL
)
6991 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
6993 /*Stopping remain-on-channel timer*/
6994 WILC_TimerStop(&(pstrWFIDrv
->hRemainOnChannel
), NULL
);
6996 /* prepare the timer fire Message */
6997 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
6998 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_LISTEN_TIMER_FIRED
;
6999 strHostIFmsg
.drvHandler
= hWFIDrv
;
7000 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRemainOnChan
.u32ListenSessionID
= u32SessionID
;
7002 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7004 WILC_ERRORREPORT(s32Error
, s32Error
);
7005 WILC_CATCH(s32Error
)
7013 * @brief host_int_frame_register
7015 * @param[in] Handle to wifi driver
7016 * @return Error code.
7020 s32
host_int_frame_register(tstrWILC_WFIDrv
*hWFIDrv
, u16 u16FrameType
, bool bReg
)
7022 s32 s32Error
= WILC_SUCCESS
;
7023 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7024 tstrHostIFmsg strHostIFmsg
;
7026 if (pstrWFIDrv
== NULL
)
7027 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7029 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7031 /* prepare the WiphyParams Message */
7032 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_REGISTER_FRAME
;
7033 switch (u16FrameType
) {
7035 PRINT_D(HOSTINF_DBG
, "ACTION\n");
7036 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRegisterFrame
.u8Regid
= ACTION_FRM_IDX
;
7040 PRINT_D(HOSTINF_DBG
, "PROBE REQ\n");
7041 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRegisterFrame
.u8Regid
= PROBE_REQ_IDX
;
7045 PRINT_D(HOSTINF_DBG
, "Not valid frame type\n");
7048 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRegisterFrame
.u16FrameType
= u16FrameType
;
7049 strHostIFmsg
.uniHostIFmsgBody
.strHostIfRegisterFrame
.bReg
= bReg
;
7050 strHostIFmsg
.drvHandler
= hWFIDrv
;
7052 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7054 WILC_ERRORREPORT(s32Error
, s32Error
);
7055 WILC_CATCH(s32Error
)
7066 #ifdef WILC_AP_EXTERNAL_MLME
7068 * @brief host_int_add_beacon
7069 * @details Setting add beacon params in message queue
7070 * @param[in] WILC_WFIDrvHandle hWFIDrv, u32 u32Interval,
7071 * u32 u32DTIMPeriod,u32 u32HeadLen, u8* pu8Head,
7072 * u32 u32TailLen, u8* pu8Tail
7073 * @return Error code.
7078 s32
host_int_add_beacon(tstrWILC_WFIDrv
*hWFIDrv
, u32 u32Interval
,
7080 u32 u32HeadLen
, u8
*pu8Head
,
7081 u32 u32TailLen
, u8
*pu8Tail
)
7083 s32 s32Error
= WILC_SUCCESS
;
7084 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7085 tstrHostIFmsg strHostIFmsg
;
7086 tstrHostIFSetBeacon
*pstrSetBeaconParam
= &strHostIFmsg
.uniHostIFmsgBody
.strHostIFSetBeacon
;
7088 if (pstrWFIDrv
== NULL
)
7089 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7091 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7093 PRINT_D(HOSTINF_DBG
, "Setting adding beacon message queue params\n");
7096 /* prepare the WiphyParams Message */
7097 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_ADD_BEACON
;
7098 strHostIFmsg
.drvHandler
= hWFIDrv
;
7099 pstrSetBeaconParam
->u32Interval
= u32Interval
;
7100 pstrSetBeaconParam
->u32DTIMPeriod
= u32DTIMPeriod
;
7101 pstrSetBeaconParam
->u32HeadLen
= u32HeadLen
;
7102 pstrSetBeaconParam
->pu8Head
= (u8
*)WILC_MALLOC(u32HeadLen
);
7103 if (pstrSetBeaconParam
->pu8Head
== NULL
)
7104 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
7105 memcpy(pstrSetBeaconParam
->pu8Head
, pu8Head
, u32HeadLen
);
7106 pstrSetBeaconParam
->u32TailLen
= u32TailLen
;
7108 /* Bug 4599 : if tail length = 0 skip allocating & copying */
7109 if (u32TailLen
> 0) {
7110 pstrSetBeaconParam
->pu8Tail
= (u8
*)WILC_MALLOC(u32TailLen
);
7111 if (pstrSetBeaconParam
->pu8Tail
== NULL
)
7112 WILC_ERRORREPORT(s32Error
, WILC_NO_MEM
);
7113 memcpy(pstrSetBeaconParam
->pu8Tail
, pu8Tail
, u32TailLen
);
7115 pstrSetBeaconParam
->pu8Tail
= NULL
;
7118 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7120 WILC_ERRORREPORT(s32Error
, s32Error
);
7122 WILC_CATCH(s32Error
)
7124 if (pstrSetBeaconParam
->pu8Head
!= NULL
)
7125 kfree(pstrSetBeaconParam
->pu8Head
);
7127 if (pstrSetBeaconParam
->pu8Tail
!= NULL
)
7128 kfree(pstrSetBeaconParam
->pu8Tail
);
7137 * @brief host_int_del_beacon
7138 * @details Setting add beacon params in message queue
7139 * @param[in] WILC_WFIDrvHandle hWFIDrv
7140 * @return Error code.
7145 s32
host_int_del_beacon(tstrWILC_WFIDrv
*hWFIDrv
)
7147 s32 s32Error
= WILC_SUCCESS
;
7148 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7149 tstrHostIFmsg strHostIFmsg
;
7151 if (pstrWFIDrv
== NULL
)
7152 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7154 /* prepare the WiphyParams Message */
7155 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_DEL_BEACON
;
7156 strHostIFmsg
.drvHandler
= hWFIDrv
;
7157 PRINT_D(HOSTINF_DBG
, "Setting deleting beacon message queue params\n");
7159 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7160 WILC_ERRORCHECK(s32Error
);
7162 WILC_CATCH(s32Error
)
7170 * @brief host_int_add_station
7171 * @details Setting add station params in message queue
7172 * @param[in] WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam* pstrStaParams
7173 * @return Error code.
7178 s32
host_int_add_station(tstrWILC_WFIDrv
*hWFIDrv
, tstrWILC_AddStaParam
*pstrStaParams
)
7180 s32 s32Error
= WILC_SUCCESS
;
7181 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7182 tstrHostIFmsg strHostIFmsg
;
7183 tstrWILC_AddStaParam
*pstrAddStationMsg
= &strHostIFmsg
.uniHostIFmsgBody
.strAddStaParam
;
7186 if (pstrWFIDrv
== NULL
)
7187 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7189 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7191 PRINT_D(HOSTINF_DBG
, "Setting adding station message queue params\n");
7194 /* prepare the WiphyParams Message */
7195 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_ADD_STATION
;
7196 strHostIFmsg
.drvHandler
= hWFIDrv
;
7198 memcpy(pstrAddStationMsg
, pstrStaParams
, sizeof(tstrWILC_AddStaParam
));
7199 if (pstrAddStationMsg
->u8NumRates
> 0) {
7200 u8
*rates
= WILC_MALLOC(pstrAddStationMsg
->u8NumRates
);
7202 WILC_NULLCHECK(s32Error
, rates
);
7204 memcpy(rates
, pstrStaParams
->pu8Rates
, pstrAddStationMsg
->u8NumRates
);
7205 pstrAddStationMsg
->pu8Rates
= rates
;
7209 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7211 WILC_ERRORREPORT(s32Error
, s32Error
);
7213 WILC_CATCH(s32Error
)
7220 * @brief host_int_del_station
7221 * @details Setting delete station params in message queue
7222 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8MacAddr
7223 * @return Error code.
7228 s32
host_int_del_station(tstrWILC_WFIDrv
*hWFIDrv
, const u8
*pu8MacAddr
)
7230 s32 s32Error
= WILC_SUCCESS
;
7231 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7232 tstrHostIFmsg strHostIFmsg
;
7233 tstrHostIFDelSta
*pstrDelStationMsg
= &strHostIFmsg
.uniHostIFmsgBody
.strDelStaParam
;
7235 if (pstrWFIDrv
== NULL
)
7236 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7238 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7240 PRINT_D(HOSTINF_DBG
, "Setting deleting station message queue params\n");
7244 /* prepare the WiphyParams Message */
7245 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_DEL_STATION
;
7246 strHostIFmsg
.drvHandler
= hWFIDrv
;
7248 /*BugID_4795: Handling situation of deleting all stations*/
7249 if (pu8MacAddr
== NULL
)
7250 memset(pstrDelStationMsg
->au8MacAddr
, 255, ETH_ALEN
);
7252 memcpy(pstrDelStationMsg
->au8MacAddr
, pu8MacAddr
, ETH_ALEN
);
7254 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7256 WILC_ERRORREPORT(s32Error
, s32Error
);
7258 WILC_CATCH(s32Error
)
7264 * @brief host_int_del_allstation
7265 * @details Setting del station params in message queue
7266 * @param[in] WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN]s
7267 * @return Error code.
7272 s32
host_int_del_allstation(tstrWILC_WFIDrv
*hWFIDrv
, u8 pu8MacAddr
[][ETH_ALEN
])
7274 s32 s32Error
= WILC_SUCCESS
;
7275 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7276 tstrHostIFmsg strHostIFmsg
;
7277 tstrHostIFDelAllSta
*pstrDelAllStationMsg
= &strHostIFmsg
.uniHostIFmsgBody
.strHostIFDelAllSta
;
7278 u8 au8Zero_Buff
[ETH_ALEN
] = {0};
7283 if (pstrWFIDrv
== NULL
)
7284 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7286 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7288 PRINT_D(HOSTINF_DBG
, "Setting deauthenticating station message queue params\n");
7290 /* prepare the WiphyParams Message */
7291 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_DEL_ALL_STA
;
7292 strHostIFmsg
.drvHandler
= hWFIDrv
;
7294 /* Handling situation of deauthenticing all associated stations*/
7295 for (i
= 0; i
< MAX_NUM_STA
; i
++) {
7296 if (memcmp(pu8MacAddr
[i
], au8Zero_Buff
, ETH_ALEN
)) {
7297 memcpy(pstrDelAllStationMsg
->au8Sta_DelAllSta
[i
], pu8MacAddr
[i
], ETH_ALEN
);
7298 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],
7299 pstrDelAllStationMsg
->au8Sta_DelAllSta
[i
][5]);
7304 PRINT_D(CFG80211_DBG
, "NO ASSOCIATED STAS\n");
7308 pstrDelAllStationMsg
->u8Num_AssocSta
= u8AssocNumb
;
7309 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7313 WILC_ERRORREPORT(s32Error
, s32Error
);
7315 WILC_CATCH(s32Error
)
7319 down(&hWaitResponse
);
7326 * @brief host_int_edit_station
7327 * @details Setting edit station params in message queue
7328 * @param[in] WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam* pstrStaParams
7329 * @return Error code.
7334 s32
host_int_edit_station(tstrWILC_WFIDrv
*hWFIDrv
, tstrWILC_AddStaParam
*pstrStaParams
)
7336 s32 s32Error
= WILC_SUCCESS
;
7337 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7338 tstrHostIFmsg strHostIFmsg
;
7339 tstrWILC_AddStaParam
*pstrAddStationMsg
= &strHostIFmsg
.uniHostIFmsgBody
.strAddStaParam
;
7341 if (pstrWFIDrv
== NULL
)
7342 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7344 PRINT_D(HOSTINF_DBG
, "Setting editing station message queue params\n");
7346 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7349 /* prepare the WiphyParams Message */
7350 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_EDIT_STATION
;
7351 strHostIFmsg
.drvHandler
= hWFIDrv
;
7353 memcpy(pstrAddStationMsg
, pstrStaParams
, sizeof(tstrWILC_AddStaParam
));
7354 if (pstrAddStationMsg
->u8NumRates
> 0) {
7355 u8
*rates
= WILC_MALLOC(pstrAddStationMsg
->u8NumRates
);
7357 WILC_NULLCHECK(s32Error
, rates
);
7358 memcpy(rates
, pstrStaParams
->pu8Rates
, pstrAddStationMsg
->u8NumRates
);
7359 pstrAddStationMsg
->pu8Rates
= rates
;
7362 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7364 WILC_ERRORREPORT(s32Error
, s32Error
);
7365 WILC_CATCH(s32Error
)
7370 #endif /*WILC_AP_EXTERNAL_MLME*/
7371 uint32_t wilc_get_chipid(uint8_t);
7373 s32
host_int_set_power_mgmt(tstrWILC_WFIDrv
*hWFIDrv
, bool bIsEnabled
, u32 u32Timeout
)
7375 s32 s32Error
= WILC_SUCCESS
;
7376 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7377 tstrHostIFmsg strHostIFmsg
;
7378 tstrHostIfPowerMgmtParam
*pstrPowerMgmtParam
= &strHostIFmsg
.uniHostIFmsgBody
.strPowerMgmtparam
;
7380 PRINT_INFO(HOSTINF_DBG
, "\n\n>> Setting PS to %d <<\n\n", bIsEnabled
);
7382 if (pstrWFIDrv
== NULL
)
7383 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7385 PRINT_D(HOSTINF_DBG
, "Setting Power management message queue params\n");
7387 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7390 /* prepare the WiphyParams Message */
7391 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_POWER_MGMT
;
7392 strHostIFmsg
.drvHandler
= hWFIDrv
;
7394 pstrPowerMgmtParam
->bIsEnabled
= bIsEnabled
;
7395 pstrPowerMgmtParam
->u32Timeout
= u32Timeout
;
7398 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7400 WILC_ERRORREPORT(s32Error
, s32Error
);
7401 WILC_CATCH(s32Error
)
7407 s32
host_int_setup_multicast_filter(tstrWILC_WFIDrv
*hWFIDrv
, bool bIsEnabled
, u32 u32count
)
7409 s32 s32Error
= WILC_SUCCESS
;
7411 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7412 tstrHostIFmsg strHostIFmsg
;
7413 tstrHostIFSetMulti
*pstrMulticastFilterParam
= &strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetMulti
;
7416 if (pstrWFIDrv
== NULL
)
7417 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7419 PRINT_D(HOSTINF_DBG
, "Setting Multicast Filter params\n");
7421 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7424 /* prepare the WiphyParams Message */
7425 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SET_MULTICAST_FILTER
;
7426 strHostIFmsg
.drvHandler
= hWFIDrv
;
7428 pstrMulticastFilterParam
->bIsEnabled
= bIsEnabled
;
7429 pstrMulticastFilterParam
->u32count
= u32count
;
7431 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7433 WILC_ERRORREPORT(s32Error
, s32Error
);
7434 WILC_CATCH(s32Error
)
7442 /*Bug4218: Parsing Join Param*/
7443 #ifdef WILC_PARSE_SCAN_IN_HOST
7445 /*Bug4218: Parsing Join Param*/
7447 * @brief host_int_ParseJoinBssParam
7448 * @details Parse Needed Join Parameters and save it in a new JoinBssParam entry
7449 * @param[in] tstrNetworkInfo* ptstrNetworkInfo
7454 static void *host_int_ParseJoinBssParam(tstrNetworkInfo
*ptstrNetworkInfo
)
7456 tstrJoinBssParam
*pNewJoinBssParam
= NULL
;
7465 u8 pcipherTotalCount
= 0;
7466 u8 authTotalCount
= 0;
7469 pu8IEs
= ptstrNetworkInfo
->pu8IEs
;
7470 u16IEsLen
= ptstrNetworkInfo
->u16IEsLen
;
7472 pNewJoinBssParam
= WILC_MALLOC(sizeof(tstrJoinBssParam
));
7473 if (pNewJoinBssParam
!= NULL
) {
7474 memset(pNewJoinBssParam
, 0, sizeof(tstrJoinBssParam
));
7475 pNewJoinBssParam
->dtim_period
= ptstrNetworkInfo
->u8DtimPeriod
;
7476 pNewJoinBssParam
->beacon_period
= ptstrNetworkInfo
->u16BeaconPeriod
;
7477 pNewJoinBssParam
->cap_info
= ptstrNetworkInfo
->u16CapInfo
;
7478 memcpy(pNewJoinBssParam
->au8bssid
, ptstrNetworkInfo
->au8bssid
, 6);
7480 * PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->au8bssid[i]);*/
7481 memcpy((u8
*)pNewJoinBssParam
->ssid
, ptstrNetworkInfo
->au8ssid
, ptstrNetworkInfo
->u8SsidLen
+ 1);
7482 pNewJoinBssParam
->ssidLen
= ptstrNetworkInfo
->u8SsidLen
;
7483 memset(pNewJoinBssParam
->rsn_pcip_policy
, 0xFF, 3);
7484 memset(pNewJoinBssParam
->rsn_auth_policy
, 0xFF, 3);
7485 /*for(i=0; i<pNewJoinBssParam->ssidLen;i++)
7486 * PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->ssid[i]);*/
7488 /* parse supported rates: */
7489 while (index
< u16IEsLen
) {
7490 /* supportedRates IE */
7491 if (pu8IEs
[index
] == SUPP_RATES_IE
) {
7492 /* PRINT_D(HOSTINF_DBG, "Supported Rates\n"); */
7493 suppRatesNo
= pu8IEs
[index
+ 1];
7494 pNewJoinBssParam
->supp_rates
[0] = suppRatesNo
;
7495 index
+= 2; /* skipping ID and length bytes; */
7497 for (i
= 0; i
< suppRatesNo
; i
++) {
7498 pNewJoinBssParam
->supp_rates
[i
+ 1] = pu8IEs
[index
+ i
];
7499 /* PRINT_D(HOSTINF_DBG,"%0x ",pNewJoinBssParam->supp_rates[i+1]); */
7501 index
+= suppRatesNo
;
7504 /* Ext SupportedRates IE */
7505 else if (pu8IEs
[index
] == EXT_SUPP_RATES_IE
) {
7506 /* PRINT_D(HOSTINF_DBG, "Extended Supported Rates\n"); */
7507 /* checking if no of ext. supp and supp rates < max limit */
7508 extSuppRatesNo
= pu8IEs
[index
+ 1];
7509 if (extSuppRatesNo
> (MAX_RATES_SUPPORTED
- suppRatesNo
))
7510 pNewJoinBssParam
->supp_rates
[0] = MAX_RATES_SUPPORTED
;
7512 pNewJoinBssParam
->supp_rates
[0] += extSuppRatesNo
;
7514 /* pNewJoinBssParam.supp_rates[0] contains now old number not the ext. no */
7515 for (i
= 0; i
< (pNewJoinBssParam
->supp_rates
[0] - suppRatesNo
); i
++) {
7516 pNewJoinBssParam
->supp_rates
[suppRatesNo
+ i
+ 1] = pu8IEs
[index
+ i
];
7517 /* PRINT_D(HOSTINF_DBG,"%0x ",pNewJoinBssParam->supp_rates[suppRatesNo+i+1]); */
7519 index
+= extSuppRatesNo
;
7523 else if (pu8IEs
[index
] == HT_CAPABILITY_IE
) {
7524 /* if IE found set the flag */
7525 pNewJoinBssParam
->ht_capable
= true;
7526 index
+= pu8IEs
[index
+ 1] + 2; /* ID,Length bytes and IE body */
7527 /* PRINT_D(HOSTINF_DBG,"HT_CAPABALE\n"); */
7529 } else if ((pu8IEs
[index
] == WMM_IE
) && /* WMM Element ID */
7530 (pu8IEs
[index
+ 2] == 0x00) && (pu8IEs
[index
+ 3] == 0x50) &&
7531 (pu8IEs
[index
+ 4] == 0xF2) && /* OUI */
7532 (pu8IEs
[index
+ 5] == 0x02) && /* OUI Type */
7533 ((pu8IEs
[index
+ 6] == 0x00) || (pu8IEs
[index
+ 6] == 0x01)) && /* OUI Sub Type */
7534 (pu8IEs
[index
+ 7] == 0x01)) {
7535 /* Presence of WMM Info/Param element indicates WMM capability */
7536 pNewJoinBssParam
->wmm_cap
= true;
7538 /* Check if Bit 7 is set indicating U-APSD capability */
7539 if (pu8IEs
[index
+ 8] & (1 << 7))
7540 pNewJoinBssParam
->uapsd_cap
= true;
7541 index
+= pu8IEs
[index
+ 1] + 2;
7545 else if ((pu8IEs
[index
] == P2P_IE
) && /* P2P Element ID */
7546 (pu8IEs
[index
+ 2] == 0x50) && (pu8IEs
[index
+ 3] == 0x6f) &&
7547 (pu8IEs
[index
+ 4] == 0x9a) && /* OUI */
7548 (pu8IEs
[index
+ 5] == 0x09) && (pu8IEs
[index
+ 6] == 0x0c)) { /* OUI Type */
7551 pNewJoinBssParam
->tsf
= ptstrNetworkInfo
->u32Tsf
;
7552 pNewJoinBssParam
->u8NoaEnbaled
= 1;
7553 pNewJoinBssParam
->u8Index
= pu8IEs
[index
+ 9];
7555 /* Check if Bit 7 is set indicating Opss capability */
7556 if (pu8IEs
[index
+ 10] & (1 << 7)) {
7557 pNewJoinBssParam
->u8OppEnable
= 1;
7558 pNewJoinBssParam
->u8CtWindow
= pu8IEs
[index
+ 10];
7560 pNewJoinBssParam
->u8OppEnable
= 0;
7562 PRINT_D(GENERIC_DBG
, "P2P Dump\n");
7563 for (i
= 0; i
< pu8IEs
[index
+ 7]; i
++)
7564 PRINT_D(GENERIC_DBG
, " %x\n", pu8IEs
[index
+ 9 + i
]);
7566 pNewJoinBssParam
->u8Count
= pu8IEs
[index
+ 11];
7567 u16P2P_count
= index
+ 12;
7569 memcpy(pNewJoinBssParam
->au8Duration
, pu8IEs
+ u16P2P_count
, 4);
7572 memcpy(pNewJoinBssParam
->au8Interval
, pu8IEs
+ u16P2P_count
, 4);
7575 memcpy(pNewJoinBssParam
->au8StartTime
, pu8IEs
+ u16P2P_count
, 4);
7577 index
+= pu8IEs
[index
+ 1] + 2;
7582 else if ((pu8IEs
[index
] == RSN_IE
) ||
7583 ((pu8IEs
[index
] == WPA_IE
) && (pu8IEs
[index
+ 2] == 0x00) &&
7584 (pu8IEs
[index
+ 3] == 0x50) && (pu8IEs
[index
+ 4] == 0xF2) &&
7585 (pu8IEs
[index
+ 5] == 0x01))) {
7586 u16 rsnIndex
= index
;
7587 /*PRINT_D(HOSTINF_DBG,"RSN IE Length:%d\n",pu8IEs[rsnIndex+1]);
7588 * for(i=0; i<pu8IEs[rsnIndex+1]; i++)
7590 * PRINT_D(HOSTINF_DBG,"%0x ",pu8IEs[rsnIndex+2+i]);
7592 if (pu8IEs
[rsnIndex
] == RSN_IE
) {
7593 pNewJoinBssParam
->mode_802_11i
= 2;
7594 /* PRINT_D(HOSTINF_DBG,"\nRSN_IE\n"); */
7595 } else { /* check if rsn was previously parsed */
7596 if (pNewJoinBssParam
->mode_802_11i
== 0)
7597 pNewJoinBssParam
->mode_802_11i
= 1;
7598 /* PRINT_D(HOSTINF_DBG,"\nWPA_IE\n"); */
7601 rsnIndex
+= 7; /* skipping id, length, version(2B) and first 3 bytes of gcipher */
7602 pNewJoinBssParam
->rsn_grp_policy
= pu8IEs
[rsnIndex
];
7604 /* PRINT_D(HOSTINF_DBG,"Group Policy: %0x\n",pNewJoinBssParam->rsn_grp_policy); */
7605 /* initialize policies with invalid values */
7607 jumpOffset
= pu8IEs
[rsnIndex
] * 4; /* total no.of bytes of pcipher field (count*4) */
7609 /*parsing pairwise cipher*/
7611 /* saving 3 pcipher max. */
7612 pcipherCount
= (pu8IEs
[rsnIndex
] > 3) ? 3 : pu8IEs
[rsnIndex
];
7613 rsnIndex
+= 2; /* jump 2 bytes of pcipher count */
7615 /* PRINT_D(HOSTINF_DBG,"\npcipher:%d\n",pcipherCount); */
7616 for (i
= pcipherTotalCount
, j
= 0; i
< pcipherCount
+ pcipherTotalCount
&& i
< 3; i
++, j
++) {
7617 /* each count corresponds to 4 bytes, only last byte is saved */
7618 pNewJoinBssParam
->rsn_pcip_policy
[i
] = pu8IEs
[rsnIndex
+ ((j
+ 1) * 4) - 1];
7619 /* PRINT_D(HOSTINF_DBG,"PAIR policy = [%0x,%0x]\n",pNewJoinBssParam->rsn_pcip_policy[i],i); */
7621 pcipherTotalCount
+= pcipherCount
;
7622 rsnIndex
+= jumpOffset
;
7624 jumpOffset
= pu8IEs
[rsnIndex
] * 4;
7626 /*parsing AKM suite (auth_policy)*/
7627 /* saving 3 auth policies max. */
7628 authCount
= (pu8IEs
[rsnIndex
] > 3) ? 3 : pu8IEs
[rsnIndex
];
7629 rsnIndex
+= 2; /* jump 2 bytes of pcipher count */
7631 for (i
= authTotalCount
, j
= 0; i
< authTotalCount
+ authCount
; i
++, j
++) {
7632 /* each count corresponds to 4 bytes, only last byte is saved */
7633 pNewJoinBssParam
->rsn_auth_policy
[i
] = pu8IEs
[rsnIndex
+ ((j
+ 1) * 4) - 1];
7635 authTotalCount
+= authCount
;
7636 rsnIndex
+= jumpOffset
;
7637 /*pasring rsn cap. only if rsn IE*/
7638 if (pu8IEs
[index
] == RSN_IE
) {
7639 pNewJoinBssParam
->rsn_cap
[0] = pu8IEs
[rsnIndex
];
7640 pNewJoinBssParam
->rsn_cap
[1] = pu8IEs
[rsnIndex
+ 1];
7643 pNewJoinBssParam
->rsn_found
= true;
7644 index
+= pu8IEs
[index
+ 1] + 2; /* ID,Length bytes and IE body */
7647 index
+= pu8IEs
[index
+ 1] + 2; /* ID,Length bytes and IE body */
7654 return (void *)pNewJoinBssParam
;
7658 void host_int_freeJoinParams(void *pJoinParams
)
7660 if ((tstrJoinBssParam
*)pJoinParams
!= NULL
)
7661 kfree((tstrJoinBssParam
*)pJoinParams
);
7663 PRINT_ER("Unable to FREE null pointer\n");
7665 #endif /*WILC_PARSE_SCAN_IN_HOST*/
7669 * @brief host_int_addBASession
7670 * @details Open a block Ack session with the given parameters
7671 * @param[in] tstrNetworkInfo* ptstrNetworkInfo
7673 * @author anoureldin
7677 static int host_int_addBASession(tstrWILC_WFIDrv
*hWFIDrv
, char *pBSSID
, char TID
, short int BufferSize
,
7678 short int SessionTimeout
, void *drvHandler
)
7680 s32 s32Error
= WILC_SUCCESS
;
7681 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7682 tstrHostIFmsg strHostIFmsg
;
7683 tstrHostIfBASessionInfo
*pBASessionInfo
= &strHostIFmsg
.uniHostIFmsgBody
.strHostIfBASessionInfo
;
7685 if (pstrWFIDrv
== NULL
)
7686 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7688 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7690 /* prepare the WiphyParams Message */
7691 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_ADD_BA_SESSION
;
7693 memcpy(pBASessionInfo
->au8Bssid
, pBSSID
, ETH_ALEN
);
7694 pBASessionInfo
->u8Ted
= TID
;
7695 pBASessionInfo
->u16BufferSize
= BufferSize
;
7696 pBASessionInfo
->u16SessionTimeout
= SessionTimeout
;
7697 strHostIFmsg
.drvHandler
= hWFIDrv
;
7699 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7701 WILC_ERRORREPORT(s32Error
, s32Error
);
7702 WILC_CATCH(s32Error
)
7711 s32
host_int_delBASession(tstrWILC_WFIDrv
*hWFIDrv
, char *pBSSID
, char TID
)
7713 s32 s32Error
= WILC_SUCCESS
;
7714 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7715 tstrHostIFmsg strHostIFmsg
;
7716 tstrHostIfBASessionInfo
*pBASessionInfo
= &strHostIFmsg
.uniHostIFmsgBody
.strHostIfBASessionInfo
;
7718 if (pstrWFIDrv
== NULL
)
7719 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7721 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7723 /* prepare the WiphyParams Message */
7724 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_DEL_BA_SESSION
;
7726 memcpy(pBASessionInfo
->au8Bssid
, pBSSID
, ETH_ALEN
);
7727 pBASessionInfo
->u8Ted
= TID
;
7728 strHostIFmsg
.drvHandler
= hWFIDrv
;
7730 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7732 WILC_ERRORREPORT(s32Error
, s32Error
);
7733 WILC_CATCH(s32Error
)
7739 down(&hWaitResponse
);
7744 s32
host_int_del_All_Rx_BASession(tstrWILC_WFIDrv
*hWFIDrv
, char *pBSSID
, char TID
)
7746 s32 s32Error
= WILC_SUCCESS
;
7747 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7748 tstrHostIFmsg strHostIFmsg
;
7749 tstrHostIfBASessionInfo
*pBASessionInfo
= &strHostIFmsg
.uniHostIFmsgBody
.strHostIfBASessionInfo
;
7751 if (pstrWFIDrv
== NULL
)
7752 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7754 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7756 /* prepare the WiphyParams Message */
7757 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS
;
7759 memcpy(pBASessionInfo
->au8Bssid
, pBSSID
, ETH_ALEN
);
7760 pBASessionInfo
->u8Ted
= TID
;
7761 strHostIFmsg
.drvHandler
= hWFIDrv
;
7763 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7765 WILC_ERRORREPORT(s32Error
, s32Error
);
7766 WILC_CATCH(s32Error
)
7772 down(&hWaitResponse
);
7778 * @brief host_int_setup_ipaddress
7779 * @details setup IP in firmware
7780 * @param[in] Handle to wifi driver
7781 * @return Error code.
7782 * @author Abdelrahman Sobhy
7785 s32
host_int_setup_ipaddress(tstrWILC_WFIDrv
*hWFIDrv
, u8
*u16ipadd
, u8 idx
)
7787 s32 s32Error
= WILC_SUCCESS
;
7788 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7789 tstrHostIFmsg strHostIFmsg
;
7791 /* TODO: Enable This feature on softap firmware */
7794 if (pstrWFIDrv
== NULL
)
7795 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7797 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7799 /* prepare the WiphyParams Message */
7800 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_SET_IPADDRESS
;
7802 strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.au8IPAddr
= u16ipadd
;
7803 strHostIFmsg
.drvHandler
= hWFIDrv
;
7804 strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.idx
= idx
;
7806 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7808 WILC_ERRORREPORT(s32Error
, s32Error
);
7809 WILC_CATCH(s32Error
)
7820 * @brief host_int_get_ipaddress
7821 * @details Get IP from firmware
7822 * @param[in] Handle to wifi driver
7823 * @return Error code.
7824 * @author Abdelrahman Sobhy
7827 s32
host_int_get_ipaddress(tstrWILC_WFIDrv
*hWFIDrv
, u8
*u16ipadd
, u8 idx
)
7829 s32 s32Error
= WILC_SUCCESS
;
7830 tstrWILC_WFIDrv
*pstrWFIDrv
= (tstrWILC_WFIDrv
*)hWFIDrv
;
7831 tstrHostIFmsg strHostIFmsg
;
7833 if (pstrWFIDrv
== NULL
)
7834 WILC_ERRORREPORT(s32Error
, WILC_INVALID_ARGUMENT
);
7836 memset(&strHostIFmsg
, 0, sizeof(tstrHostIFmsg
));
7838 /* prepare the WiphyParams Message */
7839 strHostIFmsg
.u16MsgId
= HOST_IF_MSG_GET_IPADDRESS
;
7841 strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.au8IPAddr
= u16ipadd
;
7842 strHostIFmsg
.drvHandler
= hWFIDrv
;
7843 strHostIFmsg
.uniHostIFmsgBody
.strHostIfSetIP
.idx
= idx
;
7845 s32Error
= WILC_MsgQueueSend(&gMsgQHostIF
, &strHostIFmsg
, sizeof(tstrHostIFmsg
), NULL
);
7847 WILC_ERRORREPORT(s32Error
, s32Error
);
7848 WILC_CATCH(s32Error
)