drivers/staging/wilc1000/host_interface.c

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