drivers/net/wireless/rockchip_wlan/mt5931_kk/drv_wlan/common/wlan_bow.c

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