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

   1 #include "precomp.h"
   2
   3 BOOLEAN
   4 p2pDevStateInit_IDLE(IN P_ADAPTER_T prAdapter,
   5                      IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo, OUT P_ENUM_P2P_DEV_STATE_T peNextState)
   6 {
   7         BOOLEAN fgIsTransition = FALSE;
   8
   9         do {
  10                 ASSERT_BREAK((prAdapter != NULL) && (prChnlReqInfo) && (peNextState != NULL));
  11
  12
  13                 if (!LINK_IS_EMPTY(&(prChnlReqInfo->rP2pChnlReqLink))) {
  14                         fgIsTransition = TRUE;
  15                         *peNextState = P2P_DEV_STATE_REQING_CHANNEL;
  16                         break;
  17                 }
  18
  19                 /* Stay in IDLE state. */
  20                 UNSET_NET_ACTIVE(prAdapter, P2P_DEV_BSS_INDEX);
  21                 nicDeactivateNetwork(prAdapter, P2P_DEV_BSS_INDEX);
  22         } while (FALSE);
  23
  24         return fgIsTransition;
  25 }                               /* p2pDevStateInit_IDLE */
  26
  27
  28 VOID p2pDevStateAbort_IDLE(IN P_ADAPTER_T prAdapter)
  29 {
  30         /* Currently Aobrt IDLE do nothing. */
  31         return;
  32 }                               /* p2pDevStateAbort_IDLE */
  33
  34
  35
  36
  37
  38 BOOLEAN
  39 p2pDevStateInit_REQING_CHANNEL(IN P_ADAPTER_T                   prAdapter,
  40                                IN UINT_8                        ucBssIdx,
  41                                IN P_P2P_CHNL_REQ_INFO_T         prChnlReqInfo,
  42                                OUT P_ENUM_P2P_DEV_STATE_T       peNextState)
  43 {
  44         BOOLEAN fgIsTransition = FALSE;
  45         P_MSG_P2P_CHNL_REQUEST_T prP2pMsgChnlReq = (P_MSG_P2P_CHNL_REQUEST_T)NULL;
  46     P_BSS_INFO_T prBssInfo = (P_BSS_INFO_T)NULL;
  47
  48         do {
  49                 ASSERT_BREAK((prAdapter != NULL) &&
  50                              (prChnlReqInfo != NULL) && (peNextState != NULL));
  51
  52         prBssInfo = GET_BSS_INFO_BY_INDEX(prAdapter, ucBssIdx);
  53
  54                 if (LINK_IS_EMPTY(&(prChnlReqInfo->rP2pChnlReqLink))) {
  55                         /* NO Channel Request Pending. */
  56                         DBGLOG(P2P, ERROR,
  57                                ("NO Pending Channel Request, but enter Req Channel State\n"));
  58                         fgIsTransition = TRUE;
  59                         *peNextState = P2P_DEV_STATE_IDLE;
  60                         break;
  61                 }
  62
  63
  64                 LINK_REMOVE_HEAD(&(prChnlReqInfo->rP2pChnlReqLink),
  65                                  prP2pMsgChnlReq, P_MSG_P2P_CHNL_REQUEST_T);
  66
  67                 ASSERT(prP2pMsgChnlReq);
  68
  69                 prChnlReqInfo->u4MaxInterval = prP2pMsgChnlReq->u4Duration;
  70                 prChnlReqInfo->ucReqChnlNum = prP2pMsgChnlReq->rChannelInfo.ucChannelNum;
  71                 prChnlReqInfo->eChnlSco = prP2pMsgChnlReq->eChnlSco;
  72                 prChnlReqInfo->eBand = prP2pMsgChnlReq->rChannelInfo.eBand;
  73                 prChnlReqInfo->u8Cookie = prP2pMsgChnlReq->u8Cookie;
  74                 prChnlReqInfo->eChnlReqType = prP2pMsgChnlReq->eChnlReqType;
  75                 prChnlReqInfo->eChannelWidth = prBssInfo->ucVhtChannelWidth;
  76         prChnlReqInfo->ucCenterFreqS1 = prBssInfo->ucVhtChannelFrequencyS1;
  77         prChnlReqInfo->ucCenterFreqS2 = prBssInfo->ucVhtChannelFrequencyS2;
  78
  79                 p2pFuncAcquireCh(prAdapter, ucBssIdx, prChnlReqInfo);
  80         } while (FALSE);
  81
  82         if (prP2pMsgChnlReq) {
  83                 cnmMemFree(prAdapter, prP2pMsgChnlReq);
  84         }
  85
  86         return fgIsTransition;
  87 }                               /* p2pDevStateInit_REQING_CHANNEL */
  88
  89
  90 VOID
  91 p2pDevStateAbort_REQING_CHANNEL(IN P_ADAPTER_T                  prAdapter,
  92                                 IN P_P2P_CHNL_REQ_INFO_T        prChnlReqInfo,
  93                                 IN ENUM_P2P_DEV_STATE_T         eNextState)
  94 {
  95         do {
  96                 ASSERT_BREAK((prAdapter != NULL) &&
  97                              (prChnlReqInfo != NULL) && (eNextState < P2P_DEV_STATE_NUM));
  98
  99                 switch (eNextState) {
 100                 case P2P_DEV_STATE_IDLE:
 101                         /* Channel abort case. */
 102                         p2pFuncReleaseCh(prAdapter, P2P_DEV_BSS_INDEX, prChnlReqInfo);
 103                         break;
 104                 case P2P_DEV_STATE_CHNL_ON_HAND:
 105                         /* Channel on hand case. */
 106                         break;
 107                 default:
 108                         /* Un-expected state transition. */
 109                         DBGLOG(P2P, ERROR, ("Unexpected State Transition(eNextState=%d)\n", eNextState));
 110                         ASSERT(FALSE);
 111                         break;
 112                 }
 113         } while (FALSE);
 114
 115         return;
 116 }                               /* p2pDevStateAbort_REQING_CHANNEL */
 117
 118
 119 VOID
 120 p2pDevStateInit_CHNL_ON_HAND(IN P_ADAPTER_T             prAdapter,
 121                              IN P_BSS_INFO_T            prP2pBssInfo,
 122                              IN P_P2P_DEV_FSM_INFO_T    prP2pDevFsmInfo,
 123                              IN P_P2P_CHNL_REQ_INFO_T   prChnlReqInfo)
 124 {
 125         do {
 126                 ASSERT_BREAK((prAdapter != NULL) &&
 127                              (prP2pDevFsmInfo != NULL) && (prChnlReqInfo != NULL));
 128
 129                 ASSERT(prChnlReqInfo->eChnlReqType == CH_REQ_TYPE_P2P_LISTEN);
 130
 131                 prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
 132                 prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
 133                 prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;
 134
 135                 prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
 136                 prP2pBssInfo->eBand = prChnlReqInfo->eBand;
 137                 prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;
 138
 139                 cnmTimerStartTimer(prAdapter, &(prP2pDevFsmInfo->rP2pFsmTimeoutTimer),
 140                                    prChnlReqInfo->u4MaxInterval);
 141
 142                 kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
 143                                            prChnlReqInfo->u8Cookie,
 144                                            prChnlReqInfo->ucReqChnlNum,
 145                                            prChnlReqInfo->eBand,
 146                                            prChnlReqInfo->eChnlSco, prChnlReqInfo->u4MaxInterval);
 147         } while (FALSE);
 148
 149         return;
 150 }                               /* p2pDevStateInit_CHNL_ON_HAND */
 151
 152
 153 VOID
 154 p2pDevStateAbort_CHNL_ON_HAND(IN P_ADAPTER_T            prAdapter,
 155                               IN P_BSS_INFO_T           prP2pBssInfo,
 156                               IN P_P2P_DEV_FSM_INFO_T   prP2pDevFsmInfo,
 157                               IN P_P2P_CHNL_REQ_INFO_T  prChnlReqInfo)
 158 {
 159         do {
 160                 ASSERT_BREAK((prAdapter != NULL) || (prChnlReqInfo != NULL));
 161
 162                 cnmTimerStopTimer(prAdapter, &(prP2pDevFsmInfo->rP2pFsmTimeoutTimer));
 163
 164                 prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
 165                 prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
 166                 prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;
 167
 168                 kalP2PIndicateChannelExpired(prAdapter->prGlueInfo,
 169                                              prChnlReqInfo->u8Cookie,
 170                                              prChnlReqInfo->ucReqChnlNum,
 171                                              prChnlReqInfo->eBand, prChnlReqInfo->eChnlSco);
 172
 173                 p2pFuncReleaseCh(prAdapter, prP2pDevFsmInfo->ucBssIndex, prChnlReqInfo);
 174         } while (FALSE);
 175
 176         return;
 177 }                               /* p2pDevStateAbort_CHNL_ON_HAND */
 178
 179
 180 VOID
 181 p2pDevStateInit_SCAN(IN P_ADAPTER_T prAdapter,
 182                      IN UINT_8 ucBssIndex, IN P_P2P_SCAN_REQ_INFO_T prScanReqInfo)
 183 {
 184         do {
 185                 ASSERT_BREAK((prAdapter != NULL) && (prScanReqInfo != NULL));
 186
 187                 prScanReqInfo->fgIsScanRequest = TRUE;
 188
 189                 p2pFuncRequestScan(prAdapter, ucBssIndex, prScanReqInfo);
 190         } while (FALSE);
 191
 192         return;
 193 }                               /* p2pDevStateInit_CHNL_ON_HAND */
 194
 195
 196 VOID p2pDevStateAbort_SCAN(IN P_ADAPTER_T prAdapter, IN P_P2P_DEV_FSM_INFO_T prP2pDevFsmInfo)
 197 {
 198         P_P2P_SCAN_REQ_INFO_T prScanInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
 199
 200         do {
 201                 ASSERT_BREAK((prAdapter != NULL) && (prP2pDevFsmInfo != NULL));
 202
 203                 prScanInfo = &(prP2pDevFsmInfo->rScanReqInfo);
 204
 205                 p2pFuncCancelScan(prAdapter, prP2pDevFsmInfo->ucBssIndex, prScanInfo);
 206
 207                 kalP2PIndicateScanDone(prAdapter->prGlueInfo, 0xFF, prScanInfo->fgIsAbort);
 208         } while (FALSE);
 209
 210         return;
 211 }                               /* p2pDevStateAbort_CHNL_ON_HAND */
 212
 213
 214 BOOLEAN
 215 p2pDevStateInit_OFF_CHNL_TX(IN P_ADAPTER_T              prAdapter,
 216                             IN P_P2P_DEV_FSM_INFO_T     prP2pDevFsmInfo,
 217                             IN P_P2P_CHNL_REQ_INFO_T    prChnlReqInfo,
 218                             IN P_P2P_MGMT_TX_REQ_INFO_T prP2pMgmtTxInfo,
 219                             OUT P_ENUM_P2P_DEV_STATE_T  peNextState)
 220 {
 221         P_P2P_OFF_CHNL_TX_REQ_INFO_T prP2pOffChnlTxPkt = (P_P2P_OFF_CHNL_TX_REQ_INFO_T)NULL;
 222         BOOLEAN fgIsTransition = FALSE;
 223
 224         do {
 225                 ASSERT_BREAK((prAdapter != NULL) && (prP2pMgmtTxInfo != NULL)
 226                              && (peNextState != NULL));
 227
 228                 if (!LINK_IS_EMPTY(&(prP2pMgmtTxInfo->rP2pTxReqLink))) {
 229                         prP2pOffChnlTxPkt =
 230                                 LINK_PEEK_HEAD(&(prP2pMgmtTxInfo->rP2pTxReqLink),
 231                                                P2P_OFF_CHNL_TX_REQ_INFO_T, rLinkEntry);
 232
 233                         if (prP2pOffChnlTxPkt == NULL) {
 234                                 DBGLOG(P2P, ERROR,
 235                                        ("Fetal Error, Link not empty but get NULL pointer.\n"));
 236                                 ASSERT(FALSE);
 237                                 break;
 238                         }
 239
 240                         if (prChnlReqInfo->ucReqChnlNum !=
 241                             prP2pOffChnlTxPkt->rChannelInfo.ucChannelNum) {
 242                                 prChnlReqInfo->ucReqChnlNum =
 243                                         prP2pOffChnlTxPkt->rChannelInfo.ucChannelNum;
 244                                 prChnlReqInfo->eChnlSco = prP2pOffChnlTxPkt->eChnlExt;
 245                                 prChnlReqInfo->eBand = prP2pOffChnlTxPkt->rChannelInfo.eBand;
 246                                 prChnlReqInfo->u8Cookie = 0;
 247                                 prChnlReqInfo->eChannelWidth = CW_20_40MHZ;
 248                                 prChnlReqInfo->ucCenterFreqS1 = 0;
 249                                 prChnlReqInfo->ucCenterFreqS2 = 0;
 250                                 ASSERT(prChnlReqInfo->eChnlReqType == CH_REQ_TYPE_OFFCHNL_TX);
 251
 252                                 p2pFuncAcquireCh(prAdapter,
 253                                                  prP2pDevFsmInfo->ucBssIndex, prChnlReqInfo);
 254                         } else {
 255                                 LINK_REMOVE_HEAD(&(prP2pMgmtTxInfo->rP2pTxReqLink),
 256                                                  prP2pOffChnlTxPkt, P_P2P_OFF_CHNL_TX_REQ_INFO_T);
 257
 258                                 p2pFuncTxMgmtFrame(prAdapter,
 259                                                    prP2pDevFsmInfo->ucBssIndex,
 260                                                    prP2pOffChnlTxPkt->prMgmtTxMsdu,
 261                                                    prP2pOffChnlTxPkt->fgNoneCckRate);
 262
 263                                 prP2pMgmtTxInfo->prMgmtTxMsdu = prP2pOffChnlTxPkt->prMgmtTxMsdu;
 264                                 prP2pMgmtTxInfo->fgIsWaitRsp = prP2pOffChnlTxPkt->fgIsWaitRsp;
 265                         }
 266                 } else {
 267                         /* Link is empty, return back to IDLE. */
 268                         *peNextState = P2P_DEV_STATE_IDLE;
 269                         fgIsTransition = TRUE;
 270                 }
 271         } while (FALSE);
 272
 273         return fgIsTransition;
 274 }                               /* p2pDevSateInit_OFF_CHNL_TX */
 275
 276
 277 VOID
 278 p2pDevStateAbort_OFF_CHNL_TX(IN P_ADAPTER_T                     prAdapter,
 279                              IN P_P2P_MGMT_TX_REQ_INFO_T        prP2pMgmtTxInfo,
 280                              IN P_P2P_CHNL_REQ_INFO_T           prChnlReqInfo,
 281                              IN ENUM_P2P_DEV_STATE_T            eNextState)
 282 {
 283         P_P2P_OFF_CHNL_TX_REQ_INFO_T prP2pOffChnlTxPkt = (P_P2P_OFF_CHNL_TX_REQ_INFO_T)NULL;
 284
 285         do {
 286                 ASSERT_BREAK((prAdapter != NULL) &&
 287                              (prP2pMgmtTxInfo != NULL) && (prChnlReqInfo != NULL));
 288
 289                 if (eNextState != P2P_DEV_STATE_OFF_CHNL_TX) {
 290                         while (!LINK_IS_EMPTY(&(prP2pMgmtTxInfo->rP2pTxReqLink))) {
 291                                 LINK_REMOVE_HEAD(&(prP2pMgmtTxInfo->rP2pTxReqLink),
 292                                                  prP2pOffChnlTxPkt, P_P2P_OFF_CHNL_TX_REQ_INFO_T);
 293
 294                                 kalP2PIndicateMgmtTxStatus(prAdapter->prGlueInfo,
 295                                                            prP2pOffChnlTxPkt->prMgmtTxMsdu, FALSE);
 296                         }
 297
 298                         p2pFuncReleaseCh(prAdapter, P2P_DEV_BSS_INDEX, prChnlReqInfo);
 299                 }
 300         } while (FALSE);
 301
 302         return;
 303 }                               /* p2pDevSateAbort_OFF_CHNL_TX */