drivers/net/wireless/rockchip_wlan/combo_mt66xx/mt6620/wlan/mgmt/p2p_state.c

   1 #include "p2p_precomp.h"
   2
   3
   4 BOOLEAN
   5 p2pStateInit_IDLE (
   6     IN P_ADAPTER_T prAdapter,
   7     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
   8     IN P_BSS_INFO_T prP2pBssInfo,
   9     OUT P_ENUM_P2P_STATE_T peNextState
  10     )
  11 {
  12     BOOLEAN fgIsTransOut = FALSE;
  13 //    P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
  14
  15     do {
  16         ASSERT_BREAK((prAdapter != NULL) &&
  17                         (prP2pFsmInfo != NULL) &&
  18                         (prP2pBssInfo != NULL) &&
  19                         (peNextState != NULL));
  20
  21         if ((prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) && IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
  22             P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
  23
  24             fgIsTransOut = TRUE;
  25             prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
  26             *peNextState = P2P_STATE_REQING_CHANNEL;
  27
  28         }
  29         else {
  30 #if 0
  31         else if (IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
  32
  33             ASSERT((prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) ||
  34                     (prP2pBssInfo->eCurrentOPMode == OP_MODE_INFRASTRUCTURE));
  35
  36             prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
  37
  38             if (prChnlReqInfo->fgIsChannelRequested) {
  39                 /* Start a timer for return channel. */
  40                 DBGLOG(P2P, TRACE, ("start a GO channel timer.\n"));
  41             }
  42
  43         }
  44
  45 #endif
  46             cnmTimerStartTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer), 5000);
  47         }
  48
  49     } while (FALSE);
  50
  51     return fgIsTransOut;
  52 } /* p2pStateInit_IDLE */
  53
  54
  55 VOID
  56 p2pStateAbort_IDLE (
  57     IN P_ADAPTER_T prAdapter,
  58     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
  59     IN ENUM_P2P_STATE_T eNextState
  60     )
  61 {
  62
  63     P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
  64
  65     do {
  66         ASSERT_BREAK((prAdapter != NULL) &&
  67                                     (prP2pFsmInfo != NULL));
  68
  69         prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
  70
  71
  72         if (prChnlReqInfo->fgIsChannelRequested) {
  73             /* Release channel before timeout. */
  74             p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
  75         }
  76
  77
  78         /* Stop timer for leaving this state. */
  79         cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
  80
  81     } while (FALSE);
  82
  83     return;
  84 } /* p2pStateAbort_IDLE */
  85
  86
  87
  88 VOID
  89 p2pStateInit_CHNL_ON_HAND (
  90     IN P_ADAPTER_T prAdapter,
  91     IN P_BSS_INFO_T prP2pBssInfo,
  92     IN P_P2P_FSM_INFO_T prP2pFsmInfo
  93     )
  94 {
  95     P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
  96
  97     do {
  98         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
  99
 100         prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
 101
 102         /* Store the original channel info. */
 103         prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
 104         prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
 105         prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;
 106
 107         /* RX Probe Request would check primary channel.*/
 108         prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
 109         prP2pBssInfo->eBand = prChnlReqInfo->eBand;
 110         prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;
 111
 112
 113         DBGLOG(P2P, TRACE, ("start a channel on hand timer.\n"));
 114         cnmTimerStartTimer(prAdapter,
 115                         &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
 116                         prChnlReqInfo->u4MaxInterval);
 117
 118         kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
 119                             prChnlReqInfo->u8Cookie,
 120                             prChnlReqInfo->ucReqChnlNum,
 121                             prChnlReqInfo->eBand,
 122                             prChnlReqInfo->eChnlSco,
 123                             prChnlReqInfo->u4MaxInterval);
 124
 125     } while (FALSE);
 126
 127     return;
 128 } /* p2pStateInit_CHNL_ON_HAND */
 129
 130
 131 VOID
 132 p2pStateAbort_CHNL_ON_HAND (
 133     IN P_ADAPTER_T prAdapter,
 134     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 135     IN P_BSS_INFO_T prP2pBssInfo,
 136     IN ENUM_P2P_STATE_T eNextState
 137     )
 138 {
 139     P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
 140
 141
 142     do {
 143         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
 144
 145         prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
 146
 147         cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
 148
 149         /* Restore the original channel info. */
 150         prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
 151         prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
 152         prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;
 153
 154         if (eNextState != P2P_STATE_CHNL_ON_HAND) {
 155             /* Indicate channel return. */
 156             kalP2PIndicateChannelExpired(prAdapter->prGlueInfo, &prP2pFsmInfo->rChnlReqInfo);
 157
 158             // Return Channel.
 159             p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 160         }
 161
 162     } while (FALSE);
 163     return;
 164 } /* p2pStateAbort_CHNL_ON_HAND */
 165
 166
 167 VOID
 168 p2pStateAbort_REQING_CHANNEL (
 169     IN P_ADAPTER_T prAdapter,
 170     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 171     IN ENUM_P2P_STATE_T eNextState
 172     )
 173 {
 174     P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
 175     P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
 176
 177     do {
 178
 179         ASSERT_BREAK((prAdapter != NULL) &&
 180                             (prP2pFsmInfo != NULL) &&
 181                             (eNextState < P2P_STATE_NUM));
 182
 183         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
 184         prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
 185
 186         if (eNextState == P2P_STATE_IDLE) {
 187             if (prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) {
 188                 /* Intend to be AP. */
 189                 /* Setup for AP mode. */
 190                 p2pFuncStartGO(prAdapter,
 191                                     prP2pBssInfo,
 192                                     prP2pSpecificBssInfo->aucGroupSsid,
 193                                     prP2pSpecificBssInfo->u2GroupSsidLen,
 194                                     prP2pSpecificBssInfo->ucPreferredChannel,
 195                                     prP2pSpecificBssInfo->eRfBand,
 196                                     prP2pSpecificBssInfo->eRfSco,
 197                                     prP2pFsmInfo->fgIsApMode);
 198
 199             }
 200             else {
 201                 // Return Channel.
 202                 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 203             }
 204
 205         }
 206
 207
 208     } while (FALSE);
 209
 210     return;
 211 } /* p2pStateInit_AP_CHANNEL_DETECT */
 212
 213
 214 VOID
 215 p2pStateInit_AP_CHANNEL_DETECT (
 216     IN P_ADAPTER_T prAdapter,
 217     IN P_P2P_FSM_INFO_T prP2pFsmInfo
 218     )
 219 {
 220     P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
 221
 222     do {
 223         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
 224
 225         prScanReqInfo = &(prP2pFsmInfo->rScanReqInfo);
 226
 227         prScanReqInfo->eScanType = SCAN_TYPE_PASSIVE_SCAN;
 228         prScanReqInfo->eChannelSet = SCAN_CHANNEL_2G4;
 229         prScanReqInfo->u2PassiveDewellTime = 50;    // 50ms for passive channel load detection
 230         prScanReqInfo->fgIsAbort = TRUE;
 231         prScanReqInfo->fgIsScanRequest = TRUE;
 232         prScanReqInfo->ucNumChannelList = 0;
 233         prScanReqInfo->u4BufLength = 0;
 234         prScanReqInfo->rSsidStruct.ucSsidLen = 0;
 235
 236         p2pFuncRequestScan(prAdapter, prScanReqInfo);
 237
 238     } while (FALSE);
 239
 240     return;
 241 } /* p2pStateInit_AP_CHANNEL_DETECT */
 242
 243
 244
 245 VOID
 246 p2pStateAbort_AP_CHANNEL_DETECT (
 247     IN P_ADAPTER_T prAdapter,
 248     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 249     IN P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo,
 250     IN ENUM_P2P_STATE_T eNextState
 251     )
 252 {
 253     P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
 254     P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
 255
 256     do {
 257
 258         if (eNextState == P2P_STATE_REQING_CHANNEL) {
 259             UINT_8 ucPreferedChnl = 0;
 260             ENUM_BAND_T eBand = BAND_NULL;
 261             ENUM_CHNL_EXT_T eSco = CHNL_EXT_SCN;
 262
 263             prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
 264
 265             /* Determine the channel for AP. */
 266             if (cnmPreferredChannel(prAdapter,
 267                     &eBand,
 268                     &ucPreferedChnl,
 269                     &eSco) == FALSE) {
 270
 271                 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
 272
 273                 if ((ucPreferedChnl = prP2pConnSettings->ucOperatingChnl) == 0) {
 274
 275                     if (scnQuerySparseChannel(prAdapter, &eBand, &ucPreferedChnl) == FALSE) {
 276
 277                         // What to do?
 278                         ASSERT(FALSE);
 279                         // TODO: Pick up a valid channel from channel list.
 280                                                 ucPreferedChnl = 1;
 281                         eBand = BAND_2G4;
 282                     }
 283                 }
 284             }
 285
 286
 287             prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
 288             prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel = ucPreferedChnl;
 289             prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
 290             prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
 291         }
 292         else {
 293             p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
 294         }
 295
 296
 297     } while (FALSE);
 298
 299     return;
 300 } /* p2pStateAbort_AP_CHANNEL_DETECT */
 301
 302
 303 VOID
 304 p2pStateInit_SCAN (
 305
 306     IN P_ADAPTER_T prAdapter,
 307     IN P_P2P_FSM_INFO_T prP2pFsmInfo
 308     )
 309 {
 310     P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
 311
 312     do {
 313
 314         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
 315
 316         prScanReqInfo = &prP2pFsmInfo->rScanReqInfo;
 317
 318         prScanReqInfo->fgIsScanRequest = TRUE;
 319
 320         p2pFuncRequestScan(prAdapter, prScanReqInfo);
 321
 322     } while (FALSE);
 323     return;
 324 } /* p2pStateInit_SCAN */
 325
 326
 327 VOID
 328 p2pStateAbort_SCAN (
 329     IN P_ADAPTER_T prAdapter,
 330     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 331     IN ENUM_P2P_STATE_T eNextState
 332     )
 333 {
 334     do {
 335         ASSERT_BREAK(prAdapter != NULL);
 336
 337         // 1. Scan cancel. (Make sure the scan request is invalid.
 338         p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
 339
 340         // Scan done indication.
 341         kalP2PIndicateScanDone(prAdapter->prGlueInfo, prP2pFsmInfo->rScanReqInfo.fgIsAbort);
 342     } while (FALSE);
 343
 344     return;
 345 } /* p2pStateAbort_SCAN */
 346
 347
 348 VOID
 349 p2pStateInit_GC_JOIN (
 350     IN P_ADAPTER_T prAdapter,
 351     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 352     IN P_BSS_INFO_T prP2pBssInfo,
 353     IN P_P2P_JOIN_INFO_T prJoinInfo,
 354     IN P_BSS_DESC_T prBssDesc
 355     )
 356 {
 357     P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T)NULL;
 358     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
 359     P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
 360
 361     do {
 362         ASSERT_BREAK((prAdapter != NULL) &&
 363                                     (prP2pFsmInfo != NULL) &&
 364                                     (prP2pBssInfo != NULL) &&
 365                                     (prJoinInfo != NULL) &&
 366                                     (prBssDesc != NULL));
 367
 368         prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
 369
 370         if (prBssDesc->ucSSIDLen) {
 371             COPY_SSID(prP2pConnSettings->aucSSID,
 372                             prP2pConnSettings->ucSSIDLen,
 373                             prBssDesc->aucSSID,
 374                             prBssDesc->ucSSIDLen);
 375         }
 376
 377
 378         // Setup a join timer.
 379         DBGLOG(P2P, TRACE, ("Start a join init timer\n"));
 380         cnmTimerStartTimer(prAdapter,
 381                             &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
 382                             (prP2pFsmInfo->u4GrantInterval - AIS_JOIN_CH_GRANT_THRESHOLD));
 383
 384         //2 <1> We are goin to connect to this BSS
 385         prBssDesc->fgIsConnecting = TRUE;
 386
 387         //2 <2> Setup corresponding STA_RECORD_T
 388         prStaRec = bssCreateStaRecFromBssDesc(prAdapter,
 389                                     (prBssDesc->fgIsP2PPresent?(STA_TYPE_P2P_GO):(STA_TYPE_LEGACY_AP)),
 390                                     NETWORK_TYPE_P2P_INDEX,
 391                                     prBssDesc);
 392
 393         if (prStaRec == NULL) {
 394             DBGLOG(P2P, TRACE, ("Create station record fail\n"));
 395             break;
 396         }
 397
 398
 399         prJoinInfo->prTargetStaRec = prStaRec;
 400         prJoinInfo->fgIsJoinComplete = FALSE;
 401         prJoinInfo->u4BufLength = 0;
 402
 403         //2 <2.1> Sync. to FW domain
 404         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
 405
 406
 407         if (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
 408             P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
 409
 410             prStaRec->fgIsReAssoc = FALSE;
 411
 412             prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
 413
 414             switch (prP2pConnSettings->eAuthMode) {
 415             case AUTH_MODE_OPEN:                /* Note: Omit break here. */
 416             case AUTH_MODE_WPA:
 417             case AUTH_MODE_WPA_PSK:
 418             case AUTH_MODE_WPA2:
 419             case AUTH_MODE_WPA2_PSK:
 420                 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_OPEN_SYSTEM;
 421                 break;
 422             case AUTH_MODE_SHARED:
 423                 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_SHARED_KEY;
 424                 break;
 425             case AUTH_MODE_AUTO_SWITCH:
 426                 DBGLOG(P2P, LOUD, ("JOIN INIT: eAuthMode == AUTH_MODE_AUTO_SWITCH\n"));
 427                 prJoinInfo->ucAvailableAuthTypes = (UINT_8)(AUTH_TYPE_OPEN_SYSTEM |
 428                                                               AUTH_TYPE_SHARED_KEY);
 429                 break;
 430             default:
 431                 ASSERT(!(prP2pConnSettings->eAuthMode == AUTH_MODE_WPA_NONE));
 432                 DBGLOG(P2P, ERROR, ("JOIN INIT: Auth Algorithm : %d was not supported by JOIN\n",
 433                                                prP2pConnSettings->eAuthMode));
 434                 /* TODO(Kevin): error handling ? */
 435                 return;
 436             }
 437             prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
 438         }
 439         else {
 440             ASSERT(FALSE);
 441             // TODO: Shall we considering ROAMIN case for P2P Device?.
 442         }
 443
 444
 445         //2 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes.
 446         if (prJoinInfo->ucAvailableAuthTypes &
 447             (UINT_8)AUTH_TYPE_OPEN_SYSTEM) {
 448
 449             DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));
 450
 451             prJoinInfo->ucAvailableAuthTypes &=
 452                                             ~(UINT_8)AUTH_TYPE_OPEN_SYSTEM;
 453
 454             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
 455         }
 456         else if (prJoinInfo->ucAvailableAuthTypes &
 457             (UINT_8)AUTH_TYPE_SHARED_KEY) {
 458
 459             DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == SHARED_KEY.\n"));
 460
 461             prJoinInfo->ucAvailableAuthTypes &=
 462                                             ~(UINT_8)AUTH_TYPE_SHARED_KEY;
 463
 464             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_SHARED_KEY;
 465         }
 466         else if (prJoinInfo->ucAvailableAuthTypes &
 467             (UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION) {
 468
 469             DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == FAST_BSS_TRANSITION.\n"));
 470
 471             prJoinInfo->ucAvailableAuthTypes &=
 472                                             ~(UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION;
 473
 474             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_FAST_BSS_TRANSITION;
 475         }
 476         else {
 477             ASSERT(0);
 478         }
 479
 480
 481         //4 <5> Overwrite Connection Setting for eConnectionPolicy == ANY (Used by Assoc Req)
 482         if (prBssDesc->ucSSIDLen) {
 483             COPY_SSID(prJoinInfo->rSsidStruct.aucSsid,
 484                       prJoinInfo->rSsidStruct.ucSsidLen,
 485                       prBssDesc->aucSSID,
 486                       prBssDesc->ucSSIDLen);
 487         }
 488
 489         //2 <5> Backup desired channel.
 490
 491         //2 <6> Send a Msg to trigger SAA to start JOIN process.
 492         prJoinReqMsg = (P_MSG_JOIN_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
 493
 494         if (!prJoinReqMsg) {
 495             DBGLOG(P2P, TRACE, ("Allocation Join Message Fail\n"));
 496             ASSERT(FALSE);
 497             return;
 498         }
 499
 500         prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
 501         prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
 502         prJoinReqMsg->prStaRec = prStaRec;
 503
 504         // TODO: Consider fragmentation info in station record.
 505
 506         mboxSendMsg(prAdapter,
 507                     MBOX_ID_0,
 508                     (P_MSG_HDR_T)prJoinReqMsg,
 509                     MSG_SEND_METHOD_BUF);
 510
 511
 512
 513
 514     } while (FALSE);
 515
 516     return;
 517 } /* p2pStateInit_GC_JOIN */
 518
 519
 520
 521 /*----------------------------------------------------------------------------*/
 522 /*!
 523 * @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
 524 *
 525 * @param (none)
 526 *
 527 * @return (none)
 528 */
 529 /*----------------------------------------------------------------------------*/
 530 VOID
 531 p2pStateAbort_GC_JOIN (
 532     IN P_ADAPTER_T prAdapter,
 533     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 534     IN P_P2P_JOIN_INFO_T prJoinInfo,
 535     IN ENUM_P2P_STATE_T eNextState
 536     )
 537 {
 538     P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)NULL;
 539
 540
 541     do {
 542         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));
 543
 544         if (prJoinInfo->fgIsJoinComplete == FALSE) {
 545
 546             prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_ABORT_T));
 547             if (!prJoinAbortMsg) {
 548                 DBGLOG(P2P, TRACE, ("Fail to allocate join abort message buffer\n"));
 549                 ASSERT(FALSE);
 550                 return;
 551             }
 552
 553             prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
 554             prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
 555             prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;
 556
 557             mboxSendMsg(prAdapter,
 558                         MBOX_ID_0,
 559                         (P_MSG_HDR_T)prJoinAbortMsg,
 560                         MSG_SEND_METHOD_BUF);
 561
 562         }
 563
 564         /* Stop Join Timer. */
 565         cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
 566
 567         /* Release channel requested. */
 568         p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 569
 570     } while (FALSE);
 571
 572     return;
 573
 574 } /* p2pStateAbort_GC_JOIN */
 575
 576
 577