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