release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/usb/Beceem_driver/src/Common/LeakyBucket.c

   1 /*
   2 * LeakyBucket.c
   3 *
   4 *Copyright (C) 2010 Beceem Communications, Inc.
   5 *
   6 *This program is free software: you can redistribute it and/or modify
   7 *it under the terms of the GNU General Public License version 2 as
   8 *published by the Free Software Foundation.
   9 *
  10 *This program is distributed in the hope that it will be useful,but
  11 *WITHOUT ANY WARRANTY; without even the implied warranty of
  12 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13 *See the GNU General Public License for more details.
  14 *
  15 *You should have received a copy of the GNU General Public License
  16 *along with this program. If not, write to the Free Software Foundation, Inc.,
  17 *51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 *
  19 */
  20
  21
  22 /**********************************************************************
  23 *       This file contains the routines related to Leaky Bucket Algorithm.
  24 ***********************************************************************/
  25 #include<headers.h>
  26
  27 /*********************************************************************
  28 * Function    - UpdateTokenCount()
  29 *
  30 * Description - This function calculates the token count for each
  31 *                               channel and updates the same in Adapter strucuture.
  32 *
  33 * Parameters  - Adapter: Pointer to the Adapter structure.
  34 *
  35 * Returns     - None
  36 **********************************************************************/
  37
  38 VOID UpdateTokenCount(register PMINI_ADAPTER Adapter)
  39 {
  40         ULONG   liElapsedTime;
  41         INT     i = 0;
  42         ULONG   currjiffies = jiffies;
  43
  44
  45         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "=====>\n");
  46         if(NULL == Adapter)
  47         {
  48                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "Adapter found NULL!\n");
  49                 return;
  50         }
  51
  52         for(i = 0; i < NO_OF_QUEUES; i++)
  53         {
  54                 if(TRUE == Adapter->PackInfo[i].bValid &&
  55                         (1 == Adapter->PackInfo[i].ucDirection))
  56                 {
  57                         liElapsedTime = currjiffies - Adapter->localjiffies;
  58                         if(0!=liElapsedTime)
  59                         {
  60                                 Adapter->PackInfo[i].uiCurrentTokenCount += (ULONG)
  61                                         (((Adapter->PackInfo[i].uiMaxAllowedRate) * liElapsedTime)/HZ);
  62
  63                                 if((Adapter->PackInfo[i].uiCurrentTokenCount) >= Adapter->PackInfo[i].uiMaxBucketSize)
  64                                 {
  65                                         Adapter->PackInfo[i].uiCurrentTokenCount = Adapter->PackInfo[i].uiMaxBucketSize;
  66                                 }
  67                         }
  68                 }
  69         }
  70         Adapter->localjiffies = currjiffies;
  71         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "<=====\n");
  72         return;
  73
  74 }
  75
  76
  77 /*********************************************************************
  78 * Function    - IsPacketAllowedForFlow()
  79 *
  80 * Description - This function checks whether the given packet from the
  81 *                               specified queue can be allowed for transmission by
  82 *                               checking the token count.
  83 *
  84 * Parameters  - Adapter       : Pointer to the Adpater structure.
  85 *                         - iQIndex           : The queue Identifier.
  86 *                         - ulPacketLength:     Number of bytes to be transmitted.
  87 *
  88 * Returns     - The number of bytes allowed for transmission.
  89 *
  90 ***********************************************************************/
  91 static __inline ULONG GetSFTokenCount(PMINI_ADAPTER Adapter, PacketInfo *psSF)
  92 {
  93         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "IsPacketAllowedForFlow ===>");
  94         /* Validate the parameters */
  95         if(NULL == Adapter || (psSF < Adapter->PackInfo &&
  96                 (UINT)psSF > (UINT) &Adapter->PackInfo[HiPriority]))
  97         {
  98                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "IPAFF: Got wrong Parameters:Adapter: %p, QIndex: %d\n", Adapter, (psSF-Adapter->PackInfo));
  99                 return 0;
 100         }
 101
 102         if(FALSE != psSF->bValid && psSF->ucDirection)
 103         {
 104                 if(0 != psSF->uiCurrentTokenCount)
 105                 {
 106                                 return psSF->uiCurrentTokenCount;
 107                 }
 108                 else
 109                 {
 110                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "Not enough tokens in queue %d Available %u\n",
 111                                 psSF-Adapter->PackInfo, psSF->uiCurrentTokenCount);
 112                         psSF->uiPendedLast = 1;
 113                 }
 114         }
 115         else
 116         {
 117                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "IPAFF: Queue %d not valid\n", psSF-Adapter->PackInfo);
 118         }
 119         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "IsPacketAllowedForFlow <===");
 120         return 0;
 121 }
 122
 123 static __inline void RemovePacketFromQueue(PacketInfo *pPackInfo , struct sk_buff *Packet)
 124 {
 125         struct sk_buff *psQueueCurrent=NULL, *psLastQueueNode=NULL;
 126         psQueueCurrent = pPackInfo->FirstTxQueue;
 127         while(psQueueCurrent)
 128         {
 129                 if((UINT)Packet == (UINT)psQueueCurrent)
 130                 {
 131                         if((UINT)psQueueCurrent == (UINT)pPackInfo->FirstTxQueue)
 132                         {
 133                                 pPackInfo->FirstTxQueue=psQueueCurrent->next;
 134                                 if((UINT)psQueueCurrent==(UINT)pPackInfo->LastTxQueue)
 135                                         pPackInfo->LastTxQueue=NULL;
 136                         }
 137                         else
 138                         {
 139                                 psLastQueueNode->next=psQueueCurrent->next;
 140                         }
 141                         break;
 142                 }
 143                 psLastQueueNode = psQueueCurrent;
 144                 psQueueCurrent=psQueueCurrent->next;
 145         }
 146 }
 147 /**
 148 @ingroup tx_functions
 149 This function despatches packet from the specified queue.
 150 @return Zero(success) or Negative value(failure)
 151 */
 152 static __inline INT SendPacketFromQueue(PMINI_ADAPTER Adapter,/**<Logical Adapter*/
 153                                                                 PacketInfo *psSF,               /**<Queue identifier*/
 154                                                                 struct sk_buff*  Packet)        /**<Pointer to the packet to be sent*/
 155 {
 156         INT     Status=STATUS_FAILURE;
 157         UINT uiIndex =0,PktLen = 0;
 158
 159         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, SEND_QUEUE, DBG_LVL_ALL, "=====>");
 160         if(!Adapter || !Packet || !psSF)
 161         {
 162                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, SEND_QUEUE, DBG_LVL_ALL, "Got NULL Adapter or Packet");
 163                 return -EINVAL;
 164         }
 165
 166         if(psSF->liDrainCalculated==0)
 167         {
 168                 psSF->liDrainCalculated = jiffies;
 169         }
 170         ///send the packet to the fifo..
 171         PktLen = Packet->len;
 172         Status = SetupNextSend(Adapter, Packet, psSF->usVCID_Value);
 173         if(Status == 0)
 174         {
 175                 for(uiIndex = 0 ; uiIndex < MIBS_MAX_HIST_ENTRIES ; uiIndex++)
 176                 {       if((PktLen <= MIBS_PKTSIZEHIST_RANGE*(uiIndex+1)) && (PktLen > MIBS_PKTSIZEHIST_RANGE*(uiIndex)))
 177                                 Adapter->aTxPktSizeHist[uiIndex]++;
 178                 }
 179         }
 180         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, SEND_QUEUE, DBG_LVL_ALL, "<=====");
 181         return Status;
 182 }
 183
 184 /************************************************************************
 185 * Function    - CheckAndSendPacketFromIndex()
 186 *
 187 * Description - This function dequeues the data/control packet from the
 188 *                               specified queue for transmission.
 189 *
 190 * Parameters  - Adapter : Pointer to the driver control structure.
 191 *                         - iQIndex : The queue Identifier.
 192 *
 193 * Returns     - None.
 194 *
 195 ****************************************************************************/
 196 static __inline VOID CheckAndSendPacketFromIndex
 197 (PMINI_ADAPTER Adapter, PacketInfo *psSF)
 198 {
 199         struct sk_buff  *QueuePacket=NULL;
 200         char                    *pControlPacket = NULL;
 201         INT                             Status=0;
 202         int                             iPacketLen=0;
 203
 204
 205         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "%d ====>", (psSF-Adapter->PackInfo));
 206         if(((UINT)psSF != (UINT)&Adapter->PackInfo[HiPriority]) && Adapter->LinkUpStatus )//Get data packet
 207         {
 208                 if(!psSF->ucDirection )
 209                         return;
 210
 211                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "UpdateTokenCount ");
 212                 if(Adapter->IdleMode || Adapter->bPreparingForLowPowerMode)
 213                 {
 214                         //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle Mode..Hence blocking Data Packets..\n");
 215                         return;
 216                 }
 217                 // Check for Free Descriptors
 218                 if(atomic_read(&Adapter->CurrNumFreeTxDesc) <= MINIMUM_PENDING_DESCRIPTORS)
 219                 {
 220                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, " No Free Tx Descriptor(%d) is available for Data pkt..",atomic_read(&Adapter->CurrNumFreeTxDesc));
 221                         return ;
 222                 }
 223
 224 #if 0
 225                 PruneQueue(Adapter,(psSF-Adapter->PackInfo));
 226 #endif
 227                 spin_lock_bh(&psSF->SFQueueLock);
 228                 QueuePacket=psSF->FirstTxQueue;
 229
 230                 if(QueuePacket)
 231                 {
 232                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Dequeuing Data Packet");
 233
 234                         if(psSF->bEthCSSupport)
 235                                 iPacketLen = QueuePacket->len;
 236                         else
 237                                 iPacketLen = QueuePacket->len-ETH_HLEN;
 238
 239                         iPacketLen<<=3;
 240                         if(iPacketLen <= GetSFTokenCount(Adapter, psSF))
 241                         {
 242                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Allowed bytes %d",
 243                                         (iPacketLen >> 3));
 244
 245                                 DEQUEUEPACKET(psSF->FirstTxQueue,psSF->LastTxQueue);
 246                                 psSF->uiCurrentBytesOnHost -= (QueuePacket->len);
 247                                 psSF->uiCurrentPacketsOnHost--;
 248                                 atomic_dec(&Adapter->TotalPacketCount);
 249                                 spin_unlock_bh(&psSF->SFQueueLock);
 250
 251                                 Status = SendPacketFromQueue(Adapter, psSF, QueuePacket);
 252                                 psSF->uiPendedLast = FALSE;
 253                         }
 254                         else
 255                         {
 256                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "For Queue: %d\n", psSF-Adapter->PackInfo);
 257                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "\nAvailable Tokens = %d required = %d\n",
 258                                         psSF->uiCurrentTokenCount, iPacketLen);
 259                                 //this part indicates that becuase of non-availability of the tokens
 260                                 //pkt has not been send out hence setting the pending flag indicating the host to send it out
 261                                 //first next iteration  .
 262                                 psSF->uiPendedLast = TRUE;
 263                                 spin_unlock_bh(&psSF->SFQueueLock);
 264                         }
 265                 }
 266                 else
 267                 {
 268                         spin_unlock_bh(&psSF->SFQueueLock);
 269                 }
 270         }
 271         else if((UINT)psSF == (UINT)&Adapter->PackInfo[HiPriority])
 272         {
 273                 spin_lock_bh(&psSF->SFQueueLock);
 274                 if((atomic_read(&Adapter->CurrNumFreeTxDesc) > 0 ) &&
 275                         (atomic_read(&Adapter->index_rd_txcntrlpkt) !=
 276                          atomic_read(&Adapter->index_wr_txcntrlpkt))
 277                         )
 278                 {
 279                         pControlPacket = Adapter->txctlpacket
 280                         [(atomic_read(&Adapter->index_rd_txcntrlpkt)%MAX_CNTRL_PKTS)];
 281                         if(pControlPacket)
 282                         {
 283                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Sending Control packet");
 284                                 Status = SendControlPacket(Adapter, pControlPacket);
 285                                 if(STATUS_SUCCESS==Status)
 286                                 {
 287
 288                                         psSF->NumOfPacketsSent++;
 289                                         psSF->uiSentBytes+=((PLEADER)pControlPacket)->PLength;
 290                                         psSF->uiSentPackets++;
 291                                         atomic_dec(&Adapter->TotalPacketCount);
 292                                         psSF->uiCurrentBytesOnHost -= ((PLEADER)pControlPacket)->PLength;
 293                                         psSF->uiCurrentPacketsOnHost--;
 294                                         atomic_inc(&Adapter->index_rd_txcntrlpkt);
 295
 296                                 }
 297                                 else
 298                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "SendControlPacket Failed\n");
 299                         }
 300                         else
 301                         {
 302                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, " Control Pkt is not available, Indexing is wrong....");
 303                         }
 304                 }
 305
 306                 spin_unlock_bh(&psSF->SFQueueLock);
 307         }
 308
 309         if(Status != STATUS_SUCCESS)    //Tx of data packet to device Failed
 310         {
 311                 if(Adapter->bcm_jiffies == 0)
 312                         Adapter->bcm_jiffies = jiffies;
 313         }
 314         else
 315         {
 316                 Adapter->bcm_jiffies = 0;
 317         }
 318         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "<=====");
 319 }
 320
 321
 322 /*******************************************************************
 323 * Function    - transmit_packets()
 324 *
 325 * Description - This function transmits the packets from different
 326 *                               queues, if free descriptors are available on target.
 327 *
 328 * Parameters  - Adapter:  Pointer to the Adapter structure.
 329 *
 330 * Returns     - None.
 331 ********************************************************************/
 332 VOID transmit_packets(PMINI_ADAPTER Adapter)
 333 {
 334         UINT    uiPrevTotalCount = 0;
 335         int iIndex = 0;
 336
 337         BOOLEAN exit_flag = TRUE ;
 338
 339         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "=====>");
 340
 341         if(NULL == Adapter)
 342         {
 343                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX,TX_PACKETS, DBG_LVL_ALL, "Got NULL Adapter");
 344                 return;
 345         }
 346         if(Adapter->device_removed == TRUE)
 347         {
 348                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Device removed");
 349                 return;
 350         }
 351
 352     BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "\nUpdateTokenCount ====>\n");
 353
 354         UpdateTokenCount(Adapter);
 355
 356     BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "\nPruneQueueAllSF ====>\n");
 357
 358         PruneQueueAllSF(Adapter);
 359
 360         uiPrevTotalCount = atomic_read(&Adapter->TotalPacketCount);
 361
 362         for(iIndex=HiPriority;iIndex>=0;iIndex--)
 363         {
 364                 if(     !uiPrevTotalCount || (TRUE == Adapter->device_removed))
 365                                 break;
 366
 367                 if(Adapter->PackInfo[iIndex].bValid &&
 368                         Adapter->PackInfo[iIndex].uiPendedLast &&
 369                         Adapter->PackInfo[iIndex].uiCurrentBytesOnHost &&
 370                         ((iIndex==HiPriority) || (atomic_read(&Adapter->PackInfo[iIndex].uiPerSFTxResourceCount)>0))
 371                         )
 372                 {
 373                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Calling CheckAndSendPacketFromIndex..");
 374                         CheckAndSendPacketFromIndex(Adapter, &Adapter->PackInfo[iIndex]);
 375                         uiPrevTotalCount--;
 376                 }
 377         }
 378
 379         while(uiPrevTotalCount > 0 && !Adapter->device_removed)
 380         {
 381                 exit_flag = TRUE ;
 382                         //second iteration to parse non-pending queues
 383                 for(iIndex=HiPriority;iIndex>=0;iIndex--)
 384                 {
 385                         if( !uiPrevTotalCount || (TRUE == Adapter->device_removed))
 386                                         break;
 387
 388                         if(Adapter->PackInfo[iIndex].bValid &&
 389                                 Adapter->PackInfo[iIndex].uiCurrentBytesOnHost &&
 390                                 !Adapter->PackInfo[iIndex].uiPendedLast &&
 391                 ((iIndex==HiPriority) || (atomic_read(&Adapter->PackInfo[iIndex].uiPerSFTxResourceCount)>0))
 392                                 )
 393                         {
 394                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Calling CheckAndSendPacketFromIndex..");
 395                                 CheckAndSendPacketFromIndex(Adapter, &Adapter->PackInfo[iIndex]);
 396                                 uiPrevTotalCount--;
 397                                 exit_flag = FALSE;
 398                         }
 399                 }
 400
 401                 if(Adapter->IdleMode || Adapter->bPreparingForLowPowerMode)
 402                 {
 403                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "In Idle Mode\n");
 404                         break;
 405                 }
 406                 if(exit_flag == TRUE )
 407                     break ;
 408         }/* end of inner while loop */
 409         if(Adapter->bcm_jiffies == 0 &&
 410                 atomic_read(&Adapter->TotalPacketCount) != 0 &&
 411                 uiPrevTotalCount == atomic_read(&Adapter->TotalPacketCount))
 412         {
 413                 Adapter->bcm_jiffies = jiffies;
 414         }
 415         update_per_cid_rx  (Adapter);
 416         Adapter->txtransmit_running = 0;
 417         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "<======");
 418 }