drivers/misc/mediatek/connectivity/combo/drv_wlan/mt6630/wlan/mgmt/p2p_state.c

   1 #include "p2p_precomp.h"
   2
   3
   4 BOOLEAN
   5 p2pStateInit_IDLE(IN P_ADAPTER_T prAdapter,
   6                   IN P_P2P_FSM_INFO_T prP2pFsmInfo,
   7                   IN P_BSS_INFO_T prP2pBssInfo, OUT P_ENUM_P2P_STATE_T peNextState)
   8 {
   9         BOOLEAN fgIsTransOut = FALSE;
  10 /* P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL; */
  11
  12         do {
  13                 ASSERT_BREAK((prAdapter != NULL) &&
  14                              (prP2pFsmInfo != NULL) &&
  15                              (prP2pBssInfo != NULL) && (peNextState != NULL));
  16
  17                 if ((prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT)
  18                     && IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
  19                         P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
  20
  21                         fgIsTransOut = TRUE;
  22                         prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
  23                         *peNextState = P2P_STATE_REQING_CHANNEL;
  24
  25                 } else {
  26 #if 0
  27                         else
  28                 if (IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
  29
  30                         ASSERT((prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) ||
  31                                (prP2pBssInfo->eCurrentOPMode == OP_MODE_INFRASTRUCTURE));
  32
  33                         prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
  34
  35                         if (prChnlReqInfo->fgIsChannelRequested) {
  36                                 /* Start a timer for return channel. */
  37                                 DBGLOG(P2P, TRACE, ("start a GO channel timer.\n"));
  38                         }
  39
  40                 }
  41 #endif
  42                         cnmTimerStartTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer), 5000);
  43                 }
  44
  45         } while (FALSE);
  46
  47         return fgIsTransOut;
  48 }                               /* p2pStateInit_IDLE */
  49
  50
  51 VOID
  52 p2pStateAbort_IDLE(IN P_ADAPTER_T prAdapter,
  53                    IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
  54 {
  55
  56         P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
  57
  58         do {
  59                 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
  60
  61                 prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
  62
  63
  64                 if (prChnlReqInfo->fgIsChannelRequested) {
  65                         /* Release channel before timeout. */
  66                         p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
  67                 }
  68
  69
  70                 /* Stop timer for leaving this state. */
  71                 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
  72
  73         } while (FALSE);
  74
  75         return;
  76 }                               /* p2pStateAbort_IDLE */
  77
  78
  79
  80 VOID
  81 p2pStateInit_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
  82                           IN P_BSS_INFO_T prP2pBssInfo, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
  83 {
  84         P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
  85
  86         do {
  87                 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
  88
  89                 prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
  90
  91                 /* Store the original channel info. */
  92                 prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
  93                 prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
  94                 prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;
  95
  96                 /* RX Probe Request would check primary channel. */
  97                 prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
  98                 prP2pBssInfo->eBand = prChnlReqInfo->eBand;
  99                 prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;
 100
 101
 102                 DBGLOG(P2P, TRACE, ("start a channel on hand timer.\n"));
 103                 cnmTimerStartTimer(prAdapter,
 104                                    &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
 105                                    prChnlReqInfo->u4MaxInterval);
 106
 107                 kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
 108                                            prChnlReqInfo->u8Cookie,
 109                                            prChnlReqInfo->ucReqChnlNum,
 110                                            prChnlReqInfo->eBand,
 111                                            prChnlReqInfo->eChnlSco, prChnlReqInfo->u4MaxInterval);
 112
 113         } while (FALSE);
 114
 115         return;
 116 }                               /* p2pStateInit_CHNL_ON_HAND */
 117
 118
 119 VOID
 120 p2pStateAbort_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
 121                            IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 122                            IN P_BSS_INFO_T prP2pBssInfo, IN ENUM_P2P_STATE_T eNextState)
 123 {
 124         P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
 125
 126
 127         do {
 128                 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
 129
 130                 prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
 131
 132                 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
 133
 134                 /* Restore the original channel info. */
 135                 prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
 136                 prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
 137                 prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;
 138 #if 0
 139                 if (eNextState != P2P_STATE_CHNL_ON_HAND) {
 140                         /* Indicate channel return. */
 141                         kalP2PIndicateChannelExpired(prAdapter->prGlueInfo,
 142                                                      &prP2pFsmInfo->rChnlReqInfo);
 143
 144                         /* Return Channel. */
 145                         p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 146                 }
 147 #endif
 148         } while (FALSE);
 149         return;
 150 }                               /* p2pStateAbort_CHNL_ON_HAND */
 151
 152
 153 VOID
 154 p2pStateAbort_REQING_CHANNEL(IN P_ADAPTER_T prAdapter,
 155                              IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
 156 {
 157         P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T) NULL;
 158         P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T) NULL;
 159
 160         do {
 161
 162                 ASSERT_BREAK((prAdapter != NULL) &&
 163                              (prP2pFsmInfo != NULL) && (eNextState < P2P_STATE_NUM));
 164
 165                 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
 166                 prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
 167
 168                 if (eNextState == P2P_STATE_IDLE) {
 169                         if (prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) {
 170                                 /* Intend to be AP. */
 171                                 /* Setup for AP mode. */
 172 #if 0
 173                                 p2pFuncStartGO(prAdapter,
 174                                                prP2pBssInfo,
 175                                                prP2pSpecificBssInfo->aucGroupSsid,
 176                                                prP2pSpecificBssInfo->u2GroupSsidLen,
 177                                                prP2pSpecificBssInfo->ucPreferredChannel,
 178                                                prP2pSpecificBssInfo->eRfBand,
 179                                                prP2pSpecificBssInfo->eRfSco,
 180                                                prP2pFsmInfo->fgIsApMode);
 181 #endif
 182                         } else {
 183                                 /* Return Channel. */
 184                                 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 185                         }
 186
 187                 }
 188
 189
 190         } while (FALSE);
 191
 192         return;
 193 }                               /* p2pStateInit_AP_CHANNEL_DETECT */
 194
 195
 196 VOID
 197 p2pStateAbort_AP_CHANNEL_DETECT(IN P_ADAPTER_T prAdapter,
 198                                 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 199                                 IN P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo,
 200                                 IN ENUM_P2P_STATE_T eNextState)
 201 {
 202         P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
 203         P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T) NULL;
 204
 205         do {
 206
 207                 if (eNextState == P2P_STATE_REQING_CHANNEL) {
 208                         UINT_8 ucPreferedChnl = 0;
 209                         ENUM_BAND_T eBand = BAND_NULL;
 210                         ENUM_CHNL_EXT_T eSco = CHNL_EXT_SCN;
 211
 212                         prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
 213
 214                         /* Determine the channel for AP. */
 215                         if (cnmPreferredChannel(prAdapter, &eBand, &ucPreferedChnl, &eSco) == FALSE) {
 216 #if 0
 217                                 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
 218
 219                                 ucPreferedChnl = prP2pConnSettings->ucOperatingChnl;
 220                                 if ((ucPreferedChnl) == 0) {
 221
 222                                         if (scnQuerySparseChannel
 223                                             (prAdapter, &eBand, &ucPreferedChnl) == FALSE) {
 224
 225                                                 /* What to do? */
 226                                                 ASSERT(FALSE);
 227                                                 /* TODO: Pick up a valid channel from channel list. */
 228                                         }
 229                                 }
 230 #endif
 231                         }
 232
 233
 234                         prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
 235                         prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel =
 236                             ucPreferedChnl;
 237                         prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
 238                         prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
 239                 } else {
 240                         /* p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo)); */
 241                 }
 242
 243
 244         } while (FALSE);
 245
 246         return;
 247 }                               /* p2pStateAbort_AP_CHANNEL_DETECT */
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257 /*----------------------------------------------------------------------------*/
 258 /*!
 259 * @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
 260 *
 261 * @param (none)
 262 *
 263 * @return (none)
 264 */
 265 /*----------------------------------------------------------------------------*/
 266 VOID
 267 p2pStateAbort_GC_JOIN(IN P_ADAPTER_T prAdapter,
 268                       IN P_P2P_FSM_INFO_T prP2pFsmInfo,
 269                       IN P_P2P_JOIN_INFO_T prJoinInfo, IN ENUM_P2P_STATE_T eNextState)
 270 {
 271         P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T) NULL;
 272
 273
 274         do {
 275                 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));
 276
 277                 if (prJoinInfo->fgIsJoinComplete == FALSE) {
 278
 279                         prJoinAbortMsg =
 280                             (P_MSG_JOIN_ABORT_T) cnmMemAlloc(prAdapter, RAM_TYPE_MSG,
 281                                                              sizeof(MSG_JOIN_ABORT_T));
 282                         if (!prJoinAbortMsg) {
 283                                 DBGLOG(P2P, TRACE,
 284                                        ("Fail to allocate join abort message buffer\n"));
 285                                 ASSERT(FALSE);
 286                                 return;
 287                         }
 288
 289                         prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
 290                         prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
 291                         prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;
 292
 293                         mboxSendMsg(prAdapter,
 294                                     MBOX_ID_0, (P_MSG_HDR_T) prJoinAbortMsg, MSG_SEND_METHOD_BUF);
 295
 296                 }
 297
 298                 /* Stop Join Timer. */
 299                 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
 300
 301                 /* Release channel requested. */
 302                 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
 303
 304         } while (FALSE);
 305
 306         return;
 307
 308 }                               /* p2pStateAbort_GC_JOIN */