drivers/staging/rt2860/common/cmm_data_usb.c

   1 /*
   2  *************************************************************************
   3  * Ralink Tech Inc.
   4  * 5F., No.36, Taiyuan St., Jhubei City,
   5  * Hsinchu County 302,
   6  * Taiwan, R.O.C.
   7  *
   8  * (c) Copyright 2002-2007, Ralink Technology, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify  *
  11  * it under the terms of the GNU General Public License as published by  *
  12  * the Free Software Foundation; either version 2 of the License, or     *
  13  * (at your option) any later version.                                   *
  14  *                                                                       *
  15  * This program is distributed in the hope that it will be useful,       *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  18  * GNU General Public License for more details.                          *
  19  *                                                                       *
  20  * You should have received a copy of the GNU General Public License     *
  21  * along with this program; if not, write to the                         *
  22  * Free Software Foundation, Inc.,                                       *
  23  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  24  *                                                                       *
  25  *************************************************************************
  26 */
  27
  28 /*
  29    All functions in this file must be USB-depended, or you should out your function
  30         in other files.
  31
  32 */
  33
  34 #ifdef RTMP_MAC_USB
  35
  36 #include        "../rt_config.h"
  37
  38 /*
  39         We can do copy the frame into pTxContext when match following conditions.
  40                 =>
  41                 =>
  42                 =>
  43 */
  44 static inline int RtmpUSBCanDoWrite(struct rt_rtmp_adapter *pAd,
  45                                             u8 QueIdx,
  46                                             struct rt_ht_tx_context *pHTTXContext)
  47 {
  48         int canWrite = NDIS_STATUS_RESOURCES;
  49
  50         if (((pHTTXContext->CurWritePosition) <
  51              pHTTXContext->NextBulkOutPosition)
  52             && (pHTTXContext->CurWritePosition + LOCAL_TXBUF_SIZE) >
  53             pHTTXContext->NextBulkOutPosition) {
  54                 DBGPRINT(RT_DEBUG_ERROR, ("RtmpUSBCanDoWrite c1!\n"));
  55                 RTUSB_SET_BULK_FLAG(pAd,
  56                                     (fRTUSB_BULK_OUT_DATA_NORMAL << QueIdx));
  57         } else if ((pHTTXContext->CurWritePosition == 8)
  58                    && (pHTTXContext->NextBulkOutPosition < LOCAL_TXBUF_SIZE)) {
  59                 DBGPRINT(RT_DEBUG_ERROR, ("RtmpUSBCanDoWrite c2!\n"));
  60                 RTUSB_SET_BULK_FLAG(pAd,
  61                                     (fRTUSB_BULK_OUT_DATA_NORMAL << QueIdx));
  62         } else if (pHTTXContext->bCurWriting == TRUE) {
  63                 DBGPRINT(RT_DEBUG_ERROR, ("RtmpUSBCanDoWrite c3!\n"));
  64         } else {
  65                 canWrite = NDIS_STATUS_SUCCESS;
  66         }
  67
  68         return canWrite;
  69 }
  70
  71 u16 RtmpUSB_WriteSubTxResource(struct rt_rtmp_adapter *pAd,
  72                                   struct rt_tx_blk *pTxBlk,
  73                                   IN BOOLEAN bIsLast, u16 * FreeNumber)
  74 {
  75
  76         /* Dummy function. Should be removed in the future. */
  77         return 0;
  78
  79 }
  80
  81 u16 RtmpUSB_WriteFragTxResource(struct rt_rtmp_adapter *pAd,
  82                                    struct rt_tx_blk *pTxBlk,
  83                                    u8 fragNum, u16 * FreeNumber)
  84 {
  85         struct rt_ht_tx_context *pHTTXContext;
  86         u16 hwHdrLen;   /* The hwHdrLen consist of 802.11 header length plus the header padding length. */
  87         u32 fillOffset;
  88         struct rt_txinfo *pTxInfo;
  89         struct rt_txwi *pTxWI;
  90         u8 *pWirelessPacket = NULL;
  91         u8 QueIdx;
  92         int Status;
  93         unsigned long IrqFlags;
  94         u32 USBDMApktLen = 0, DMAHdrLen, padding;
  95         BOOLEAN TxQLastRound = FALSE;
  96
  97         /* */
  98         /* get Tx Ring Resource & Dma Buffer address */
  99         /* */
 100         QueIdx = pTxBlk->QueIdx;
 101         pHTTXContext = &pAd->TxContext[QueIdx];
 102
 103         RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 104
 105         pHTTXContext = &pAd->TxContext[QueIdx];
 106         fillOffset = pHTTXContext->CurWritePosition;
 107
 108         if (fragNum == 0) {
 109                 /* Check if we have enough space for this bulk-out batch. */
 110                 Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
 111                 if (Status == NDIS_STATUS_SUCCESS) {
 112                         pHTTXContext->bCurWriting = TRUE;
 113
 114                         /* Reserve space for 8 bytes padding. */
 115                         if ((pHTTXContext->ENextBulkOutPosition ==
 116                              pHTTXContext->CurWritePosition)) {
 117                                 pHTTXContext->ENextBulkOutPosition += 8;
 118                                 pHTTXContext->CurWritePosition += 8;
 119                                 fillOffset += 8;
 120                         }
 121                         pTxBlk->Priv = 0;
 122                         pHTTXContext->CurWriteRealPos =
 123                             pHTTXContext->CurWritePosition;
 124                 } else {
 125                         RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx],
 126                                         IrqFlags);
 127
 128                         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
 129                                             NDIS_STATUS_FAILURE);
 130                         return (Status);
 131                 }
 132         } else {
 133                 /* For sub-sequent frames of this bulk-out batch. Just copy it to our bulk-out buffer. */
 134                 Status =
 135                     ((pHTTXContext->bCurWriting ==
 136                       TRUE) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_FAILURE);
 137                 if (Status == NDIS_STATUS_SUCCESS) {
 138                         fillOffset += pTxBlk->Priv;
 139                 } else {
 140                         RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx],
 141                                         IrqFlags);
 142
 143                         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
 144                                             NDIS_STATUS_FAILURE);
 145                         return (Status);
 146                 }
 147         }
 148
 149         NdisZeroMemory((u8 *)(&pTxBlk->HeaderBuf[0]), TXINFO_SIZE);
 150         pTxInfo = (struct rt_txinfo *)(&pTxBlk->HeaderBuf[0]);
 151         pTxWI = (struct rt_txwi *) (&pTxBlk->HeaderBuf[TXINFO_SIZE]);
 152
 153         pWirelessPacket =
 154             &pHTTXContext->TransferBuffer->field.WirelessPacket[fillOffset];
 155
 156         /* copy TXWI + WLAN Header + LLC into DMA Header Buffer */
 157         /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
 158         hwHdrLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
 159
 160         /* Build our URB for USBD */
 161         DMAHdrLen = TXWI_SIZE + hwHdrLen;
 162         USBDMApktLen = DMAHdrLen + pTxBlk->SrcBufLen;
 163         padding = (4 - (USBDMApktLen % 4)) & 0x03;      /* round up to 4 byte alignment */
 164         USBDMApktLen += padding;
 165
 166         pTxBlk->Priv += (TXINFO_SIZE + USBDMApktLen);
 167
 168         /* For TxInfo, the length of USBDMApktLen = TXWI_SIZE + 802.11 header + payload */
 169         RTMPWriteTxInfo(pAd, pTxInfo, (u16)(USBDMApktLen), FALSE, FIFO_EDCA,
 170                         FALSE /*NextValid */ , FALSE);
 171
 172         if (fragNum == pTxBlk->TotalFragNum) {
 173                 pTxInfo->USBDMATxburst = 0;
 174                 if ((pHTTXContext->CurWritePosition + pTxBlk->Priv + 3906) >
 175                     MAX_TXBULK_LIMIT) {
 176                         pTxInfo->SwUseLastRound = 1;
 177                         TxQLastRound = TRUE;
 178                 }
 179         } else {
 180                 pTxInfo->USBDMATxburst = 1;
 181         }
 182
 183         NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
 184                        TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
 185         pWirelessPacket += (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
 186         pHTTXContext->CurWriteRealPos += (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
 187
 188         RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 189
 190         NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen);
 191
 192         /*      Zero the last padding. */
 193         pWirelessPacket += pTxBlk->SrcBufLen;
 194         NdisZeroMemory(pWirelessPacket, padding + 8);
 195
 196         if (fragNum == pTxBlk->TotalFragNum) {
 197                 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 198
 199                 /* Update the pHTTXContext->CurWritePosition. 3906 used to prevent the NextBulkOut is a A-RALINK/A-MSDU Frame. */
 200                 pHTTXContext->CurWritePosition += pTxBlk->Priv;
 201                 if (TxQLastRound == TRUE)
 202                         pHTTXContext->CurWritePosition = 8;
 203                 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
 204
 205                 /* Finally, set bCurWriting as FALSE */
 206                 pHTTXContext->bCurWriting = FALSE;
 207
 208                 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 209
 210                 /* succeed and release the skb buffer */
 211                 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
 212         }
 213
 214         return (Status);
 215
 216 }
 217
 218 u16 RtmpUSB_WriteSingleTxResource(struct rt_rtmp_adapter *pAd,
 219                                      struct rt_tx_blk *pTxBlk,
 220                                      IN BOOLEAN bIsLast,
 221                                      u16 * FreeNumber)
 222 {
 223         struct rt_ht_tx_context *pHTTXContext;
 224         u16 hwHdrLen;
 225         u32 fillOffset;
 226         struct rt_txinfo *pTxInfo;
 227         struct rt_txwi *pTxWI;
 228         u8 *pWirelessPacket;
 229         u8 QueIdx;
 230         unsigned long IrqFlags;
 231         int Status;
 232         u32 USBDMApktLen = 0, DMAHdrLen, padding;
 233         BOOLEAN bTxQLastRound = FALSE;
 234
 235         /* For USB, didn't need PCI_MAP_SINGLE() */
 236         /*SrcBufPA = PCI_MAP_SINGLE(pAd, (char *) pTxBlk->pSrcBufData, pTxBlk->SrcBufLen, PCI_DMA_TODEVICE); */
 237
 238         /* */
 239         /* get Tx Ring Resource & Dma Buffer address */
 240         /* */
 241         QueIdx = pTxBlk->QueIdx;
 242
 243         RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 244         pHTTXContext = &pAd->TxContext[QueIdx];
 245         fillOffset = pHTTXContext->CurWritePosition;
 246
 247         /* Check ring full. */
 248         Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
 249         if (Status == NDIS_STATUS_SUCCESS) {
 250                 pHTTXContext->bCurWriting = TRUE;
 251
 252                 pTxInfo = (struct rt_txinfo *)(&pTxBlk->HeaderBuf[0]);
 253                 pTxWI = (struct rt_txwi *) (&pTxBlk->HeaderBuf[TXINFO_SIZE]);
 254
 255                 /* Reserve space for 8 bytes padding. */
 256                 if ((pHTTXContext->ENextBulkOutPosition ==
 257                      pHTTXContext->CurWritePosition)) {
 258                         pHTTXContext->ENextBulkOutPosition += 8;
 259                         pHTTXContext->CurWritePosition += 8;
 260                         fillOffset += 8;
 261                 }
 262                 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
 263
 264                 pWirelessPacket =
 265                     &pHTTXContext->TransferBuffer->field.
 266                     WirelessPacket[fillOffset];
 267
 268                 /* copy TXWI + WLAN Header + LLC into DMA Header Buffer */
 269                 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
 270                 hwHdrLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
 271
 272                 /* Build our URB for USBD */
 273                 DMAHdrLen = TXWI_SIZE + hwHdrLen;
 274                 USBDMApktLen = DMAHdrLen + pTxBlk->SrcBufLen;
 275                 padding = (4 - (USBDMApktLen % 4)) & 0x03;      /* round up to 4 byte alignment */
 276                 USBDMApktLen += padding;
 277
 278                 pTxBlk->Priv = (TXINFO_SIZE + USBDMApktLen);
 279
 280                 /* For TxInfo, the length of USBDMApktLen = TXWI_SIZE + 802.11 header + payload */
 281                 RTMPWriteTxInfo(pAd, pTxInfo, (u16)(USBDMApktLen), FALSE,
 282                                 FIFO_EDCA, FALSE /*NextValid */ , FALSE);
 283
 284                 if ((pHTTXContext->CurWritePosition + 3906 + pTxBlk->Priv) >
 285                     MAX_TXBULK_LIMIT) {
 286                         pTxInfo->SwUseLastRound = 1;
 287                         bTxQLastRound = TRUE;
 288                 }
 289                 NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
 290                                TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
 291                 pWirelessPacket += (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
 292
 293                 /* We unlock it here to prevent the first 8 bytes maybe over-writed issue. */
 294                 /*      1. First we got CurWritePosition but the first 8 bytes still not write to the pTxcontext. */
 295                 /*      2. An interrupt break our routine and handle bulk-out complete. */
 296                 /*      3. In the bulk-out compllete, it need to do another bulk-out, */
 297                 /*                      if the ENextBulkOutPosition is just the same as CurWritePosition, it will save the first 8 bytes from CurWritePosition, */
 298                 /*                      but the payload still not copyed. the pTxContext->SavedPad[] will save as allzero. and set the bCopyPad = TRUE. */
 299                 /*      4. Interrupt complete. */
 300                 /*  5. Our interrupted routine go back and fill the first 8 bytes to pTxContext. */
 301                 /*      6. Next time when do bulk-out, it found the bCopyPad==TRUE and will copy the SavedPad[] to pTxContext->NextBulkOutPosition. */
 302                 /*              and the packet will wrong. */
 303                 pHTTXContext->CurWriteRealPos +=
 304                     (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
 305                 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 306
 307                 NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData,
 308                                pTxBlk->SrcBufLen);
 309                 pWirelessPacket += pTxBlk->SrcBufLen;
 310                 NdisZeroMemory(pWirelessPacket, padding + 8);
 311
 312                 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 313
 314                 pHTTXContext->CurWritePosition += pTxBlk->Priv;
 315                 if (bTxQLastRound)
 316                         pHTTXContext->CurWritePosition = 8;
 317                 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
 318
 319                 pHTTXContext->bCurWriting = FALSE;
 320         }
 321
 322         RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 323
 324         /* succeed and release the skb buffer */
 325         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
 326
 327         return (Status);
 328
 329 }
 330
 331 u16 RtmpUSB_WriteMultiTxResource(struct rt_rtmp_adapter *pAd,
 332                                     struct rt_tx_blk *pTxBlk,
 333                                     u8 frameNum, u16 * FreeNumber)
 334 {
 335         struct rt_ht_tx_context *pHTTXContext;
 336         u16 hwHdrLen;   /* The hwHdrLen consist of 802.11 header length plus the header padding length. */
 337         u32 fillOffset;
 338         struct rt_txinfo *pTxInfo;
 339         struct rt_txwi *pTxWI;
 340         u8 *pWirelessPacket = NULL;
 341         u8 QueIdx;
 342         int Status;
 343         unsigned long IrqFlags;
 344         /*u32                        USBDMApktLen = 0, DMAHdrLen, padding; */
 345
 346         /* */
 347         /* get Tx Ring Resource & Dma Buffer address */
 348         /* */
 349         QueIdx = pTxBlk->QueIdx;
 350         pHTTXContext = &pAd->TxContext[QueIdx];
 351
 352         RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 353
 354         if (frameNum == 0) {
 355                 /* Check if we have enough space for this bulk-out batch. */
 356                 Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
 357                 if (Status == NDIS_STATUS_SUCCESS) {
 358                         pHTTXContext->bCurWriting = TRUE;
 359
 360                         pTxInfo = (struct rt_txinfo *)(&pTxBlk->HeaderBuf[0]);
 361                         pTxWI = (struct rt_txwi *) (&pTxBlk->HeaderBuf[TXINFO_SIZE]);
 362
 363                         /* Reserve space for 8 bytes padding. */
 364                         if ((pHTTXContext->ENextBulkOutPosition ==
 365                              pHTTXContext->CurWritePosition)) {
 366
 367                                 pHTTXContext->CurWritePosition += 8;
 368                                 pHTTXContext->ENextBulkOutPosition += 8;
 369                         }
 370                         fillOffset = pHTTXContext->CurWritePosition;
 371                         pHTTXContext->CurWriteRealPos =
 372                             pHTTXContext->CurWritePosition;
 373
 374                         pWirelessPacket =
 375                             &pHTTXContext->TransferBuffer->field.
 376                             WirelessPacket[fillOffset];
 377
 378                         /* */
 379                         /* Copy TXINFO + TXWI + WLAN Header + LLC into DMA Header Buffer */
 380                         /* */
 381                         if (pTxBlk->TxFrameType == TX_AMSDU_FRAME)
 382                                 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_AMSDU_SUBFRAMEHEAD, 4)+LENGTH_AMSDU_SUBFRAMEHEAD; */
 383                                 hwHdrLen =
 384                                     pTxBlk->MpduHeaderLen -
 385                                     LENGTH_AMSDU_SUBFRAMEHEAD +
 386                                     pTxBlk->HdrPadLen +
 387                                     LENGTH_AMSDU_SUBFRAMEHEAD;
 388                         else if (pTxBlk->TxFrameType == TX_RALINK_FRAME)
 389                                 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_ARALINK_HEADER_FIELD, 4)+LENGTH_ARALINK_HEADER_FIELD; */
 390                                 hwHdrLen =
 391                                     pTxBlk->MpduHeaderLen -
 392                                     LENGTH_ARALINK_HEADER_FIELD +
 393                                     pTxBlk->HdrPadLen +
 394                                     LENGTH_ARALINK_HEADER_FIELD;
 395                         else
 396                                 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
 397                                 hwHdrLen =
 398                                     pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
 399
 400                         /* Update the pTxBlk->Priv. */
 401                         pTxBlk->Priv = TXINFO_SIZE + TXWI_SIZE + hwHdrLen;
 402
 403                         /*      pTxInfo->USBDMApktLen now just a temp value and will to correct latter. */
 404                         RTMPWriteTxInfo(pAd, pTxInfo, (u16)(pTxBlk->Priv),
 405                                         FALSE, FIFO_EDCA, FALSE /*NextValid */ ,
 406                                         FALSE);
 407
 408                         /* Copy it. */
 409                         NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
 410                                        pTxBlk->Priv);
 411                         pHTTXContext->CurWriteRealPos += pTxBlk->Priv;
 412                         pWirelessPacket += pTxBlk->Priv;
 413                 }
 414         } else {                /* For sub-sequent frames of this bulk-out batch. Just copy it to our bulk-out buffer. */
 415
 416                 Status =
 417                     ((pHTTXContext->bCurWriting ==
 418                       TRUE) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_FAILURE);
 419                 if (Status == NDIS_STATUS_SUCCESS) {
 420                         fillOffset =
 421                             (pHTTXContext->CurWritePosition + pTxBlk->Priv);
 422                         pWirelessPacket =
 423                             &pHTTXContext->TransferBuffer->field.
 424                             WirelessPacket[fillOffset];
 425
 426                         /*hwHdrLen = pTxBlk->MpduHeaderLen; */
 427                         NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
 428                                        pTxBlk->MpduHeaderLen);
 429                         pWirelessPacket += (pTxBlk->MpduHeaderLen);
 430                         pTxBlk->Priv += pTxBlk->MpduHeaderLen;
 431                 } else {        /* It should not happened now unless we are going to shutdown. */
 432                         DBGPRINT(RT_DEBUG_ERROR,
 433                                  ("WriteMultiTxResource():bCurWriting is FALSE when handle sub-sequent frames.\n"));
 434                         Status = NDIS_STATUS_FAILURE;
 435                 }
 436         }
 437
 438         /* We unlock it here to prevent the first 8 bytes maybe over-write issue. */
 439         /*      1. First we got CurWritePosition but the first 8 bytes still not write to the pTxContext. */
 440         /*      2. An interrupt break our routine and handle bulk-out complete. */
 441         /*      3. In the bulk-out compllete, it need to do another bulk-out, */
 442         /*                      if the ENextBulkOutPosition is just the same as CurWritePosition, it will save the first 8 bytes from CurWritePosition, */
 443         /*                      but the payload still not copyed. the pTxContext->SavedPad[] will save as allzero. and set the bCopyPad = TRUE. */
 444         /*      4. Interrupt complete. */
 445         /*  5. Our interrupted routine go back and fill the first 8 bytes to pTxContext. */
 446         /*      6. Next time when do bulk-out, it found the bCopyPad==TRUE and will copy the SavedPad[] to pTxContext->NextBulkOutPosition. */
 447         /*              and the packet will wrong. */
 448         RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 449
 450         if (Status != NDIS_STATUS_SUCCESS) {
 451                 DBGPRINT(RT_DEBUG_ERROR,
 452                          ("WriteMultiTxResource: CWPos = %ld, NBOutPos = %ld.\n",
 453                           pHTTXContext->CurWritePosition,
 454                           pHTTXContext->NextBulkOutPosition));
 455                 goto done;
 456         }
 457         /* Copy the frame content into DMA buffer and update the pTxBlk->Priv */
 458         NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen);
 459         pWirelessPacket += pTxBlk->SrcBufLen;
 460         pTxBlk->Priv += pTxBlk->SrcBufLen;
 461
 462 done:
 463         /* Release the skb buffer here */
 464         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
 465
 466         return (Status);
 467
 468 }
 469
 470 void RtmpUSB_FinalWriteTxResource(struct rt_rtmp_adapter *pAd,
 471                                   struct rt_tx_blk *pTxBlk,
 472                                   u16 totalMPDUSize, u16 TxIdx)
 473 {
 474         u8 QueIdx;
 475         struct rt_ht_tx_context *pHTTXContext;
 476         u32 fillOffset;
 477         struct rt_txinfo *pTxInfo;
 478         struct rt_txwi *pTxWI;
 479         u32 USBDMApktLen, padding;
 480         unsigned long IrqFlags;
 481         u8 *pWirelessPacket;
 482
 483         QueIdx = pTxBlk->QueIdx;
 484         pHTTXContext = &pAd->TxContext[QueIdx];
 485
 486         RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 487
 488         if (pHTTXContext->bCurWriting == TRUE) {
 489                 fillOffset = pHTTXContext->CurWritePosition;
 490                 if (((pHTTXContext->ENextBulkOutPosition ==
 491                       pHTTXContext->CurWritePosition)
 492                      || ((pHTTXContext->ENextBulkOutPosition - 8) ==
 493                          pHTTXContext->CurWritePosition))
 494                     && (pHTTXContext->bCopySavePad == TRUE))
 495                         pWirelessPacket = (u8 *)(&pHTTXContext->SavedPad[0]);
 496                 else
 497                         pWirelessPacket =
 498                             (u8 *)(&pHTTXContext->TransferBuffer->field.
 499                                       WirelessPacket[fillOffset]);
 500
 501                 /* */
 502                 /* Update TxInfo->USBDMApktLen , */
 503                 /*              the length = TXWI_SIZE + 802.11_hdr + 802.11_hdr_pad + payload_of_all_batch_frames + Bulk-Out-padding */
 504                 /* */
 505                 pTxInfo = (struct rt_txinfo *)(pWirelessPacket);
 506
 507                 /* Calculate the bulk-out padding */
 508                 USBDMApktLen = pTxBlk->Priv - TXINFO_SIZE;
 509                 padding = (4 - (USBDMApktLen % 4)) & 0x03;      /* round up to 4 byte alignment */
 510                 USBDMApktLen += padding;
 511
 512                 pTxInfo->USBDMATxPktLen = USBDMApktLen;
 513
 514                 /* */
 515                 /* Update TXWI->MPDUtotalByteCount , */
 516                 /*              the length = 802.11 header + payload_of_all_batch_frames */
 517                 pTxWI = (struct rt_txwi *) (pWirelessPacket + TXINFO_SIZE);
 518                 pTxWI->MPDUtotalByteCount = totalMPDUSize;
 519
 520                 /* */
 521                 /* Update the pHTTXContext->CurWritePosition */
 522                 /* */
 523                 pHTTXContext->CurWritePosition += (TXINFO_SIZE + USBDMApktLen);
 524                 if ((pHTTXContext->CurWritePosition + 3906) > MAX_TXBULK_LIMIT) {       /* Add 3906 for prevent the NextBulkOut packet size is a A-RALINK/A-MSDU Frame. */
 525                         pHTTXContext->CurWritePosition = 8;
 526                         pTxInfo->SwUseLastRound = 1;
 527                 }
 528                 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
 529
 530                 /* */
 531                 /*      Zero the last padding. */
 532                 /* */
 533                 pWirelessPacket =
 534                     (&pHTTXContext->TransferBuffer->field.
 535                      WirelessPacket[fillOffset + pTxBlk->Priv]);
 536                 NdisZeroMemory(pWirelessPacket, padding + 8);
 537
 538                 /* Finally, set bCurWriting as FALSE */
 539                 pHTTXContext->bCurWriting = FALSE;
 540
 541         } else {                /* It should not happened now unless we are going to shutdown. */
 542                 DBGPRINT(RT_DEBUG_ERROR,
 543                          ("FinalWriteTxResource():bCurWriting is FALSE when handle last frames.\n"));
 544         }
 545
 546         RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
 547
 548 }
 549
 550 void RtmpUSBDataLastTxIdx(struct rt_rtmp_adapter *pAd,
 551                           u8 QueIdx, u16 TxIdx)
 552 {
 553         /* DO nothing for USB. */
 554 }
 555
 556 /*
 557         When can do bulk-out:
 558                 1. TxSwFreeIdx < TX_RING_SIZE;
 559                         It means has at least one Ring entity is ready for bulk-out, kick it out.
 560                 2. If TxSwFreeIdx == TX_RING_SIZE
 561                         Check if the CurWriting flag is FALSE, if it's FALSE, we can do kick out.
 562
 563 */
 564 void RtmpUSBDataKickOut(struct rt_rtmp_adapter *pAd,
 565                         struct rt_tx_blk *pTxBlk, u8 QueIdx)
 566 {
 567         RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << QueIdx));
 568         RTUSBKickBulkOut(pAd);
 569
 570 }
 571
 572 /*
 573         Must be run in Interrupt context
 574         This function handle RT2870 specific TxDesc and cpu index update and kick the packet out.
 575  */
 576 int RtmpUSBMgmtKickOut(struct rt_rtmp_adapter *pAd,
 577                        u8 QueIdx,
 578                        void *pPacket,
 579                        u8 *pSrcBufVA, u32 SrcBufLen)
 580 {
 581         struct rt_txinfo *pTxInfo;
 582         unsigned long BulkOutSize;
 583         u8 padLen;
 584         u8 *pDest;
 585         unsigned long SwIdx = pAd->MgmtRing.TxCpuIdx;
 586         struct rt_tx_context *pMLMEContext =
 587             (struct rt_tx_context *)pAd->MgmtRing.Cell[SwIdx].AllocVa;
 588         unsigned long IrqFlags;
 589
 590         pTxInfo = (struct rt_txinfo *)(pSrcBufVA);
 591
 592         /* Build our URB for USBD */
 593         BulkOutSize = SrcBufLen;
 594         BulkOutSize = (BulkOutSize + 3) & (~3);
 595         RTMPWriteTxInfo(pAd, pTxInfo, (u16)(BulkOutSize - TXINFO_SIZE),
 596                         TRUE, EpToQueue[MGMTPIPEIDX], FALSE, FALSE);
 597
 598         BulkOutSize += 4;       /* Always add 4 extra bytes at every packet. */
 599
 600         /* If BulkOutSize is multiple of BulkOutMaxPacketSize, add extra 4 bytes again. */
 601         if ((BulkOutSize % pAd->BulkOutMaxPacketSize) == 0)
 602                 BulkOutSize += 4;
 603
 604         padLen = BulkOutSize - SrcBufLen;
 605         ASSERT((padLen <= RTMP_PKT_TAIL_PADDING));
 606
 607         /* Now memzero all extra padding bytes. */
 608         pDest = (u8 *)(pSrcBufVA + SrcBufLen);
 609         skb_put(GET_OS_PKT_TYPE(pPacket), padLen);
 610         NdisZeroMemory(pDest, padLen);
 611
 612         RTMP_IRQ_LOCK(&pAd->MLMEBulkOutLock, IrqFlags);
 613
 614         pAd->MgmtRing.Cell[pAd->MgmtRing.TxCpuIdx].pNdisPacket = pPacket;
 615         pMLMEContext->TransferBuffer =
 616             (struct rt_tx_buffer *)(GET_OS_PKT_DATAPTR(pPacket));
 617
 618         /* Length in TxInfo should be 8 less than bulkout size. */
 619         pMLMEContext->BulkOutSize = BulkOutSize;
 620         pMLMEContext->InUse = TRUE;
 621         pMLMEContext->bWaitingBulkOut = TRUE;
 622
 623         /*for debug */
 624         /*hex_dump("RtmpUSBMgmtKickOut", &pMLMEContext->TransferBuffer->field.WirelessPacket[0], (pMLMEContext->BulkOutSize > 16 ? 16 : pMLMEContext->BulkOutSize)); */
 625
 626         /*pAd->RalinkCounters.KickTxCount++; */
 627         /*pAd->RalinkCounters.OneSecTxDoneCount++; */
 628
 629         /*if (pAd->MgmtRing.TxSwFreeIdx == MGMT_RING_SIZE) */
 630         /*      needKickOut = TRUE; */
 631
 632         /* Decrease the TxSwFreeIdx and Increase the TX_CTX_IDX */
 633         pAd->MgmtRing.TxSwFreeIdx--;
 634         INC_RING_INDEX(pAd->MgmtRing.TxCpuIdx, MGMT_RING_SIZE);
 635
 636         RTMP_IRQ_UNLOCK(&pAd->MLMEBulkOutLock, IrqFlags);
 637
 638         RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
 639         /*if (needKickOut) */
 640         RTUSBKickBulkOut(pAd);
 641
 642         return 0;
 643 }
 644
 645 void RtmpUSBNullFrameKickOut(struct rt_rtmp_adapter *pAd,
 646                              u8 QueIdx,
 647                              u8 * pNullFrame, u32 frameLen)
 648 {
 649         if (pAd->NullContext.InUse == FALSE) {
 650                 struct rt_tx_context *pNullContext;
 651                 struct rt_txinfo *pTxInfo;
 652                 struct rt_txwi * pTxWI;
 653                 u8 *pWirelessPkt;
 654
 655                 pNullContext = &(pAd->NullContext);
 656
 657                 /* Set the in use bit */
 658                 pNullContext->InUse = TRUE;
 659                 pWirelessPkt =
 660                     (u8 *)& pNullContext->TransferBuffer->field.
 661                     WirelessPacket[0];
 662
 663                 RTMPZeroMemory(&pWirelessPkt[0], 100);
 664                 pTxInfo = (struct rt_txinfo *)& pWirelessPkt[0];
 665                 RTMPWriteTxInfo(pAd, pTxInfo,
 666                                 (u16)(sizeof(struct rt_header_802_11) + TXWI_SIZE),
 667                                 TRUE, EpToQueue[MGMTPIPEIDX], FALSE, FALSE);
 668                 pTxInfo->QSEL = FIFO_EDCA;
 669                 pTxWI = (struct rt_txwi *) & pWirelessPkt[TXINFO_SIZE];
 670                 RTMPWriteTxWI(pAd, pTxWI, FALSE, FALSE, FALSE, FALSE, TRUE,
 671                               FALSE, 0, BSSID_WCID, (sizeof(struct rt_header_802_11)), 0,
 672                               0, (u8)pAd->CommonCfg.MlmeTransmit.field.MCS,
 673                               IFS_HTTXOP, FALSE, &pAd->CommonCfg.MlmeTransmit);
 674
 675                 RTMPMoveMemory(&pWirelessPkt[TXWI_SIZE + TXINFO_SIZE],
 676                                &pAd->NullFrame, sizeof(struct rt_header_802_11));
 677                 pAd->NullContext.BulkOutSize =
 678                     TXINFO_SIZE + TXWI_SIZE + sizeof(pAd->NullFrame) + 4;
 679
 680                 /* Fill out frame length information for global Bulk out arbitor */
 681                 /*pNullContext->BulkOutSize = TransferBufferLength; */
 682                 DBGPRINT(RT_DEBUG_TRACE,
 683                          ("SYNC - send NULL Frame @%d Mbps...\n",
 684                           RateIdToMbps[pAd->CommonCfg.TxRate]));
 685                 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NULL);
 686
 687                 /* Kick bulk out */
 688                 RTUSBKickBulkOut(pAd);
 689         }
 690
 691 }
 692
 693 /*
 694 ========================================================================
 695 Routine Description:
 696     Get a received packet.
 697
 698 Arguments:
 699         pAd                                     device control block
 700         pSaveRxD                        receive descriptor information
 701         *pbReschedule           need reschedule flag
 702         *pRxPending                     pending received packet flag
 703
 704 Return Value:
 705     the received packet
 706
 707 Note:
 708 ========================================================================
 709 */
 710 void *GetPacketFromRxRing(struct rt_rtmp_adapter *pAd,
 711                                  OUT PRT28XX_RXD_STRUC pSaveRxD,
 712                                  OUT BOOLEAN * pbReschedule,
 713                                  IN u32 * pRxPending)
 714 {
 715         struct rt_rx_context *pRxContext;
 716         void *pSkb;
 717         u8 *pData;
 718         unsigned long ThisFrameLen;
 719         unsigned long RxBufferLength;
 720         struct rt_rxwi * pRxWI;
 721
 722         pRxContext = &pAd->RxContext[pAd->NextRxBulkInReadIndex];
 723         if ((pRxContext->Readable == FALSE) || (pRxContext->InUse == TRUE))
 724                 return NULL;
 725
 726         RxBufferLength = pRxContext->BulkInOffset - pAd->ReadPosition;
 727         if (RxBufferLength <
 728             (RT2870_RXDMALEN_FIELD_SIZE + sizeof(struct rt_rxwi) +
 729              sizeof(struct rt_rxinfo))) {
 730                 goto label_null;
 731         }
 732
 733         pData = &pRxContext->TransferBuffer[pAd->ReadPosition]; /* 4KB */
 734         /* The RXDMA field is 4 bytes, now just use the first 2 bytes. The Length including the (RXWI + MSDU + Padding) */
 735         ThisFrameLen = *pData + (*(pData + 1) << 8);
 736         if (ThisFrameLen == 0) {
 737                 DBGPRINT(RT_DEBUG_TRACE,
 738                          ("BIRIdx(%d): RXDMALen is zero.[%ld], BulkInBufLen = %ld)\n",
 739                           pAd->NextRxBulkInReadIndex, ThisFrameLen,
 740                           pRxContext->BulkInOffset));
 741                 goto label_null;
 742         }
 743         if ((ThisFrameLen & 0x3) != 0) {
 744                 DBGPRINT(RT_DEBUG_ERROR,
 745                          ("BIRIdx(%d): RXDMALen not multiple of 4.[%ld], BulkInBufLen = %ld)\n",
 746                           pAd->NextRxBulkInReadIndex, ThisFrameLen,
 747                           pRxContext->BulkInOffset));
 748                 goto label_null;
 749         }
 750
 751         if ((ThisFrameLen + 8) > RxBufferLength)        /* 8 for (RT2870_RXDMALEN_FIELD_SIZE + sizeof(struct rt_rxinfo)) */
 752         {
 753                 DBGPRINT(RT_DEBUG_TRACE,
 754                          ("BIRIdx(%d):FrameLen(0x%lx) outranges. BulkInLen=0x%lx, remaining RxBufLen=0x%lx, ReadPos=0x%lx\n",
 755                           pAd->NextRxBulkInReadIndex, ThisFrameLen,
 756                           pRxContext->BulkInOffset, RxBufferLength,
 757                           pAd->ReadPosition));
 758
 759                 /* error frame. finish this loop */
 760                 goto label_null;
 761         }
 762         /* skip USB frame length field */
 763         pData += RT2870_RXDMALEN_FIELD_SIZE;
 764         pRxWI = (struct rt_rxwi *) pData;
 765         if (pRxWI->MPDUtotalByteCount > ThisFrameLen) {
 766                 DBGPRINT(RT_DEBUG_ERROR,
 767                          ("%s():pRxWIMPDUtotalByteCount(%d) large than RxDMALen(%ld)\n",
 768                           __FUNCTION__, pRxWI->MPDUtotalByteCount,
 769                           ThisFrameLen));
 770                 goto label_null;
 771         }
 772         /* allocate a rx packet */
 773         pSkb = dev_alloc_skb(ThisFrameLen);
 774         if (pSkb == NULL) {
 775                 DBGPRINT(RT_DEBUG_ERROR,
 776                          ("%s():Cannot Allocate sk buffer for this Bulk-In buffer!\n",
 777                           __FUNCTION__));
 778                 goto label_null;
 779         }
 780         /* copy the rx packet */
 781         memcpy(skb_put(pSkb, ThisFrameLen), pData, ThisFrameLen);
 782         RTPKT_TO_OSPKT(pSkb)->dev = get_netdev_from_bssid(pAd, BSS0);
 783         RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pSkb), PKTSRC_NDIS);
 784
 785         /* copy RxD */
 786         *pSaveRxD = *(struct rt_rxinfo *) (pData + ThisFrameLen);
 787
 788         /* update next packet read position. */
 789         pAd->ReadPosition += (ThisFrameLen + RT2870_RXDMALEN_FIELD_SIZE + RXINFO_SIZE); /* 8 for (RT2870_RXDMALEN_FIELD_SIZE + sizeof(struct rt_rxinfo)) */
 790
 791         return pSkb;
 792
 793 label_null:
 794
 795         return NULL;
 796 }
 797
 798 /*
 799         ========================================================================
 800
 801         Routine Description:
 802                 Check Rx descriptor, return NDIS_STATUS_FAILURE if any error dound
 803
 804         Arguments:
 805                 pRxD            Pointer to the Rx descriptor
 806
 807         Return Value:
 808                 NDIS_STATUS_SUCCESS             No err
 809                 NDIS_STATUS_FAILURE             Error
 810
 811         Note:
 812
 813         ========================================================================
 814 */
 815 int RTMPCheckRxError(struct rt_rtmp_adapter *pAd,
 816                              struct rt_header_802_11 * pHeader,
 817                              struct rt_rxwi * pRxWI, IN PRT28XX_RXD_STRUC pRxINFO)
 818 {
 819         struct rt_cipher_key *pWpaKey;
 820         int dBm;
 821
 822         if (pAd->bPromiscuous == TRUE)
 823                 return (NDIS_STATUS_SUCCESS);
 824         if (pRxINFO == NULL)
 825                 return (NDIS_STATUS_FAILURE);
 826
 827         /* Phy errors & CRC errors */
 828         if (pRxINFO->Crc) {
 829                 /* Check RSSI for Noise Hist statistic collection. */
 830                 dBm = (int)(pRxWI->RSSI0) - pAd->BbpRssiToDbmDelta;
 831                 if (dBm <= -87)
 832                         pAd->StaCfg.RPIDensity[0] += 1;
 833                 else if (dBm <= -82)
 834                         pAd->StaCfg.RPIDensity[1] += 1;
 835                 else if (dBm <= -77)
 836                         pAd->StaCfg.RPIDensity[2] += 1;
 837                 else if (dBm <= -72)
 838                         pAd->StaCfg.RPIDensity[3] += 1;
 839                 else if (dBm <= -67)
 840                         pAd->StaCfg.RPIDensity[4] += 1;
 841                 else if (dBm <= -62)
 842                         pAd->StaCfg.RPIDensity[5] += 1;
 843                 else if (dBm <= -57)
 844                         pAd->StaCfg.RPIDensity[6] += 1;
 845                 else if (dBm > -57)
 846                         pAd->StaCfg.RPIDensity[7] += 1;
 847
 848                 return (NDIS_STATUS_FAILURE);
 849         }
 850         /* Add Rx size to channel load counter, we should ignore error counts */
 851         pAd->StaCfg.CLBusyBytes += (pRxWI->MPDUtotalByteCount + 14);
 852
 853         /* Drop ToDs promiscuous frame, it is opened due to CCX 2 channel load statistics */
 854         if (pHeader->FC.ToDs) {
 855                 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Err;FC.ToDs\n"));
 856                 return NDIS_STATUS_FAILURE;
 857         }
 858         /* Paul 04-03 for OFDM Rx length issue */
 859         if (pRxWI->MPDUtotalByteCount > MAX_AGGREGATION_SIZE) {
 860                 DBGPRINT_RAW(RT_DEBUG_ERROR, ("received packet too long\n"));
 861                 return NDIS_STATUS_FAILURE;
 862         }
 863         /* Drop not U2M frames, can't drop here because we will drop beacon in this case */
 864         /* I am kind of doubting the U2M bit operation */
 865         /* if (pRxD->U2M == 0) */
 866         /*      return(NDIS_STATUS_FAILURE); */
 867
 868         /* drop decyption fail frame */
 869         if (pRxINFO->Decrypted && pRxINFO->CipherErr) {
 870
 871                 if (((pRxINFO->CipherErr & 1) == 1)
 872                     && pAd->CommonCfg.bWirelessEvent && INFRA_ON(pAd))
 873                         RTMPSendWirelessEvent(pAd, IW_ICV_ERROR_EVENT_FLAG,
 874                                               pAd->MacTab.Content[BSSID_WCID].
 875                                               Addr, BSS0, 0);
 876
 877                 if (((pRxINFO->CipherErr & 2) == 2)
 878                     && pAd->CommonCfg.bWirelessEvent && INFRA_ON(pAd))
 879                         RTMPSendWirelessEvent(pAd, IW_MIC_ERROR_EVENT_FLAG,
 880                                               pAd->MacTab.Content[BSSID_WCID].
 881                                               Addr, BSS0, 0);
 882                 /* */
 883                 /* MIC Error */
 884                 /* */
 885                 if ((pRxINFO->CipherErr == 2) && pRxINFO->MyBss) {
 886                         pWpaKey = &pAd->SharedKey[BSS0][pRxWI->KeyIndex];
 887                         RTMPReportMicError(pAd, pWpaKey);
 888                         DBGPRINT_RAW(RT_DEBUG_ERROR, ("Rx MIC Value error\n"));
 889                 }
 890
 891                 if (pRxINFO->Decrypted &&
 892                     (pAd->SharedKey[BSS0][pRxWI->KeyIndex].CipherAlg ==
 893                      CIPHER_AES)
 894                     && (pHeader->Sequence == pAd->FragFrame.Sequence)) {
 895                         /* */
 896                         /* Acceptable since the First FragFrame no CipherErr problem. */
 897                         /* */
 898                         return (NDIS_STATUS_SUCCESS);
 899                 }
 900
 901                 return (NDIS_STATUS_FAILURE);
 902         }
 903
 904         return (NDIS_STATUS_SUCCESS);
 905 }
 906
 907 void RtmpUsbStaAsicForceWakeupTimeout(void *SystemSpecific1,
 908                                       void *FunctionContext,
 909                                       void *SystemSpecific2,
 910                                       void *SystemSpecific3)
 911 {
 912         struct rt_rtmp_adapter *pAd = (struct rt_rtmp_adapter *)FunctionContext;
 913
 914         if (pAd && pAd->Mlme.AutoWakeupTimerRunning) {
 915                 AsicSendCommandToMcu(pAd, 0x31, 0xff, 0x00, 0x02);
 916
 917                 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_DOZE);
 918                 pAd->Mlme.AutoWakeupTimerRunning = FALSE;
 919         }
 920 }
 921
 922 void RT28xxUsbStaAsicForceWakeup(struct rt_rtmp_adapter *pAd, IN BOOLEAN bFromTx)
 923 {
 924         BOOLEAN Canceled;
 925
 926         if (pAd->Mlme.AutoWakeupTimerRunning)
 927                 RTMPCancelTimer(&pAd->Mlme.AutoWakeupTimer, &Canceled);
 928
 929         AsicSendCommandToMcu(pAd, 0x31, 0xff, 0x00, 0x02);
 930
 931         OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_DOZE);
 932 }
 933
 934 void RT28xxUsbStaAsicSleepThenAutoWakeup(struct rt_rtmp_adapter *pAd,
 935                                          u16 TbttNumToNextWakeUp)
 936 {
 937
 938         /* we have decided to SLEEP, so at least do it for a BEACON period. */
 939         if (TbttNumToNextWakeUp == 0)
 940                 TbttNumToNextWakeUp = 1;
 941
 942         RTMPSetTimer(&pAd->Mlme.AutoWakeupTimer, AUTO_WAKEUP_TIMEOUT);
 943         pAd->Mlme.AutoWakeupTimerRunning = TRUE;
 944
 945         AsicSendCommandToMcu(pAd, 0x30, 0xff, 0xff, 0x02);      /* send POWER-SAVE command to MCU. Timeout 40us. */
 946
 947         OPSTATUS_SET_FLAG(pAd, fOP_STATUS_DOZE);
 948
 949 }
 950
 951 #endif /* RTMP_MAC_USB // */