drivers/net/wireless/combo_mt66xx/mt6620/wlan/common/wlan_bow.c

   1 /*
   2 ** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/common/wlan_bow.c#1 $
   3 */
   4
   5 /*! \file wlan_bow.c
   6     \brief This file contains the 802.11 PAL commands processing routines for
   7            MediaTek Inc. 802.11 Wireless LAN Adapters.
   8 */
   9
  10
  11
  12 /*
  13 ** $Log: wlan_bow.c $
  14  *
  15  * 03 02 2012 terry.wu
  16  * NULL
  17  * Sync CFG80211 modification from branch 2,2.
  18  *
  19  * 01 16 2012 chinghwa.yu
  20  * [WCXRP00000065] Update BoW design and settings
  21  * Support BOW for 5GHz band.
  22  *
  23  * 01 09 2012 chinghwa.yu
  24  * [WCXRP00000065] Update BoW design and settings
  25  * [ALPS00110632] [Rose][LCA42][Cross Feature][Bluetooth]The "KE" pops up after the device reboots automatically.(once)
  26  *
  27  * Fix bow link disconnected event dereference.
  28  *
  29  * 09 29 2011 cm.chang
  30  * NULL
  31  * Change the function prototype of rlmDomainGetChnlList()
  32  *
  33  * 07 06 2011 terry.wu
  34  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  35  * Improve BoW connection establishment speed.
  36  *
  37  * 06 23 2011 cp.wu
  38  * [WCXRP00000798] [MT6620 Wi-Fi][Firmware] Follow-ups for WAPI frequency offset workaround in firmware SCN module
  39  * change parameter name from PeerAddr to BSSID
  40  *
  41  * 06 21 2011 terry.wu
  42  * NULL
  43  * Fix BoW KE.
  44  *
  45  * 06 20 2011 terry.wu
  46  * NULL
  47  * Add BoW Rate Limitation.
  48  *
  49  * 06 20 2011 cp.wu
  50  * [WCXRP00000798] [MT6620 Wi-Fi][Firmware] Follow-ups for WAPI frequency offset workaround in firmware SCN module
  51  * 1. specify target's BSSID when requesting channel privilege.
  52  * 2. pass BSSID information to firmware domain
  53  *
  54  * 06 17 2011 terry.wu
  55  * NULL
  56  * Add BoW 11N support.
  57  *
  58  * 06 07 2011 cp.wu
  59  * [WCXRP00000681] [MT5931][Firmware] HIF code size reduction
  60  * aware more compile options.
  61  *
  62  * 05 25 2011 terry.wu
  63  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  64  * Add BoW Cancel Scan Request and Turn On deactive network function.
  65  *
  66  * 05 23 2011 terry.wu
  67  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  68  * Add some BoW error handling.
  69  *
  70  * 05 22 2011 terry.wu
  71  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  72  * .
  73  *
  74  * 05 22 2011 terry.wu
  75  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  76  * Only reply probe response to its peer or mached SSID for BoW AP.
  77  *
  78  * 05 22 2011 terry.wu
  79  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  80  * Add BoW SAA retry and disable disconnect event when AAA fail .
  81  *
  82  * 05 21 2011 terry.wu
  83  * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment
  84  * Protect BoW connection establishment.
  85  *
  86  * 05 17 2011 terry.wu
  87  * [WCXRP00000730] [MT6620 Wi-Fi][BoW] Send deauth while disconnecting
  88  * Send deauth while disconnecting BoW link.
  89  *
  90  * 05 17 2011 terry.wu
  91  * [WCXRP00000707] [MT6620 Wi-Fi][Driver] Fix BoW Multiple Physical Link connect/disconnect issue
  92  * Fix wrong StaRec state of BoW .
  93  *
  94  * 05 06 2011 terry.wu
  95  * [WCXRP00000707] [MT6620 Wi-Fi][Driver] Fix BoW Multiple Physical Link connect/disconnect issue
  96  * Fix BoW Multiple Physical Link connect/disconnect issue.
  97  *
  98  * 05 03 2011 chinghwa.yu
  99  * [WCXRP00000065] Update BoW design and settings
 100  * Use kalMemAlloc to allocate event buffer for kalIndicateBOWEvent.
 101  *
 102  * 04 15 2011 chinghwa.yu
 103  * [WCXRP00000065] Update BoW design and settings
 104  * Fix prAssocRspSwRfb casting.
 105  *
 106  * 04 15 2011 chinghwa.yu
 107  * [WCXRP00000065] Update BoW design and settings
 108  * Add BOW short range mode.
 109  *
 110  * 04 12 2011 chinghwa.yu
 111  * [WCXRP00000065] Update BoW design and settings
 112  * Add WMM IE for BOW initiator data.
 113  *
 114  * 04 10 2011 chinghwa.yu
 115  * [WCXRP00000065] Update BoW design and settings
 116  * Change Link disconnection event procedure for hotspot and change skb length check to 1514 bytes.
 117  *
 118  * 04 09 2011 chinghwa.yu
 119  * [WCXRP00000065] Update BoW design and settings
 120  * Change Link connection event procedure and change skb length check to 1512 bytes.
 121  *
 122  * 03 28 2011 chinghwa.yu
 123  * [WCXRP00000065] Update BoW design and settings
 124  * Simplify link disconnected routine, remove link disconnected other routine.
 125  *
 126  * 03 27 2011 chinghwa.yu
 127  * [WCXRP00000065] Update BoW design and settings
 128  * Support multiple physical link.
 129  *
 130  * 03 27 2011 chinghwa.yu
 131  * [WCXRP00000065] Update BoW design and settings
 132  * Add new feature - multiple physical link support.
 133  *
 134  * 02 22 2011 wh.su
 135  * [WCXRP00000486] [MT6620 Wi-Fi][BOW] Fixed the bow send frame but not encrypted issue
 136  * fixed the BOW packet sending without encrypted issue.
 137  *
 138  * 02 21 2011 chinghwa.yu
 139  * [WCXRP00000065] Update BoW design and settings
 140  * Fix BOW link disconnection bug.
 141  *
 142  * 02 16 2011 chinghwa.yu
 143  * [WCXRP00000065] Update BoW design and settings
 144  * Add bowNotifyAllLinkDisconnected  interface and change channel grant procedure for bow starting.
 145  *
 146  * 02 11 2011 chinghwa.yu
 147  * [WCXRP00000065] Update BoW design and settings
 148  * Update BOW channel granted function.
 149  *
 150  * 02 10 2011 chinghwa.yu
 151  * [WCXRP00000065] Update BoW design and settings
 152  * Fix kernel API change issue.
 153  * Before ALPS 2.2 (2.2 included), kfifo_alloc() is
 154  * struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask, spinlock_t *lock);
 155  * After ALPS 2.3, kfifo_alloc() is changed to
 156  * int kfifo_alloc(struct kfifo *fifo, unsigned int size, gfp_t gfp_mask);
 157  *
 158  * 02 09 2011 cp.wu
 159  * [WCXRP00000430] [MT6620 Wi-Fi][Firmware][Driver] Create V1.2 branch for MT6620E1 and MT6620E3
 160  * create V1.2 driver branch based on label MT6620_WIFI_DRIVER_V1_2_110209_1031
 161  * with BOW and P2P enabled as default
 162  *
 163  * 02 08 2011 chinghwa.yu
 164  * [WCXRP00000065] Update BoW design and settings
 165  * Replace kfifo_get and kfifo_put with kfifo_out and kfifo_in.
 166  * Update BOW get MAC status, remove returning event for AIS network type.
 167  *
 168  * 01 26 2011 cm.chang
 169  * [WCXRP00000395] [MT6620 Wi-Fi][Driver][FW] Search STA_REC with additional net type index argument
 170  * .
 171  *
 172  * 01 11 2011 chinghwa.yu
 173  * [WCXRP00000065] Update BoW design and settings
 174  * Update BOW Activity Report structure and bug fix.
 175  *
 176  * 01 10 2011 chinghwa.yu
 177  * [WCXRP00000065] Update BoW design and settings
 178  * Update BOW to support multiple physical link.
 179  *
 180  * 12 08 2010 chinghwa.yu
 181  * [WCXRP00000065] Update BoW design and settings
 182  * Support concurrent networks.
 183  *
 184  * 12 07 2010 cm.chang
 185  * [WCXRP00000239] MT6620 Wi-Fi][Driver][FW] Merge concurrent branch back to maintrunk
 186  * 1. BSSINFO include RLM parameter
 187  * 2. free all sta records when network is disconnected
 188  *
 189  * 11 11 2010 chinghwa.yu
 190  * [WCXRP00000065] Update BoW design and settings
 191  * Fix BoW timer assert issue.
 192  *
 193  * 10 18 2010 chinghwa.yu
 194  * [WCXRP00000110] [MT6620 Wi-Fi] [Driver] Fix BoW Connected event size
 195  * Fix for event returnning Band.
 196  *
 197  * 10 18 2010 chinghwa.yu
 198  * [WCXRP00000110] [MT6620 Wi-Fi] [Driver] Fix BoW Connected event size
 199  * Fix wrong BoW event size.
 200  *
 201  * 10 04 2010 cp.wu
 202  * [WCXRP00000077] [MT6620 Wi-Fi][Driver][FW] Eliminate use of ENUM_NETWORK_TYPE_T and replaced by ENUM_NETWORK_TYPE_INDEX_T only
 203  * remove ENUM_NETWORK_TYPE_T definitions
 204  *
 205  * 09 27 2010 chinghwa.yu
 206  * [WCXRP00000063] Update BCM CoEx design and settings[WCXRP00000065] Update BoW design and settings
 207  * Update BCM/BoW design and settings.
 208  *
 209  * 09 16 2010 chinghwa.yu
 210  * NULL
 211  * Fix bowResponderScanDone error when prBssDesc is NULL.
 212  *
 213  * 09 14 2010 chinghwa.yu
 214  * NULL
 215  * Add bowRunEventAAAComplete.
 216  *
 217  * 09 14 2010 cp.wu
 218  * NULL
 219  * indicate correct AIS network information for PAL.
 220  *
 221  * 09 03 2010 kevin.huang
 222  * NULL
 223  * Refine #include sequence and solve recursive/nested #include issue
 224  *
 225  * 08 24 2010 cm.chang
 226  * NULL
 227  * Support RLM initail channel of Ad-hoc, P2P and BOW
 228  *
 229  * 08 24 2010 chinghwa.yu
 230  * NULL
 231  * Initialize nicActivateNetwork(prAdapter as soon as bow is starting..
 232  *
 233  * 08 24 2010 chinghwa.yu
 234  * NULL
 235  * Update BOW for the 1st time.
 236  *
 237  * 08 23 2010 cp.wu
 238  * NULL
 239  * revise constant definitions to be matched with implementation (original cmd-event definition is deprecated)
 240  *
 241  * 07 30 2010 cp.wu
 242  * NULL
 243  * 1) BoW wrapper: use definitions instead of hard-coded constant for error code
 244  * 2) AIS-FSM: eliminate use of desired RF parameters, use prTargetBssDesc instead
 245  * 3) add handling for RX_PKT_DESTINATION_HOST_WITH_FORWARD for GO-broadcast frames
 246  *
 247  * 07 15 2010 cp.wu
 248  *
 249  * sync. bluetooth-over-Wi-Fi interface to driver interface document v0.2.6.
 250  *
 251  * 07 08 2010 cp.wu
 252  *
 253  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 254  *
 255  * 06 25 2010 cp.wu
 256  * [WPD00003833][MT6620 and MT5931] Driver migration
 257  * add API in que_mgt to retrieve sta-rec index for security frames.
 258  *
 259  * 06 24 2010 cp.wu
 260  * [WPD00003833][MT6620 and MT5931] Driver migration
 261  * 802.1x and bluetooth-over-Wi-Fi security frames are now delievered to firmware via command path instead of data path.
 262  *
 263  * 06 11 2010 cp.wu
 264  * [WPD00003833][MT6620 and MT5931] Driver migration
 265  * 1) migrate assoc.c.
 266  * 2) add ucTxSeqNum for tracking frames which needs TX-DONE awareness
 267  * 3) add configuration options for CNM_MEM and RSN modules
 268  * 4) add data path for management frames
 269  * 5) eliminate rPacketInfo of MSDU_INFO_T
 270  *
 271  * 06 06 2010 kevin.huang
 272  * [WPD00003832][MT6620 5931] Create driver base
 273  * [MT6620 5931] Create driver base
 274  *
 275  * 05 17 2010 cp.wu
 276  * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 277  * 1) add timeout handler mechanism for pending command packets
 278  * 2) add p2p add/removal key
 279  *
 280  * 05 13 2010 cp.wu
 281  * [WPD00001943]Create WiFi test driver framework on WinXP
 282  * add NULL OID implementation for WOL-related OIDs.
 283  *
 284  * 05 13 2010 cp.wu
 285  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 286  * 1) all BT physical handles shares the same RSSI/Link Quality.
 287  * 2) simplify BT command composing
 288  *
 289  * 04 28 2010 cp.wu
 290  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 291  * change prefix for data structure used to communicate with 802.11 PAL
 292  * to avoid ambiguous naming with firmware interface
 293  *
 294  * 04 27 2010 cp.wu
 295  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 296  * add multiple physical link support
 297  *
 298  * 04 14 2010 cp.wu
 299  * [WPD00001943]Create WiFi test driver framework on WinXP
 300  * information buffer for query oid/ioctl is now buffered in prCmdInfo
 301  * instead of glue-layer variable to improve multiple oid/ioctl capability
 302  *
 303  * 04 13 2010 cp.wu
 304  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 305  * add framework for BT-over-Wi-Fi support.
 306  *  * 1) prPendingCmdInfo is replaced by queue for multiple handler capability
 307  *  * 2) command sequence number is now increased atomically
 308  *  * 3) private data could be hold and taken use for other purpose
 309 **
 310 */
 311
 312 /******************************************************************************
 313 *                         C O M P I L E R   F L A G S
 314 *******************************************************************************
 315 */
 316
 317 /******************************************************************************
 318 *                    E X T E R N A L   R E F E R E N C E S
 319 *******************************************************************************
 320 */
 321 #include "precomp.h"
 322
 323 #if CFG_ENABLE_BT_OVER_WIFI
 324
 325 #if CFG_BOW_TEST
 326 extern UINT_32 g_arBowRevPalPacketTime[32];
 327 #endif
 328
 329
 330 /******************************************************************************
 331 *                              C O N S T A N T S
 332 *******************************************************************************
 333 */
 334
 335 /******************************************************************************
 336 *                             D A T A   T Y P E S
 337 *******************************************************************************
 338 */
 339
 340 /******************************************************************************
 341 *                            P U B L I C   D A T A
 342 *******************************************************************************
 343 */
 344
 345 static UINT_32         g_u4LinkCount = 0;
 346 static UINT_32         g_u4Beaconing = 0;
 347 static BOW_TABLE_T     arBowTable[CFG_BOW_PHYSICAL_LINK_NUM];
 348
 349 /******************************************************************************
 350 *                           P R I V A T E   D A T A
 351 *******************************************************************************
 352 */
 353
 354 const BOW_CMD_T arBowCmdTable[] = {
 355     {BOW_CMD_ID_GET_MAC_STATUS,     bowCmdGetMacStatus},
 356     {BOW_CMD_ID_SETUP_CONNECTION,   bowCmdSetupConnection},
 357     {BOW_CMD_ID_DESTROY_CONNECTION, bowCmdDestroyConnection},
 358     {BOW_CMD_ID_SET_PTK,            bowCmdSetPTK},
 359     {BOW_CMD_ID_READ_RSSI,          bowCmdReadRSSI},
 360     {BOW_CMD_ID_READ_LINK_QUALITY,  bowCmdReadLinkQuality},
 361     {BOW_CMD_ID_SHORT_RANGE_MODE,   bowCmdShortRangeMode},
 362     {BOW_CMD_ID_GET_CHANNEL_LIST,   bowCmdGetChannelList},
 363 };
 364
 365 /******************************************************************************
 366 *                                 M A C R O S
 367 *******************************************************************************
 368 */
 369
 370 /******************************************************************************
 371 *                   F U N C T I O N   D E C L A R A T I O N S
 372 *******************************************************************************
 373 */
 374
 375 /******************************************************************************
 376 *                              F U N C T I O N S
 377 *******************************************************************************
 378 */
 379
 380 /*----------------------------------------------------------------------------*/
 381 /*!
 382 * \brief command packet generation utility
 383 *
 384 * \param[in] prAdapter          Pointer to the Adapter structure.
 385 * \param[in] ucCID              Command ID
 386 * \param[in] fgSetQuery         Set or Query
 387 * \param[in] fgNeedResp         Need for response
 388 * \param[in] pfCmdDoneHandler   Function pointer when command is done
 389 * \param[in] u4SetQueryInfoLen  The length of the set/query buffer
 390 * \param[in] pucInfoBuffer      Pointer to set/query buffer
 391 *
 392 *
 393 * \retval WLAN_STATUS_PENDING
 394 * \retval WLAN_STATUS_FAILURE
 395 */
 396 /*----------------------------------------------------------------------------*/
 397 WLAN_STATUS
 398 wlanoidSendSetQueryBowCmd (
 399     IN P_ADAPTER_T  prAdapter,
 400     IN UINT_8          ucCID,
 401     IN BOOLEAN         fgSetQuery,
 402     IN BOOLEAN         fgNeedResp,
 403     IN PFN_CMD_DONE_HANDLER pfCmdDoneHandler,
 404     IN PFN_CMD_TIMEOUT_HANDLER pfCmdTimeoutHandler,
 405     IN UINT_32         u4SetQueryInfoLen,
 406     IN PUINT_8         pucInfoBuffer,
 407     IN UINT_8       ucSeqNumber
 408     )
 409 {
 410     P_GLUE_INFO_T prGlueInfo;
 411     P_CMD_INFO_T prCmdInfo;
 412     P_WIFI_CMD_T prWifiCmd;
 413     UINT_8 ucCmdSeqNum;
 414
 415     ASSERT(prAdapter);
 416
 417     prGlueInfo = prAdapter->prGlueInfo;
 418     ASSERT(prGlueInfo);
 419
 420     DBGLOG(REQ, TRACE, ("Command ID = 0x%08X\n", ucCID));
 421
 422     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + u4SetQueryInfoLen));
 423
 424     if (!prCmdInfo) {
 425         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
 426         return WLAN_STATUS_FAILURE;
 427     }
 428
 429     // increase command sequence number
 430     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
 431     DBGLOG(REQ, TRACE, ("ucCmdSeqNum =%d\n", ucCmdSeqNum));
 432
 433     // Setup common CMD Info Packet
 434     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
 435     prCmdInfo->eNetworkType = NETWORK_TYPE_BOW_INDEX;
 436     prCmdInfo->u2InfoBufLen = (UINT_16)(CMD_HDR_SIZE + u4SetQueryInfoLen);
 437     prCmdInfo->pfCmdDoneHandler = pfCmdDoneHandler;
 438     prCmdInfo->pfCmdTimeoutHandler = pfCmdTimeoutHandler;
 439     prCmdInfo->fgIsOid = FALSE;
 440     prCmdInfo->ucCID = ucCID;
 441     prCmdInfo->fgSetQuery = fgSetQuery;
 442     prCmdInfo->fgNeedResp = fgNeedResp;
 443     prCmdInfo->fgDriverDomainMCR = FALSE;
 444     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
 445     prCmdInfo->u4SetInfoLen = u4SetQueryInfoLen;
 446     prCmdInfo->pvInformationBuffer = NULL;
 447     prCmdInfo->u4InformationBufferLength = 0;
 448     prCmdInfo->u4PrivateData = (UINT_32) ucSeqNumber;
 449
 450     // Setup WIFI_CMD_T (no payload)
 451     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
 452     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
 453     prWifiCmd->ucCID = prCmdInfo->ucCID;
 454     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
 455     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
 456
 457     if(u4SetQueryInfoLen > 0 && pucInfoBuffer != NULL) {
 458         kalMemCopy(prWifiCmd->aucBuffer, pucInfoBuffer, u4SetQueryInfoLen);
 459     }
 460
 461     // insert into prCmdQueue
 462     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
 463
 464     // wakeup txServiceThread later
 465     GLUE_SET_EVENT(prGlueInfo);
 466     return WLAN_STATUS_PENDING;
 467 }
 468
 469 /*----------------------------------------------------------------------------*/
 470 /*!
 471 * \brief This routine is called to dispatch command coming from 802.11 PAL
 472 *
 473 * \param[in] prAdapter  Pointer to the Adapter structure.
 474 * \param[in] prCmd      Pointer to the buffer that holds the command
 475 *
 476 * \retval WLAN_STATUS_SUCCESS
 477 * \retval WLAN_STATUS_INVALID_LENGTH
 478 */
 479 /*----------------------------------------------------------------------------*/
 480 WLAN_STATUS
 481 wlanbowHandleCommand(
 482     IN P_ADAPTER_T      prAdapter,
 483     IN P_AMPC_COMMAND   prCmd
 484     )
 485 {
 486     WLAN_STATUS retval = WLAN_STATUS_FAILURE;
 487     UINT_16 i;
 488
 489     ASSERT(prAdapter);
 490
 491     for (i = 0; i < sizeof(arBowCmdTable) / sizeof(BOW_CMD_T); i++) {
 492         if ((arBowCmdTable[i].uCmdID == prCmd->rHeader.ucCommandId) &&
 493                 arBowCmdTable[i].pfCmdHandle) {
 494             retval = arBowCmdTable[i].pfCmdHandle(prAdapter, prCmd);
 495             break;
 496         }
 497     }
 498
 499     return retval;
 500 }
 501
 502
 503 /*----------------------------------------------------------------------------*/
 504 /*!
 505 * \brief This is command handler for BOW_CMD_ID_GET_MAC_STATUS
 506 *        coming from 802.11 PAL
 507 *
 508 * \param[in] prAdapter  Pointer to the Adapter structure.
 509 * \param[in] prCmd      Pointer to the buffer that holds the command
 510 *
 511 * \retval WLAN_STATUS_SUCCESS
 512 * \retval WLAN_STATUS_INVALID_LENGTH
 513 */
 514 /*----------------------------------------------------------------------------*/
 515 WLAN_STATUS
 516 bowCmdGetMacStatus(
 517     IN P_ADAPTER_T      prAdapter,
 518     IN P_AMPC_COMMAND   prCmd
 519     )
 520 {
 521     P_AMPC_EVENT prEvent;
 522     P_BOW_MAC_STATUS prMacStatus;
 523     UINT_8 idx = 0;
 524     UINT_8 ucPrimaryChannel;
 525     ENUM_BAND_T eBand;
 526     ENUM_CHNL_EXT_T eBssSCO;
 527     UINT_8 ucNumOfChannel = 0;//MAX_BOW_NUMBER_OF_CHANNEL;
 528
 529     RF_CHANNEL_INFO_T aucChannelList[MAX_BOW_NUMBER_OF_CHANNEL];
 530
 531     ASSERT(prAdapter);
 532
 533     //3 <1> If LinkCount != 0 -> OK (optional)
 534
 535     eBand = BAND_2G4;
 536     eBssSCO = CHNL_EXT_SCN;
 537
 538     // fill event header
 539     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_MAC_STATUS)), VIR_MEM_TYPE);
 540
 541     prEvent->rHeader.ucEventId = BOW_EVENT_ID_MAC_STATUS;
 542     prEvent->rHeader.ucSeqNumber = prCmd->rHeader.ucSeqNumber;
 543     prEvent->rHeader.u2PayloadLength = sizeof(BOW_MAC_STATUS);
 544
 545     // fill event body
 546     prMacStatus = (P_BOW_MAC_STATUS)(prEvent->aucPayload);
 547     kalMemZero(prMacStatus, sizeof(BOW_MAC_STATUS));
 548
 549     //3 <2> Call CNM to decide if BOW available.
 550     if (cnmBowIsPermitted(prAdapter))
 551     {
 552         prMacStatus->ucAvailability = TRUE;
 553     }
 554     else
 555     {
 556         prMacStatus->ucAvailability = FALSE;
 557     }
 558
 559     memcpy(prMacStatus->aucMacAddr, prAdapter->rWifiVar.aucDeviceAddress, PARAM_MAC_ADDR_LEN);
 560
 561     if (cnmPreferredChannel(prAdapter, &eBand, &ucPrimaryChannel, &eBssSCO))
 562     {
 563 #if CFG_BOW_TEST
 564         DBGLOG(BOW, EVENT, ("bowCmdGetMacStatus, Get preferred channel.\n"));
 565 #endif
 566
 567         prMacStatus->ucNumOfChannel = 1;
 568         prMacStatus->arChannelList[0].ucChannelBand = eBand;
 569         prMacStatus->arChannelList[0].ucChannelNum = ucPrimaryChannel;
 570     }
 571     else
 572     {
 573 #if CFG_BOW_TEST
 574         DBGLOG(BOW, EVENT, ("bowCmdGetMacStatus, Get channel list. Current number of channel, %d.\n", ucNumOfChannel));
 575 #endif
 576
 577         rlmDomainGetChnlList(prAdapter, BAND_2G4, MAX_BOW_NUMBER_OF_CHANNEL_2G4, &ucNumOfChannel, aucChannelList);
 578
 579         if (ucNumOfChannel > 0) {
 580             for (idx = 0; idx < ucNumOfChannel/*MAX_BOW_NUMBER_OF_CHANNEL_2G4*/; idx++)
 581         {
 582             prMacStatus->arChannelList[idx].ucChannelBand = aucChannelList[idx].eBand;
 583             prMacStatus->arChannelList[idx].ucChannelNum = aucChannelList[idx].ucChannelNum;
 584         }
 585
 586             prMacStatus->ucNumOfChannel = ucNumOfChannel;
 587     }
 588
 589         rlmDomainGetChnlList(prAdapter, BAND_5G, MAX_BOW_NUMBER_OF_CHANNEL_5G, &ucNumOfChannel, aucChannelList);
 590
 591         if (ucNumOfChannel > 0) {
 592             for (idx = 0; idx < ucNumOfChannel/*MAX_BOW_NUMBER_OF_CHANNEL_5G*/; idx++)
 593             {
 594                 prMacStatus->arChannelList[prMacStatus->ucNumOfChannel + idx].ucChannelBand = aucChannelList[idx].eBand;
 595                 prMacStatus->arChannelList[prMacStatus->ucNumOfChannel + idx].ucChannelNum = aucChannelList[idx].ucChannelNum;
 596             }
 597
 598             prMacStatus->ucNumOfChannel = prMacStatus->ucNumOfChannel + ucNumOfChannel;
 599
 600             }
 601     }
 602
 603 #if CFG_BOW_TEST
 604     DBGLOG(BOW, EVENT, ("ucNumOfChannel, eBand, aucChannelList, %x, %x, %x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x.\n",
 605         ucNumOfChannel,
 606         aucChannelList[0].eBand,
 607         aucChannelList[0].ucChannelNum,
 608         aucChannelList[1].ucChannelNum,
 609         aucChannelList[2].ucChannelNum,
 610         aucChannelList[3].ucChannelNum,
 611         aucChannelList[4].ucChannelNum,
 612         aucChannelList[5].ucChannelNum,
 613         aucChannelList[6].ucChannelNum,
 614         aucChannelList[7].ucChannelNum,
 615         aucChannelList[8].ucChannelNum,
 616         aucChannelList[9].ucChannelNum,
 617         aucChannelList[10].ucChannelNum,
 618         aucChannelList[11].ucChannelNum,
 619         aucChannelList[12].ucChannelNum,
 620         aucChannelList[13].ucChannelNum,
 621         aucChannelList[14].ucChannelNum,
 622         aucChannelList[15].ucChannelNum,
 623         aucChannelList[16].ucChannelNum,
 624         aucChannelList[17].ucChannelNum));
 625
 626     DBGLOG(BOW, EVENT, ("prMacStatus->ucNumOfChannel, eBand, prMacStatus->arChannelList, %x, %x, %x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x.\n",
 627         prMacStatus->ucNumOfChannel,
 628         prMacStatus->arChannelList[0].ucChannelBand,
 629         prMacStatus->arChannelList[0].ucChannelNum,
 630         prMacStatus->arChannelList[1].ucChannelNum,
 631         prMacStatus->arChannelList[2].ucChannelNum,
 632         prMacStatus->arChannelList[3].ucChannelNum,
 633         prMacStatus->arChannelList[4].ucChannelNum,
 634         prMacStatus->arChannelList[5].ucChannelNum,
 635         prMacStatus->arChannelList[6].ucChannelNum,
 636         prMacStatus->arChannelList[7].ucChannelNum,
 637         prMacStatus->arChannelList[8].ucChannelNum,
 638         prMacStatus->arChannelList[9].ucChannelNum,
 639         prMacStatus->arChannelList[10].ucChannelNum,
 640         prMacStatus->arChannelList[11].ucChannelNum,
 641         prMacStatus->arChannelList[12].ucChannelNum,
 642         prMacStatus->arChannelList[13].ucChannelNum,
 643         prMacStatus->arChannelList[14].ucChannelNum,
 644         prMacStatus->arChannelList[15].ucChannelNum,
 645         prMacStatus->arChannelList[16].ucChannelNum,
 646         prMacStatus->arChannelList[17].ucChannelNum));
 647
 648     DBGLOG(BOW, EVENT, ("prMacStatus->ucNumOfChannel, %x.\n", prMacStatus->ucNumOfChannel));
 649     DBGLOG(BOW, EVENT, ("prMacStatus->arChannelList[0].ucChannelBand, %x.\n", prMacStatus->arChannelList[0].ucChannelBand));
 650     DBGLOG(BOW, EVENT, ("prMacStatus->arChannelList[0].ucChannelNum, %x.\n", prMacStatus->arChannelList[0].ucChannelNum));
 651     DBGLOG(BOW, EVENT, ("prMacStatus->ucAvailability, %x.\n", prMacStatus->ucAvailability));
 652     DBGLOG(BOW, EVENT, ("prMacStatus->aucMacAddr, %x:%x:%x:%x:%x:%x.\n",
 653         prMacStatus->aucMacAddr[0],
 654         prMacStatus->aucMacAddr[1],
 655         prMacStatus->aucMacAddr[2],
 656         prMacStatus->aucMacAddr[3],
 657         prMacStatus->aucMacAddr[4],
 658         prMacStatus->aucMacAddr[5]));
 659 #endif
 660
 661     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
 662
 663     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_MAC_STATUS)));
 664
 665     return WLAN_STATUS_SUCCESS;
 666 }
 667
 668
 669 /*----------------------------------------------------------------------------*/
 670 /*!
 671 * \brief This is command handler for BOW_CMD_ID_SETUP_CONNECTION
 672 *        coming from 802.11 PAL
 673 *
 674 * \param[in] prAdapter  Pointer to the Adapter structure.
 675 * \param[in] prCmd      Pointer to the buffer that holds the command
 676 *
 677 * \retval WLAN_STATUS_SUCCESS
 678 * \retval WLAN_STATUS_INVALID_LENGTH
 679 */
 680 /*----------------------------------------------------------------------------*/
 681 WLAN_STATUS
 682 bowCmdSetupConnection(
 683     IN P_ADAPTER_T      prAdapter,
 684     IN P_AMPC_COMMAND   prCmd
 685     )
 686 {
 687     P_BOW_SETUP_CONNECTION prBowSetupConnection;
 688     CMD_BT_OVER_WIFI rCmdBtOverWifi;
 689     P_BOW_FSM_INFO_T prBowFsmInfo;
 690     BOW_TABLE_T rBowTable;
 691
 692     UINT_8  ucBowTableIdx = 0;
 693
 694     ASSERT(prAdapter);
 695
 696     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
 697     prBowSetupConnection = (P_BOW_SETUP_CONNECTION) &(prCmd->aucPayload[0]);
 698
 699     // parameter size check
 700     if(prCmd->rHeader.u2PayloadLength != sizeof(BOW_SETUP_CONNECTION))
 701     {
 702         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_INVALID);
 703         return WLAN_STATUS_INVALID_LENGTH;
 704     }
 705
 706     //3 <1> If ucLinkCount >= 4 -> Fail.
 707     if (g_u4LinkCount >= CFG_BOW_PHYSICAL_LINK_NUM)
 708     {
 709         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 710         return WLAN_STATUS_NOT_ACCEPTED;
 711     }
 712
 713     //3 <2> Call CNM, check if BOW is available.
 714     if (!cnmBowIsPermitted(prAdapter))
 715     {
 716         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 717         return WLAN_STATUS_NOT_ACCEPTED;
 718     }
 719
 720     //3 <3> Lookup BOW Table, if Peer MAC address exist and valid -> Fail.
 721     if (bowCheckBowTableIfVaild(prAdapter, prBowSetupConnection->aucPeerAddress))
 722     {
 723         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 724         return WLAN_STATUS_NOT_ACCEPTED;
 725     }
 726
 727     if(EQUAL_MAC_ADDR(prBowSetupConnection->aucPeerAddress, prAdapter->rWifiVar.aucDeviceAddress))
 728     {
 729         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_INVALID);
 730         return WLAN_STATUS_NOT_ACCEPTED;
 731     }
 732
 733
 734     // fill CMD_BT_OVER_WIFI
 735     rCmdBtOverWifi.ucAction = BOW_SETUP_CMD;
 736     rCmdBtOverWifi.ucChannelNum = prBowSetupConnection->ucChannelNum;
 737     COPY_MAC_ADDR(rCmdBtOverWifi.rPeerAddr, prBowSetupConnection->aucPeerAddress);
 738     rCmdBtOverWifi.u2BeaconInterval = prBowSetupConnection->u2BeaconInterval;
 739     rCmdBtOverWifi.ucTimeoutDiscovery = prBowSetupConnection->ucTimeoutDiscovery;
 740     rCmdBtOverWifi.ucTimeoutInactivity = prBowSetupConnection->ucTimeoutInactivity;
 741     rCmdBtOverWifi.ucRole = prBowSetupConnection->ucRole;
 742     rCmdBtOverWifi.PAL_Capabilities = prBowSetupConnection->ucPAL_Capabilities;
 743     rCmdBtOverWifi.cMaxTxPower = prBowSetupConnection->cMaxTxPower;
 744
 745     if (prBowSetupConnection->ucChannelNum > 14) {
 746         rCmdBtOverWifi.ucChannelBand = BAND_5G;
 747     }
 748     else {
 749         rCmdBtOverWifi.ucChannelBand = BAND_2G4;
 750     }
 751
 752     COPY_MAC_ADDR(prBowFsmInfo->aucPeerAddress, prBowSetupConnection->aucPeerAddress);
 753
 754 #if CFG_BOW_PHYSICAL_LINK_NUM > 1
 755     /*Channel check for supporting multiple physical link*/
 756     if(g_u4LinkCount > 0) {
 757         if (prBowSetupConnection->ucChannelNum != prBowFsmInfo->ucPrimaryChannel) {
 758             wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 759             return WLAN_STATUS_NOT_ACCEPTED;
 760         }
 761     }
 762 #endif
 763
 764     prBowFsmInfo->ucPrimaryChannel = prBowSetupConnection->ucChannelNum;
 765     prBowFsmInfo->eBand = rCmdBtOverWifi.ucChannelBand;
 766     prBowFsmInfo->u2BeaconInterval = prBowSetupConnection->u2BeaconInterval;
 767     prBowFsmInfo->ucRole = prBowSetupConnection->ucRole;
 768
 769     if (prBowSetupConnection->ucPAL_Capabilities > 0)
 770     {
 771         prBowFsmInfo->fgSupportQoS = TRUE;
 772     }
 773
 774 #if CFG_BOW_TEST
 775     DBGLOG(BOW, EVENT, ("bowCmdSetupConnection.\n"));
 776     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Channel Number - 0x%x.\n", rCmdBtOverWifi.ucChannelNum));
 777     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Peer address - %x:%x:%x:%x:%x:%x.\n", rCmdBtOverWifi.rPeerAddr[0],
 778         rCmdBtOverWifi.rPeerAddr[1],
 779         rCmdBtOverWifi.rPeerAddr[2],
 780         rCmdBtOverWifi.rPeerAddr[3],
 781         rCmdBtOverWifi.rPeerAddr[4],
 782         rCmdBtOverWifi.rPeerAddr[5]));
 783     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Beacon interval - 0x%x.\n", rCmdBtOverWifi.u2BeaconInterval));
 784     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Timeout activity - 0x%x.\n", rCmdBtOverWifi.ucTimeoutDiscovery));
 785     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Timeout inactivity - 0x%x.\n", rCmdBtOverWifi.ucTimeoutInactivity));
 786     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Role - 0x%x.\n", rCmdBtOverWifi.ucRole));
 787     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi PAL capability - 0x%x.\n", rCmdBtOverWifi.PAL_Capabilities));
 788     DBGLOG(BOW, EVENT, ("rCmdBtOverWifi Max Tx power - 0x%x.\n", rCmdBtOverWifi.cMaxTxPower));
 789 #endif
 790
 791     //3 <4> Get a free BOW entry, mark as Valid, fill in Peer MAC address, LinkCount += 1, state == Starting.
 792     if (!bowGetBowTableFreeEntry(prAdapter, &ucBowTableIdx))
 793     {
 794         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 795         return WLAN_STATUS_NOT_ACCEPTED;
 796     }
 797
 798     prBowFsmInfo->prTargetBssDesc = NULL;
 799
 800     COPY_MAC_ADDR(rBowTable.aucPeerAddress, prBowSetupConnection->aucPeerAddress);
 801     //owTable.eState = BOW_DEVICE_STATE_ACQUIRING_CHANNEL;
 802     rBowTable.fgIsValid = TRUE;
 803     rBowTable.ucAcquireID = prBowFsmInfo->ucSeqNumOfChReq;
 804     //rBowTable.ucRole = prBowSetupConnection->ucRole;
 805     //rBowTable.ucChannelNum = prBowSetupConnection->ucChannelNum;
 806     bowSetBowTableContent(prAdapter, ucBowTableIdx, &rBowTable);
 807
 808     kalSetBowRole(prAdapter->prGlueInfo, rCmdBtOverWifi.ucRole, prBowSetupConnection->aucPeerAddress);
 809
 810     GLUE_INC_REF_CNT(g_u4LinkCount);
 811
 812 #if CFG_BOW_TEST
 813     DBGLOG(BOW, EVENT, ("bowStarting, g_u4LinkCount, %x.\n", g_u4LinkCount));
 814 #endif
 815
 816     if (g_u4LinkCount == 1)
 817     {
 818 #if CFG_BOW_TEST
 819         DBGLOG(BOW, EVENT, ("bowStarting, cnmTimerInitTimer.\n"));
 820         DBGLOG(BOW, EVENT, ("prBowFsmInfo->u2BeaconInterval, %d.\n", prBowFsmInfo->u2BeaconInterval));
 821 #endif
 822         cnmTimerInitTimer(prAdapter,
 823                 &prBowFsmInfo->rStartingBeaconTimer,
 824                 (PFN_MGMT_TIMEOUT_FUNC)bowSendBeacon,
 825                 (UINT_32)NULL);
 826
 827         cnmTimerInitTimer(prAdapter,
 828                 &prBowFsmInfo->rChGrantedTimer,
 829                 (PFN_MGMT_TIMEOUT_FUNC)bowChGrantedTimeout,
 830                 (UINT_32)NULL);
 831
 832         //Reset Global Variable
 833         g_u4Beaconing = 0;
 834
 835 #if CFG_BOW_TEST
 836         DBGLOG(BOW, EVENT, ("bowCmdSetupConnection, g_u4LinkCount, %x.\n", g_u4LinkCount));
 837         DBGLOG(BOW, EVENT, ("kalInitBowDevice, bow0\n"));
 838 #endif
 839 #if CFG_BOW_SEPARATE_DATA_PATH
 840         kalInitBowDevice(prAdapter->prGlueInfo, BOWDEVNAME);
 841 #endif
 842
 843         /*Active BoW Network*/
 844         SET_NET_ACTIVE(prAdapter, NETWORK_TYPE_BOW_INDEX);
 845         SET_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_BOW_INDEX);
 846         nicActivateNetwork(prAdapter, NETWORK_TYPE_BOW_INDEX);
 847
 848     }
 849
 850     if(rCmdBtOverWifi.ucRole == BOW_INITIATOR) {
 851         bowSetBowTableState(prAdapter, prBowSetupConnection->aucPeerAddress, BOW_DEVICE_STATE_ACQUIRING_CHANNEL);
 852     bowRequestCh(prAdapter);
 853     } else {
 854         bowSetBowTableState(prAdapter, prBowSetupConnection->aucPeerAddress, BOW_DEVICE_STATE_SCANNING);
 855         bowResponderScan(prAdapter);
 856     }
 857
 858     wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_SUCCESS);
 859
 860     return WLAN_STATUS_SUCCESS;
 861 }
 862
 863
 864 /*----------------------------------------------------------------------------*/
 865 /*!
 866 * \brief This is command handler for BOW_CMD_ID_DESTROY_CONNECTION
 867 *        coming from 802.11 PAL
 868 *
 869 * \param[in] prAdapter  Pointer to the Adapter structure.
 870 * \param[in] prCmd      Pointer to the buffer that holds the command
 871 *
 872 * \retval WLAN_STATUS_SUCCESS
 873 * \retval WLAN_STATUS_INVALID_LENGTH
 874 */
 875 /*----------------------------------------------------------------------------*/
 876 WLAN_STATUS
 877 bowCmdDestroyConnection(
 878     IN P_ADAPTER_T      prAdapter,
 879     IN P_AMPC_COMMAND   prCmd
 880     )
 881 {
 882     P_BOW_DESTROY_CONNECTION prBowDestroyConnection;
 883     CMD_BT_OVER_WIFI rCmdBtOverWifi;
 884     P_BOW_FSM_INFO_T prBowFsmInfo;
 885 #if CFG_BOW_TEST
 886     UINT_8 ucIdx;
 887 #endif
 888
 889     ASSERT(prAdapter);
 890
 891     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
 892
 893     //3 <1> If LinkCount == 0 ->Fail (Optional)
 894     if (g_u4LinkCount == 0)
 895     {
 896         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 897         return WLAN_STATUS_NOT_ACCEPTED;
 898     }
 899
 900     // parameter size check
 901     if(prCmd->rHeader.u2PayloadLength != sizeof(BOW_DESTROY_CONNECTION))
 902     {
 903         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
 904         return WLAN_STATUS_INVALID_LENGTH;
 905     }
 906
 907     //3 <2> Lookup BOW table, check if is not exist (Valid and Peer MAC address) -> Fail
 908     prBowDestroyConnection = (P_BOW_DESTROY_CONNECTION) &(prCmd->aucPayload[0]);
 909
 910     if (!bowCheckBowTableIfVaild(prAdapter, prBowDestroyConnection->aucPeerAddress))
 911     {
 912 #if CFG_BOW_TEST
 913         DBGLOG(BOW, EVENT, ("bowCmdDestroyConnection, bowCheckIfVaild, not accepted.\n"));
 914 #endif
 915         return WLAN_STATUS_NOT_ACCEPTED;
 916     }
 917
 918 #if CFG_BOW_TEST
 919     DBGLOG(BOW, EVENT, ("bowCmdDestroyConnection, destroy Peer address - %x:%x:%x:%x:%x:%x.\n", prBowDestroyConnection->aucPeerAddress[0],
 920         prBowDestroyConnection->aucPeerAddress[1],
 921         prBowDestroyConnection->aucPeerAddress[2],
 922         prBowDestroyConnection->aucPeerAddress[3],
 923         prBowDestroyConnection->aucPeerAddress[4],
 924         prBowDestroyConnection->aucPeerAddress[5]));
 925 #endif
 926
 927     // fill CMD_BT_OVER_WIFI
 928     rCmdBtOverWifi.ucAction = 2;
 929     COPY_MAC_ADDR(rCmdBtOverWifi.rPeerAddr, prBowDestroyConnection->aucPeerAddress);
 930     COPY_MAC_ADDR(prBowFsmInfo->aucPeerAddress, prBowDestroyConnection->aucPeerAddress);
 931 #if CFG_BOW_TEST
 932     DBGLOG(BOW, EVENT, ("bowCmdDestroyConnection, rCmdBtOverWifi.rPeerAddr - %x:%x:%x:%x:%x:%x.\n", rCmdBtOverWifi.rPeerAddr[0],
 933         rCmdBtOverWifi.rPeerAddr[1],
 934         rCmdBtOverWifi.rPeerAddr[2],
 935         rCmdBtOverWifi.rPeerAddr[3],
 936         rCmdBtOverWifi.rPeerAddr[4],
 937         rCmdBtOverWifi.rPeerAddr[5]));
 938 #endif
 939
 940 #if CFG_BOW_TEST
 941     for (ucIdx = 0; ucIdx < 11; ucIdx++)
 942     {
 943         DBGLOG(BOW, EVENT, ("BoW receiving PAL packet delta time vs packet number -- %d ms vs %x.\n", ucIdx, g_arBowRevPalPacketTime[ucIdx]));
 944     }
 945 #endif
 946
 947     wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_SUCCESS);
 948
 949     return wlanoidSendSetQueryBowCmd(prAdapter,
 950             CMD_ID_CMD_BT_OVER_WIFI,
 951             TRUE,
 952             FALSE,
 953             wlanbowCmdEventLinkDisconnected,
 954             wlanbowCmdTimeoutHandler,
 955             sizeof(CMD_BT_OVER_WIFI),
 956             (PUINT_8) &rCmdBtOverWifi,
 957             prCmd->rHeader.ucSeqNumber
 958             );
 959 }
 960
 961
 962 /*----------------------------------------------------------------------------*/
 963 /*!
 964 * \brief This is command handler for BOW_CMD_ID_SET_PTK
 965 *        coming from 802.11 PAL
 966 *
 967 * \param[in] prAdapter  Pointer to the Adapter structure.
 968 * \param[in] prCmd      Pointer to the buffer that holds the command
 969 *
 970 * \retval WLAN_STATUS_SUCCESS
 971 * \retval WLAN_STATUS_INVALID_LENGTH
 972 */
 973 /*----------------------------------------------------------------------------*/
 974 WLAN_STATUS
 975 bowCmdSetPTK(
 976     IN P_ADAPTER_T      prAdapter,
 977     IN P_AMPC_COMMAND   prCmd
 978     )
 979 {
 980     P_BOW_SET_PTK prBowSetPTK;
 981     CMD_802_11_KEY rCmdKey;
 982
 983     ASSERT(prAdapter);
 984
 985     // parameter size check
 986     if(prCmd->rHeader.u2PayloadLength != sizeof(BOW_SET_PTK)) {
 987         return WLAN_STATUS_INVALID_LENGTH;
 988     }
 989
 990     prBowSetPTK = (P_BOW_SET_PTK) &(prCmd->aucPayload[0]);
 991
 992 #if CFG_BOW_TEST
 993     DBGLOG(BOW, EVENT, ("prBowSetPTK->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
 994         prBowSetPTK->aucPeerAddress[0],
 995         prBowSetPTK->aucPeerAddress[1],
 996         prBowSetPTK->aucPeerAddress[2],
 997         prBowSetPTK->aucPeerAddress[3],
 998         prBowSetPTK->aucPeerAddress[4],
 999         prBowSetPTK->aucPeerAddress[5]));
1000
1001      DBGLOG(BOW, EVENT, ("rCmdKey.ucIsAuthenticator, %x.\n", kalGetBowRole(prAdapter->prGlueInfo, prBowSetPTK->aucPeerAddress)));
1002 #endif
1003
1004     if (!bowCheckBowTableIfVaild(prAdapter, prBowSetPTK->aucPeerAddress))
1005     {
1006         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
1007
1008         return WLAN_STATUS_NOT_ACCEPTED;
1009     }
1010
1011     if (bowGetBowTableState(prAdapter, prBowSetPTK->aucPeerAddress) != BOW_DEVICE_STATE_CONNECTED)
1012     {
1013         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_FAILURE);
1014
1015         return WLAN_STATUS_NOT_ACCEPTED;
1016     }
1017
1018     // fill CMD_802_11_KEY
1019     rCmdKey.ucAddRemove = 1; // add
1020     rCmdKey.ucTxKey = 1;
1021     rCmdKey.ucKeyType = 1;
1022     rCmdKey.ucIsAuthenticator = kalGetBowRole(prAdapter->prGlueInfo, prBowSetPTK->aucPeerAddress);
1023     COPY_MAC_ADDR(rCmdKey.aucPeerAddr, prBowSetPTK->aucPeerAddress);
1024     rCmdKey.ucNetType = NETWORK_TYPE_BOW_INDEX; // BT Over Wi-Fi
1025     rCmdKey.ucAlgorithmId = CIPHER_SUITE_CCMP; // AES
1026     rCmdKey.ucKeyId = 0;
1027     rCmdKey.ucKeyLen = 16; // AES = 128bit
1028     kalMemCopy(rCmdKey.aucKeyMaterial, prBowSetPTK->aucTemporalKey, 16);
1029
1030 #if CFG_BOW_TEST
1031     DBGLOG(BOW, EVENT, ("prBowSetPTK->aucTemporalKey, %x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x.\n",
1032         prBowSetPTK->aucTemporalKey[0],
1033         prBowSetPTK->aucTemporalKey[1],
1034         prBowSetPTK->aucTemporalKey[2],
1035         prBowSetPTK->aucTemporalKey[3],
1036         prBowSetPTK->aucTemporalKey[4],
1037         prBowSetPTK->aucTemporalKey[5],
1038         prBowSetPTK->aucTemporalKey[6],
1039         prBowSetPTK->aucTemporalKey[7],
1040         prBowSetPTK->aucTemporalKey[8],
1041         prBowSetPTK->aucTemporalKey[9],
1042         prBowSetPTK->aucTemporalKey[10],
1043         prBowSetPTK->aucTemporalKey[11],
1044         prBowSetPTK->aucTemporalKey[12],
1045         prBowSetPTK->aucTemporalKey[13],
1046         prBowSetPTK->aucTemporalKey[14],
1047         prBowSetPTK->aucTemporalKey[15]));
1048
1049     DBGLOG(BOW, EVENT, ("rCmdKey.aucKeyMaterial, %x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x.\n",
1050         rCmdKey.aucKeyMaterial[0],
1051         rCmdKey.aucKeyMaterial[1],
1052         rCmdKey.aucKeyMaterial[2],
1053         rCmdKey.aucKeyMaterial[3],
1054         rCmdKey.aucKeyMaterial[4],
1055         rCmdKey.aucKeyMaterial[5],
1056         rCmdKey.aucKeyMaterial[6],
1057         rCmdKey.aucKeyMaterial[7],
1058         rCmdKey.aucKeyMaterial[8],
1059         rCmdKey.aucKeyMaterial[9],
1060         rCmdKey.aucKeyMaterial[10],
1061         rCmdKey.aucKeyMaterial[11],
1062         rCmdKey.aucKeyMaterial[12],
1063         rCmdKey.aucKeyMaterial[13],
1064         rCmdKey.aucKeyMaterial[14],
1065         rCmdKey.aucKeyMaterial[15]));
1066 #endif
1067
1068     return wlanoidSendSetQueryBowCmd(prAdapter,
1069             CMD_ID_ADD_REMOVE_KEY,
1070             TRUE,
1071             FALSE,
1072             wlanbowCmdEventSetCommon,
1073             wlanbowCmdTimeoutHandler,
1074             sizeof(CMD_802_11_KEY),
1075             (PUINT_8) &rCmdKey,
1076             prCmd->rHeader.ucSeqNumber
1077             );
1078 }
1079
1080
1081 /*----------------------------------------------------------------------------*/
1082 /*!
1083 * \brief This is command handler for BOW_CMD_ID_READ_RSSI
1084 *        coming from 802.11 PAL
1085 *
1086 * \param[in] prAdapter  Pointer to the Adapter structure.
1087 * \param[in] prCmd      Pointer to the buffer that holds the command
1088 *
1089 * \retval WLAN_STATUS_SUCCESS
1090 * \retval WLAN_STATUS_INVALID_LENGTH
1091 */
1092 /*----------------------------------------------------------------------------*/
1093 WLAN_STATUS
1094 bowCmdReadRSSI(
1095     IN P_ADAPTER_T      prAdapter,
1096     IN P_AMPC_COMMAND   prCmd
1097     )
1098 {
1099     P_BOW_READ_RSSI prBowReadRSSI;
1100
1101     ASSERT(prAdapter);
1102
1103     // parameter size check
1104     if(prCmd->rHeader.u2PayloadLength != sizeof(BOW_READ_RSSI)) {
1105         return WLAN_STATUS_INVALID_LENGTH;
1106     }
1107
1108     prBowReadRSSI = (P_BOW_READ_RSSI) &(prCmd->aucPayload[0]);
1109
1110     return wlanoidSendSetQueryBowCmd(prAdapter,
1111             CMD_ID_GET_LINK_QUALITY,
1112             FALSE,
1113             TRUE,
1114             wlanbowCmdEventReadRssi,
1115             wlanbowCmdTimeoutHandler,
1116             0,
1117             NULL,
1118             prCmd->rHeader.ucSeqNumber
1119             );
1120 }
1121
1122 /*----------------------------------------------------------------------------*/
1123 /*!
1124 * \brief This is command handler for BOW_CMD_ID_READ_LINK_QUALITY
1125 *        coming from 802.11 PAL
1126 *
1127 * \param[in] prAdapter  Pointer to the Adapter structure.
1128 * \param[in] prCmd      Pointer to the buffer that holds the command
1129 *
1130 * \retval WLAN_STATUS_SUCCESS
1131 * \retval WLAN_STATUS_INVALID_LENGTH
1132 */
1133 /*----------------------------------------------------------------------------*/
1134 WLAN_STATUS
1135 bowCmdReadLinkQuality(
1136     IN P_ADAPTER_T      prAdapter,
1137     IN P_AMPC_COMMAND   prCmd
1138     )
1139 {
1140     P_BOW_READ_LINK_QUALITY prBowReadLinkQuality;
1141
1142     ASSERT(prAdapter);
1143
1144     // parameter size check
1145     if(prCmd->rHeader.u2PayloadLength != sizeof(P_BOW_READ_LINK_QUALITY)) {
1146         return WLAN_STATUS_INVALID_LENGTH;
1147     }
1148
1149     prBowReadLinkQuality = (P_BOW_READ_LINK_QUALITY) &(prCmd->aucPayload[0]);
1150
1151     return wlanoidSendSetQueryBowCmd(prAdapter,
1152             CMD_ID_GET_LINK_QUALITY,
1153             FALSE,
1154             TRUE,
1155             wlanbowCmdEventReadLinkQuality,
1156             wlanbowCmdTimeoutHandler,
1157             0,
1158             NULL,
1159             prCmd->rHeader.ucSeqNumber
1160             );
1161 }
1162
1163
1164 /*----------------------------------------------------------------------------*/
1165 /*!
1166 * \brief This is command handler for BOW_CMD_ID_SHORT_RANGE_MODE
1167 *        coming from 802.11 PAL
1168 *
1169 * \param[in] prAdapter  Pointer to the Adapter structure.
1170 * \param[in] prCmd      Pointer to the buffer that holds the command
1171 *
1172 * \retval WLAN_STATUS_SUCCESS
1173 * \retval WLAN_STATUS_INVALID_LENGTH
1174 */
1175 /*----------------------------------------------------------------------------*/
1176 WLAN_STATUS
1177 bowCmdShortRangeMode(
1178     IN P_ADAPTER_T      prAdapter,
1179     IN P_AMPC_COMMAND   prCmd
1180     )
1181 {
1182     P_BOW_SHORT_RANGE_MODE prBowShortRangeMode;
1183     CMD_TX_PWR_T rTxPwrParam;
1184
1185     ASSERT(prAdapter);
1186
1187 #if CFG_BOW_TEST
1188     DBGLOG(BOW, EVENT, ("bowCmdShortRangeMode.\n"));
1189 #endif
1190
1191     prBowShortRangeMode = (P_BOW_SHORT_RANGE_MODE) &(prCmd->aucPayload[0]);
1192
1193     // parameter size check
1194     if(prCmd->rHeader.u2PayloadLength != sizeof(BOW_SHORT_RANGE_MODE)) {
1195         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
1196         return WLAN_STATUS_INVALID_LENGTH;
1197     }
1198
1199     if (!bowCheckBowTableIfVaild(prAdapter, prBowShortRangeMode->aucPeerAddress))
1200     {
1201         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_UNACCEPTED);
1202         return WLAN_STATUS_NOT_ACCEPTED;
1203     }
1204
1205     if (bowGetBowTableState(prAdapter, prBowShortRangeMode->aucPeerAddress) != BOW_DEVICE_STATE_CONNECTED)
1206     {
1207         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_FAILURE);
1208         return WLAN_STATUS_NOT_ACCEPTED;
1209     }
1210
1211
1212 #if CFG_BOW_TEST
1213     DBGLOG(BOW, EVENT, ("prBowShortRangeMode->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
1214         prBowShortRangeMode->aucPeerAddress[0],
1215         prBowShortRangeMode->aucPeerAddress[1],
1216         prBowShortRangeMode->aucPeerAddress[2],
1217         prBowShortRangeMode->aucPeerAddress[3],
1218         prBowShortRangeMode->aucPeerAddress[4],
1219         prBowShortRangeMode->aucPeerAddress[5]));
1220 #endif
1221
1222     rTxPwrParam.cTxPwr2G4Cck = (prBowShortRangeMode->cTxPower << 1);
1223
1224     rTxPwrParam.cTxPwr2G4OFDM_BPSK = (prBowShortRangeMode->cTxPower << 1);
1225     rTxPwrParam.cTxPwr2G4OFDM_QPSK = (prBowShortRangeMode->cTxPower << 1);
1226     rTxPwrParam.cTxPwr2G4OFDM_16QAM = (prBowShortRangeMode->cTxPower << 1);
1227
1228     rTxPwrParam.cTxPwr2G4OFDM_48Mbps = (prBowShortRangeMode->cTxPower << 1);
1229     rTxPwrParam.cTxPwr2G4OFDM_54Mbps = (prBowShortRangeMode->cTxPower << 1);
1230
1231     rTxPwrParam.cTxPwr2G4HT20_BPSK = (prBowShortRangeMode->cTxPower << 1);
1232     rTxPwrParam.cTxPwr2G4HT20_QPSK = (prBowShortRangeMode->cTxPower << 1);
1233     rTxPwrParam.cTxPwr2G4HT20_16QAM = (prBowShortRangeMode->cTxPower << 1);
1234     rTxPwrParam.cTxPwr2G4HT20_MCS5 = (prBowShortRangeMode->cTxPower << 1);
1235     rTxPwrParam.cTxPwr2G4HT20_MCS6 = (prBowShortRangeMode->cTxPower << 1);
1236     rTxPwrParam.cTxPwr2G4HT20_MCS7 = (prBowShortRangeMode->cTxPower << 1);
1237
1238     rTxPwrParam.cTxPwr2G4HT40_BPSK = (prBowShortRangeMode->cTxPower << 1);
1239     rTxPwrParam.cTxPwr2G4HT40_QPSK = (prBowShortRangeMode->cTxPower << 1);
1240     rTxPwrParam.cTxPwr2G4HT40_16QAM = (prBowShortRangeMode->cTxPower << 1);
1241     rTxPwrParam.cTxPwr2G4HT40_MCS5 = (prBowShortRangeMode->cTxPower << 1);
1242     rTxPwrParam.cTxPwr2G4HT40_MCS6 = (prBowShortRangeMode->cTxPower << 1);
1243     rTxPwrParam.cTxPwr2G4HT40_MCS7 = (prBowShortRangeMode->cTxPower << 1);
1244
1245     rTxPwrParam.cTxPwr5GOFDM_BPSK = (prBowShortRangeMode->cTxPower << 1);
1246     rTxPwrParam.cTxPwr5GOFDM_QPSK = (prBowShortRangeMode->cTxPower << 1);
1247     rTxPwrParam.cTxPwr5GOFDM_16QAM = (prBowShortRangeMode->cTxPower << 1);
1248     rTxPwrParam.cTxPwr5GOFDM_48Mbps = (prBowShortRangeMode->cTxPower << 1);
1249     rTxPwrParam.cTxPwr5GOFDM_54Mbps = (prBowShortRangeMode->cTxPower << 1);
1250
1251     rTxPwrParam.cTxPwr5GHT20_BPSK = (prBowShortRangeMode->cTxPower << 1);
1252     rTxPwrParam.cTxPwr5GHT20_QPSK = (prBowShortRangeMode->cTxPower << 1);
1253     rTxPwrParam.cTxPwr5GHT20_16QAM = (prBowShortRangeMode->cTxPower << 1);
1254     rTxPwrParam.cTxPwr5GHT20_MCS5 = (prBowShortRangeMode->cTxPower << 1);
1255     rTxPwrParam.cTxPwr5GHT20_MCS6 = (prBowShortRangeMode->cTxPower << 1);
1256     rTxPwrParam.cTxPwr5GHT20_MCS7 = (prBowShortRangeMode->cTxPower << 1);
1257     rTxPwrParam.cTxPwr5GHT40_BPSK = (prBowShortRangeMode->cTxPower << 1);
1258     rTxPwrParam.cTxPwr5GHT40_QPSK = (prBowShortRangeMode->cTxPower << 1);
1259     rTxPwrParam.cTxPwr5GHT40_16QAM = (prBowShortRangeMode->cTxPower << 1);
1260     rTxPwrParam.cTxPwr5GHT40_MCS5 = (prBowShortRangeMode->cTxPower << 1);
1261     rTxPwrParam.cTxPwr5GHT40_MCS6 = (prBowShortRangeMode->cTxPower << 1);
1262     rTxPwrParam.cTxPwr5GHT40_MCS7 = (prBowShortRangeMode->cTxPower << 1);
1263
1264     if (nicUpdateTxPower(prAdapter, &rTxPwrParam) == WLAN_STATUS_SUCCESS)
1265     {
1266 #if CFG_BOW_TEST
1267         DBGLOG(BOW, EVENT, ("bowCmdShortRangeMode, %x.\n", WLAN_STATUS_SUCCESS));
1268 #endif
1269         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_SUCCESS);
1270         return WLAN_STATUS_SUCCESS;
1271     }
1272     else
1273     {
1274         wlanbowCmdEventSetStatus(prAdapter, prCmd, BOWCMD_STATUS_FAILURE);
1275         return WLAN_STATUS_FAILURE;
1276     }
1277
1278 }
1279
1280
1281 /*----------------------------------------------------------------------------*/
1282 /*!
1283 * \brief This is command handler for BOW_CMD_ID_GET_CHANNEL_LIST
1284 *        coming from 802.11 PAL
1285 *
1286 * \param[in] prAdapter  Pointer to the Adapter structure.
1287 * \param[in] prCmd      Pointer to the buffer that holds the command
1288 *
1289 * \retval WLAN_STATUS_SUCCESS
1290 * \retval WLAN_STATUS_INVALID_LENGTH
1291 */
1292 /*----------------------------------------------------------------------------*/
1293 WLAN_STATUS
1294 bowCmdGetChannelList(
1295     IN P_ADAPTER_T      prAdapter,
1296     IN P_AMPC_COMMAND   prCmd
1297     )
1298 {
1299     ASSERT(prAdapter);
1300
1301     // not supported yet
1302     return WLAN_STATUS_FAILURE;
1303 }
1304
1305
1306
1307 /*----------------------------------------------------------------------------*/
1308 /*!
1309 * \brief This is generic command done handler
1310 *
1311 * \param[in] prAdapter      Pointer to the Adapter structure.
1312 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1313 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1314 *
1315 * \retval none
1316 */
1317 /*----------------------------------------------------------------------------*/
1318 VOID
1319 wlanbowCmdEventSetStatus(
1320     IN P_ADAPTER_T  prAdapter,
1321     IN P_AMPC_COMMAND   prCmd,
1322     IN UINT_8   ucEventBuf
1323     )
1324 {
1325     P_AMPC_EVENT prEvent;
1326     P_BOW_COMMAND_STATUS prBowCmdStatus;
1327
1328     ASSERT(prAdapter);
1329
1330     // fill event header
1331     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)), VIR_MEM_TYPE);
1332     prEvent->rHeader.ucEventId = BOW_EVENT_ID_COMMAND_STATUS;
1333     prEvent->rHeader.ucSeqNumber = prCmd->rHeader.ucSeqNumber;
1334     prEvent->rHeader.u2PayloadLength = sizeof(BOW_COMMAND_STATUS);
1335
1336     // fill event body
1337     prBowCmdStatus = (P_BOW_COMMAND_STATUS)(prEvent->aucPayload);
1338     kalMemZero(prBowCmdStatus, sizeof(BOW_COMMAND_STATUS));
1339
1340     prBowCmdStatus->ucStatus = ucEventBuf;
1341
1342     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1343
1344     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)));
1345 }
1346
1347
1348 /*----------------------------------------------------------------------------*/
1349 /*!
1350 * \brief This is generic command done handler
1351 *
1352 * \param[in] prAdapter      Pointer to the Adapter structure.
1353 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1354 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1355 *
1356 * \retval none
1357 */
1358 /*----------------------------------------------------------------------------*/
1359 VOID
1360 wlanbowCmdEventSetCommon(
1361     IN P_ADAPTER_T  prAdapter,
1362     IN P_CMD_INFO_T prCmdInfo,
1363     IN PUINT_8      pucEventBuf
1364     )
1365 {
1366     P_AMPC_EVENT prEvent;
1367     P_BOW_COMMAND_STATUS prBowCmdStatus;
1368
1369     ASSERT(prAdapter);
1370
1371     // fill event header
1372     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)), VIR_MEM_TYPE);
1373     prEvent->rHeader.ucEventId = BOW_EVENT_ID_COMMAND_STATUS;
1374     prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1375     prEvent->rHeader.u2PayloadLength = sizeof(BOW_COMMAND_STATUS);
1376
1377     // fill event body
1378     prBowCmdStatus = (P_BOW_COMMAND_STATUS)(prEvent->aucPayload);
1379     kalMemZero(prBowCmdStatus, sizeof(BOW_COMMAND_STATUS));
1380
1381     prBowCmdStatus->ucStatus = BOWCMD_STATUS_SUCCESS;
1382
1383     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1384
1385     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)));
1386 }
1387
1388
1389 /*----------------------------------------------------------------------------*/
1390 /*!
1391 * \brief command done handler for CMD_ID_CMD_BT_OVER_WIFI
1392 *
1393 * \param[in] prAdapter      Pointer to the Adapter structure.
1394 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1395 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1396 *
1397 * \retval none
1398 */
1399 /*----------------------------------------------------------------------------*/
1400 VOID
1401 wlanbowCmdEventLinkConnected(
1402     IN P_ADAPTER_T  prAdapter,
1403     IN P_CMD_INFO_T prCmdInfo,
1404     IN PUINT_8      pucEventBuf
1405     )
1406 {
1407     P_AMPC_EVENT prEvent;
1408     P_BOW_LINK_CONNECTED prBowLinkConnected;
1409     P_BOW_FSM_INFO_T prBowFsmInfo;
1410     P_BSS_INFO_T prBssInfo;
1411
1412     ASSERT(prAdapter);
1413
1414     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
1415     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
1416
1417     // fill event header
1418     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_LINK_CONNECTED)), VIR_MEM_TYPE);
1419     prEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_CONNECTED;
1420     prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1421     prEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_CONNECTED);
1422
1423     // fill event body
1424     prBowLinkConnected = (P_BOW_LINK_CONNECTED)(prEvent->aucPayload);
1425     kalMemZero(prBowLinkConnected, sizeof(BOW_LINK_CONNECTED));
1426     prBowLinkConnected->rChannel.ucChannelNum = prBssInfo->ucPrimaryChannel;
1427     prBowLinkConnected->rChannel.ucChannelBand = prBssInfo->eBand;
1428     COPY_MAC_ADDR(prBowLinkConnected->aucPeerAddress, prBowFsmInfo->aucPeerAddress);
1429
1430 #if CFG_BOW_TEST
1431     DBGLOG(BOW, EVENT, ("prEvent->rHeader.ucEventId, 0x%x\n", prEvent->rHeader.ucEventId));
1432     DBGLOG(BOW, EVENT, ("prEvent->rHeader.ucSeqNumber, 0x%x\n", prEvent->rHeader.ucSeqNumber));
1433     DBGLOG(BOW, EVENT, ("prEvent->rHeader.u2PayloadLength, 0x%x\n", prEvent->rHeader.u2PayloadLength));
1434     DBGLOG(BOW, EVENT, ("prBowLinkConnected->rChannel.ucChannelNum, 0x%x\n", prBowLinkConnected->rChannel.ucChannelNum));
1435     DBGLOG(BOW, EVENT, ("prBowLinkConnected->rChannel.ucChannelBand, 0x%x\n", prBowLinkConnected->rChannel.ucChannelBand));
1436     DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkConnected, prBowFsmInfo->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
1437         prBowFsmInfo->aucPeerAddress[0],
1438         prBowFsmInfo->aucPeerAddress[1],
1439         prBowFsmInfo->aucPeerAddress[2],
1440         prBowFsmInfo->aucPeerAddress[3],
1441         prBowFsmInfo->aucPeerAddress[4],
1442         prBowFsmInfo->aucPeerAddress[5]));
1443     DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkConnected, prBowLinkConnected->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
1444         prBowLinkConnected->aucPeerAddress[0],
1445         prBowLinkConnected->aucPeerAddress[1],
1446         prBowLinkConnected->aucPeerAddress[2],
1447         prBowLinkConnected->aucPeerAddress[3],
1448         prBowLinkConnected->aucPeerAddress[4],
1449         prBowLinkConnected->aucPeerAddress[5]));
1450     DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkConnected, g_u4LinkCount, %x.\n", g_u4LinkCount));
1451 #endif
1452
1453     /*Indicate Event to PAL*/
1454     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1455     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_LINK_CONNECTED)));
1456
1457     /*Release channel if granted*/
1458     if(prBowFsmInfo->fgIsChannelGranted) {
1459         cnmTimerStopTimer(prAdapter, &prBowFsmInfo->rChGrantedTimer);
1460         //bowReleaseCh(prAdapter);
1461     /*Requested, not granted yet*/
1462     } else if(prBowFsmInfo->fgIsChannelRequested) {
1463         prBowFsmInfo->fgIsChannelRequested = FALSE;
1464     }
1465
1466     /* set to connected status*/
1467     bowSetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress, BOW_DEVICE_STATE_CONNECTED);
1468
1469 }
1470
1471
1472 /*----------------------------------------------------------------------------*/
1473 /*!
1474 * \brief command done handler for CMD_ID_CMD_BT_OVER_WIFI
1475 *
1476 * \param[in] prAdapter      Pointer to the Adapter structure.
1477 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1478 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1479 *
1480 * \retval none
1481 */
1482 /*----------------------------------------------------------------------------*/
1483 VOID
1484 wlanbowCmdEventLinkDisconnected(
1485     IN P_ADAPTER_T  prAdapter,
1486     IN P_CMD_INFO_T prCmdInfo,
1487     IN PUINT_8      pucEventBuf
1488     )
1489 {
1490     P_AMPC_EVENT prEvent;
1491     P_BOW_LINK_DISCONNECTED prBowLinkDisconnected;
1492     P_BOW_FSM_INFO_T prBowFsmInfo;
1493     BOW_TABLE_T rBowTable;
1494     UINT_8 ucBowTableIdx;
1495     ENUM_BOW_DEVICE_STATE eFsmState;
1496     BOOL fgSendDeauth = FALSE;
1497
1498     ASSERT(prAdapter);
1499
1500     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
1501     eFsmState = bowGetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress);
1502
1503     if(eFsmState == BOW_DEVICE_STATE_DISCONNECTED) {
1504         /*do nothing*/
1505         return;
1506     }
1507     /*Cancel scan*/
1508     else if(eFsmState == BOW_DEVICE_STATE_SCANNING &&
1509         !(prBowFsmInfo->fgIsChannelRequested)) {
1510         bowResponderCancelScan(prAdapter, FALSE);
1511         bowSetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress, BOW_DEVICE_STATE_DISCONNECTING);
1512         return;
1513     }
1514
1515     // fill event header
1516     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_LINK_DISCONNECTED)), VIR_MEM_TYPE);
1517     prEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_DISCONNECTED;
1518     if ((prCmdInfo->u4PrivateData))
1519     {
1520         prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1521     }
1522     else
1523     {
1524         prEvent->rHeader.ucSeqNumber = 0;
1525     }
1526
1527     prEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_DISCONNECTED);
1528
1529     // fill event body
1530     prBowLinkDisconnected = (P_BOW_LINK_DISCONNECTED)(prEvent->aucPayload);
1531     kalMemZero(prBowLinkDisconnected, sizeof(BOW_LINK_DISCONNECTED));
1532     prBowLinkDisconnected->ucReason = 0x0;
1533     COPY_MAC_ADDR(prBowLinkDisconnected->aucPeerAddress, prBowFsmInfo->aucPeerAddress);
1534
1535 #if CFG_BOW_TEST
1536     DBGLOG(BOW, EVENT, ("prEvent->rHeader.ucEventId, 0x%x\n", prEvent->rHeader.ucEventId));
1537     DBGLOG(BOW, EVENT, ("prEvent->rHeader.ucSeqNumber, 0x%x\n", prEvent->rHeader.ucSeqNumber));
1538     DBGLOG(BOW, EVENT, ("prEvent->rHeader.u2PayloadLength, 0x%x\n", prEvent->rHeader.u2PayloadLength));
1539
1540     DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkDisconnected, prBowFsmInfo->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
1541         prBowFsmInfo->aucPeerAddress[0],
1542         prBowFsmInfo->aucPeerAddress[1],
1543         prBowFsmInfo->aucPeerAddress[2],
1544         prBowFsmInfo->aucPeerAddress[3],
1545         prBowFsmInfo->aucPeerAddress[4],
1546         prBowFsmInfo->aucPeerAddress[5]));
1547
1548     DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkDisconnected, prBowLinkDisconnected->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
1549         prBowLinkDisconnected->aucPeerAddress[0],
1550         prBowLinkDisconnected->aucPeerAddress[1],
1551         prBowLinkDisconnected->aucPeerAddress[2],
1552         prBowLinkDisconnected->aucPeerAddress[3],
1553         prBowLinkDisconnected->aucPeerAddress[4],
1554         prBowLinkDisconnected->aucPeerAddress[5]));
1555
1556     DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkDisconnected, g_u4LinkCount, %x.\n", g_u4LinkCount));
1557 #endif
1558
1559     /*Indicate BoW event to PAL*/
1560 #if 0
1561     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1562     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_LINK_DISCONNECTED)));
1563 #endif
1564
1565     // set to disconnected status
1566     prBowFsmInfo->prTargetStaRec = cnmGetStaRecByAddress(prAdapter, NETWORK_TYPE_BOW_INDEX, prBowLinkDisconnected->aucPeerAddress);
1567
1568     /*Release channel if granted*/
1569     if(prBowFsmInfo->fgIsChannelGranted) {
1570         cnmTimerStopTimer(prAdapter, &prBowFsmInfo->rChGrantedTimer);
1571         bowReleaseCh(prAdapter);
1572     /*Requested, not granted yet*/
1573     } else if(prBowFsmInfo->fgIsChannelRequested) {
1574         prBowFsmInfo->fgIsChannelRequested = FALSE;
1575         //bowReleaseCh(prAdapter);
1576     }
1577
1578 #if 1
1579     /*Send Deauth to connected peer*/
1580     if (eFsmState == BOW_DEVICE_STATE_CONNECTED &&
1581         (prBowFsmInfo->prTargetStaRec->ucStaState == STA_STATE_3))
1582     {
1583         fgSendDeauth = TRUE;
1584 #if CFG_BOW_TEST
1585         DBGLOG(BOW, EVENT, ("wlanbowCmdEventLinkDisconnected, bowGetBowTableState, %x.\n", bowGetBowTableState(prAdapter, prBowLinkDisconnected->aucPeerAddress)));
1586 #endif
1587         authSendDeauthFrame(prAdapter,
1588                 prBowFsmInfo->prTargetStaRec,
1589                 (P_SW_RFB_T)NULL,
1590                 REASON_CODE_DEAUTH_LEAVING_BSS,
1591                 (PFN_TX_DONE_HANDLER)bowDisconnectLink);
1592     }
1593 #endif
1594
1595 #if 0
1596     //3 <3>Stop this link; flush Tx; send deAuthentication -> abort. SAA, AAA. need to check BOW table state == Connected.
1597     if (prAdapter->prGlueInfo->i4TxPendingFrameNum > 0) {
1598         kalFlushPendingTxPackets(prAdapter->prGlueInfo);
1599     }
1600
1601     /* flush pending security frames */
1602     if (prAdapter->prGlueInfo->i4TxPendingSecurityFrameNum > 0) {
1603         kalClearSecurityFrames(prAdapter->prGlueInfo);
1604     }
1605 #endif
1606
1607     /*Update BoW table*/
1608     bowGetBowTableEntryByPeerAddress(prAdapter, prBowLinkDisconnected->aucPeerAddress, &ucBowTableIdx);
1609     rBowTable.fgIsValid = FALSE;
1610     rBowTable.eState = BOW_DEVICE_STATE_DISCONNECTED;
1611     bowSetBowTableContent(prAdapter, ucBowTableIdx, &rBowTable);
1612
1613     /*Indicate BoW event to PAL*/
1614     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1615     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_LINK_DISCONNECTED)));
1616
1617     /*Decrease link count*/
1618     GLUE_DEC_REF_CNT(g_u4LinkCount);
1619
1620     /*If no need to send deauth, DO disconnect now*/
1621     /*If need to send deauth, DO disconnect at deauth Tx done*/
1622     if(!fgSendDeauth){
1623         bowDisconnectLink(prAdapter, NULL, TX_RESULT_SUCCESS);
1624     }
1625 }
1626
1627
1628 /*----------------------------------------------------------------------------*/
1629 /*!
1630 * \brief command done handler for CMD_ID_CMD_BT_OVER_WIFI
1631 *
1632 * \param[in] prAdapter      Pointer to the Adapter structure.
1633 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1634 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1635 *
1636 * \retval none
1637 */
1638 /*----------------------------------------------------------------------------*/
1639 VOID
1640 wlanbowCmdEventSetSetupConnection (
1641     IN P_ADAPTER_T  prAdapter,
1642     IN P_CMD_INFO_T prCmdInfo,
1643     IN PUINT_8      pucEventBuf
1644     )
1645 {
1646     P_AMPC_EVENT prEvent;
1647     P_BOW_COMMAND_STATUS prBowCmdStatus;
1648     P_WIFI_CMD_T prWifiCmd;
1649     P_CMD_BT_OVER_WIFI prCmdBtOverWifi;
1650     P_BOW_FSM_INFO_T prBowFsmInfo;
1651
1652     ASSERT(prAdapter);
1653
1654     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
1655
1656     // restore original command for rPeerAddr
1657     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
1658     prCmdBtOverWifi = (P_CMD_BT_OVER_WIFI)(prWifiCmd->aucBuffer);
1659
1660     // fill event header
1661     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)), VIR_MEM_TYPE);
1662     prEvent->rHeader.ucEventId = BOW_EVENT_ID_COMMAND_STATUS;
1663     prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1664     prEvent->rHeader.u2PayloadLength = sizeof(BOW_COMMAND_STATUS);
1665
1666     // fill event body
1667     prBowCmdStatus = (P_BOW_COMMAND_STATUS)(prEvent->aucPayload);
1668     kalMemZero(prBowCmdStatus, sizeof(BOW_COMMAND_STATUS));
1669     prBowCmdStatus->ucStatus = BOWCMD_STATUS_SUCCESS;
1670
1671     /*Indicate BoW event to PAL*/
1672     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1673     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)));
1674
1675     // set to starting status
1676     kalSetBowState(prAdapter->prGlueInfo,
1677             BOW_DEVICE_STATE_STARTING,
1678             prCmdBtOverWifi->rPeerAddr);
1679 }
1680
1681 /*----------------------------------------------------------------------------*/
1682 /*!
1683 * \brief This is the command done handler for BOW_CMD_ID_READ_LINK_QUALITY
1684 *
1685 * \param[in] prAdapter      Pointer to the Adapter structure.
1686 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1687 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1688 *
1689 * \retval none
1690 */
1691 /*----------------------------------------------------------------------------*/
1692 VOID
1693 wlanbowCmdEventReadLinkQuality (
1694     IN P_ADAPTER_T  prAdapter,
1695     IN P_CMD_INFO_T prCmdInfo,
1696     IN PUINT_8      pucEventBuf
1697     )
1698 {
1699     P_EVENT_LINK_QUALITY prLinkQuality;
1700     P_AMPC_EVENT prEvent;
1701     P_BOW_LINK_QUALITY prBowLinkQuality;
1702
1703     ASSERT(prAdapter);
1704
1705     prLinkQuality = (P_EVENT_LINK_QUALITY)pucEventBuf;
1706
1707     // fill event header
1708     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_LINK_QUALITY)), VIR_MEM_TYPE);
1709     prEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_QUALITY;
1710     prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1711     prEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_QUALITY);
1712
1713     // fill event body
1714     prBowLinkQuality = (P_BOW_LINK_QUALITY)(prEvent->aucPayload);
1715     kalMemZero(prBowLinkQuality, sizeof(BOW_LINK_QUALITY));
1716     prBowLinkQuality->ucLinkQuality = (UINT_8)prLinkQuality->cLinkQuality;
1717
1718     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1719
1720     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_LINK_QUALITY)));
1721 }
1722
1723
1724 /*----------------------------------------------------------------------------*/
1725 /*!
1726 * \brief This is the command done handler for BOW_CMD_ID_READ_RSSI
1727 *
1728 * \param[in] prAdapter      Pointer to the Adapter structure.
1729 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1730 * \param[in] pucEventBuf    Pointer to the set buffer OR event buffer
1731 *
1732 * \retval none
1733 */
1734 /*----------------------------------------------------------------------------*/
1735 VOID
1736 wlanbowCmdEventReadRssi (
1737     IN P_ADAPTER_T  prAdapter,
1738     IN P_CMD_INFO_T prCmdInfo,
1739     IN PUINT_8      pucEventBuf
1740     )
1741 {
1742     P_EVENT_LINK_QUALITY prLinkQuality;
1743     P_AMPC_EVENT prEvent;
1744     P_BOW_RSSI prBowRssi;
1745
1746     ASSERT(prAdapter);
1747
1748     prLinkQuality = (P_EVENT_LINK_QUALITY)pucEventBuf;
1749
1750     // fill event header
1751     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_LINK_QUALITY)), VIR_MEM_TYPE);
1752     prEvent->rHeader.ucEventId = BOW_EVENT_ID_RSSI;
1753     prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1754     prEvent->rHeader.u2PayloadLength = sizeof(BOW_RSSI);
1755
1756     // fill event body
1757     prBowRssi = (P_BOW_RSSI)(prEvent->aucPayload);
1758     kalMemZero(prBowRssi, sizeof(BOW_RSSI));
1759     prBowRssi->cRssi = (INT_8) prLinkQuality->cRssi;
1760
1761     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1762
1763     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_LINK_QUALITY)));
1764
1765 }
1766
1767
1768 /*----------------------------------------------------------------------------*/
1769 /*!
1770 * \brief This is the default command timeout handler
1771 *
1772 * \param[in] prAdapter      Pointer to the Adapter structure.
1773 * \param[in] prCmdInfo      Pointer to the buffer that holds the command info
1774 *
1775 * \retval none
1776 */
1777 /*----------------------------------------------------------------------------*/
1778 VOID
1779 wlanbowCmdTimeoutHandler (
1780     IN P_ADAPTER_T  prAdapter,
1781     IN P_CMD_INFO_T prCmdInfo
1782     )
1783 {
1784     P_AMPC_EVENT prEvent;
1785     P_BOW_COMMAND_STATUS prBowCmdStatus;
1786
1787     ASSERT(prAdapter);
1788
1789     // fill event header
1790     prEvent = (P_AMPC_EVENT) kalMemAlloc((sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)), VIR_MEM_TYPE);
1791     prEvent->rHeader.ucEventId = BOW_EVENT_ID_COMMAND_STATUS;
1792     prEvent->rHeader.ucSeqNumber = (UINT_8) prCmdInfo->u4PrivateData;
1793     prEvent->rHeader.u2PayloadLength = sizeof(BOW_COMMAND_STATUS);
1794
1795     // fill event body
1796     prBowCmdStatus = (P_BOW_COMMAND_STATUS)(prEvent->aucPayload);
1797     kalMemZero(prBowCmdStatus, sizeof(BOW_COMMAND_STATUS));
1798
1799     prBowCmdStatus->ucStatus = BOWCMD_STATUS_TIMEOUT; // timeout
1800
1801     kalIndicateBOWEvent(prAdapter->prGlueInfo, prEvent);
1802
1803     kalMemFree(prEvent, VIR_MEM_TYPE, (sizeof(AMPC_EVENT) + sizeof(BOW_COMMAND_STATUS)));
1804
1805     return;
1806 }
1807
1808
1809 VOID
1810 bowStopping(
1811     IN P_ADAPTER_T prAdapter
1812     )
1813 {
1814     P_BOW_FSM_INFO_T prBowFsmInfo;
1815     P_BSS_INFO_T prBowBssInfo;
1816
1817     ASSERT(prAdapter);
1818
1819     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
1820     prBowBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
1821
1822 #if CFG_BOW_TEST
1823     DBGLOG(BOW, EVENT, ("bowStoping.\n"));
1824     DBGLOG(BOW, EVENT, ("bowStoping, SSID %s.\n", prBowBssInfo->aucSSID));
1825     DBGLOG(BOW, EVENT, ("bowStoping, prBowBssInfo->aucBSSID, %x:%x:%x:%x:%x:%x.\n",
1826         prBowBssInfo->aucBSSID[0],
1827         prBowBssInfo->aucBSSID[1],
1828         prBowBssInfo->aucBSSID[2],
1829         prBowBssInfo->aucBSSID[3],
1830         prBowBssInfo->aucBSSID[4],
1831         prBowBssInfo->aucBSSID[5]));
1832     DBGLOG(BOW, EVENT, ("bowStoping, prBssInfo->aucOwnMacAddr, %x:%x:%x:%x:%x:%x.\n",
1833         prBowBssInfo->aucOwnMacAddr[0],
1834         prBowBssInfo->aucOwnMacAddr[1],
1835         prBowBssInfo->aucOwnMacAddr[2],
1836         prBowBssInfo->aucOwnMacAddr[3],
1837         prBowBssInfo->aucOwnMacAddr[4],
1838         prBowBssInfo->aucOwnMacAddr[5]));
1839     DBGLOG(BOW, EVENT, ("bowStoping, prAdapter->rWifiVar.aucDeviceAddress, %x:%x:%x:%x:%x:%x.\n",
1840         prAdapter->rWifiVar.aucDeviceAddress[0],
1841         prAdapter->rWifiVar.aucDeviceAddress[1],
1842         prAdapter->rWifiVar.aucDeviceAddress[2],
1843         prAdapter->rWifiVar.aucDeviceAddress[3],
1844         prAdapter->rWifiVar.aucDeviceAddress[4],
1845         prAdapter->rWifiVar.aucDeviceAddress[5]));
1846     DBGLOG(BOW, EVENT, ("bowStopping, g_u4LinkCount, %x.\n", g_u4LinkCount));
1847     DBGLOG(BOW, EVENT, ("prBowFsmInfo->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n", prBowFsmInfo->aucPeerAddress[0],
1848         prBowFsmInfo->aucPeerAddress[1],
1849         prBowFsmInfo->aucPeerAddress[2],
1850         prBowFsmInfo->aucPeerAddress[3],
1851         prBowFsmInfo->aucPeerAddress[4],
1852         prBowFsmInfo->aucPeerAddress[5]));
1853     kalPrint("BoW Stoping,[%d,%d]\n", g_u4LinkCount, g_u4Beaconing);
1854 #endif
1855
1856     if (g_u4LinkCount == 0)
1857     {
1858         /*Stop beaconing*/
1859         GLUE_DEC_REF_CNT(g_u4Beaconing);
1860
1861         /*Deactive BoW network*/
1862         //prBowBssInfo->fgIsNetActive = FALSE;
1863         //prBowBssInfo->fgIsBeaconActivated = FALSE;
1864         nicPmIndicateBssAbort(prAdapter, NETWORK_TYPE_BOW_INDEX);
1865         bowChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
1866         nicUpdateBss(prAdapter, NETWORK_TYPE_BOW_INDEX);
1867         /*temp solution for FW hal_pwr_mgt.c#3037 ASSERT*/
1868         nicDeactivateNetwork(prAdapter, NETWORK_TYPE_BOW_INDEX);
1869         SET_NET_PWR_STATE_IDLE(prAdapter, NETWORK_TYPE_BOW_INDEX);
1870         UNSET_NET_ACTIVE(prAdapter, NETWORK_TYPE_BOW_INDEX);
1871
1872     }
1873
1874     return;
1875 }
1876
1877
1878 VOID
1879 bowStarting(
1880     IN P_ADAPTER_T prAdapter
1881     )
1882 {
1883     P_BOW_FSM_INFO_T prBowFsmInfo;
1884     P_BSS_INFO_T prBssInfo;
1885
1886     ASSERT(prAdapter);
1887
1888     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
1889
1890     if (g_u4LinkCount == 1)
1891     {
1892 #if CFG_BOW_TEST
1893         DBGLOG(BOW, EVENT, ("BoW Starting.\n"));
1894         DBGLOG(BOW, EVENT, ("BoW channel granted.\n"));
1895 #endif
1896
1897 #if 0
1898         /*Active BoW Network*/
1899         SET_NET_ACTIVE(prAdapter, NETWORK_TYPE_BOW_INDEX);
1900         SET_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_BOW_INDEX);
1901         nicActivateNetwork(prAdapter, NETWORK_TYPE_BOW_INDEX);
1902 #endif
1903
1904     //3 <1> Update BSS_INFO_T per Network Basis
1905     //4 <1.1> Setup Operation Mode
1906         prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
1907         prBssInfo->ucNetTypeIndex = NETWORK_TYPE_BOW_INDEX;
1908         prBssInfo->eCurrentOPMode = OP_MODE_BOW;
1909
1910     //4 <1.2> Setup SSID
1911         COPY_MAC_ADDR(prBssInfo->aucOwnMacAddr, prAdapter->rWifiVar.aucDeviceAddress);
1912         COPY_MAC_ADDR(prBssInfo->aucBSSID, prAdapter->rWifiVar.aucDeviceAddress);
1913         prBssInfo->ucSSIDLen = BOW_SSID_LEN;
1914         bowAssignSsid(prBssInfo->aucSSID, prBssInfo->aucOwnMacAddr);
1915
1916 #if CFG_BOW_TEST
1917         DBGLOG(BOW, EVENT, ("SSID %s.\n", prBssInfo->aucSSID));
1918         DBGLOG(BOW, EVENT, ("prBssInfo->aucBSSID, %x:%x:%x:%x:%x:%x.\n",
1919             prBssInfo->aucBSSID[0],
1920             prBssInfo->aucBSSID[1],
1921             prBssInfo->aucBSSID[2],
1922             prBssInfo->aucBSSID[3],
1923             prBssInfo->aucBSSID[4],
1924             prBssInfo->aucBSSID[5]));
1925         DBGLOG(BOW, EVENT, ("prBssInfo->aucOwnMacAddr, %x:%x:%x:%x:%x:%x.\n",
1926             prBssInfo->aucOwnMacAddr[0],
1927             prBssInfo->aucOwnMacAddr[1],
1928             prBssInfo->aucOwnMacAddr[2],
1929             prBssInfo->aucOwnMacAddr[3],
1930             prBssInfo->aucOwnMacAddr[4],
1931             prBssInfo->aucOwnMacAddr[5]));
1932         DBGLOG(BOW, EVENT, ("prAdapter->rWifiVar.aucDeviceAddress, %x:%x:%x:%x:%x:%x.\n",
1933             prAdapter->rWifiVar.aucDeviceAddress[0],
1934             prAdapter->rWifiVar.aucDeviceAddress[1],
1935             prAdapter->rWifiVar.aucDeviceAddress[2],
1936             prAdapter->rWifiVar.aucDeviceAddress[3],
1937             prAdapter->rWifiVar.aucDeviceAddress[4],
1938             prAdapter->rWifiVar.aucDeviceAddress[5]));
1939 #endif
1940
1941     //4 <1.3> Clear current AP's STA_RECORD_T and current AID
1942         prBssInfo->prStaRecOfAP = (P_STA_RECORD_T)NULL;
1943         prBssInfo->u2AssocId = 0;
1944
1945     //4 <1.4> Setup Channel, Band and Phy Attributes
1946         prBssInfo->ucPrimaryChannel = prBowFsmInfo->ucPrimaryChannel;
1947         if (prBowFsmInfo->eBand == BAND_2G4)
1948         {
1949             prBssInfo->eBand = BAND_2G4;
1950         }
1951         else
1952         {
1953             prBssInfo->eBand = BAND_5G;
1954         }
1955
1956 #if CFG_BOW_SUPPORT_11N
1957         prBssInfo->ucPhyTypeSet = prAdapter->rWifiVar.ucAvailablePhyTypeSet & PHY_TYPE_SET_802_11BGN; /* Depend on eBand */
1958         prBssInfo->ucConfigAdHocAPMode = AP_MODE_MIXED_11BG; /* Depend on eCurrentOPMode and ucPhyTypeSet */
1959
1960         prBssInfo->ucNonHTBasicPhyType = (UINT_8)
1961             rNonHTApModeAttributes[prBssInfo->ucConfigAdHocAPMode].ePhyTypeIndex;
1962         prBssInfo->u2BSSBasicRateSet =
1963             rNonHTApModeAttributes[prBssInfo->ucConfigAdHocAPMode].u2BSSBasicRateSet;
1964
1965         prBssInfo->u2OperationalRateSet =
1966             rNonHTPhyAttributes[prBssInfo->ucNonHTBasicPhyType].u2SupportedRateSet;
1967
1968         rateGetDataRatesFromRateSet(prBssInfo->u2OperationalRateSet,
1969                                     prBssInfo->u2BSSBasicRateSet,
1970                                     prBssInfo->aucAllSupportedRates,
1971                                     &prBssInfo->ucAllSupportedRatesLen);
1972
1973 #else
1974         if (prBssInfo->eBand == BAND_2G4)
1975         {
1976         prBssInfo->ucPhyTypeSet = PHY_TYPE_SET_802_11BG; /* Depend on eBand */
1977         prBssInfo->ucConfigAdHocAPMode = AP_MODE_MIXED_11BG; /* Depend on eCurrentOPMode and ucPhyTypeSet */
1978
1979             prBssInfo->u2BSSBasicRateSet = BASIC_RATE_SET_ERP; //RATE_SET_ERP;
1980         prBssInfo->u2OperationalRateSet = RATE_SET_ERP;
1981             prBssInfo->ucNonHTBasicPhyType = PHY_TYPE_ERP_INDEX;
1982         }
1983         else
1984         {
1985             //prBssInfo->ucPhyTypeSet = PHY_TYPE_SET_802_11BG; /* Depend on eBand */
1986             //prBssInfo->ucConfigAdHocAPMode = AP_MODE_MIXED_11BG; /* Depend on eCurrentOPMode and ucPhyTypeSet */
1987             prBssInfo->ucPhyTypeSet = PHY_TYPE_SET_802_11A; /* Depend on eBand */
1988             prBssInfo->ucConfigAdHocAPMode = AP_MODE_11A; /* Depend on eCurrentOPMode and ucPhyTypeSet */
1989
1990             //prBssInfo->u2BSSBasicRateSet = BASIC_RATE_SET_ERP; //RATE_SET_ERP;
1991             //prBssInfo->u2OperationalRateSet = RATE_SET_ERP;
1992
1993             prBssInfo->u2BSSBasicRateSet = BASIC_RATE_SET_OFDM; //RATE_SET_ERP;
1994             prBssInfo->u2OperationalRateSet = RATE_SET_OFDM;
1995             prBssInfo->ucNonHTBasicPhyType = PHY_TYPE_OFDM_INDEX;
1996         }
1997
1998
1999 #endif
2000         prBssInfo->fgErpProtectMode = FALSE;
2001
2002     //4 <1.5> Setup MIB for current BSS
2003         prBssInfo->u2BeaconInterval = prBowFsmInfo->u2BeaconInterval;
2004         prBssInfo->ucDTIMPeriod = DOT11_DTIM_PERIOD_DEFAULT;
2005         prBssInfo->u2ATIMWindow = 0;
2006         prBssInfo->ucBeaconTimeoutCount = 0;
2007         if (prBowFsmInfo->fgSupportQoS)
2008         {
2009             prAdapter->rWifiVar.fgSupportQoS = TRUE;
2010             prBssInfo->fgIsQBSS = TRUE;
2011         }
2012
2013
2014     //3 <2> Update BSS_INFO_T common part
2015 #if CFG_SUPPORT_AAA
2016         bssInitForAP(prAdapter, prBssInfo, TRUE);
2017         nicQmUpdateWmmParms(prAdapter, NETWORK_TYPE_BOW_INDEX);
2018 #endif /* CFG_SUPPORT_AAA */
2019         prBssInfo->fgIsNetActive = TRUE;
2020         prBssInfo->fgIsBeaconActivated = TRUE;
2021
2022     //3 <3> Set MAC HW
2023
2024     //4 <2> Initiate BSS_INFO_T - common part
2025         BOW_BSS_INFO_INIT(prAdapter, NETWORK_TYPE_BOW_INDEX);
2026 #if CFG_BOW_TEST
2027         DBGLOG(BOW, EVENT, ("prBowFsmInfo->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n", prBowFsmInfo->aucPeerAddress[0],
2028             prBowFsmInfo->aucPeerAddress[1],
2029             prBowFsmInfo->aucPeerAddress[2],
2030             prBowFsmInfo->aucPeerAddress[3],
2031             prBowFsmInfo->aucPeerAddress[4],
2032             prBowFsmInfo->aucPeerAddress[5]));
2033 #endif
2034
2035     //4 <3.1> use command packets to inform firmware
2036         rlmBssInitForAPandIbss(prAdapter, prBssInfo);
2037         nicUpdateBss(prAdapter, NETWORK_TYPE_BOW_INDEX);
2038
2039     //4 <3.2> Update AdHoc PM parameter
2040         nicPmIndicateBssCreated(prAdapter, NETWORK_TYPE_BOW_INDEX);
2041
2042     //4 <3.1> Reset HW TSF Update Mode and Beacon Mode
2043
2044     //4 <3.2> Setup BSSID
2045     // TODO: rxmSetRxFilterBSSID0
2046 //    rxmSetRxFilterBSSID0(prBssInfo->ucHwBssidId, prBssInfo->aucBSSID);
2047
2048     //4 <3.3> Setup RX Filter to accept Probe Request
2049     // TODO: f get/set RX filter.
2050
2051 #if 0
2052     {
2053         UINT_32 u4RxFilter;
2054         if (halMacRxGetRxFilters(&u4RxFilter)== HAL_STATUS_SUCCESS) {
2055
2056                 u4RxFilter &= ~BIT(RXFILTER_DROP_PROBE_REQ);
2057
2058             halMacRxSetRxFilters(u4RxFilter);
2059         }
2060     }
2061 #endif
2062     }
2063
2064     /*Update BoW Table*/
2065     bowSetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress, BOW_DEVICE_STATE_STARTING);
2066
2067 #if CFG_BOW_TEST
2068     kalPrint("BoW Starting,[%d,%d]\n", g_u4LinkCount, g_u4Beaconing);
2069     DBGLOG(BOW, EVENT, ("bowStarting, g_u4LinkCount, %x.\n", g_u4LinkCount));
2070 #endif
2071
2072     /*Start beaconing*/
2073     if (g_u4Beaconing < 1)
2074     {
2075         GLUE_INC_REF_CNT(g_u4Beaconing);
2076         bssSendBeaconProbeResponse(prAdapter, NETWORK_TYPE_BOW_INDEX, NULL, 0);
2077         cnmTimerStartTimer(prAdapter, &prBowFsmInfo->rStartingBeaconTimer, prBowFsmInfo->u2BeaconInterval);
2078     }
2079
2080 #if 0
2081     /*Responder: Start to scan Initiator*/
2082     if (prBowFsmInfo->ucRole == BOW_RESPONDER)
2083     {
2084 #if CFG_BOW_TEST
2085         DBGLOG(BOW, EVENT, ("bowStarting responder, start scan result searching.\n"));
2086 #endif
2087         cnmTimerStopTimer(prAdapter, &prBowFsmInfo->rChGrantedTimer);
2088         bowReleaseCh(prAdapter);
2089         bowResponderScan(prAdapter);
2090     }
2091     /*Initiator: Request channel, wait for responder*/
2092     else {
2093         //bowRequestCh(prAdapter);
2094     }
2095 #endif
2096     return;
2097 }
2098
2099 VOID
2100 bowAssignSsid (
2101     IN PUINT_8 pucSsid,
2102     IN PUINT_8 puOwnMacAddr
2103     )
2104 {
2105     UINT_8 i;
2106     UINT_8 aucSSID[]=BOW_WILDCARD_SSID;
2107
2108     kalMemCopy(pucSsid, aucSSID, BOW_WILDCARD_SSID_LEN);
2109
2110     for (i = 0; i < 6; i++)
2111     {
2112         pucSsid[(3 * i) + 3] = 0x2D;
2113         if ((*(puOwnMacAddr + i) >> 4) < 0xA)
2114         {
2115             *(pucSsid + (3 * i) + 4) = (*(puOwnMacAddr +  i) >> 4) + 0x30;
2116         }
2117         else
2118         {
2119             *(pucSsid + (3 * i) + 4) = (*(puOwnMacAddr +  i) >> 4) + 0x57;
2120         }
2121
2122         if ((*(puOwnMacAddr + i) & 0x0F) < 0xA)
2123         {
2124             pucSsid[(3 * i) + 5] = (*(puOwnMacAddr + i) & 0x0F) + 0x30;
2125         }
2126         else
2127         {
2128             pucSsid[(3 * i) + 5] = (*(puOwnMacAddr + i) & 0x0F) + 0x57;
2129         }
2130     }
2131
2132     return;
2133 }
2134
2135
2136 /*----------------------------------------------------------------------------*/
2137 /*!
2138 * @brief This function will validate the Rx Probe Request Frame and then return
2139 *        result to BSS to indicate if need to send the corresponding Probe Response
2140 *        Frame if the specified conditions were matched.
2141 *
2142 * @param[in] prAdapter          Pointer to the Adapter structure.
2143 * @param[in] prSwRfb            Pointer to SW RFB data structure.
2144 * @param[out] pu4ControlFlags   Control flags for replying the Probe Response
2145 *
2146 * @retval TRUE      Reply the Probe Response
2147 * @retval FALSE     Don't reply the Probe Response
2148 */
2149 /*----------------------------------------------------------------------------*/
2150 BOOLEAN
2151 bowValidateProbeReq(
2152     IN P_ADAPTER_T prAdapter,
2153     IN P_SW_RFB_T prSwRfb,
2154     OUT PUINT_32 pu4ControlFlags
2155     )
2156 {
2157     P_WLAN_MAC_MGMT_HEADER_T prMgtHdr;
2158     P_BOW_FSM_INFO_T prBowFsmInfo;
2159     P_BSS_INFO_T prBssInfo;
2160     P_IE_SSID_T prIeSsid = (P_IE_SSID_T)NULL;
2161     PUINT_8 pucIE;
2162     UINT_16 u2IELength;
2163     UINT_16 u2Offset = 0;
2164     BOOLEAN fgReplyProbeResp = FALSE;
2165
2166     ASSERT(prSwRfb);
2167     ASSERT(pu4ControlFlags);
2168
2169     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2170     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2171
2172
2173 #if 0//CFG_BOW_TEST
2174     DBGLOG(BOW, EVENT, ("bowValidateProbeReq.\n"));
2175 #endif
2176
2177     //4 <1> Parse Probe Req IE and Get IE ptr (SSID, Supported Rate IE, ...)
2178     prMgtHdr = (P_WLAN_MAC_MGMT_HEADER_T)prSwRfb->pvHeader;
2179
2180     u2IELength = prSwRfb->u2PacketLen - prSwRfb->u2HeaderLen;
2181     pucIE = (PUINT_8)((UINT_32)prSwRfb->pvHeader + prSwRfb->u2HeaderLen);
2182
2183     IE_FOR_EACH(pucIE, u2IELength, u2Offset) {
2184         if (ELEM_ID_SSID == IE_ID(pucIE)) {
2185             if ((!prIeSsid) &&
2186                 (IE_LEN(pucIE) <= ELEM_MAX_LEN_SSID)) {
2187                 prIeSsid = (P_IE_SSID_T)pucIE;
2188             }
2189             break;
2190         }
2191     } /* end of IE_FOR_EACH */
2192
2193    IE_FOR_EACH(pucIE, u2IELength, u2Offset) {
2194         if (ELEM_ID_SSID == IE_ID(pucIE)) {
2195             if ((!prIeSsid) &&
2196                 (IE_LEN(pucIE) <= ELEM_MAX_LEN_SSID)) {
2197                 prIeSsid = (P_IE_SSID_T)pucIE;
2198         }
2199             break;
2200         }
2201     } /* end of IE_FOR_EACH */
2202
2203     //4 <2> Check network conditions
2204     /*If BoW AP is beaconing*/
2205     if (prBssInfo->eCurrentOPMode == OP_MODE_BOW &&
2206         g_u4Beaconing > 0) {
2207
2208         /*Check the probe requset sender is our peer*/
2209         if(bowCheckBowTableIfVaild(prAdapter, prMgtHdr->aucSrcAddr)) {
2210             fgReplyProbeResp = TRUE;
2211         }
2212         /*Check the probe request target SSID is our SSID*/
2213         else if ((prIeSsid) &&
2214                   EQUAL_SSID(prBssInfo->aucSSID, prBssInfo->ucSSIDLen,
2215                              prIeSsid->aucSSID, prIeSsid->ucLength)) {
2216             fgReplyProbeResp = TRUE;
2217         }
2218         else {
2219             fgReplyProbeResp = FALSE;
2220         }
2221     }
2222
2223     return fgReplyProbeResp;
2224
2225 }
2226
2227
2228 /*----------------------------------------------------------------------------*/
2229 /*!
2230 * @brief This function will indicate an Event of "Media Disconnect" to HOST
2231 *
2232 * @param[in] u4Param  Unused timer parameter
2233 *
2234 * @return (none)
2235 */
2236 /*----------------------------------------------------------------------------*/
2237 VOID
2238 bowSendBeacon(
2239     IN P_ADAPTER_T prAdapter,
2240     IN UINT_32 u4Param
2241     )
2242 {
2243     P_BOW_FSM_INFO_T prBowFsmInfo;
2244
2245     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2246
2247     if ((g_u4Beaconing != 0) && (g_u4LinkCount > 0) && (g_u4LinkCount < CFG_BOW_PHYSICAL_LINK_NUM))
2248     {
2249         //Send beacon
2250         bssSendBeaconProbeResponse(prAdapter, NETWORK_TYPE_BOW_INDEX, NULL, 0);
2251         cnmTimerStartTimer(prAdapter, &prBowFsmInfo->rStartingBeaconTimer, prBowFsmInfo->u2BeaconInterval);
2252     }
2253 #if CFG_BOW_TEST
2254     else {
2255         kalPrint("BoW Send Beacon,[%d,%d]\n", g_u4LinkCount, g_u4Beaconing);
2256     }
2257 #endif
2258 }
2259
2260
2261 /*----------------------------------------------------------------------------*/
2262 /*!
2263 * @brief This function will indicate an Event of "Media Disconnect" to HOST
2264 *
2265 * @param[in] u4Param  Unused timer parameter
2266 *
2267 * @return (none)
2268 */
2269 /*----------------------------------------------------------------------------*/
2270 VOID
2271 bowResponderScan(
2272     IN P_ADAPTER_T prAdapter
2273     )
2274 {
2275     P_BOW_FSM_INFO_T prBowFsmInfo;
2276     P_MSG_SCN_SCAN_REQ prScanReqMsg;
2277     P_BSS_INFO_T prBssInfo;
2278
2279     ASSERT(prAdapter);
2280
2281     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2282     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2283
2284 #if CFG_BOW_TEST
2285     DBGLOG(BOW, EVENT, ("bowResponderScan.\n"));
2286     kalPrint("BOW SCAN [REQ:%d]\n", prBowFsmInfo->ucSeqNumOfScanReq+1);
2287 #endif
2288
2289     prScanReqMsg = (P_MSG_SCN_SCAN_REQ)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_SCN_SCAN_REQ));
2290
2291     if (!prScanReqMsg)
2292     {
2293         ASSERT(0); // Can't trigger SCAN FSM
2294         return;
2295     }
2296
2297     /*Fill scan message*/
2298     prScanReqMsg->rMsgHdr.eMsgId = MID_BOW_SCN_SCAN_REQ;
2299     prScanReqMsg->ucSeqNum = ++prBowFsmInfo->ucSeqNumOfScanReq;
2300     prScanReqMsg->ucNetTypeIndex = (UINT_8)NETWORK_TYPE_BOW_INDEX;
2301     prScanReqMsg->eScanType = SCAN_TYPE_ACTIVE_SCAN;
2302     prScanReqMsg->ucSSIDType = SCAN_REQ_SSID_SPECIFIED;
2303     prScanReqMsg->ucSSIDLength = BOW_SSID_LEN;
2304     bowAssignSsid(prScanReqMsg->aucSSID, prBowFsmInfo->aucPeerAddress);
2305     prScanReqMsg->ucChannelListNum = 1;
2306
2307     if (prBowFsmInfo->eBand == BAND_2G4)
2308     {
2309         prScanReqMsg->eScanChannel = SCAN_CHANNEL_SPECIFIED;
2310         prScanReqMsg->arChnlInfoList[0].eBand = BAND_2G4;
2311     }
2312     else
2313     {
2314         prScanReqMsg->eScanChannel = SCAN_CHANNEL_5G;
2315         prScanReqMsg->arChnlInfoList[0].eBand = BAND_5G;
2316     }
2317
2318     prScanReqMsg->arChnlInfoList[0].ucChannelNum = prBowFsmInfo->ucPrimaryChannel;
2319     prScanReqMsg->u2IELen = 0;
2320
2321     /*Send scan message*/
2322     mboxSendMsg(prAdapter, MBOX_ID_0, (P_MSG_HDR_T) prScanReqMsg, MSG_SEND_METHOD_BUF);
2323
2324     /*Change state to SCANNING*/
2325     bowSetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress, BOW_DEVICE_STATE_SCANNING);
2326
2327     //prBowFsmInfo->fgTryScan = FALSE; /* Will enable background sleep for infrastructure */
2328
2329     return;
2330 }
2331
2332
2333 /*----------------------------------------------------------------------------*/
2334 /*!
2335 * \brief
2336 *
2337 * \param[in]
2338 *
2339 * \return none
2340 */
2341 /*----------------------------------------------------------------------------*/
2342 VOID
2343 bowResponderScanDone(
2344     IN P_ADAPTER_T prAdapter,
2345     IN P_MSG_HDR_T prMsgHdr
2346     )
2347 {
2348     P_MSG_SCN_SCAN_DONE prScanDoneMsg;
2349     P_BOW_FSM_INFO_T prBowFsmInfo;
2350     P_BSS_DESC_T prBssDesc;
2351     UINT_8 ucSeqNumOfCompMsg;
2352     P_CONNECTION_SETTINGS_T prConnSettings;
2353     ENUM_BOW_DEVICE_STATE eFsmState;
2354     ENUM_SCAN_STATUS eScanStatus;
2355
2356     ASSERT(prAdapter);
2357     ASSERT(prMsgHdr);
2358
2359     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2360     prConnSettings = &(prAdapter->rWifiVar.rConnSettings);
2361     prScanDoneMsg = (P_MSG_SCN_SCAN_DONE) prMsgHdr;
2362     eFsmState = bowGetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress);
2363
2364     ASSERT(prScanDoneMsg->ucNetTypeIndex == NETWORK_TYPE_BOW_INDEX);
2365
2366     ucSeqNumOfCompMsg = prScanDoneMsg->ucSeqNum;
2367     eScanStatus = prScanDoneMsg->eScanStatus;
2368
2369     cnmMemFree(prAdapter, prMsgHdr);
2370
2371 #if CFG_BOW_TEST
2372     DBGLOG(BOW, EVENT, ("bowResponderScanDone.\n"));
2373     kalPrint("BOW SCAN [DONE:%d]\n", ucSeqNumOfCompMsg);
2374 #endif
2375
2376     if( eScanStatus == SCAN_STATUS_CANCELLED) {
2377 #if CFG_BOW_TEST
2378         kalPrint("BOW SCAN [CANCELLED:%d]\n", ucSeqNumOfCompMsg);
2379 #endif
2380         if(eFsmState == BOW_DEVICE_STATE_DISCONNECTING) {
2381             wlanoidSendSetQueryBowCmd(prAdapter,
2382                 CMD_ID_CMD_BT_OVER_WIFI,
2383                 TRUE,
2384                 FALSE,
2385                 wlanbowCmdEventLinkDisconnected,
2386                 wlanbowCmdTimeoutHandler,
2387                 0,
2388                 NULL,
2389                 0
2390                 );
2391         }
2392         return;
2393     }
2394     else if(eFsmState == BOW_DEVICE_STATE_DISCONNECTED) {
2395         //bowDisconnectLink(prAdapter, NULL, TX_RESULT_SUCCESS);
2396         return;
2397     }
2398     else if (ucSeqNumOfCompMsg != prBowFsmInfo->ucSeqNumOfScanReq)
2399     {
2400         DBGLOG(BOW, EVENT, ("Sequence no. of BOW Responder scan done is not matched.\n"));
2401         return;
2402     }
2403     else
2404     {
2405         prConnSettings->fgIsScanReqIssued = FALSE;
2406         prBssDesc = scanSearchBssDescByBssid(prAdapter, prBowFsmInfo->aucPeerAddress);
2407 #if CFG_BOW_TEST
2408         DBGLOG(BOW, EVENT, ("End scan result searching.\n"));
2409 #endif
2410
2411         /*Initiator is FOUND*/
2412         if (prBssDesc != NULL)// (prBssDesc->aucBSSID != NULL))
2413         {
2414 #if CFG_BOW_TEST
2415             DBGLOG(BOW, EVENT, ("Search Bow Peer address - %x:%x:%x:%x:%x:%x.\n", prBssDesc->aucBSSID[0],
2416             prBssDesc->aucBSSID[1],
2417             prBssDesc->aucBSSID[2],
2418             prBssDesc->aucBSSID[3],
2419             prBssDesc->aucBSSID[4],
2420             prBssDesc->aucBSSID[5]));
2421             DBGLOG(BOW, EVENT, ("Starting to join initiator.\n"));
2422 #endif
2423             /*Set target BssDesc*/
2424             prBowFsmInfo->prTargetBssDesc = prBssDesc;
2425             /*Request channel to do JOIN*/
2426             bowSetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress, BOW_DEVICE_STATE_ACQUIRING_CHANNEL);
2427             bowRequestCh(prAdapter);
2428         }
2429         /*Initiator is NOT FOUND*/
2430         else
2431         {
2432             /*Scan again, until PAL timeout*/
2433             bowResponderScan(prAdapter);
2434 #if 0
2435             wlanoidSendSetQueryBowCmd(prAdapter,
2436                 CMD_ID_CMD_BT_OVER_WIFI,
2437                 TRUE,
2438                 FALSE,
2439                 wlanbowCmdEventLinkDisconnected,
2440                 wlanbowCmdTimeoutHandler,
2441                 0,
2442                 NULL,
2443                 0
2444                 );
2445 #endif
2446         }
2447     }
2448
2449     return;
2450 }
2451
2452
2453 /*----------------------------------------------------------------------------*/
2454 /*!
2455 * @brief Function for cancelling scan request. There is another option to extend channel privilige
2456 *           for another purpose.
2457 *
2458 * @param fgIsChannelExtention - Keep the channel previlege, but can cancel scan timer.
2459 *
2460 * @return (none)
2461 */
2462 /*----------------------------------------------------------------------------*/
2463 VOID
2464 bowResponderCancelScan (
2465     IN P_ADAPTER_T prAdapter,
2466     IN BOOLEAN fgIsChannelExtention
2467     )
2468 {
2469
2470     P_MSG_SCN_SCAN_CANCEL prScanCancel = (P_MSG_SCN_SCAN_CANCEL)NULL;
2471     P_BOW_FSM_INFO_T prBowFsmInfo = (P_BOW_FSM_INFO_T)NULL;
2472
2473     DEBUGFUNC("bowResponderCancelScan()");
2474
2475     do {
2476         ASSERT(prAdapter);
2477
2478         prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2479
2480         if (TRUE) {
2481 #if CFG_BOW_TEST
2482             kalPrint("BOW SCAN [CANCEL:%d]\n", prBowFsmInfo->ucSeqNumOfScanReq);
2483 #endif
2484             /* There is a channel privilege on hand. */
2485
2486             DBGLOG(P2P, TRACE, ("BOW Cancel Scan\n"));
2487
2488             prScanCancel = (P_MSG_SCN_SCAN_CANCEL)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_SCN_SCAN_CANCEL));
2489             if (!prScanCancel) {
2490                 /* Buffer not enough, can not cancel scan request. */
2491                 DBGLOG(P2P, TRACE, ("Buffer not enough, can not cancel scan.\n"));
2492                 ASSERT(FALSE);
2493                 break;
2494             }
2495
2496             prScanCancel->rMsgHdr.eMsgId = MID_BOW_SCN_SCAN_CANCEL;
2497             prScanCancel->ucNetTypeIndex = NETWORK_TYPE_BOW_INDEX;
2498             prScanCancel->ucSeqNum = prBowFsmInfo->ucSeqNumOfScanReq;
2499 #if CFG_ENABLE_WIFI_DIRECT
2500             prScanCancel->fgIsChannelExt = fgIsChannelExtention;
2501 #endif
2502             mboxSendMsg(prAdapter,
2503                                 MBOX_ID_0,
2504                                 (P_MSG_HDR_T)prScanCancel,
2505                                 MSG_SEND_METHOD_BUF);
2506
2507         }
2508
2509     } while (FALSE);
2510
2511 } /* bowResponderCancelScan */
2512
2513
2514 /*----------------------------------------------------------------------------*/
2515 /*!
2516 * @brief Initialization of JOIN STATE
2517 *
2518 * @param[in] prBssDesc  The pointer of BSS_DESC_T which is the BSS we will try to join with.
2519 *
2520 * @return (none)
2521 */
2522 /*----------------------------------------------------------------------------*/
2523 VOID
2524 bowResponderJoin(
2525     IN P_ADAPTER_T prAdapter,
2526     IN P_BSS_DESC_T prBssDesc
2527     )
2528 {
2529     P_BOW_FSM_INFO_T prBowFsmInfo;
2530     P_BSS_INFO_T prBssInfo;
2531     P_CONNECTION_SETTINGS_T prConnSettings;
2532     P_STA_RECORD_T prStaRec;
2533     P_MSG_JOIN_REQ_T prJoinReqMsg;
2534
2535     ASSERT(prBssDesc);
2536     ASSERT(prAdapter);
2537
2538     DBGLOG(BOW, EVENT, ("Starting bowResponderJoin.\n"));
2539
2540     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2541     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2542     prConnSettings = &(prAdapter->rWifiVar.rConnSettings);
2543
2544     //4 <1> We are going to connect to this BSS.
2545     prBssDesc->fgIsConnecting = TRUE;
2546     bowSetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress, BOW_DEVICE_STATE_CONNECTING);
2547
2548     //4 <2> Setup corresponding STA_RECORD_T
2549     /*Support First JOIN and retry*/
2550     prStaRec = bssCreateStaRecFromBssDesc(
2551             prAdapter,
2552             STA_TYPE_BOW_AP,
2553             NETWORK_TYPE_BOW_INDEX,
2554             prBssDesc);
2555
2556     prBowFsmInfo->prTargetStaRec = prStaRec;
2557
2558     //4 <3> Update ucAvailableAuthTypes which we can choice during SAA
2559     prStaRec->fgIsReAssoc = FALSE;
2560     prBowFsmInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_OPEN_SYSTEM;
2561     prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
2562
2563
2564     //4 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes
2565     if (prBowFsmInfo->ucAvailableAuthTypes &
2566         (UINT_8)AUTH_TYPE_OPEN_SYSTEM) {
2567
2568         DBGLOG(BOW, LOUD, ("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));
2569         prBowFsmInfo->ucAvailableAuthTypes &=
2570             ~(UINT_8)AUTH_TYPE_OPEN_SYSTEM;
2571
2572         prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
2573     }
2574     else {
2575         ASSERT(0);
2576     }
2577
2578     //4 <4.1> sync. to firmware domain
2579     cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
2580
2581     //4 <5> Overwrite Connection Setting for eConnectionPolicy
2582     if (prBssDesc->ucSSIDLen) {
2583         COPY_SSID(prConnSettings->aucSSID,
2584                   prConnSettings->ucSSIDLen,
2585                   prBssDesc->aucSSID,
2586                   prBssDesc->ucSSIDLen);
2587 #if CFG_BOW_TEST
2588         DBGLOG(BOW, EVENT, ("bowResponderJoin, SSID %s.\n", prBssDesc->aucSSID));
2589         DBGLOG(BOW, EVENT, ("bowResponderJoin, SSID %s.\n", prConnSettings->aucSSID));
2590 #endif
2591     }
2592
2593     //4 <6> Send a Msg to trigger SAA to start JOIN process.
2594     prJoinReqMsg = (P_MSG_JOIN_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
2595     if (!prJoinReqMsg) {
2596
2597         ASSERT(0); // Can't trigger SAA FSM
2598         return;
2599     }
2600
2601     prJoinReqMsg->rMsgHdr.eMsgId = MID_BOW_SAA_FSM_START;
2602     prJoinReqMsg->ucSeqNum = ++prBowFsmInfo->ucSeqNumOfReqMsg;
2603     prJoinReqMsg->prStaRec = prStaRec;
2604
2605     prBssInfo->prStaRecOfAP = prStaRec;
2606
2607 #if CFG_BOW_TEST
2608     DBGLOG(BOW, EVENT, ("prStaRec->eStaType, %x.\n", prStaRec->eStaType));
2609     printk("BoW trigger SAA ["MACSTR"]\n", MAC2STR(prStaRec->aucMacAddr));
2610 #endif
2611
2612     mboxSendMsg(prAdapter,
2613             MBOX_ID_0,
2614             (P_MSG_HDR_T) prJoinReqMsg,
2615             MSG_SEND_METHOD_BUF);
2616
2617     return;
2618 }
2619
2620
2621 /*----------------------------------------------------------------------------*/
2622 /*!
2623 * @brief This function will handle the Join Complete Event from SAA FSM for BOW FSM
2624 *
2625 * @param[in] prMsgHdr   Message of Join Complete of SAA FSM.
2626 *
2627 * @return (none)
2628 */
2629 /*----------------------------------------------------------------------------*/
2630 VOID
2631 bowFsmRunEventJoinComplete(
2632     IN P_ADAPTER_T prAdapter,
2633     IN P_MSG_HDR_T prMsgHdr
2634     )
2635 {
2636     P_MSG_JOIN_COMP_T prJoinCompMsg;
2637     P_BOW_FSM_INFO_T prBowFsmInfo;
2638     P_STA_RECORD_T prStaRec;
2639     P_SW_RFB_T prAssocRspSwRfb;
2640     P_BSS_INFO_T prBssInfo;
2641     P_WLAN_ASSOC_RSP_FRAME_T prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T) NULL;
2642     UINT_16 u2IELength;
2643     PUINT_8 pucIE;
2644     P_BSS_INFO_T prBowBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2645
2646     ASSERT(prAdapter);
2647     ASSERT(prMsgHdr);
2648
2649     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2650     prJoinCompMsg = (P_MSG_JOIN_COMP_T)prMsgHdr;
2651     prStaRec = prJoinCompMsg->prStaRec;
2652
2653 #if CFG_BOW_TEST
2654     DBGLOG(BOW, EVENT, ("Start bowfsmRunEventJoinComplete.\n"));
2655     DBGLOG(BOW, EVENT, ("bowfsmRunEventJoinComplete ptr check\n"));
2656     DBGLOG(BOW, EVENT, ("prMsgHdr %x\n", prMsgHdr));
2657     DBGLOG(BOW, EVENT, ("prAdapter %x\n", prAdapter));
2658     DBGLOG(BOW, EVENT, ("prBowFsmInfo %x\n", prBowFsmInfo));
2659     DBGLOG(BOW, EVENT, ("prStaRec %x\n", prStaRec));
2660 #endif
2661
2662     ASSERT(prStaRec);
2663     ASSERT(prBowFsmInfo);
2664
2665     // Check SEQ NUM
2666     if (prJoinCompMsg->ucSeqNum == prBowFsmInfo->ucSeqNumOfReqMsg) {
2667         COPY_MAC_ADDR(prBowFsmInfo->aucPeerAddress, prStaRec->aucMacAddr);
2668
2669         //4 <1> JOIN was successful
2670         if (prJoinCompMsg->rJoinStatus == WLAN_STATUS_SUCCESS) {
2671             prAssocRspSwRfb = prJoinCompMsg->prSwRfb;
2672             prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T) prAssocRspSwRfb->pvHeader;
2673             prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2674
2675             u2IELength = (UINT_16) ((prAssocRspSwRfb->u2PacketLen - prAssocRspSwRfb->u2HeaderLen) -
2676                                 (OFFSET_OF(WLAN_ASSOC_RSP_FRAME_T, aucInfoElem[0]) - WLAN_MAC_MGMT_HEADER_LEN));
2677             pucIE = prAssocRspFrame->aucInfoElem;
2678
2679             prStaRec->eStaType = STA_TYPE_BOW_AP;
2680             prStaRec->u2DesiredNonHTRateSet &= prBowBssInfo->u2OperationalRateSet;
2681             prStaRec->ucDesiredPhyTypeSet = prStaRec->ucPhyTypeSet & prBowBssInfo->ucPhyTypeSet;
2682 #if CFG_BOW_RATE_LIMITATION
2683             //4 <1.2>Update Rate Set
2684             /*Limit Rate Set to 24M,  48M, 54M */
2685             prStaRec->u2DesiredNonHTRateSet &= (RATE_SET_BIT_24M |
2686                                                 RATE_SET_BIT_48M |
2687                                                 RATE_SET_BIT_54M);
2688             /*If peer cannot support the above rate set, fix on the avaliable highest rate*/
2689             if(prStaRec->u2DesiredNonHTRateSet == 0) {
2690                 UINT_8 ucHighestRateIndex;
2691                 if (rateGetHighestRateIndexFromRateSet(prBowBssInfo->u2OperationalRateSet, &ucHighestRateIndex)) {
2692                     prStaRec->u2DesiredNonHTRateSet = BIT(ucHighestRateIndex);
2693                 }
2694             }
2695 #endif
2696
2697             //4 <1.1> Change FW's Media State immediately.
2698             bowChangeMediaState(prAdapter, PARAM_MEDIA_STATE_CONNECTED);
2699
2700             mqmProcessAssocRsp(prAdapter, prAssocRspSwRfb, pucIE, u2IELength);
2701
2702             //4 <1.2> Update HT information and set channel
2703             /* Record HT related parameters in rStaRec and rBssInfo
2704                          * Note: it shall be called before nicUpdateBss()
2705                          */
2706 #if CFG_BOW_SUPPORT_11N
2707             rlmProcessAssocRsp(prAdapter, prAssocRspSwRfb, pucIE, u2IELength);
2708 #endif
2709
2710             //4 <1.3> Update BSS_INFO_T
2711             nicUpdateBss(prAdapter, NETWORK_TYPE_BOW_INDEX);
2712 #if CFG_BOW_TEST
2713             DBGLOG(BOW, EVENT, ("Finish bowUpdateBssInfoForJOIN.\n"));
2714 #endif
2715             //4 <1.4> Activate current AP's STA_RECORD_T in Driver.
2716             cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_3);
2717
2718 #if CFG_BOW_TEST
2719             DBGLOG(BOW, EVENT, ("bowFsmRunEventJoinComplete, qmActivateStaRec.\n"));
2720 #endif
2721
2722             //4 <1.7> Set the Next State of BOW  FSM
2723             wlanoidSendSetQueryBowCmd(prAdapter,
2724                 CMD_ID_CMD_BT_OVER_WIFI,
2725                 TRUE,
2726                 FALSE,
2727                 wlanbowCmdEventLinkConnected,
2728                 wlanbowCmdTimeoutHandler,
2729                 0,
2730                 NULL,
2731                 0
2732                 );
2733         }
2734         //4 <2> JOIN was not successful
2735         else
2736         {
2737             /*Retry*/
2738             bowResponderJoin(prAdapter, prBowFsmInfo->prTargetBssDesc);
2739 #if 0
2740             wlanoidSendSetQueryBowCmd(prAdapter,
2741                 CMD_ID_CMD_BT_OVER_WIFI,
2742                 TRUE,
2743                 FALSE,
2744                 wlanbowCmdEventLinkDisconnected,
2745                 wlanbowCmdTimeoutHandler,
2746                 0,
2747                 NULL,
2748                 0
2749                 );
2750 #endif
2751 #if CFG_BOW_TEST
2752             DBGLOG(BOW, EVENT, ("Start bowfsmRunEventJoinComplete -- Join failed.\n"));
2753             printk("BoW trigger SAA REJOIN\n");
2754 #endif
2755         }
2756     }
2757
2758     cnmMemFree(prAdapter, prMsgHdr);
2759
2760 }
2761
2762
2763 /*----------------------------------------------------------------------------*/
2764 /*!
2765 * @brief This function will indicate the Media State to HOST
2766 *
2767 * @param[in] eConnectionState   Current Media State
2768 * @param[in] fgDelayIndication  Set TRUE for postponing the Disconnect Indication.
2769 *
2770 * @return (none)
2771 */
2772 /*----------------------------------------------------------------------------*/
2773 VOID
2774 bowIndicationOfMediaStateToHost (
2775     IN P_ADAPTER_T prAdapter,
2776     IN ENUM_PARAM_MEDIA_STATE_T eConnectionState,
2777     IN BOOLEAN fgDelayIndication
2778     )
2779 {
2780     EVENT_CONNECTION_STATUS rEventConnStatus;
2781     P_CONNECTION_SETTINGS_T prConnSettings;
2782     P_BSS_INFO_T prBssInfo;
2783     P_BOW_FSM_INFO_T prBowFsmInfo;
2784
2785
2786     prConnSettings = &(prAdapter->rWifiVar.rConnSettings);
2787     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2788     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2789
2790     // NOTE(Kevin): Move following line to bowChangeMediaState() macro per CM's request.
2791     //prBowBssInfo->eConnectionState = eConnectionState;
2792
2793     /* For indicating the Disconnect Event only if current media state is
2794      * disconnected and we didn't do indication yet.
2795      */
2796     if (prBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
2797         if (prBssInfo->eConnectionStateIndicated == eConnectionState) {
2798             return;
2799         }
2800     }
2801
2802     if (!fgDelayIndication) {
2803         //4 <0> Cancel Delay Timer
2804         cnmTimerStopTimer(prAdapter, &prBowFsmInfo->rIndicationOfDisconnectTimer);
2805
2806         //4 <1> Fill EVENT_CONNECTION_STATUS
2807         rEventConnStatus.ucMediaStatus = (UINT_8)eConnectionState;
2808
2809         if (eConnectionState == PARAM_MEDIA_STATE_CONNECTED) {
2810             rEventConnStatus.ucReasonOfDisconnect = DISCONNECT_REASON_CODE_RESERVED;
2811
2812             if (prBssInfo->eCurrentOPMode == OP_MODE_BOW) {
2813                 rEventConnStatus.ucInfraMode = (UINT_8)NET_TYPE_INFRA;
2814                 rEventConnStatus.u2AID = prBssInfo->u2AssocId;
2815                 rEventConnStatus.u2ATIMWindow = 0;
2816             }
2817             else if (prBssInfo->eCurrentOPMode == OP_MODE_IBSS) {
2818                 rEventConnStatus.ucInfraMode = (UINT_8)NET_TYPE_IBSS;
2819                 rEventConnStatus.u2AID = 0;
2820                 rEventConnStatus.u2ATIMWindow = prBssInfo->u2ATIMWindow;
2821             }
2822             else {
2823                 ASSERT(0);
2824             }
2825
2826             COPY_SSID(rEventConnStatus.aucSsid,
2827                       rEventConnStatus.ucSsidLen,
2828                       prConnSettings->aucSSID,
2829                       prConnSettings->ucSSIDLen);
2830
2831             COPY_MAC_ADDR(rEventConnStatus.aucBssid, prBssInfo->aucBSSID);
2832
2833             rEventConnStatus.u2BeaconPeriod = prBssInfo->u2BeaconInterval;
2834             rEventConnStatus.u4FreqInKHz = nicChannelNum2Freq(prBssInfo->ucPrimaryChannel);
2835
2836             switch (prBssInfo->ucNonHTBasicPhyType) {
2837             case PHY_TYPE_HR_DSSS_INDEX:
2838                 rEventConnStatus.ucNetworkType = (UINT_8)PARAM_NETWORK_TYPE_DS;
2839                 break;
2840
2841             case PHY_TYPE_ERP_INDEX:
2842                 rEventConnStatus.ucNetworkType = (UINT_8)PARAM_NETWORK_TYPE_OFDM24;
2843                 break;
2844
2845             case PHY_TYPE_OFDM_INDEX:
2846                 rEventConnStatus.ucNetworkType = (UINT_8)PARAM_NETWORK_TYPE_OFDM5;
2847                 break;
2848
2849             default:
2850                 ASSERT(0);
2851                 rEventConnStatus.ucNetworkType = (UINT_8)PARAM_NETWORK_TYPE_DS;
2852                 break;
2853             }
2854         }
2855         else {
2856             #if CFG_PRIVACY_MIGRATION
2857             /* Clear the pmkid cache while media disconnect */
2858             secClearPmkid(prAdapter);
2859             #endif
2860
2861             rEventConnStatus.ucReasonOfDisconnect = prBssInfo->ucReasonOfDisconnect;
2862
2863         }
2864
2865         //4 <2> Indication
2866         nicMediaStateChange(prAdapter, NETWORK_TYPE_BOW_INDEX, &rEventConnStatus);
2867         prBssInfo->eConnectionStateIndicated = eConnectionState;
2868     }
2869     else {
2870         /* NOTE: Only delay the Indication of Disconnect Event */
2871         ASSERT(eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED);
2872
2873         DBGLOG(BOW, INFO, ("Postpone the indication of Disconnect for %d seconds\n",
2874             prConnSettings->ucDelayTimeOfDisconnectEvent));
2875
2876         cnmTimerStartTimer(prAdapter,
2877                 &prBowFsmInfo->rIndicationOfDisconnectTimer,
2878                 SEC_TO_MSEC(prConnSettings->ucDelayTimeOfDisconnectEvent));
2879     }
2880
2881     return;
2882 }
2883
2884
2885 /*----------------------------------------------------------------------------*/
2886 /*!
2887 * @brief This function will indiate the Event of Tx Fail of AAA Module.
2888 *
2889 * @param[in] prAdapter          Pointer to the Adapter structure.
2890 * @param[in] prStaRec           Pointer to the STA_RECORD_T
2891 *
2892 * @return (none)
2893 */
2894 /*----------------------------------------------------------------------------*/
2895 VOID
2896 bowRunEventAAATxFail (
2897     IN P_ADAPTER_T prAdapter,
2898     IN P_STA_RECORD_T prStaRec
2899     )
2900 {
2901     P_BSS_INFO_T prBssInfo;
2902
2903     ASSERT(prAdapter);
2904     ASSERT(prStaRec);
2905
2906 #if CFG_BOW_TEST
2907     DBGLOG(BOW, EVENT, ("bowRunEventAAATxFail , bssRemoveStaRecFromClientList.\n"));
2908     printk("BoW AAA TxFail, target state %d\n", prStaRec->ucStaState+1);
2909 #endif
2910
2911     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[prStaRec->ucNetTypeIndex]);
2912     bssRemoveStaRecFromClientList(prAdapter, prBssInfo, prStaRec);
2913
2914     return;
2915 }
2916
2917
2918 /*----------------------------------------------------------------------------*/
2919 /*!
2920 * @brief This function will indiate the Event of Successful Completion of AAA Module.
2921 *
2922 * @param[in] prAdapter          Pointer to the Adapter structure.
2923 * @param[in] prStaRec           Pointer to the STA_RECORD_T
2924 *
2925 * @return (none)
2926 */
2927 /*----------------------------------------------------------------------------*/
2928 WLAN_STATUS
2929 bowRunEventAAAComplete (
2930     IN P_ADAPTER_T prAdapter,
2931     IN P_STA_RECORD_T prStaRec
2932     )
2933 {
2934     P_BOW_FSM_INFO_T prBowFsmInfo;
2935
2936     ASSERT(prStaRec);
2937
2938     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2939
2940 #if CFG_BOW_TEST
2941     DBGLOG(BOW, EVENT, ("bowRunEventAAAComplete, cnmStaRecChangeState, STA_STATE_3.\n"));
2942     printk("BoW AAA complete ["MACSTR"]\n", MAC2STR(prStaRec->aucMacAddr));
2943 #endif
2944
2945     /*Update BssInfo to connected*/
2946     bowChangeMediaState(prAdapter, PARAM_MEDIA_STATE_CONNECTED);
2947     nicUpdateBss(prAdapter, NETWORK_TYPE_BOW_INDEX);
2948
2949     /*Update StaRec to State3*/
2950     cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_3);
2951
2952     /*Connected*/
2953     wlanoidSendSetQueryBowCmd(prAdapter,
2954                     CMD_ID_CMD_BT_OVER_WIFI,
2955                     TRUE,
2956                     FALSE,
2957                     wlanbowCmdEventLinkConnected,
2958                     wlanbowCmdTimeoutHandler,
2959                     0,
2960                     NULL,
2961                     0
2962                     );
2963
2964     return WLAN_STATUS_SUCCESS;
2965 }
2966
2967 /*----------------------------------------------------------------------------*/
2968 /*!
2969 * @brief This function will handle RxDeauth
2970 *
2971 * @param[in] prAdapter          Pointer to the Adapter structure.
2972 * @param[in] prStaRec           Pointer to the STA_RECORD_T
2973 *
2974 * @return (none)
2975 */
2976 /*----------------------------------------------------------------------------*/
2977
2978 WLAN_STATUS
2979 bowRunEventRxDeAuth (
2980     IN P_ADAPTER_T prAdapter,
2981     IN P_STA_RECORD_T prStaRec,
2982     IN P_SW_RFB_T prSwRfb
2983     )
2984 {
2985     P_BSS_INFO_T prBowBssInfo;
2986     P_BOW_FSM_INFO_T prBowFsmInfo;
2987     ENUM_BOW_DEVICE_STATE eFsmState;
2988
2989     ASSERT(prAdapter);
2990
2991     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
2992     prBowBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
2993
2994     if(!IS_STA_IN_BOW(prStaRec)) {
2995        return WLAN_STATUS_NOT_ACCEPTED;
2996     }
2997
2998     eFsmState = bowGetBowTableState(prAdapter, prStaRec->aucMacAddr);
2999
3000     if(eFsmState == BOW_DEVICE_STATE_DISCONNECTED) {
3001         /*do nothing*/
3002         return WLAN_STATUS_NOT_ACCEPTED;
3003     }
3004
3005     if (prStaRec->ucStaState > STA_STATE_1) {
3006
3007         if (STA_STATE_3 == prStaRec->ucStaState) {
3008                 //P_MSG_AIS_ABORT_T prAisAbortMsg;
3009
3010                 /* NOTE(Kevin): Change state immediately to avoid starvation of
3011                             * MSG buffer because of too many deauth frames before changing
3012                             * the STA state.
3013                             */
3014                 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
3015         }
3016
3017         COPY_MAC_ADDR(prBowFsmInfo->aucPeerAddress, prStaRec->aucMacAddr);
3018
3019         wlanoidSendSetQueryBowCmd(prAdapter,
3020             CMD_ID_CMD_BT_OVER_WIFI,
3021             TRUE,
3022             FALSE,
3023             wlanbowCmdEventLinkDisconnected,
3024             wlanbowCmdTimeoutHandler,
3025             0,
3026             NULL,
3027             0
3028             );
3029
3030         return WLAN_STATUS_SUCCESS;
3031     }
3032
3033     return WLAN_STATUS_NOT_ACCEPTED;
3034 }
3035
3036
3037 /*----------------------------------------------------------------------------*/
3038 /*!
3039 * \brief This function handle BoW Link disconnect.
3040 *
3041 * \param[in] pMsduInfo            Pointer to the Msdu Info
3042 * \param[in] rStatus              The Tx done status
3043 *
3044 * \return -
3045 *
3046 * \note after receive deauth frame, callback function call this
3047 */
3048 /*----------------------------------------------------------------------------*/
3049 VOID
3050 bowDisconnectLink (
3051     IN P_ADAPTER_T            prAdapter,
3052     IN P_MSDU_INFO_T          prMsduInfo,
3053     IN ENUM_TX_RESULT_CODE_T  rTxDoneStatus
3054     )
3055 {
3056     P_BOW_FSM_INFO_T prBowFsmInfo;
3057     P_STA_RECORD_T prStaRec;
3058
3059     ASSERT(prAdapter);
3060
3061     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3062
3063     /*Free target StaRec*/
3064     if(prMsduInfo) {
3065         prStaRec = cnmGetStaRecByIndex(prAdapter, prMsduInfo->ucStaRecIndex);
3066     }
3067     else {
3068         prStaRec = prBowFsmInfo->prTargetStaRec;
3069     }
3070
3071     if(prStaRec) {
3072         //cnmStaRecFree(prAdapter, prStaRec, TRUE);
3073         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
3074     }
3075     kalPrint("bowDisconnectLink\n");
3076     /*No one connected*/
3077     if (g_u4LinkCount == 0 && g_u4Beaconing != 0)
3078     {
3079         cnmTimerStopTimer(prAdapter, &prBowFsmInfo->rStartingBeaconTimer);
3080         bowStopping(prAdapter);
3081         kalPrint("bowStopping\n");
3082         /*Restore TxPower from Short range mode*/
3083 #if CFG_SUPPORT_NVRAM && 0
3084         wlanLoadManufactureData(prAdapter, kalGetConfiguration(prAdapter->prGlueInfo));
3085 #endif
3086         /*Uninit BoW Interface*/
3087 #if CFG_BOW_SEPARATE_DATA_PATH
3088         kalUninitBowDevice(prAdapter->prGlueInfo);
3089 #endif
3090     }
3091 }
3092
3093
3094 /*----------------------------------------------------------------------------*/
3095 /*!
3096 * @brief This function will validate the Rx Assoc Req Frame and then return
3097 *        the status code to AAA to indicate if need to perform following actions
3098 *        when the specified conditions were matched.
3099 *
3100 * @param[in] prAdapter          Pointer to the Adapter structure.
3101 * @param[in] prSwRfb            Pointer to SW RFB data structure.
3102 * @param[out] pu2StatusCode     The Status Code of Validation Result
3103 *
3104 * @retval TRUE      Reply the Assoc Resp
3105 * @retval FALSE     Don't reply the Assoc Resp
3106 */
3107 /*----------------------------------------------------------------------------*/
3108 BOOLEAN
3109 bowValidateAssocReq (
3110     IN P_ADAPTER_T prAdapter,
3111     IN P_SW_RFB_T prSwRfb,
3112     OUT PUINT_16 pu2StatusCode
3113     )
3114 {
3115     BOOLEAN fgReplyAssocResp = FALSE;
3116     P_BSS_INFO_T prBowBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
3117     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
3118     P_BOW_FSM_INFO_T prBowFsmInfo;
3119     P_WLAN_ASSOC_REQ_FRAME_T prAssocReqFrame = (P_WLAN_ASSOC_REQ_FRAME_T)NULL;
3120     OS_SYSTIME rCurrentTime;
3121     static OS_SYSTIME rLastRejectAssocTime = 0;
3122
3123     ASSERT(prAdapter);
3124
3125     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3126     prAssocReqFrame = (P_WLAN_ASSOC_REQ_FRAME_T) prSwRfb->pvHeader;
3127     *pu2StatusCode = STATUS_CODE_REQ_DECLINED;
3128
3129 #if CFG_BOW_TEST
3130     DBGLOG(BOW, EVENT, ("bowValidateAssocReq, prBowFsmInfo->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
3131         prBowFsmInfo->aucPeerAddress[0],
3132         prBowFsmInfo->aucPeerAddress[1],
3133         prBowFsmInfo->aucPeerAddress[2],
3134         prBowFsmInfo->aucPeerAddress[3],
3135         prBowFsmInfo->aucPeerAddress[4],
3136         prBowFsmInfo->aucPeerAddress[5]));
3137     DBGLOG(BOW, EVENT, ("bowValidateAssocReq, prAssocReqFrame->aucSrcAddr, %x:%x:%x:%x:%x:%x.\n",
3138         prAssocReqFrame->aucSrcAddr[0],
3139         prAssocReqFrame->aucSrcAddr[1],
3140         prAssocReqFrame->aucSrcAddr[2],
3141         prAssocReqFrame->aucSrcAddr[3],
3142         prAssocReqFrame->aucSrcAddr[4],
3143         prAssocReqFrame->aucSrcAddr[5]));
3144 #endif
3145
3146     /*Assoc Accept*/
3147     while(EQUAL_MAC_ADDR(prAssocReqFrame->aucSrcAddr, prBowFsmInfo->aucPeerAddress)) {
3148 #if CFG_BOW_TEST
3149         DBGLOG(BOW, EVENT, ("bowValidateAssocReq, return wlanbowCmdEventLinkConnected.\n"));
3150 #endif
3151         /*Update StaRec*/
3152         prStaRec = cnmGetStaRecByAddress(prAdapter,
3153                             (UINT_8) NETWORK_TYPE_BOW_INDEX,
3154                             prAssocReqFrame->aucSrcAddr);
3155         prStaRec->eStaType = STA_TYPE_BOW_CLIENT;
3156         prStaRec->u2DesiredNonHTRateSet &= prBowBssInfo->u2OperationalRateSet;
3157         prStaRec->ucDesiredPhyTypeSet = prStaRec->ucPhyTypeSet & prBowBssInfo->ucPhyTypeSet;
3158
3159 #if CFG_BOW_RATE_LIMITATION
3160         /*Limit Rate Set to 24M,  48M, 54M */
3161         prStaRec->u2DesiredNonHTRateSet &= (RATE_SET_BIT_24M |
3162                                             RATE_SET_BIT_48M |
3163                                             RATE_SET_BIT_54M);
3164         /*If peer cannot support the above rate set, fix on the avaliable highest rate*/
3165         if(prStaRec->u2DesiredNonHTRateSet == 0) {
3166             UINT_8 ucHighestRateIndex;
3167             if (rateGetHighestRateIndexFromRateSet(prBowBssInfo->u2OperationalRateSet, &ucHighestRateIndex)) {
3168                 prStaRec->u2DesiredNonHTRateSet = BIT(ucHighestRateIndex);
3169             } else {
3170                 /*If no avaliable rate is found, DECLINE the association*/
3171                 *pu2StatusCode = STATUS_CODE_ASSOC_DENIED_RATE_NOT_SUPPORTED;
3172                 break;
3173             }
3174         }
3175 #endif
3176         prStaRec->ucNetTypeIndex = NETWORK_TYPE_BOW_INDEX;
3177
3178         /*Undpate BssInfo to FW*/
3179         bowChangeMediaState(prAdapter, PARAM_MEDIA_STATE_CONNECTED);
3180         nicUpdateBss(prAdapter, NETWORK_TYPE_BOW_INDEX);
3181
3182         /*reply successful*/
3183         *pu2StatusCode = STATUS_CODE_SUCCESSFUL;
3184         fgReplyAssocResp = TRUE;
3185         break;
3186     }
3187
3188     /*Reject Assoc*/
3189     if(*pu2StatusCode != STATUS_CODE_SUCCESSFUL) {
3190         /*Reply Assoc with reject every 5s*/
3191         rCurrentTime = kalGetTimeTick();
3192         if(CHECK_FOR_TIMEOUT(rCurrentTime, rLastRejectAssocTime, MSEC_TO_SYSTIME(5000)) ||
3193            rLastRejectAssocTime == 0
3194             ) {
3195             fgReplyAssocResp = TRUE;
3196             rLastRejectAssocTime = rCurrentTime;
3197         }
3198     }
3199
3200     return fgReplyAssocResp;
3201 }
3202
3203
3204 /*----------------------------------------------------------------------------*/
3205 /*!
3206 * @brief This function will validate the Rx Auth Frame and then return
3207 *        the status code to AAA to indicate if need to perform following actions
3208 *        when the specified conditions were matched.
3209 *
3210 * @param[in] prAdapter          Pointer to the Adapter structure.
3211 * @param[in] prSwRfb            Pointer to SW RFB data structure.
3212 * @param[in] pprStaRec          Pointer to pointer of STA_RECORD_T structure.
3213 * @param[out] pu2StatusCode     The Status Code of Validation Result
3214 *
3215 * @retval TRUE      Reply the Auth
3216 * @retval FALSE     Don't reply the Auth
3217 */
3218 /*----------------------------------------------------------------------------*/
3219 BOOLEAN
3220 bowValidateAuth (
3221     IN P_ADAPTER_T prAdapter,
3222     IN P_SW_RFB_T prSwRfb,
3223     IN PP_STA_RECORD_T pprStaRec,
3224     OUT PUINT_16 pu2StatusCode
3225     )
3226 {
3227     BOOLEAN fgReplyAuth = FALSE;
3228     P_BSS_INFO_T prBowBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
3229     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
3230     P_BOW_FSM_INFO_T prBowFsmInfo;
3231     P_WLAN_AUTH_FRAME_T prAuthFrame = (P_WLAN_AUTH_FRAME_T)NULL;
3232     OS_SYSTIME rCurrentTime;
3233     static OS_SYSTIME rLastRejectAuthTime = 0;
3234
3235     /* TODO(Kevin): Call BoW functions to check ..
3236                     1. Check we are BoW now.
3237                     2. Check we can accept connection from thsi peer
3238                     3. Check Black List here.
3239      */
3240
3241     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3242     prAuthFrame = (P_WLAN_AUTH_FRAME_T) prSwRfb->pvHeader;
3243
3244 #if CFG_BOW_TEST
3245     DBGLOG(BOW, EVENT, ("bowValidateAuth, prBowFsmInfo->aucPeerAddress, %x:%x:%x:%x:%x:%x.\n",
3246         prBowFsmInfo->aucPeerAddress[0],
3247         prBowFsmInfo->aucPeerAddress[1],
3248         prBowFsmInfo->aucPeerAddress[2],
3249         prBowFsmInfo->aucPeerAddress[3],
3250         prBowFsmInfo->aucPeerAddress[4],
3251         prBowFsmInfo->aucPeerAddress[5]));
3252     DBGLOG(BOW, EVENT, ("bowValidateAuth, prAuthFrame->aucSrcAddr, %x:%x:%x:%x:%x:%x.\n",
3253         prAuthFrame->aucSrcAddr[0],
3254         prAuthFrame->aucSrcAddr[1],
3255         prAuthFrame->aucSrcAddr[2],
3256         prAuthFrame->aucSrcAddr[3],
3257         prAuthFrame->aucSrcAddr[4],
3258         prAuthFrame->aucSrcAddr[5]));
3259 #endif
3260
3261     prStaRec = cnmGetStaRecByAddress(prAdapter,
3262                         (UINT_8) NETWORK_TYPE_BOW_INDEX,
3263                         prAuthFrame->aucSrcAddr);
3264     if (!prStaRec) {
3265 #if CFG_BOW_TEST
3266         DBGLOG(BOW, EVENT, ("bowValidateAuth, cnmStaRecAlloc.\n"));
3267 #endif
3268         prStaRec = cnmStaRecAlloc(prAdapter,
3269                         (UINT_8) NETWORK_TYPE_BOW_INDEX);
3270
3271         /* TODO(Kevin): Error handling of allocation of STA_RECORD_T for
3272               * exhausted case and do removal of unused STA_RECORD_T.
3273               */
3274         ASSERT(prStaRec);
3275         COPY_MAC_ADDR(prStaRec->aucMacAddr, prAuthFrame->aucSrcAddr);
3276         prSwRfb->ucStaRecIdx = prStaRec->ucIndex;
3277         prBowBssInfo->prStaRecOfAP = prStaRec;
3278
3279         /* NOTE(Kevin): Better to change state here, not at TX Done */
3280         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
3281 #if CFG_BOW_TEST
3282         DBGLOG(BOW, EVENT, ("bowValidateAuth, cnmStaRecChangeState.\n"));
3283 #endif
3284     }
3285     else
3286     {
3287         prSwRfb->ucStaRecIdx = prStaRec->ucIndex;
3288 #if CFG_BOW_TEST
3289         DBGLOG(BOW, EVENT, ("bowValidateAuth, prStaRec->ucIndex, %x.\n", prStaRec->ucIndex));
3290 #endif
3291         bssRemoveStaRecFromClientList(prAdapter, prBowBssInfo, prStaRec);
3292     }
3293
3294     if (EQUAL_MAC_ADDR(prAuthFrame->aucSrcAddr, prBowFsmInfo->aucPeerAddress)) {
3295
3296         prStaRec->eStaType = STA_TYPE_BOW_CLIENT;
3297         prStaRec->ucNetTypeIndex = NETWORK_TYPE_BOW_INDEX;
3298 #if CFG_BOW_TEST
3299         DBGLOG(BOW, EVENT, ("bowValidateAuth, prStaRec->eStaType, %x.\n", prStaRec->eStaType));
3300         DBGLOG(BOW, EVENT, ("bowValidateAuth, prStaRec->ucNetTypeIndex, %x.\n", prStaRec->ucNetTypeIndex));
3301 #endif
3302         /* Update Station Record - Status/Reason Code */
3303         prStaRec->u2StatusCode = STATUS_CODE_SUCCESSFUL;
3304         prStaRec->ucJoinFailureCount = 0;
3305         *pprStaRec = prStaRec;
3306         *pu2StatusCode = STATUS_CODE_SUCCESSFUL;
3307         fgReplyAuth = TRUE;
3308     }
3309     else {
3310         cnmStaRecFree(prAdapter, prStaRec, FALSE);
3311         *pu2StatusCode = STATUS_CODE_REQ_DECLINED;
3312
3313         /*Reply auth with reject every 5s*/
3314         rCurrentTime = kalGetTimeTick();
3315         if(CHECK_FOR_TIMEOUT(rCurrentTime, rLastRejectAuthTime, MSEC_TO_SYSTIME(5000)) ||
3316            rLastRejectAuthTime == 0
3317             ) {
3318             fgReplyAuth = TRUE;
3319             rLastRejectAuthTime = rCurrentTime;
3320         }
3321     }
3322
3323 #if CFG_BOW_TEST
3324     DBGLOG(BOW, EVENT, ("bowValidateAuth,  fgReplyAuth, %x.\n",  fgReplyAuth));
3325 #endif
3326     return fgReplyAuth;
3327 }
3328
3329
3330 /*----------------------------------------------------------------------------*/
3331 /*!
3332 * \brief    This function is invoked when CNM granted channel privilege
3333 *
3334 * \param[in] prAdapter  Pointer of ADAPTER_T
3335 *
3336 * \return none
3337 */
3338 /*----------------------------------------------------------------------------*/
3339 VOID
3340 bowRunEventChGrant (
3341     IN P_ADAPTER_T prAdapter,
3342     IN P_MSG_HDR_T prMsgHdr
3343     )
3344 {
3345     P_BSS_INFO_T prBowBssInfo;
3346     P_BOW_FSM_INFO_T prBowFsmInfo;
3347     P_MSG_CH_GRANT_T prMsgChGrant;
3348     UINT_8 ucTokenID;
3349     UINT_32 u4GrantInterval;
3350     ENUM_BOW_DEVICE_STATE eFsmState;
3351
3352     ASSERT(prAdapter);
3353     ASSERT(prMsgHdr);
3354
3355     prBowBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX]);
3356     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3357     prMsgChGrant = (P_MSG_CH_GRANT_T)prMsgHdr;
3358     ucTokenID = prMsgChGrant->ucTokenID;
3359     u4GrantInterval = prMsgChGrant->u4GrantInterval;
3360
3361     /* 1. free message */
3362     cnmMemFree(prAdapter, prMsgHdr);
3363     prBowFsmInfo->fgIsChannelGranted = TRUE;
3364
3365 #if CFG_BOW_TEST
3366     DBGLOG(BOW, EVENT, ("Entering bowRunEventChGrant.\n"));
3367 #endif
3368
3369     eFsmState = bowGetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress);
3370
3371     /*Release channel*/
3372     if((!prBowFsmInfo->fgIsChannelRequested) ||
3373        (prBowFsmInfo->ucSeqNumOfChReq != ucTokenID) ||
3374        (eFsmState == BOW_DEVICE_STATE_DISCONNECTED) ||
3375        (eFsmState == BOW_DEVICE_STATE_DISCONNECTING)){
3376 #if CFG_BOW_TEST
3377         printk("BoW Channel [GIVE UP:%d]\n", ucTokenID);
3378         printk("[Requested:%d][ucSeqNumOfChReq:%d][eFsmState:%d]\n",
3379         prBowFsmInfo->fgIsChannelRequested, prBowFsmInfo->ucSeqNumOfChReq, eFsmState);
3380 #endif
3381         bowReleaseCh(prAdapter);
3382         return;
3383     }
3384
3385     /* 2. channel privilege has been approved */
3386     prBowFsmInfo->u4ChGrantedInterval = u4GrantInterval;
3387
3388 #if 0
3389     cnmTimerStartTimer(prAdapter,
3390                 &prBowFsmInfo->rChGrantedTimer,
3391                 prBowFsmInfo->u4ChGrantedInterval - BOW_JOIN_CH_GRANT_THRESHOLD);
3392 #else
3393     cnmTimerStartTimer(prAdapter,
3394                 &prBowFsmInfo->rChGrantedTimer,
3395                 BOW_JOIN_CH_REQUEST_INTERVAL - BOW_JOIN_CH_GRANT_THRESHOLD);
3396 #endif
3397
3398     /* 3.2 set local variable to indicate join timer is ticking */
3399     prBowFsmInfo->fgIsInfraChannelFinished = FALSE;
3400
3401 #if CFG_BOW_TEST
3402     printk("BoW Channel [GRANTED:%d].\n", ucTokenID);
3403 #endif
3404
3405     if(eFsmState == BOW_DEVICE_STATE_ACQUIRING_CHANNEL) {
3406         bowStarting(prAdapter);
3407             bowReleaseCh(prAdapter);
3408         if(prBowFsmInfo->ucRole == BOW_RESPONDER) {
3409             bowResponderJoin(prAdapter, prBowFsmInfo->prTargetBssDesc);
3410         }
3411     }
3412     else {
3413         /*update bssinfo*/
3414         nicUpdateBss(prAdapter, NETWORK_TYPE_BOW_INDEX);
3415         bowReleaseCh(prAdapter);
3416         }
3417
3418     return;
3419 } /* end of aisFsmRunEventChGrant() */
3420
3421
3422 /*----------------------------------------------------------------------------*/
3423 /*!
3424 * \brief    This function is to inform CNM for channel privilege requesting
3425 *           has been released
3426 *
3427 * \param[in] prAdapter  Pointer of ADAPTER_T
3428 *
3429 * \return none
3430 */
3431 /*----------------------------------------------------------------------------*/
3432 VOID
3433 bowRequestCh (
3434     IN P_ADAPTER_T prAdapter
3435     )
3436 {
3437     P_BOW_FSM_INFO_T prBowFsmInfo;
3438     P_MSG_CH_REQ_T prMsgChReq;
3439
3440     ASSERT(prAdapter);
3441
3442     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3443
3444     if (prBowFsmInfo->fgIsChannelGranted == FALSE)
3445     {
3446
3447 #if CFG_BOW_TEST
3448         printk("BoW channel [REQUEST:%d], %d, %d.\n", prBowFsmInfo->ucSeqNumOfChReq+1, prBowFsmInfo->ucPrimaryChannel, prBowFsmInfo->eBand);
3449 #endif
3450         prMsgChReq = (P_MSG_CH_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_CH_REQ_T));
3451
3452         if (!prMsgChReq) {
3453                 ASSERT(0); // Can't indicate CNM for channel acquiring
3454                 return;
3455         }
3456
3457         prMsgChReq->rMsgHdr.eMsgId = MID_MNY_CNM_CH_REQ;
3458         prMsgChReq->ucNetTypeIndex = NETWORK_TYPE_BOW_INDEX;
3459         prMsgChReq->ucTokenID = ++prBowFsmInfo->ucSeqNumOfChReq;
3460         prMsgChReq->eReqType = CH_REQ_TYPE_JOIN;
3461 #if 0
3462         prMsgChReq->u4MaxInterval = BOW_JOIN_CH_REQUEST_INTERVAL;
3463 #else
3464         prMsgChReq->u4MaxInterval = 1;
3465 #endif
3466         prMsgChReq->ucPrimaryChannel  = prBowFsmInfo->ucPrimaryChannel;  //prBowFsmInfo->prTargetBssDesc->ucChannelNum;
3467         prMsgChReq->eRfSco = CHNL_EXT_SCN; //prBowFsmInfo->prTargetBssDesc->eSco;
3468         prMsgChReq->eRfBand = prBowFsmInfo->eBand;  //prBowFsmInfo->prTargetBssDesc->eBand;
3469         COPY_MAC_ADDR(prMsgChReq->aucBSSID, prBowFsmInfo->aucPeerAddress);
3470
3471
3472         prBowFsmInfo->fgIsChannelRequested = TRUE;
3473
3474         mboxSendMsg(prAdapter,
3475                     MBOX_ID_0,
3476                     (P_MSG_HDR_T) prMsgChReq,
3477                     MSG_SEND_METHOD_BUF);
3478     }
3479 }
3480
3481
3482 /*----------------------------------------------------------------------------*/
3483 /*!
3484 * \brief    This function is to inform BOW that channel privilege is granted
3485 *           has been released
3486 *
3487 * \param[in] prAdapter  Pointer of ADAPTER_T
3488 *
3489 * \return none
3490 */
3491 /*----------------------------------------------------------------------------*/
3492 VOID
3493 bowReleaseCh (
3494     IN P_ADAPTER_T prAdapter
3495     )
3496 {
3497     P_BOW_FSM_INFO_T prBowFsmInfo;
3498     P_MSG_CH_ABORT_T prMsgChAbort;
3499
3500     ASSERT(prAdapter);
3501
3502     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3503
3504     if(prBowFsmInfo->fgIsChannelGranted != FALSE || prBowFsmInfo->fgIsChannelRequested != FALSE)
3505     {
3506 #if CFG_BOW_TEST
3507         printk("BoW channel [RELEASE:%d] %d, %d.\n", prBowFsmInfo->ucSeqNumOfChReq, prBowFsmInfo->ucPrimaryChannel, prBowFsmInfo->eBand);
3508 #endif
3509
3510         prBowFsmInfo->fgIsChannelRequested = FALSE;
3511         prBowFsmInfo->fgIsChannelGranted = FALSE;
3512
3513         /* 1. return channel privilege to CNM immediately */
3514         prMsgChAbort = (P_MSG_CH_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_CH_ABORT_T));
3515         if (!prMsgChAbort) {
3516             ASSERT(0); // Can't release Channel to CNM
3517             return;
3518         }
3519
3520         prMsgChAbort->rMsgHdr.eMsgId = MID_MNY_CNM_CH_ABORT;
3521         prMsgChAbort->ucNetTypeIndex = NETWORK_TYPE_BOW_INDEX;
3522         prMsgChAbort->ucTokenID = prBowFsmInfo->ucSeqNumOfChReq;
3523
3524         mboxSendMsg(prAdapter,
3525                 MBOX_ID_0,
3526                 (P_MSG_HDR_T) prMsgChAbort,
3527                 MSG_SEND_METHOD_BUF);
3528     }
3529
3530     return;
3531 } /* end of aisFsmReleaseCh() */
3532
3533
3534 /*----------------------------------------------------------------------------*/
3535 /*!
3536 * @brief This function will indicate an Event of "Media Disconnect" to HOST
3537 *
3538 * @param[in] u4Param  Unused timer parameter
3539 *
3540 * @return (none)
3541 */
3542 /*----------------------------------------------------------------------------*/
3543 VOID
3544 bowChGrantedTimeout(
3545     IN P_ADAPTER_T prAdapter,
3546     IN UINT_32 u4Param
3547     )
3548 {
3549     P_BOW_FSM_INFO_T prBowFsmInfo;
3550     ENUM_BOW_DEVICE_STATE eFsmState;
3551
3552     ASSERT(prAdapter);
3553
3554     prBowFsmInfo = &(prAdapter->rWifiVar.rBowFsmInfo);
3555
3556 #if CFG_BOW_TEST
3557     printk("BoW Channel [TIMEOUT]\n");
3558 #endif
3559 #if 1
3560     //bowReleaseCh(prAdapter);
3561     eFsmState = bowGetBowTableState(prAdapter, prBowFsmInfo->aucPeerAddress);
3562
3563     /*If connecting is not completed, request CH again*/
3564     if((eFsmState == BOW_DEVICE_STATE_CONNECTING) ||
3565        (eFsmState == BOW_DEVICE_STATE_STARTING))
3566     {
3567         bowRequestCh(prAdapter);
3568     }
3569 #endif
3570 }
3571
3572
3573 BOOLEAN
3574 bowNotifyAllLinkDisconnected (
3575     IN P_ADAPTER_T     prAdapter
3576     )
3577 {
3578     UINT_8 ucBowTableIdx = 0;
3579     CMD_INFO_T rCmdInfo;
3580
3581     ASSERT(prAdapter);
3582
3583     kalMemZero(&rCmdInfo, sizeof(CMD_INFO_T));
3584
3585     while (ucBowTableIdx < CFG_BOW_PHYSICAL_LINK_NUM)
3586     {
3587         if (arBowTable[ucBowTableIdx].fgIsValid)
3588         {
3589             COPY_MAC_ADDR(prAdapter->rWifiVar.rBowFsmInfo.aucPeerAddress, arBowTable[ucBowTableIdx].aucPeerAddress);
3590
3591 #if CFG_BOW_TEST
3592             DBGLOG(BOW, EVENT, ("bowNotifyAllLinkDisconnected, arBowTable[%x].aucPeerAddress, %x:%x:%x:%x:%x:%x.\n", ucBowTableIdx,
3593                 arBowTable[ucBowTableIdx].aucPeerAddress[0],
3594                 arBowTable[ucBowTableIdx].aucPeerAddress[1],
3595                 arBowTable[ucBowTableIdx].aucPeerAddress[2],
3596                 arBowTable[ucBowTableIdx].aucPeerAddress[3],
3597                 arBowTable[ucBowTableIdx].aucPeerAddress[4],
3598                 arBowTable[ucBowTableIdx].aucPeerAddress[5]));
3599             DBGLOG(BOW, EVENT, ("bowNotifyAllLinkDisconnected, arBowTable[%x].fgIsValid, %x.\n", ucBowTableIdx, arBowTable[ucBowTableIdx].fgIsValid));
3600 #endif
3601 #if 1
3602             wlanoidSendSetQueryBowCmd(prAdapter,
3603                     CMD_ID_CMD_BT_OVER_WIFI,
3604                     TRUE,
3605                     FALSE,
3606                     wlanbowCmdEventLinkDisconnected,
3607                     wlanbowCmdTimeoutHandler,
3608                     0,
3609                     NULL,
3610                     0
3611                     );
3612 #else
3613             wlanbowCmdEventLinkDisconnected(prAdapter, &rCmdInfo, NULL);
3614 #endif
3615         }
3616
3617         ucBowTableIdx += 1;
3618     }
3619
3620     return TRUE;
3621 }
3622
3623
3624 /*----------------------------------------------------------------------------*/
3625 /*!
3626 * \brief to retrieve Bluetooth-over-Wi-Fi state from glue layer
3627 *
3628 * \param[in]
3629 *           prGlueInfo
3630 *           rPeerAddr
3631 * \return
3632 *           ENUM_BOW_DEVICE_STATE
3633 */
3634 /*----------------------------------------------------------------------------*/
3635
3636 BOOLEAN
3637 bowCheckBowTableIfVaild(
3638     IN P_ADAPTER_T prAdapter,
3639     IN UINT_8   aucPeerAddress[6]
3640     )
3641 {
3642     UINT_8 idx;
3643
3644     KAL_SPIN_LOCK_DECLARATION();
3645     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3646
3647     for(idx = 0 ; idx < CFG_BOW_PHYSICAL_LINK_NUM ; idx++)
3648     {
3649         if( arBowTable[idx].fgIsValid &&
3650             EQUAL_MAC_ADDR(arBowTable[idx].aucPeerAddress, aucPeerAddress))
3651         {
3652
3653 #if CFG_BOW_TEST
3654             DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, aucPeerAddress %x, %x:%x:%x:%x:%x:%x.\n", idx,
3655                 aucPeerAddress[0],
3656                 aucPeerAddress[1],
3657                 aucPeerAddress[2],
3658                 aucPeerAddress[3],
3659                 aucPeerAddress[4],
3660                 aucPeerAddress[5]));
3661
3662             DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, arBowTable[idx].aucPeerAddress %x, %x:%x:%x:%x:%x:%x.\n", idx,
3663                 arBowTable[idx].aucPeerAddress[0],
3664                 arBowTable[idx].aucPeerAddress[1],
3665                 arBowTable[idx].aucPeerAddress[2],
3666                 arBowTable[idx].aucPeerAddress[3],
3667                 arBowTable[idx].aucPeerAddress[4],
3668                 arBowTable[idx].aucPeerAddress[5]));
3669
3670             DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, arBowTable[idx].fgIsValid, %x, %x.\n", idx, arBowTable[idx].fgIsValid));
3671
3672 #endif
3673             KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3674             return TRUE;
3675         }
3676     }
3677
3678     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3679     return FALSE;
3680 }
3681
3682 BOOLEAN
3683 bowGetBowTableContent(
3684     IN P_ADAPTER_T prAdapter,
3685     IN UINT_8 ucBowTableIdx,
3686     OUT P_BOW_TABLE_T  prBowTable
3687     )
3688 {
3689     KAL_SPIN_LOCK_DECLARATION();
3690     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3691
3692     if (arBowTable[ucBowTableIdx].fgIsValid)
3693     {
3694
3695 #if CFG_BOW_TEST
3696         DBGLOG(BOW, EVENT, ("bowGetBowTableContent, arBowTable[idx].fgIsValid, %x, %x.\n", ucBowTableIdx, arBowTable[ucBowTableIdx].fgIsValid));
3697         printk("GET State [%d]\n", arBowTable[ucBowTableIdx].eState);
3698 #endif
3699         prBowTable = &(arBowTable[ucBowTableIdx]);
3700         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3701
3702         return TRUE;
3703     }
3704
3705     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3706
3707     return FALSE;
3708 }
3709
3710
3711 BOOLEAN
3712 bowSetBowTableContent(
3713     IN P_ADAPTER_T        prAdapter,
3714     IN UINT_8             ucBowTableIdx,
3715     IN P_BOW_TABLE_T      prBowTable
3716     )
3717 {
3718     KAL_SPIN_LOCK_DECLARATION();
3719     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3720
3721     COPY_MAC_ADDR(arBowTable[ucBowTableIdx].aucPeerAddress, prBowTable->aucPeerAddress);
3722     arBowTable[ucBowTableIdx].eState = prBowTable->eState;
3723     arBowTable[ucBowTableIdx].fgIsValid = prBowTable->fgIsValid;
3724     arBowTable[ucBowTableIdx].ucAcquireID = prBowTable->ucAcquireID;
3725
3726     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3727
3728     kalSetBowState(prAdapter->prGlueInfo, prBowTable->eState, prBowTable->aucPeerAddress);
3729     //kalSetBowRole(prAdapter->prGlueInfo, prBowTable->ucRole, prBowTable->aucPeerAddress);
3730
3731 #if CFG_BOW_TEST
3732     printk("SET State [%d]\n", arBowTable[ucBowTableIdx].eState);
3733     DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, arBowTable[ucBowTableIdx].fgIsValid, %x, %x.\n", ucBowTableIdx, arBowTable[ucBowTableIdx].fgIsValid));
3734 #endif
3735
3736     return TRUE;
3737
3738 }
3739
3740
3741 BOOLEAN
3742 bowGetBowTableEntryByPeerAddress(
3743     IN P_ADAPTER_T prAdapter,
3744     IN UINT_8   aucPeerAddress[6],
3745     OUT PUINT_8 pucBowTableIdx
3746     )
3747 {
3748     UINT_8 idx;
3749
3750     KAL_SPIN_LOCK_DECLARATION();
3751     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3752
3753     for(idx = 0 ; idx < CFG_BOW_PHYSICAL_LINK_NUM ; idx++)
3754     {
3755         if( arBowTable[idx].fgIsValid &&
3756             EQUAL_MAC_ADDR(arBowTable[idx].aucPeerAddress, aucPeerAddress))
3757         {
3758
3759 #if CFG_BOW_TEST
3760             DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, aucPeerAddress %x, %x:%x:%x:%x:%x:%x.\n", idx,
3761                 aucPeerAddress[0],
3762                 aucPeerAddress[1],
3763                 aucPeerAddress[2],
3764                 aucPeerAddress[3],
3765                 aucPeerAddress[4],
3766                 aucPeerAddress[5]));
3767             DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, arBowTable[idx].aucPeerAddress %x, %x:%x:%x:%x:%x:%x.\n", idx,
3768                 arBowTable[idx].aucPeerAddress[0],
3769                 arBowTable[idx].aucPeerAddress[1],
3770                 arBowTable[idx].aucPeerAddress[2],
3771                 arBowTable[idx].aucPeerAddress[3],
3772                 arBowTable[idx].aucPeerAddress[4],
3773                 arBowTable[idx].aucPeerAddress[5]));
3774             DBGLOG(BOW, EVENT, ("kalCheckBowifVaild, arBowTable[idx].fgIsValid, %x, %x.\n", idx, arBowTable[idx].fgIsValid));
3775 #endif
3776             KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3777
3778             *pucBowTableIdx = idx;
3779
3780             return TRUE;
3781         }
3782     }
3783
3784     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3785
3786     return FALSE;
3787 }
3788
3789
3790 BOOLEAN
3791 bowGetBowTableFreeEntry(
3792     IN P_ADAPTER_T prAdapter,
3793     OUT PUINT_8 pucBowTableIdx
3794     )
3795 {
3796     UINT_8 idx;
3797
3798     KAL_SPIN_LOCK_DECLARATION();
3799     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3800
3801     for(idx = 0 ; idx < CFG_BOW_PHYSICAL_LINK_NUM ; idx++)
3802     {
3803         if(!arBowTable[idx].fgIsValid)
3804         {
3805 #if CFG_BOW_TEST
3806             DBGLOG(BOW, EVENT, ("bowGetBowTableFreeEntry, arBowTable[idx].fgIsValid, %x, %x.\n", idx, arBowTable[idx].fgIsValid));
3807 #endif
3808             *pucBowTableIdx = idx;
3809             arBowTable[idx].fgIsValid = TRUE;
3810
3811             KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3812
3813             return TRUE;
3814         }
3815     }
3816
3817     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3818
3819     return FALSE;
3820 }
3821
3822
3823 ENUM_BOW_DEVICE_STATE
3824 bowGetBowTableState(
3825     IN P_ADAPTER_T prAdapter,
3826     IN UINT_8   aucPeerAddress[6]
3827     )
3828 {
3829     UINT_8 idx;
3830
3831     KAL_SPIN_LOCK_DECLARATION();
3832     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3833
3834     for(idx = 0 ; idx < CFG_BOW_PHYSICAL_LINK_NUM ; idx++)
3835     {
3836         if( arBowTable[idx].fgIsValid &&
3837             EQUAL_MAC_ADDR(arBowTable[idx].aucPeerAddress, aucPeerAddress))
3838         {
3839 #if CFG_BOW_TEST
3840             DBGLOG(BOW, EVENT, ("bowGetState, aucPeerAddress %x, %x:%x:%x:%x:%x:%x.\n", idx,
3841                 aucPeerAddress[0],
3842                 aucPeerAddress[1],
3843                 aucPeerAddress[2],
3844                 aucPeerAddress[3],
3845                 aucPeerAddress[4],
3846                 aucPeerAddress[5]));
3847             DBGLOG(BOW, EVENT, ("bowGetState, arBowTable[idx].aucPeerAddress %x, %x:%x:%x:%x:%x:%x.\n", idx,
3848                 arBowTable[idx].aucPeerAddress[0],
3849                 arBowTable[idx].aucPeerAddress[1],
3850                 arBowTable[idx].aucPeerAddress[2],
3851                 arBowTable[idx].aucPeerAddress[3],
3852                 arBowTable[idx].aucPeerAddress[4],
3853                 arBowTable[idx].aucPeerAddress[5]));
3854             DBGLOG(BOW, EVENT, ("bowGetState, arBowTable[idx].fgIsValid, %x, %x.\n", idx, arBowTable[idx].fgIsValid));
3855             DBGLOG(BOW, EVENT, ("bowGetState, arBowTable[idx].eState;, %x, %x.\n", idx, arBowTable[idx].eState));
3856             printk("GET State [%d]\n", arBowTable[idx].eState);
3857 #endif
3858
3859             KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3860
3861             return arBowTable[idx].eState;
3862         }
3863     }
3864
3865     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3866
3867     return BOW_DEVICE_STATE_DISCONNECTED;
3868 }
3869
3870
3871 BOOLEAN
3872 bowSetBowTableState(
3873     IN P_ADAPTER_T prAdapter,
3874     IN UINT_8   aucPeerAddress[6],
3875     IN ENUM_BOW_DEVICE_STATE eState
3876     )
3877 {
3878     UINT_8 ucBowTableIdx;
3879
3880     if(bowGetBowTableEntryByPeerAddress(prAdapter, aucPeerAddress, &ucBowTableIdx)) {
3881         KAL_SPIN_LOCK_DECLARATION();
3882         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3883
3884         arBowTable[ucBowTableIdx].eState = eState;
3885 #if CFG_BOW_TEST
3886         printk("SET State [%d]\n", eState);
3887 #endif
3888         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_BOW_TABLE);
3889
3890         kalSetBowState(prAdapter->prGlueInfo, eState, aucPeerAddress);
3891         return TRUE;
3892     }
3893     return FALSE;
3894 }
3895
3896
3897 #endif
3898