drivers/mtk_wcn_combo/drv_wlan/wlan/common/wlan_bow.c

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