drivers/net/wireless/mt5931/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                     }
 281                 }
 282             }
 283
 284
 285             prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
 286             prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel = ucPreferedChnl;
 287             prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
 288             prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
 289         }
 290         else {
 291             p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
 292         }
 293
 294
 295     } while (FALSE);
 296
 297     return;
 298 } /* p2pStateAbort_AP_CHANNEL_DETECT */
 299
 300
 301 VOID
 302 p2pStateInit_SCAN (
 303
 304     IN P_ADAPTER_T prAdapter,
 305     IN P_P2P_FSM_INFO_T prP2pFsmInfo
 306     )
 307 {
 308     P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
 309
 310     do {
 311
 312         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
 313
 314         prScanReqInfo = &prP2pFsmInfo->rScanReqInfo;
 315
 316         prScanReqInfo->fgIsScanRequest = TRUE;
 317
 318         p2pFuncRequestScan(prAdapter, prScanReqInfo);
 319
 320     } while (FALSE);
 321     return;
 322 } /* p2pStateInit_SCAN */
 323
 324
 325 VOID
 326 p2pStateAbort_SCAN (
 327     IN P_ADAPTER_T prAdapter,
 328     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 329     IN ENUM_P2P_STATE_T eNextState
 330     )
 331 {
 332     do {
 333         ASSERT_BREAK(prAdapter != NULL);
 334
 335         // 1. Scan cancel. (Make sure the scan request is invalid.
 336         p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
 337
 338         // Scan done indication.
 339         kalP2PIndicateScanDone(prAdapter->prGlueInfo, prP2pFsmInfo->rScanReqInfo.fgIsAbort);
 340     } while (FALSE);
 341
 342     return;
 343 } /* p2pStateAbort_SCAN */
 344
 345
 346 VOID
 347 p2pStateInit_GC_JOIN (
 348     IN P_ADAPTER_T prAdapter,
 349     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 350     IN P_BSS_INFO_T prP2pBssInfo,
 351     IN P_P2P_JOIN_INFO_T prJoinInfo,
 352     IN P_BSS_DESC_T prBssDesc
 353     )
 354 {
 355     P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T)NULL;
 356     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
 357     P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
 358
 359     do {
 360         ASSERT_BREAK((prAdapter != NULL) &&
 361                                     (prP2pFsmInfo != NULL) &&
 362                                     (prP2pBssInfo != NULL) &&
 363                                     (prJoinInfo != NULL) &&
 364                                     (prBssDesc != NULL));
 365
 366         prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
 367
 368         if (prBssDesc->ucSSIDLen) {
 369             COPY_SSID(prP2pConnSettings->aucSSID,
 370                             prP2pConnSettings->ucSSIDLen,
 371                             prBssDesc->aucSSID,
 372                             prBssDesc->ucSSIDLen);
 373         }
 374
 375
 376         // Setup a join timer.
 377         DBGLOG(P2P, TRACE, ("Start a join init timer\n"));
 378         cnmTimerStartTimer(prAdapter,
 379                             &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
 380                             (prP2pFsmInfo->u4GrantInterval - AIS_JOIN_CH_GRANT_THRESHOLD));
 381
 382         //2 <1> We are goin to connect to this BSS
 383         prBssDesc->fgIsConnecting = TRUE;
 384
 385         //2 <2> Setup corresponding STA_RECORD_T
 386         prStaRec = bssCreateStaRecFromBssDesc(prAdapter,
 387                                     (prBssDesc->fgIsP2PPresent?(STA_TYPE_P2P_GO):(STA_TYPE_LEGACY_AP)),
 388                                     NETWORK_TYPE_P2P_INDEX,
 389                                     prBssDesc);
 390
 391         if (prStaRec == NULL) {
 392             DBGLOG(P2P, TRACE, ("Create station record fail\n"));
 393             break;
 394         }
 395
 396
 397         prJoinInfo->prTargetStaRec = prStaRec;
 398         prJoinInfo->fgIsJoinComplete = FALSE;
 399         prJoinInfo->u4BufLength = 0;
 400
 401         //2 <2.1> Sync. to FW domain
 402         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
 403
 404
 405         if (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
 406             P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
 407
 408             prStaRec->fgIsReAssoc = FALSE;
 409
 410             prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
 411
 412             switch (prP2pConnSettings->eAuthMode) {
 413             case AUTH_MODE_OPEN:                /* Note: Omit break here. */
 414             case AUTH_MODE_WPA:
 415             case AUTH_MODE_WPA_PSK:
 416             case AUTH_MODE_WPA2:
 417             case AUTH_MODE_WPA2_PSK:
 418                 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_OPEN_SYSTEM;
 419                 break;
 420             case AUTH_MODE_SHARED:
 421                 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_SHARED_KEY;
 422                 break;
 423             case AUTH_MODE_AUTO_SWITCH:
 424                 DBGLOG(P2P, LOUD, ("JOIN INIT: eAuthMode == AUTH_MODE_AUTO_SWITCH\n"));
 425                 prJoinInfo->ucAvailableAuthTypes = (UINT_8)(AUTH_TYPE_OPEN_SYSTEM |
 426                                                               AUTH_TYPE_SHARED_KEY);
 427                 break;
 428             default:
 429                 ASSERT(!(prP2pConnSettings->eAuthMode == AUTH_MODE_WPA_NONE));
 430                 DBGLOG(P2P, ERROR, ("JOIN INIT: Auth Algorithm : %d was not supported by JOIN\n",
 431                                                prP2pConnSettings->eAuthMode));
 432                 /* TODO(Kevin): error handling ? */
 433                 return;
 434             }
 435             prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
 436         }
 437         else {
 438             ASSERT(FALSE);
 439             // TODO: Shall we considering ROAMIN case for P2P Device?.
 440         }
 441
 442
 443         //2 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes.
 444         if (prJoinInfo->ucAvailableAuthTypes &
 445             (UINT_8)AUTH_TYPE_OPEN_SYSTEM) {
 446
 447             DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));
 448
 449             prJoinInfo->ucAvailableAuthTypes &=
 450                                             ~(UINT_8)AUTH_TYPE_OPEN_SYSTEM;
 451
 452             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
 453         }
 454         else if (prJoinInfo->ucAvailableAuthTypes &
 455             (UINT_8)AUTH_TYPE_SHARED_KEY) {
 456
 457             DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == SHARED_KEY.\n"));
 458
 459             prJoinInfo->ucAvailableAuthTypes &=
 460                                             ~(UINT_8)AUTH_TYPE_SHARED_KEY;
 461
 462             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_SHARED_KEY;
 463         }
 464         else if (prJoinInfo->ucAvailableAuthTypes &
 465             (UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION) {
 466
 467             DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == FAST_BSS_TRANSITION.\n"));
 468
 469             prJoinInfo->ucAvailableAuthTypes &=
 470                                             ~(UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION;
 471
 472             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_FAST_BSS_TRANSITION;
 473         }
 474         else {
 475             ASSERT(0);
 476         }
 477
 478
 479         //4 <5> Overwrite Connection Setting for eConnectionPolicy == ANY (Used by Assoc Req)
 480         if (prBssDesc->ucSSIDLen) {
 481             COPY_SSID(prJoinInfo->rSsidStruct.aucSsid,
 482                       prJoinInfo->rSsidStruct.ucSsidLen,
 483                       prBssDesc->aucSSID,
 484                       prBssDesc->ucSSIDLen);
 485         }
 486
 487         //2 <5> Backup desired channel.
 488
 489         //2 <6> Send a Msg to trigger SAA to start JOIN process.
 490         prJoinReqMsg = (P_MSG_JOIN_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
 491
 492         if (!prJoinReqMsg) {
 493             DBGLOG(P2P, TRACE, ("Allocation Join Message Fail\n"));
 494             ASSERT(FALSE);
 495             return;
 496         }
 497
 498         prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
 499         prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
 500         prJoinReqMsg->prStaRec = prStaRec;
 501
 502         // TODO: Consider fragmentation info in station record.
 503
 504         mboxSendMsg(prAdapter,
 505                     MBOX_ID_0,
 506                     (P_MSG_HDR_T)prJoinReqMsg,
 507                     MSG_SEND_METHOD_BUF);
 508
 509
 510
 511
 512     } while (FALSE);
 513
 514     return;
 515 } /* p2pStateInit_GC_JOIN */
 516
 517
 518
 519 /*----------------------------------------------------------------------------*/
 520 /*!
 521 * @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
 522 *
 523 * @param (none)
 524 *
 525 * @return (none)
 526 */
 527 /*----------------------------------------------------------------------------*/
 528 VOID
 529 p2pStateAbort_GC_JOIN (
 530     IN P_ADAPTER_T prAdapter,
 531     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 532     IN P_P2P_JOIN_INFO_T prJoinInfo,
 533     IN ENUM_P2P_STATE_T eNextState
 534     )
 535 {
 536     P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)NULL;
 537
 538
 539     do {
 540         ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));
 541
 542         if (prJoinInfo->fgIsJoinComplete == FALSE) {
 543
 544             prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_ABORT_T));
 545             if (!prJoinAbortMsg) {
 546                 DBGLOG(P2P, TRACE, ("Fail to allocate join abort message buffer\n"));
 547                 ASSERT(FALSE);
 548                 return;
 549             }
 550
 551             prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
 552             prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
 553             prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;
 554
 555             mboxSendMsg(prAdapter,
 556                         MBOX_ID_0,
 557                         (P_MSG_HDR_T)prJoinAbortMsg,
 558                         MSG_SEND_METHOD_BUF);
 559
 560         }
 561
 562         /* Stop Join Timer. */
 563         cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
 564
 565         /* Release channel requested. */
 566         p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 567
 568     } while (FALSE);
 569
 570     return;
 571
 572 } /* p2pStateAbort_GC_JOIN */
 573
 574
 575