drivers/staging/bcm/CmHost.c

   1 /************************************************************
   2 *                       CMHOST.C
   3 *       This file contains the routines for handling Connnection
   4 *       Management.
   5 ************************************************************/
   6
   7 //#define CONN_MSG
   8 #include "headers.h"
   9
  10 typedef enum _E_CLASSIFIER_ACTION
  11 {
  12         eInvalidClassifierAction,
  13         eAddClassifier,
  14         eReplaceClassifier,
  15         eDeleteClassifier
  16 }E_CLASSIFIER_ACTION;
  17
  18
  19 /************************************************************
  20 * Function        -     SearchSfid
  21 *
  22 * Description - This routinue would search QOS queues having
  23 *                               specified SFID as input parameter.
  24 *
  25 * Parameters  - Adapter: Pointer to the Adapter structure
  26 *                               uiSfid : Given SFID for matching
  27 *
  28 * Returns         - Queue index for this SFID(If matched)
  29                                 Else Invalid Queue Index(If Not matched)
  30 ************************************************************/
  31 INT SearchSfid(PMINI_ADAPTER Adapter,UINT uiSfid)
  32 {
  33         INT     iIndex=0;
  34         for(iIndex=(NO_OF_QUEUES-1); iIndex>=0; iIndex--)
  35                 if(Adapter->PackInfo[iIndex].ulSFID==uiSfid)
  36                         return iIndex;
  37         return NO_OF_QUEUES+1;
  38 }
  39
  40 /***************************************************************
  41 * Function        -     SearchFreeSfid
  42 *
  43 * Description - This routinue would search Free available SFID.
  44 *
  45 * Parameter   - Adapter: Pointer to the Adapter structure
  46 *
  47 * Returns         - Queue index for the free SFID
  48 *                               Else returns Invalid Index.
  49 ****************************************************************/
  50 static INT SearchFreeSfid(PMINI_ADAPTER Adapter)
  51 {
  52         UINT    uiIndex=0;
  53
  54         for(uiIndex=0; uiIndex < (NO_OF_QUEUES-1); uiIndex++)
  55                 if(Adapter->PackInfo[uiIndex].ulSFID==0)
  56                         return uiIndex;
  57         return NO_OF_QUEUES+1;
  58 }
  59
  60 int SearchVcid(PMINI_ADAPTER Adapter,unsigned short usVcid)
  61 {
  62         int iIndex=0;
  63
  64         for(iIndex=(NO_OF_QUEUES-1);iIndex>=0;iIndex--)
  65                 if(Adapter->PackInfo[iIndex].usVCID_Value == usVcid)
  66                         return iIndex;
  67         return NO_OF_QUEUES+1;
  68
  69 }
  70
  71
  72 /*
  73 Function:                               SearchClsid
  74 Description:                    This routinue would search Classifier  having specified ClassifierID as input parameter
  75 Input parameters:               PMINI_ADAPTER Adapter - Adapter Context
  76                         unsigned int uiSfid   - The SF in which the classifier is to searched
  77                                                 B_UINT16  uiClassifierID - The classifier ID to be searched
  78 Return:                                 int :Classifier table index of matching entry
  79 */
  80
  81 static int SearchClsid(PMINI_ADAPTER Adapter,ULONG ulSFID,B_UINT16  uiClassifierID)
  82 {
  83         unsigned int uiClassifierIndex = 0;
  84         for(uiClassifierIndex=0;uiClassifierIndex<MAX_CLASSIFIERS;uiClassifierIndex++)
  85         {
  86                 if((Adapter->astClassifierTable[uiClassifierIndex].bUsed) &&
  87                         (Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex == uiClassifierID)&&
  88                         (Adapter->astClassifierTable[uiClassifierIndex].ulSFID == ulSFID))
  89                         return uiClassifierIndex;
  90         }
  91         return MAX_CLASSIFIERS+1;
  92 }
  93
  94 /**
  95 @ingroup ctrl_pkt_functions
  96 This routinue would search Free available Classifier entry in classifier table.
  97 @return free Classifier Entry index in classifier table for specified SF
  98 */
  99 static int SearchFreeClsid(PMINI_ADAPTER Adapter /**Adapter Context*/
 100                                                 )
 101 {
 102         unsigned int uiClassifierIndex = 0;
 103         for(uiClassifierIndex=0;uiClassifierIndex<MAX_CLASSIFIERS;uiClassifierIndex++)
 104         {
 105                 if(!Adapter->astClassifierTable[uiClassifierIndex].bUsed)
 106                         return uiClassifierIndex;
 107         }
 108         return MAX_CLASSIFIERS+1;
 109 }
 110
 111 VOID deleteSFBySfid(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex)
 112 {
 113         //deleting all the packet held in the SF
 114         flush_queue(Adapter,uiSearchRuleIndex);
 115
 116         //Deleting the all classifiers for this SF
 117         DeleteAllClassifiersForSF(Adapter,uiSearchRuleIndex);
 118
 119         //Resetting only MIBS related entries in the SF
 120         memset((PVOID)&Adapter->PackInfo[uiSearchRuleIndex], 0, sizeof(S_MIBS_SERVICEFLOW_TABLE));
 121 }
 122
 123 static inline VOID
 124 CopyIpAddrToClassifier(S_CLASSIFIER_RULE *pstClassifierEntry ,
 125                         B_UINT8 u8IpAddressLen , B_UINT8 *pu8IpAddressMaskSrc ,
 126                         BOOLEAN bIpVersion6 , E_IPADDR_CONTEXT eIpAddrContext)
 127 {
 128         UINT    ucLoopIndex=0;
 129         UINT    nSizeOfIPAddressInBytes = IP_LENGTH_OF_ADDRESS;
 130         UCHAR   *ptrClassifierIpAddress = NULL;
 131         UCHAR   *ptrClassifierIpMask = NULL;
 132     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 133
 134         if(bIpVersion6)
 135         {
 136                 nSizeOfIPAddressInBytes = IPV6_ADDRESS_SIZEINBYTES;
 137         }
 138         //Destination Ip Address
 139         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Ip Address Range Length:0x%X ",
 140                                 u8IpAddressLen);
 141         if((bIpVersion6?(IPV6_ADDRESS_SIZEINBYTES * MAX_IP_RANGE_LENGTH * 2):
 142                         (TOTAL_MASKED_ADDRESS_IN_BYTES)) >= u8IpAddressLen)
 143         {
 144                 /*
 145                 //checking both the mask and address togethor in Classification.
 146                 //So length will be : TotalLengthInBytes/nSizeOfIPAddressInBytes * 2
 147                 //(nSizeOfIPAddressInBytes for address and nSizeOfIPAddressInBytes for mask)
 148                 */
 149                 if(eIpAddrContext == eDestIpAddress)
 150                 {
 151                         pstClassifierEntry->ucIPDestinationAddressLength =
 152                                         u8IpAddressLen/(nSizeOfIPAddressInBytes * 2);
 153                         if(bIpVersion6)
 154                         {
 155                                 ptrClassifierIpAddress =
 156                                         pstClassifierEntry->stDestIpAddress.ucIpv6Address;
 157                                 ptrClassifierIpMask =
 158                                         pstClassifierEntry->stDestIpAddress.ucIpv6Mask;
 159                         }
 160                         else
 161                         {
 162                                 ptrClassifierIpAddress =
 163                                         pstClassifierEntry->stDestIpAddress.ucIpv4Address;
 164                                 ptrClassifierIpMask =
 165                                         pstClassifierEntry->stDestIpAddress.ucIpv4Mask;
 166                         }
 167                 }
 168                 else if(eIpAddrContext == eSrcIpAddress)
 169                 {
 170                         pstClassifierEntry->ucIPSourceAddressLength =
 171                                         u8IpAddressLen/(nSizeOfIPAddressInBytes * 2);
 172                         if(bIpVersion6)
 173                         {
 174                                 ptrClassifierIpAddress =
 175                                         pstClassifierEntry->stSrcIpAddress.ucIpv6Address;
 176                                 ptrClassifierIpMask =
 177                                         pstClassifierEntry->stSrcIpAddress.ucIpv6Mask;
 178                         }
 179                         else
 180                         {
 181                                 ptrClassifierIpAddress =
 182                                         pstClassifierEntry->stSrcIpAddress.ucIpv4Address;
 183                                 ptrClassifierIpMask =
 184                                         pstClassifierEntry->stSrcIpAddress.ucIpv4Mask;
 185                         }
 186                 }
 187                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Address Length:0x%X \n",
 188                                 pstClassifierEntry->ucIPDestinationAddressLength);
 189                 while((u8IpAddressLen>= nSizeOfIPAddressInBytes) &&
 190                                 (ucLoopIndex < MAX_IP_RANGE_LENGTH))
 191                 {
 192                         memcpy(ptrClassifierIpAddress +
 193                                 (ucLoopIndex * nSizeOfIPAddressInBytes),
 194                                 (pu8IpAddressMaskSrc+(ucLoopIndex*nSizeOfIPAddressInBytes*2)),
 195                                 nSizeOfIPAddressInBytes);
 196                         if(!bIpVersion6)
 197                         {
 198                                 if(eIpAddrContext == eSrcIpAddress)
 199                                 {
 200                                         pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex]=
 201                                                 ntohl(pstClassifierEntry->stSrcIpAddress.
 202                                                                 ulIpv4Addr[ucLoopIndex]);
 203                                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Src Ip Address:0x%luX ",pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[ucLoopIndex]);
 204                                 }
 205                                 else if(eIpAddrContext == eDestIpAddress)
 206                                 {
 207                                         pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex]=                                            ntohl(pstClassifierEntry->stDestIpAddress.
 208                                                                 ulIpv4Addr[ucLoopIndex]);
 209                                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Dest Ip Address:0x%luX ",pstClassifierEntry->stDestIpAddress.ulIpv4Addr[ucLoopIndex]);
 210                                 }
 211                         }
 212                         u8IpAddressLen-=nSizeOfIPAddressInBytes;
 213                         if(u8IpAddressLen >= nSizeOfIPAddressInBytes)
 214                         {
 215                                 memcpy(ptrClassifierIpMask +
 216                                         (ucLoopIndex * nSizeOfIPAddressInBytes),
 217                                         (pu8IpAddressMaskSrc+nSizeOfIPAddressInBytes +
 218                                         (ucLoopIndex*nSizeOfIPAddressInBytes*2)),
 219                                         nSizeOfIPAddressInBytes);
 220                                 if(!bIpVersion6)
 221                                 {
 222                                         if(eIpAddrContext == eSrcIpAddress)
 223                                         {
 224                                                 pstClassifierEntry->stSrcIpAddress.
 225                                                                                         ulIpv4Mask[ucLoopIndex]=
 226                                                                 ntohl(pstClassifierEntry->stSrcIpAddress.
 227                                                                                         ulIpv4Mask[ucLoopIndex]);
 228                                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Src Ip Mask Address:0x%luX ",pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[ucLoopIndex]);
 229                                         }
 230                                         else if(eIpAddrContext == eDestIpAddress)
 231                                         {
 232                                                 pstClassifierEntry->stDestIpAddress.
 233                                                                                 ulIpv4Mask[ucLoopIndex] =
 234                                                                         ntohl(pstClassifierEntry->stDestIpAddress.
 235                                                                                         ulIpv4Mask[ucLoopIndex]);
 236                                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Dest Ip Mask Address:0x%luX ",pstClassifierEntry->stDestIpAddress.ulIpv4Mask[ucLoopIndex]);
 237                                         }
 238                                 }
 239                                 u8IpAddressLen-=nSizeOfIPAddressInBytes;
 240                         }
 241                         if(0==u8IpAddressLen)
 242                         {
 243                                 pstClassifierEntry->bDestIpValid=TRUE;
 244                         }
 245                         ucLoopIndex++;
 246                 }
 247                 if(bIpVersion6)
 248                 {
 249                         //Restore EndianNess of Struct
 250                         for(ucLoopIndex =0 ; ucLoopIndex < MAX_IP_RANGE_LENGTH * 4 ;
 251                                         ucLoopIndex++)
 252                         {
 253                                 if(eIpAddrContext == eSrcIpAddress)
 254                                 {
 255                                         pstClassifierEntry->stSrcIpAddress.ulIpv6Addr[ucLoopIndex]=
 256                                                         ntohl(pstClassifierEntry->stSrcIpAddress.
 257                                                         ulIpv6Addr[ucLoopIndex]);
 258                                         pstClassifierEntry->stSrcIpAddress.ulIpv6Mask[ucLoopIndex]=                                                     ntohl(pstClassifierEntry->stSrcIpAddress.
 259                                                         ulIpv6Mask[ucLoopIndex]);
 260                                 }
 261                                 else if(eIpAddrContext == eDestIpAddress)
 262                                 {
 263                                         pstClassifierEntry->stDestIpAddress.ulIpv6Addr[ucLoopIndex]=                                                    ntohl(pstClassifierEntry->stDestIpAddress.
 264                                                         ulIpv6Addr[ucLoopIndex]);
 265                                         pstClassifierEntry->stDestIpAddress.ulIpv6Mask[ucLoopIndex]=                                                    ntohl(pstClassifierEntry->stDestIpAddress.
 266                                                         ulIpv6Mask[ucLoopIndex]);
 267                                 }
 268                         }
 269                 }
 270         }
 271 }
 272
 273
 274 void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter,B_UINT16 TID,BOOLEAN bFreeAll)
 275 {
 276     ULONG ulIndex;
 277         for(ulIndex=0; ulIndex < Adapter->ulTotalTargetBuffersAvailable; ulIndex++)
 278         {
 279                 if(Adapter->astTargetDsxBuffer[ulIndex].valid)
 280                         continue;
 281         if ((bFreeAll) || (Adapter->astTargetDsxBuffer[ulIndex].tid == TID)){
 282                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "ClearTargetDSXBuffer: found tid %d buffer cleared %lx\n",
 283                                 TID, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer);
 284                         Adapter->astTargetDsxBuffer[ulIndex].valid=1;
 285                         Adapter->astTargetDsxBuffer[ulIndex].tid=0;
 286                         Adapter->ulFreeTargetBufferCnt++;
 287         }
 288         }
 289 }
 290
 291 /**
 292 @ingroup ctrl_pkt_functions
 293 copy classifier rule into the specified SF index
 294 */
 295 static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter,stConvergenceSLTypes  *psfCSType,UINT uiSearchRuleIndex,UINT nClassifierIndex)
 296 {
 297         S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
 298         //VOID *pvPhsContext = NULL;
 299         UINT    ucLoopIndex=0;
 300         //UCHAR   ucProtocolLength=0;
 301         //ULONG   ulPhsStatus;
 302
 303
 304         if(Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value == 0 ||
 305                 nClassifierIndex > (MAX_CLASSIFIERS-1))
 306                 return;
 307
 308
 309         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Storing Classifier Rule Index : %X",ntohs(psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex));
 310
 311         if(nClassifierIndex > MAX_CLASSIFIERS-1)
 312                 return;
 313
 314         pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
 315         if(pstClassifierEntry)
 316         {
 317                 //Store if Ipv6
 318                 pstClassifierEntry->bIpv6Protocol =
 319                 (Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6)?TRUE:FALSE;
 320
 321                 //Destinaiton Port
 322                 pstClassifierEntry->ucDestPortRangeLength=psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength/4;
 323                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Destination Port Range Length:0x%X ",pstClassifierEntry->ucDestPortRangeLength);
 324                 if(     MAX_PORT_RANGE >= psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength)
 325                 {
 326                         for(ucLoopIndex=0;ucLoopIndex<(pstClassifierEntry->ucDestPortRangeLength);ucLoopIndex++)
 327                         {
 328                                 pstClassifierEntry->usDestPortRangeLo[ucLoopIndex] =
 329                                         *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+ucLoopIndex));
 330                                 pstClassifierEntry->usDestPortRangeHi[ucLoopIndex] =
 331                                         *((PUSHORT)(psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange+2+ucLoopIndex));
 332                                 pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]=ntohs(pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]);
 333                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Destination Port Range Lo:0x%X ",pstClassifierEntry->usDestPortRangeLo[ucLoopIndex]);
 334                                 pstClassifierEntry->usDestPortRangeHi[ucLoopIndex]=ntohs(pstClassifierEntry->usDestPortRangeHi[ucLoopIndex]);
 335                         }
 336                 }
 337                 else
 338                 {
 339                         pstClassifierEntry->ucDestPortRangeLength=0;
 340                 }
 341                 //Source Port
 342                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Source Port Range Length:0x%X ",psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
 343                 if(MAX_PORT_RANGE >=
 344                 psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength)
 345                 {
 346                         pstClassifierEntry->ucSrcPortRangeLength =
 347                                 psfCSType->cCPacketClassificationRule.
 348                                                 u8ProtocolSourcePortRangeLength/4;
 349                         for(ucLoopIndex = 0; ucLoopIndex <
 350                                 (pstClassifierEntry->ucSrcPortRangeLength); ucLoopIndex++)
 351                         {
 352                                 pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex] =
 353                                                 *((PUSHORT)(psfCSType->cCPacketClassificationRule.
 354                                                         u8ProtocolSourcePortRange+ucLoopIndex));
 355                                 pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex] =
 356                                                 *((PUSHORT)(psfCSType->cCPacketClassificationRule.
 357                                                         u8ProtocolSourcePortRange+2+ucLoopIndex));
 358                                 pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex] =
 359                                         ntohs(pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex]);
 360                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Source Port Range Lo:0x%X ",pstClassifierEntry->usSrcPortRangeLo[ucLoopIndex]);
 361                                 pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex]=ntohs(pstClassifierEntry->usSrcPortRangeHi[ucLoopIndex]);
 362                         }
 363                 }
 364                 //Destination Ip Address and Mask
 365                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Ip Destination Parameters : ");
 366
 367                 CopyIpAddrToClassifier(pstClassifierEntry,
 368                    psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength,
 369                    psfCSType->cCPacketClassificationRule.u8IPDestinationAddress,
 370                    (Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6)?
 371                         TRUE:FALSE, eDestIpAddress);
 372
 373                 //Source Ip Address and Mask
 374                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Ip Source Parameters : ");
 375
 376                 CopyIpAddrToClassifier(pstClassifierEntry,
 377                 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength,
 378                 psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress,
 379                 (Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6)?TRUE:FALSE,
 380                 eSrcIpAddress);
 381
 382                 //TOS
 383                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"TOS Length:0x%X ",psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
 384                 if(3 == psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength)
 385                 {
 386                         pstClassifierEntry->ucIPTypeOfServiceLength =
 387                                 psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength;
 388                         pstClassifierEntry->ucTosLow =
 389                                 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0];
 390                         pstClassifierEntry->ucTosHigh =
 391                                 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1];
 392                         pstClassifierEntry->ucTosMask =
 393                                 psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2];
 394                         pstClassifierEntry->bTOSValid = TRUE;
 395                 }
 396                 if(psfCSType->cCPacketClassificationRule.u8Protocol == 0)
 397                 {
 398                         //we didnt get protocol field filled in by the BS
 399                         pstClassifierEntry->ucProtocolLength=0;
 400                 }
 401                 else
 402                 {
 403                         pstClassifierEntry->ucProtocolLength=1;// 1 valid protocol
 404                 }
 405
 406                 pstClassifierEntry->ucProtocol[0] =
 407                         psfCSType->cCPacketClassificationRule.u8Protocol;
 408
 409                 pstClassifierEntry->u8ClassifierRulePriority =
 410                         psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority;
 411
 412                 //store the classifier rule ID and set this classifier entry as valid
 413                 pstClassifierEntry->ucDirection =
 414                         Adapter->PackInfo[uiSearchRuleIndex].ucDirection;
 415                 pstClassifierEntry->uiClassifierRuleIndex = ntohs(psfCSType->
 416                                 cCPacketClassificationRule.u16PacketClassificationRuleIndex);
 417                 pstClassifierEntry->usVCID_Value =
 418                         Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
 419                 pstClassifierEntry->ulSFID =
 420                         Adapter->PackInfo[uiSearchRuleIndex].ulSFID;
 421                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Search Index %d Dir: %d, Index: %d, Vcid: %d\n",
 422                         uiSearchRuleIndex, pstClassifierEntry->ucDirection,
 423                         pstClassifierEntry->uiClassifierRuleIndex,
 424                         pstClassifierEntry->usVCID_Value);
 425
 426                 if(psfCSType->cCPacketClassificationRule.u8AssociatedPHSI)
 427                 {
 428                         pstClassifierEntry->u8AssociatedPHSI = psfCSType->cCPacketClassificationRule.u8AssociatedPHSI;
 429                 }
 430
 431                 //Copy ETH CS Parameters
 432                 pstClassifierEntry->ucEthCSSrcMACLen = (psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddressLength);
 433                 memcpy(pstClassifierEntry->au8EThCSSrcMAC,psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress,MAC_ADDRESS_SIZE);
 434                 memcpy(pstClassifierEntry->au8EThCSSrcMACMask,psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress+MAC_ADDRESS_SIZE,MAC_ADDRESS_SIZE);
 435                 pstClassifierEntry->ucEthCSDestMACLen = (psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
 436                 memcpy(pstClassifierEntry->au8EThCSDestMAC,psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress,MAC_ADDRESS_SIZE);
 437                 memcpy(pstClassifierEntry->au8EThCSDestMACMask,psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress+MAC_ADDRESS_SIZE,MAC_ADDRESS_SIZE);
 438                 pstClassifierEntry->ucEtherTypeLen = (psfCSType->cCPacketClassificationRule.u8EthertypeLength);
 439                 memcpy(pstClassifierEntry->au8EthCSEtherType,psfCSType->cCPacketClassificationRule.u8Ethertype,NUM_ETHERTYPE_BYTES);
 440                 memcpy(pstClassifierEntry->usUserPriority, &psfCSType->cCPacketClassificationRule.u16UserPriority, 2);
 441                 pstClassifierEntry->usVLANID = ntohs(psfCSType->cCPacketClassificationRule.u16VLANID);
 442                 pstClassifierEntry->usValidityBitMap = ntohs(psfCSType->cCPacketClassificationRule.u16ValidityBitMap);
 443
 444                 pstClassifierEntry->bUsed = TRUE;
 445         }
 446 }
 447
 448
 449 /**
 450 @ingroup ctrl_pkt_functions
 451 */
 452 static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex,UINT nClassifierIndex)
 453 {
 454         S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
 455         B_UINT16  u16PacketClassificationRuleIndex;
 456         USHORT    usVCID;
 457         //VOID *pvPhsContext = NULL;
 458         //ULONG ulPhsStatus;
 459
 460         usVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
 461
 462         if(nClassifierIndex > MAX_CLASSIFIERS-1)
 463                 return;
 464
 465         if(usVCID == 0)
 466                 return;
 467
 468         u16PacketClassificationRuleIndex = Adapter->astClassifierTable[nClassifierIndex].uiClassifierRuleIndex;
 469
 470
 471         pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
 472         if(pstClassifierEntry)
 473         {
 474                 pstClassifierEntry->bUsed = FALSE;
 475                 pstClassifierEntry->uiClassifierRuleIndex = 0;
 476                 memset(pstClassifierEntry,0,sizeof(S_CLASSIFIER_RULE));
 477
 478                 //Delete the PHS Rule for this classifier
 479                 PhsDeleteClassifierRule(
 480                                 &Adapter->stBCMPhsContext,
 481                                 usVCID,
 482                                 u16PacketClassificationRuleIndex);
 483         }
 484 }
 485
 486 /**
 487 @ingroup ctrl_pkt_functions
 488 */
 489 VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex)
 490 {
 491         S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
 492         UINT nClassifierIndex;
 493         //B_UINT16  u16PacketClassificationRuleIndex;
 494         USHORT    ulVCID;
 495         //VOID    *pvPhsContext = NULL;
 496         //ULONG    ulPhsStatus;
 497
 498         ulVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
 499
 500         if(ulVCID == 0)
 501                 return;
 502
 503
 504         for(nClassifierIndex =0 ; nClassifierIndex < MAX_CLASSIFIERS ; nClassifierIndex++)
 505         {
 506                 if(Adapter->astClassifierTable[nClassifierIndex].usVCID_Value == ulVCID)
 507                 {
 508                         pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
 509                         if(pstClassifierEntry->bUsed)
 510                         {
 511                                 DeleteClassifierRuleFromSF(Adapter,uiSearchRuleIndex,nClassifierIndex);
 512                         }
 513                 }
 514         }
 515
 516         //Delete All Phs Rules Associated with this SF
 517         PhsDeleteSFRules(
 518                         &Adapter->stBCMPhsContext,
 519                         ulVCID);
 520
 521 }
 522
 523
 524 /**
 525 This routinue  copies the Connection Management
 526 related data into the Adapter structure.
 527 @ingroup ctrl_pkt_functions
 528 */
 529
 530 static VOID CopyToAdapter( register PMINI_ADAPTER Adapter,              /**<Pointer to the Adapter structure*/
 531                                         register pstServiceFlowParamSI psfLocalSet,     /**<Pointer to the ServiceFlowParamSI structure*/
 532                                         register UINT uiSearchRuleIndex,                        /**<Index of Queue, to which this data belongs*/
 533                                         register UCHAR ucDsxType,
 534                                         stLocalSFAddIndicationAlt *pstAddIndication)
 535 {
 536         //UCHAR   ucProtocolLength=0;
 537         ULONG   ulSFID;
 538         UINT    nClassifierIndex = 0;
 539         E_CLASSIFIER_ACTION eClassifierAction = eInvalidClassifierAction;
 540         B_UINT16  u16PacketClassificationRuleIndex=0;
 541         UINT     nIndex=0;
 542         stConvergenceSLTypes *psfCSType = NULL;
 543         S_PHS_RULE sPhsRule;
 544         USHORT uVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;
 545         UINT UGIValue = 0;
 546
 547
 548         Adapter->PackInfo[uiSearchRuleIndex].bValid=TRUE;
 549         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Search Rule Index = %d\n", uiSearchRuleIndex);
 550         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"%s: SFID= %x ",__FUNCTION__, ntohl(psfLocalSet->u32SFID));
 551         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Updating Queue %d",uiSearchRuleIndex);
 552
 553         ulSFID = ntohl(psfLocalSet->u32SFID);
 554         //Store IP Version used
 555         //Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF
 556
 557         Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = 0;
 558         Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = 0;
 559
 560         /*Enable IP/ETh CS Support As Required*/
 561         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"CopyToAdapter : u8CSSpecification : %X\n",psfLocalSet->u8CSSpecification);
 562         switch(psfLocalSet->u8CSSpecification)
 563         {
 564                 case eCSPacketIPV4:
 565                 {
 566                         Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV4_CS;
 567                         break;
 568                 }
 569                 case eCSPacketIPV6:
 570                 {
 571                         Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV6_CS;
 572                         break;
 573                 }
 574
 575                 case eCS802_3PacketEthernet:
 576                 case eCS802_1QPacketVLAN:
 577                 {
 578                         Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = ETH_CS_802_3;
 579                         break;
 580                 }
 581
 582                 case eCSPacketIPV4Over802_1QVLAN:
 583                 case eCSPacketIPV4Over802_3Ethernet:
 584                 {
 585                         Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV4_CS;
 586                         Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = ETH_CS_802_3;
 587                         break;
 588                 }
 589
 590                 case eCSPacketIPV6Over802_1QVLAN:
 591                 case eCSPacketIPV6Over802_3Ethernet:
 592                 {
 593                         Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV6_CS;
 594                         Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = ETH_CS_802_3;
 595                         break;
 596                 }
 597
 598                 default:
 599                 {
 600             BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error in value of CS Classification.. setting default to IP CS\n");
 601                         Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport = IPV4_CS;
 602                         break;
 603                 }
 604         }
 605
 606     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"CopyToAdapter : Queue No : %X ETH CS Support :  %X  , IP CS Support : %X   \n",
 607                 uiSearchRuleIndex,
 608                 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport,
 609                 Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport);
 610
 611         //Store IP Version used
 612         //Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF
 613         if(Adapter->PackInfo[uiSearchRuleIndex].bIPCSSupport == IPV6_CS)
 614         {
 615                 Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion = IPV6;
 616         }
 617         else
 618         {
 619                 Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion = IPV4;
 620         }
 621
 622         /* To ensure that the ETH CS code doesn't gets executed if the BS doesn't supports ETH CS */
 623         if(!Adapter->bETHCSEnabled)
 624                 Adapter->PackInfo[uiSearchRuleIndex].bEthCSSupport = 0;
 625
 626         if(psfLocalSet->u8ServiceClassNameLength > 0 &&
 627                         psfLocalSet->u8ServiceClassNameLength < 32)
 628         {
 629                 memcpy(Adapter->PackInfo[uiSearchRuleIndex].ucServiceClassName,
 630                         psfLocalSet->u8ServiceClassName,
 631                         psfLocalSet->u8ServiceClassNameLength);
 632         }
 633         Adapter->PackInfo[uiSearchRuleIndex].u8QueueType =
 634                         psfLocalSet->u8ServiceFlowSchedulingType;
 635
 636         if(Adapter->PackInfo[uiSearchRuleIndex].u8QueueType==BE &&
 637                         Adapter->PackInfo[uiSearchRuleIndex].ucDirection)
 638         {
 639                 Adapter->usBestEffortQueueIndex=uiSearchRuleIndex;
 640         }
 641
 642         Adapter->PackInfo[uiSearchRuleIndex].ulSFID = ntohl(psfLocalSet->u32SFID);
 643
 644         Adapter->PackInfo[uiSearchRuleIndex].u8TrafficPriority = psfLocalSet->u8TrafficPriority;
 645
 646         //copy all the classifier in the Service Flow param  structure
 647         for(nIndex=0; nIndex<psfLocalSet->u8TotalClassifiers; nIndex++)
 648         {
 649                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Classifier index =%d",nIndex);
 650                 psfCSType =  &psfLocalSet->cConvergenceSLTypes[nIndex];
 651                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Classifier index =%d",nIndex);
 652
 653                 if(psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority)
 654                 {
 655                         Adapter->PackInfo[uiSearchRuleIndex].bClassifierPriority=TRUE;
 656                 }
 657
 658                 if(psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority)
 659                 {
 660                         Adapter->PackInfo[uiSearchRuleIndex].bClassifierPriority=TRUE;
 661                 }
 662
 663
 664                 if(ucDsxType== DSA_ACK)
 665                 {
 666                         eClassifierAction = eAddClassifier;
 667                 }
 668                 else if(ucDsxType == DSC_ACK)
 669                 {
 670                         switch(psfCSType->u8ClassfierDSCAction)
 671                         {
 672                         case 0://DSC Add Classifier
 673                         {
 674                                 eClassifierAction = eAddClassifier;
 675                         }
 676                         break;
 677                         case 1://DSC Replace Classifier
 678                         {
 679                                 eClassifierAction = eReplaceClassifier;
 680                         }
 681                         break;
 682                         case 2://DSC Delete Classifier
 683                         {
 684                                 eClassifierAction = eDeleteClassifier;
 685
 686                         }
 687                         break;
 688                         default:
 689                         {
 690                                 eClassifierAction = eInvalidClassifierAction;
 691                         }
 692                         }
 693                 }
 694
 695                 u16PacketClassificationRuleIndex = ntohs(psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
 696
 697                 switch(eClassifierAction)
 698                 {
 699                 case eAddClassifier:
 700                 {
 701                         //Get a Free Classifier Index From Classifier table for this SF to add the Classifier
 702                         //Contained in this message
 703                         nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
 704
 705                         if(nClassifierIndex > MAX_CLASSIFIERS)
 706                         {
 707                                 nClassifierIndex = SearchFreeClsid(Adapter);
 708                                 if(nClassifierIndex > MAX_CLASSIFIERS)
 709                                 {
 710                                         //Failed To get a free Entry
 711                                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error Failed To get a free Classifier Entry");
 712                                         break;
 713                                 }
 714                                 //Copy the Classifier Rule for this service flow into our Classifier table maintained per SF.
 715                                 CopyClassifierRuleToSF(Adapter,psfCSType,uiSearchRuleIndex,nClassifierIndex);
 716                         }
 717
 718                         else
 719                         {
 720                                 //This Classifier Already Exists and it is invalid to Add Classifier with existing PCRI
 721                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"CopyToAdapter : Error The Specified Classifier Already Exists \
 722                                                 and attempted To Add Classifier with Same PCRI : 0x%x\n", u16PacketClassificationRuleIndex);
 723                         }
 724                 }
 725                 break;
 726
 727                 case eReplaceClassifier:
 728                 {
 729                                 //Get the Classifier Index From Classifier table for this SF and replace existing  Classifier
 730                                 //with the new classifier Contained in this message
 731                         nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
 732                         if(nClassifierIndex > MAX_CLASSIFIERS)
 733                         {
 734                                 //Failed To search the classifier
 735                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error Search for Classifier To be replaced failed");
 736                                 break;
 737                         }
 738                         //Copy the Classifier Rule for this service flow into our Classifier table maintained per SF.
 739                         CopyClassifierRuleToSF(Adapter,psfCSType,uiSearchRuleIndex,nClassifierIndex);
 740                 }
 741                 break;
 742
 743                 case eDeleteClassifier:
 744                 {
 745                                 //Get the Classifier Index From Classifier table for this SF and replace existing  Classifier
 746                                 //with the new classifier Contained in this message
 747                         nClassifierIndex = SearchClsid(Adapter,ulSFID,u16PacketClassificationRuleIndex);
 748                         if(nClassifierIndex > MAX_CLASSIFIERS)
 749                         {
 750                                 //Failed To search the classifier
 751                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Error Search for Classifier To be deleted failed");
 752                                 break;
 753                         }
 754
 755                         //Delete This classifier
 756                         DeleteClassifierRuleFromSF(Adapter,uiSearchRuleIndex,nClassifierIndex);
 757                 }
 758                 break;
 759
 760                 default:
 761                 {
 762                         //Invalid Action for classifier
 763                         break;
 764                 }
 765                 }
 766         }
 767
 768         //Repeat parsing Classification Entries to process PHS Rules
 769         for(nIndex=0; nIndex < psfLocalSet->u8TotalClassifiers; nIndex++)
 770         {
 771                 psfCSType =  &psfLocalSet->cConvergenceSLTypes[nIndex];
 772
 773                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "psfCSType->u8PhsDSCAction : 0x%x\n",
 774                                 psfCSType->u8PhsDSCAction );
 775
 776                 switch (psfCSType->u8PhsDSCAction)
 777                 {
 778                 case eDeleteAllPHSRules:
 779                 {
 780                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Deleting All PHS Rules For VCID: 0x%X\n",uVCID);
 781
 782                         //Delete All the PHS rules for this Service flow
 783
 784                         PhsDeleteSFRules(
 785                                 &Adapter->stBCMPhsContext,
 786                                 uVCID);
 787
 788                         break;
 789                 }
 790                 case eDeletePHSRule:
 791                 {
 792                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"PHS DSC Action = Delete PHS Rule \n");
 793
 794                         if(psfCSType->cPhsRule.u8PHSI)
 795                         {
 796                                 PhsDeletePHSRule(
 797                                         &Adapter->stBCMPhsContext,
 798                                         uVCID,
 799                                         psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
 800                         }
 801                         else
 802                         {
 803                                 //BCM_DEBUG_PRINT(CONN_MSG,("Error CPHSRule.PHSI is ZERO \n"));
 804                         }
 805                         break;
 806                 }
 807                 default :
 808                 {
 809                         if(ucDsxType == DSC_ACK)
 810                         {
 811                                 //BCM_DEBUG_PRINT(CONN_MSG,("Invalid PHS DSC Action For DSC \n",psfCSType->cPhsRule.u8PHSI));
 812                                 break; //FOr DSC ACK Case PHS DSC Action must be in valid set
 813                         }
 814                 }
 815                 //Proceed To Add PHS rule for DSA_ACK case even if PHS DSC action is unspecified
 816                 //No Break Here . Intentionally!
 817
 818                 case eAddPHSRule:
 819                 case eSetPHSRule:
 820                 {
 821                         if(psfCSType->cPhsRule.u8PHSI)
 822                         {
 823                                 //Apply This PHS Rule to all classifiers whose Associated PHSI Match
 824                                 unsigned int uiClassifierIndex = 0;
 825                                 if(pstAddIndication->u8Direction == UPLINK_DIR )
 826                                 {
 827                                         for(uiClassifierIndex=0;uiClassifierIndex<MAX_CLASSIFIERS;uiClassifierIndex++)
 828                                         {
 829                                                 if((Adapter->astClassifierTable[uiClassifierIndex].bUsed) &&
 830                                                         (Adapter->astClassifierTable[uiClassifierIndex].ulSFID == Adapter->PackInfo[uiSearchRuleIndex].ulSFID) &&
 831                                                         (Adapter->astClassifierTable[uiClassifierIndex].u8AssociatedPHSI == psfCSType->cPhsRule.u8PHSI))
 832                                                 {
 833                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Adding  PHS Rule For  Classifier : 0x%x cPhsRule.u8PHSI : 0x%x\n",
 834                                                                 Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex,
 835                                                                 psfCSType->cPhsRule.u8PHSI);
 836                                                         //Update The PHS Rule for this classifier as Associated PHSI id defined
 837
 838                                                         //Copy the PHS Rule
 839                                                         sPhsRule.u8PHSI =  psfCSType->cPhsRule.u8PHSI;
 840                                                         sPhsRule.u8PHSFLength =  psfCSType->cPhsRule.u8PHSFLength;
 841                                                         sPhsRule.u8PHSMLength = psfCSType->cPhsRule.u8PHSMLength;
 842                                                         sPhsRule.u8PHSS = psfCSType->cPhsRule.u8PHSS;
 843                                                         sPhsRule.u8PHSV = psfCSType->cPhsRule.u8PHSV;
 844                                                         memcpy(sPhsRule.u8PHSF,psfCSType->cPhsRule.u8PHSF,MAX_PHS_LENGTHS);
 845                                                         memcpy(sPhsRule.u8PHSM,psfCSType->cPhsRule.u8PHSM,MAX_PHS_LENGTHS);
 846                                                         sPhsRule.u8RefCnt = 0;
 847                                                         sPhsRule.bUnclassifiedPHSRule = FALSE;
 848                                                         sPhsRule.PHSModifiedBytes = 0;
 849                                                         sPhsRule.PHSModifiedNumPackets = 0;
 850                                                         sPhsRule.PHSErrorNumPackets = 0;
 851
 852                                                         //bPHSRuleAssociated = TRUE;
 853                                                         //Store The PHS Rule for this classifier
 854
 855                                                         PhsUpdateClassifierRule(
 856                                                                 &Adapter->stBCMPhsContext,
 857                                                                 uVCID,
 858                                                                 Adapter->astClassifierTable[uiClassifierIndex].uiClassifierRuleIndex,
 859                                                                 &sPhsRule,
 860                                                                 Adapter->astClassifierTable[uiClassifierIndex].u8AssociatedPHSI);
 861
 862                                                         //Update PHS Rule For the Classifier
 863                                                         if(sPhsRule.u8PHSI)
 864                                                         {
 865                                                                 Adapter->astClassifierTable[uiClassifierIndex].u32PHSRuleID = sPhsRule.u8PHSI;
 866                                                                 memcpy(&Adapter->astClassifierTable[uiClassifierIndex].sPhsRule,&sPhsRule,sizeof(S_PHS_RULE));
 867                                                         }
 868
 869                                                 }
 870                                         }
 871                                 }
 872                                 else
 873                                 {
 874                                         //Error PHS Rule specified in signaling could not be applied to any classifier
 875
 876                                                 //Copy the PHS Rule
 877                                                 sPhsRule.u8PHSI =  psfCSType->cPhsRule.u8PHSI;
 878                                                 sPhsRule.u8PHSFLength =  psfCSType->cPhsRule.u8PHSFLength;
 879                                                 sPhsRule.u8PHSMLength = psfCSType->cPhsRule.u8PHSMLength;
 880                                                 sPhsRule.u8PHSS = psfCSType->cPhsRule.u8PHSS;
 881                                                 sPhsRule.u8PHSV = psfCSType->cPhsRule.u8PHSV;
 882                                                 memcpy(sPhsRule.u8PHSF,psfCSType->cPhsRule.u8PHSF,MAX_PHS_LENGTHS);
 883                                                 memcpy(sPhsRule.u8PHSM,psfCSType->cPhsRule.u8PHSM,MAX_PHS_LENGTHS);
 884                                                 sPhsRule.u8RefCnt = 0;
 885                                                 sPhsRule.bUnclassifiedPHSRule = TRUE;
 886                                                 sPhsRule.PHSModifiedBytes = 0;
 887                                                 sPhsRule.PHSModifiedNumPackets = 0;
 888                                                 sPhsRule.PHSErrorNumPackets = 0;
 889                                                 //Store The PHS Rule for this classifier
 890
 891                                                 /*
 892                                                         Passing the argument u8PHSI instead of clsid. Because for DL with no classifier rule,
 893                                                         clsid will be zero hence we cant have multiple PHS rules for the same SF.
 894                                                         To support multiple PHS rule, passing u8PHSI.
 895                                                 */
 896
 897                                                 PhsUpdateClassifierRule(
 898                                                         &Adapter->stBCMPhsContext,
 899                                                         uVCID,
 900                                                         sPhsRule.u8PHSI,
 901                                                         &sPhsRule,
 902                                                         sPhsRule.u8PHSI);
 903
 904                                 }
 905
 906                         }
 907                 }
 908                 break;
 909                 }
 910         }
 911
 912         if(psfLocalSet->u32MaxSustainedTrafficRate == 0 )
 913         {
 914                 //No Rate Limit . Set Max Sustained Traffic Rate to Maximum
 915                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate =
 916                         WIMAX_MAX_ALLOWED_RATE;
 917
 918         }
 919         else if (ntohl(psfLocalSet->u32MaxSustainedTrafficRate) >
 920                         WIMAX_MAX_ALLOWED_RATE)
 921         {
 922                 //Too large Allowed Rate specified. Limiting to Wi Max  Allowed rate
 923                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate =
 924                         WIMAX_MAX_ALLOWED_RATE;
 925         }
 926         else
 927         {
 928                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate =
 929                         ntohl(psfLocalSet->u32MaxSustainedTrafficRate);
 930         }
 931
 932         Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency = ntohl(psfLocalSet->u32MaximumLatency);
 933
 934         if(Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency == 0) /* 0 should be treated as infinite */
 935                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency = MAX_LATENCY_ALLOWED;
 936
 937
 938         if(( Adapter->PackInfo[uiSearchRuleIndex].u8QueueType == ERTPS ||
 939                         Adapter->PackInfo[uiSearchRuleIndex].u8QueueType == UGS ) )
 940                         UGIValue = ntohs(psfLocalSet->u16UnsolicitedGrantInterval);
 941
 942         if(UGIValue == 0)
 943                 UGIValue = DEFAULT_UG_INTERVAL;
 944
 945         /*
 946         For UGI based connections...
 947         DEFAULT_UGI_FACTOR*UGIInterval worth of data is the max token count at host...
 948         The extra amount of token is to ensure that a large amount of jitter won't have loss in throughput...
 949         In case of non-UGI based connection, 200 frames worth of data is the max token count at host...
 950         */
 951
 952         Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize =
 953         (DEFAULT_UGI_FACTOR*Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate*UGIValue)/1000;
 954
 955         if(Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize < WIMAX_MAX_MTU*8)
 956         {
 957                 UINT UGIFactor = 0;
 958                 /* Special Handling to ensure the biggest size of packet can go out from host to FW as follows:
 959                 1. Any packet from Host to FW can go out in different packet size.
 960                 2. So in case the Bucket count is smaller than MTU, the packets of size (Size > TokenCount), will get dropped.
 961                 3. We can allow packets of MaxSize from Host->FW that can go out from FW in multiple SDUs by fragmentation at Wimax Layer
 962                 */
 963                 UGIFactor = (Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency/UGIValue + 1);
 964
 965                 if(UGIFactor > DEFAULT_UGI_FACTOR)
 966                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize =
 967                 (UGIFactor*Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate*UGIValue)/1000;
 968
 969                 if(Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize > WIMAX_MAX_MTU*8)
 970                         Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize = WIMAX_MAX_MTU*8;
 971         }
 972
 973
 974         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"LAT: %d, UGI: %d \n", Adapter->PackInfo[uiSearchRuleIndex].uiMaxLatency, UGIValue);
 975         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"uiMaxAllowedRate: 0x%x, u32MaxSustainedTrafficRate: 0x%x ,uiMaxBucketSize: 0x%x",
 976                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxAllowedRate,
 977                 ntohl(psfLocalSet->u32MaxSustainedTrafficRate),
 978                 Adapter->PackInfo[uiSearchRuleIndex].uiMaxBucketSize);
 979
 980         //copy the extended SF Parameters to Support MIBS
 981         CopyMIBSExtendedSFParameters(Adapter,psfLocalSet,uiSearchRuleIndex);
 982
 983         //store header suppression enabled flag per SF
 984         Adapter->PackInfo[uiSearchRuleIndex].bHeaderSuppressionEnabled =
 985                         !(psfLocalSet->u8RequesttransmissionPolicy &
 986                                 MASK_DISABLE_HEADER_SUPPRESSION);
 987
 988         if(Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication)
 989         {
 990                 kfree(Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication);
 991                 Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication = NULL;
 992         }
 993         Adapter->PackInfo[uiSearchRuleIndex].pstSFIndication = pstAddIndication;
 994
 995         //Re Sort the SF list in PackInfo according to Traffic Priority
 996         SortPackInfo(Adapter);
 997
 998         /* Re Sort the Classifier Rules table and re - arrange
 999                 according to Classifier Rule Priority */
1000         SortClassifiers(Adapter);
1001
1002         DumpPhsRules(&Adapter->stBCMPhsContext);
1003
1004         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"%s <=====", __FUNCTION__);
1005 }
1006
1007
1008 /***********************************************************************
1009 * Function        -     DumpCmControlPacket
1010 *
1011 * Description - This routinue Dumps the Contents of the AddIndication
1012 *                               Structure in the Connection Management Control Packet
1013 *
1014 * Parameter   - pvBuffer: Pointer to the buffer containing the
1015 *                               AddIndication data.
1016 *
1017 * Returns         - None
1018 *************************************************************************/
1019 static VOID DumpCmControlPacket(PVOID pvBuffer)
1020 {
1021         UINT                                    uiLoopIndex;
1022         UINT                    nIndex;
1023         stLocalSFAddIndicationAlt  *pstAddIndication;
1024         UINT                    nCurClassifierCnt;
1025     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1026
1027         pstAddIndication = (stLocalSFAddIndicationAlt *)pvBuffer;
1028         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "======>");
1029
1030         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8Type           : 0x%X",pstAddIndication->u8Type);
1031         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8Direction      : 0x%X",pstAddIndication->u8Direction);
1032         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16TID: 0x%X", ntohs(pstAddIndication->u16TID));
1033         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16CID            : 0x%X",ntohs(pstAddIndication->u16CID));
1034         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16VCID           : 0x%X",ntohs(pstAddIndication->u16VCID));
1035
1036         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " AuthorizedSet--->");
1037
1038         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32SFID          : 0x%X",htonl(pstAddIndication->sfAuthorizedSet.u32SFID));
1039         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16CID           : 0x%X",htons(pstAddIndication->sfAuthorizedSet.u16CID));
1040         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceClassNameLength : 0x%X",
1041                 pstAddIndication->sfAuthorizedSet.u8ServiceClassNameLength);
1042
1043         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceClassName                : 0x%X ,0x%X , 0x%X, 0x%X, 0x%X, 0x%X",
1044                         pstAddIndication->sfAuthorizedSet.u8ServiceClassName[0],
1045                         pstAddIndication->sfAuthorizedSet.u8ServiceClassName[1],
1046                         pstAddIndication->sfAuthorizedSet.u8ServiceClassName[2],
1047                         pstAddIndication->sfAuthorizedSet.u8ServiceClassName[3],
1048                         pstAddIndication->sfAuthorizedSet.u8ServiceClassName[4],
1049                         pstAddIndication->sfAuthorizedSet.u8ServiceClassName[5]);
1050
1051         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8MBSService             : 0x%X",
1052                 pstAddIndication->sfAuthorizedSet.u8MBSService);
1053         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8QosParamSet            : 0x%X",
1054                 pstAddIndication->sfAuthorizedSet.u8QosParamSet);
1055         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8TrafficPriority : 0x%X, %p",
1056                 pstAddIndication->sfAuthorizedSet.u8TrafficPriority, &pstAddIndication->sfAuthorizedSet.u8TrafficPriority);
1057
1058         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MaxSustainedTrafficRate       : 0x%X 0x%p",
1059                 pstAddIndication->sfAuthorizedSet.u32MaxSustainedTrafficRate,
1060                         &pstAddIndication->sfAuthorizedSet.u32MaxSustainedTrafficRate);
1061
1062         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MaxTrafficBurst                        : 0x%X",
1063                 pstAddIndication->sfAuthorizedSet.u32MaxTrafficBurst);
1064         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32MinReservedTrafficRate : 0x%X",
1065                 pstAddIndication->sfAuthorizedSet.u32MinReservedTrafficRate);
1066         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParamLength    : 0x%X",
1067                 pstAddIndication->sfAuthorizedSet.u8VendorSpecificQoSParamLength);
1068         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8VendorSpecificQoSParam          : 0x%X",
1069                 pstAddIndication->sfAuthorizedSet.u8VendorSpecificQoSParam[0]);
1070         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8ServiceFlowSchedulingType               : 0x%X",
1071                 pstAddIndication->sfAuthorizedSet.u8ServiceFlowSchedulingType);
1072         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u32ToleratedJitter                                : 0x%X",
1073                 pstAddIndication->sfAuthorizedSet.u32ToleratedJitter);
1074     BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MaximumLatency                            : 0x%X",
1075                 pstAddIndication->sfAuthorizedSet.u32MaximumLatency);
1076         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8FixedLengthVSVariableLengthSDUIndicator: 0x%X",
1077                 pstAddIndication->sfAuthorizedSet.u8FixedLengthVSVariableLengthSDUIndicator);
1078
1079         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u8SDUSize                         : 0x%X",
1080                 pstAddIndication->sfAuthorizedSet.u8SDUSize);
1081         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16TargetSAID                    : 0x%X",
1082                 pstAddIndication->sfAuthorizedSet.u16TargetSAID);
1083         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ARQEnable                              : 0x%X",
1084                 pstAddIndication->sfAuthorizedSet.u8ARQEnable);
1085         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQWindowSize          : 0x%X",
1086                 pstAddIndication->sfAuthorizedSet.u16ARQWindowSize);
1087         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQRetryTxTimeOut      : 0x%X",
1088                 pstAddIndication->sfAuthorizedSet.u16ARQRetryTxTimeOut);
1089         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQRetryRxTimeOut     : 0x%X",
1090                 pstAddIndication->sfAuthorizedSet.u16ARQRetryRxTimeOut);
1091         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "u16ARQBlockLifeTime               : 0x%X",
1092                 pstAddIndication->sfAuthorizedSet.u16ARQBlockLifeTime);
1093         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQSyncLossTimeOut    : 0x%X",
1094                 pstAddIndication->sfAuthorizedSet.u16ARQSyncLossTimeOut);
1095         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ARQDeliverInOrder              : 0x%X",
1096                 pstAddIndication->sfAuthorizedSet.u8ARQDeliverInOrder);
1097         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQRxPurgeTimeOut     : 0x%X",
1098                 pstAddIndication->sfAuthorizedSet.u16ARQRxPurgeTimeOut);
1099         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQBlockSize                  : 0x%X",
1100                 pstAddIndication->sfAuthorizedSet.u16ARQBlockSize);
1101         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8CSSpecification                : 0x%X",
1102                 pstAddIndication->sfAuthorizedSet.u8CSSpecification);
1103         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8TypeOfDataDeliveryService      : 0x%X",
1104                 pstAddIndication->sfAuthorizedSet.u8TypeOfDataDeliveryService);
1105         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16SDUInterArrivalTime   : 0x%X",
1106                 pstAddIndication->sfAuthorizedSet.u16SDUInterArrivalTime);
1107         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16TimeBase                              : 0x%X",
1108                 pstAddIndication->sfAuthorizedSet.u16TimeBase);
1109         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8PagingPreference               : 0x%X",
1110                 pstAddIndication->sfAuthorizedSet.u8PagingPreference);
1111         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16UnsolicitedPollingInterval            : 0x%X",
1112                 pstAddIndication->sfAuthorizedSet.u16UnsolicitedPollingInterval);
1113
1114         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "sfAuthorizedSet.u8HARQChannelMapping %x  %x %x ",
1115                                 *(unsigned int*)pstAddIndication->sfAuthorizedSet.u8HARQChannelMapping,
1116                                 *(unsigned int*)&pstAddIndication->sfAuthorizedSet.u8HARQChannelMapping[4],
1117                         *(USHORT*) &pstAddIndication->sfAuthorizedSet.u8HARQChannelMapping[8]);
1118         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8TrafficIndicationPreference    : 0x%X",
1119                 pstAddIndication->sfAuthorizedSet.u8TrafficIndicationPreference);
1120
1121         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " Total Classifiers Recieved              : 0x%X",pstAddIndication->sfAuthorizedSet.u8TotalClassifiers);
1122
1123         nCurClassifierCnt = pstAddIndication->sfAuthorizedSet.u8TotalClassifiers;
1124
1125         if(nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
1126         {
1127                 nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;
1128         }
1129         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "pstAddIndication->sfAuthorizedSet.bValid %d", pstAddIndication->sfAuthorizedSet.bValid);
1130         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "pstAddIndication->sfAuthorizedSet.u16MacOverhead %x", pstAddIndication->sfAuthorizedSet.u16MacOverhead);
1131         if(!pstAddIndication->sfAuthorizedSet.bValid)
1132                 pstAddIndication->sfAuthorizedSet.bValid=1;
1133         for(nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex++)
1134         {
1135                 stConvergenceSLTypes *psfCSType = NULL;
1136                 psfCSType =  &pstAddIndication->sfAuthorizedSet.cConvergenceSLTypes[nIndex];
1137
1138                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "psfCSType = %p", psfCSType);
1139                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "CCPacketClassificationRuleSI====>");
1140
1141                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ClassifierRulePriority         :0x%X ",
1142                         psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority);
1143                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPTypeOfServiceLength                  :0x%X ",
1144                         psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
1145
1146                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPTypeOfService[3]                     :0x%X ,0x%X ,0x%X ",
1147                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
1148                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
1149                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
1150
1151                 for(uiLoopIndex=0; uiLoopIndex < 1; uiLoopIndex++)
1152                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8Protocol : 0x%02X ",
1153                         psfCSType->cCPacketClassificationRule.u8Protocol);
1154
1155                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPMaskedSourceAddressLength    :0x%X ",
1156                         psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength);
1157
1158                 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1159                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPMaskedSourceAddress[32]      : 0x%02X ",
1160                         psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress[uiLoopIndex]);
1161
1162                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPDestinationAddressLength : 0x%X ",
1163                         psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength);
1164
1165                 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1166                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPDestinationAddress[32] : 0x%02X ",
1167                         psfCSType->cCPacketClassificationRule.u8IPDestinationAddress[uiLoopIndex]);
1168
1169                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolSourcePortRangeLength:0x%X ",
1170                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
1171                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolSourcePortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X ",
1172                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
1173                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
1174                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
1175                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[3]);
1176
1177                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolDestPortRangeLength : 0x%02X ",
1178                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
1179                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolDestPortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X ",
1180                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
1181                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
1182                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
1183                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[3]);
1184
1185                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetDestMacAddressLength : 0x%02X ",
1186                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1187
1188                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetDestMacAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1189                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
1190                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
1191                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
1192                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[3],
1193                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[4],
1194                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[5]);
1195
1196                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetSourceMACAddressLength : 0x%02X ",
1197                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1198
1199                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetSourceMACAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1200                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
1201                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
1202                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
1203                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[3],
1204                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[4],
1205                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[5]);
1206
1207                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthertypeLength        : 0x%02X ",
1208                         psfCSType->cCPacketClassificationRule.u8EthertypeLength);
1209                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8Ethertype[3] : 0x%02X ,0x%02X ,0x%02X ",
1210                         psfCSType->cCPacketClassificationRule.u8Ethertype[0],
1211                         psfCSType->cCPacketClassificationRule.u8Ethertype[1],
1212                         psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
1213
1214                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16UserPriority          : 0x%X ",
1215                         psfCSType->cCPacketClassificationRule.u16UserPriority);
1216
1217                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16VLANID                        : 0x%X ",
1218                         psfCSType->cCPacketClassificationRule.u16VLANID);
1219
1220                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8AssociatedPHSI : 0x%02X ",
1221                         psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
1222
1223                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16PacketClassificationRuleIndex : 0x%X ",
1224                         psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
1225
1226                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificClassifierParamLength    : 0x%X ",
1227                         psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParamLength);
1228
1229                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificClassifierParam[1]               : 0x%X ",
1230                         psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParam[0]);
1231 #ifdef VERSION_D5
1232                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPv6FlowLableLength                            :0x%X ",
1233                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
1234                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPv6FlowLable[6] : 0x %02X %02X %02X %02X %02X %02X ",
1235                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
1236                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
1237                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
1238                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[3],
1239                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[4],
1240                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[5]);
1241 #endif
1242         }
1243
1244         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "bValid           : 0x%02X",pstAddIndication->sfAuthorizedSet.bValid);
1245
1246         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "AdmittedSet--->");
1247         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32SFID          : 0x%X",pstAddIndication->sfAdmittedSet.u32SFID);
1248         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16CID           : 0x%X",pstAddIndication->sfAdmittedSet.u16CID);
1249         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceClassNameLength : 0x%X",
1250                 pstAddIndication->sfAdmittedSet.u8ServiceClassNameLength);
1251         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceClassName                       : 0x %02X %02X %02X %02X %02X %02X",
1252                         pstAddIndication->sfAdmittedSet.u8ServiceClassName[0],
1253                         pstAddIndication->sfAdmittedSet.u8ServiceClassName[1],
1254                         pstAddIndication->sfAdmittedSet.u8ServiceClassName[2],
1255                         pstAddIndication->sfAdmittedSet.u8ServiceClassName[3],
1256                         pstAddIndication->sfAdmittedSet.u8ServiceClassName[4],
1257                         pstAddIndication->sfAdmittedSet.u8ServiceClassName[5]);
1258
1259         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8MBSService                             : 0x%02X",
1260                         pstAddIndication->sfAdmittedSet.u8MBSService);
1261         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8QosParamSet                            : 0x%02X",
1262                         pstAddIndication->sfAdmittedSet.u8QosParamSet);
1263         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8TrafficPriority                        : 0x%02X",
1264                         pstAddIndication->sfAdmittedSet.u8TrafficPriority);
1265         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MaxTrafficBurst                       : 0x%X",
1266                         pstAddIndication->sfAdmittedSet.u32MaxTrafficBurst);
1267         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MinReservedTrafficRate        : 0x%X",
1268                 pstAddIndication->sfAdmittedSet.u32MinReservedTrafficRate);
1269
1270         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificQoSParamLength   : 0x%02X",
1271                 pstAddIndication->sfAdmittedSet.u8VendorSpecificQoSParamLength);
1272         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificQoSParam         : 0x%02X",
1273                 pstAddIndication->sfAdmittedSet.u8VendorSpecificQoSParam[0]);
1274         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceFlowSchedulingType              : 0x%02X",
1275                 pstAddIndication->sfAdmittedSet.u8ServiceFlowSchedulingType);
1276
1277         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32ToleratedJitter                               : 0x%X",
1278                 pstAddIndication->sfAdmittedSet.u32ToleratedJitter);
1279     BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MaximumLatency                            : 0x%X",
1280                 pstAddIndication->sfAdmittedSet.u32MaximumLatency);
1281
1282         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8FixedLengthVSVariableLengthSDUIndicator: 0x%02X",
1283                 pstAddIndication->sfAdmittedSet.u8FixedLengthVSVariableLengthSDUIndicator);
1284         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8SDUSize                        : 0x%02X",
1285                 pstAddIndication->sfAdmittedSet.u8SDUSize);
1286         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16TargetSAID            : 0x%02X",
1287                 pstAddIndication->sfAdmittedSet.u16TargetSAID);
1288         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ARQEnable                      : 0x%02X",
1289                 pstAddIndication->sfAdmittedSet.u8ARQEnable);
1290
1291         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQWindowSize         : 0x%X",
1292                 pstAddIndication->sfAdmittedSet.u16ARQWindowSize);
1293         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQRetryTxTimeOut     : 0x%X",
1294                 pstAddIndication->sfAdmittedSet.u16ARQRetryTxTimeOut);
1295         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQRetryRxTimeOut     : 0x%X",
1296                 pstAddIndication->sfAdmittedSet.u16ARQRetryRxTimeOut);
1297         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQBlockLifeTime              : 0x%X",
1298                 pstAddIndication->sfAdmittedSet.u16ARQBlockLifeTime);
1299         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQSyncLossTimeOut    : 0x%X",
1300                 pstAddIndication->sfAdmittedSet.u16ARQSyncLossTimeOut);
1301
1302         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ARQDeliverInOrder              : 0x%02X",
1303                 pstAddIndication->sfAdmittedSet.u8ARQDeliverInOrder);
1304         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQRxPurgeTimeOut     : 0x%X",
1305                 pstAddIndication->sfAdmittedSet.u16ARQRxPurgeTimeOut);
1306         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16ARQBlockSize                  : 0x%X",
1307                 pstAddIndication->sfAdmittedSet.u16ARQBlockSize);
1308         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8CSSpecification                : 0x%02X",
1309                 pstAddIndication->sfAdmittedSet.u8CSSpecification);
1310         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8TypeOfDataDeliveryService      : 0x%02X",
1311                 pstAddIndication->sfAdmittedSet.u8TypeOfDataDeliveryService);
1312         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16SDUInterArrivalTime   : 0x%X",
1313                 pstAddIndication->sfAdmittedSet.u16SDUInterArrivalTime);
1314         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16TimeBase                              : 0x%X",
1315                 pstAddIndication->sfAdmittedSet.u16TimeBase);
1316         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8PagingPreference               : 0x%X",
1317                 pstAddIndication->sfAdmittedSet.u8PagingPreference);
1318
1319
1320         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8TrafficIndicationPreference    : 0x%02X",
1321                 pstAddIndication->sfAdmittedSet.u8TrafficIndicationPreference);
1322
1323         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " Total Classifiers Recieved              : 0x%X",pstAddIndication->sfAdmittedSet.u8TotalClassifiers);
1324
1325         nCurClassifierCnt = pstAddIndication->sfAdmittedSet.u8TotalClassifiers;
1326
1327         if(nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
1328         {
1329                 nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;
1330         }
1331
1332
1333         for(nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex++)
1334         {
1335
1336                 stConvergenceSLTypes *psfCSType = NULL;
1337                 psfCSType =  &pstAddIndication->sfAdmittedSet.cConvergenceSLTypes[nIndex];
1338
1339                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " CCPacketClassificationRuleSI====>");
1340
1341                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ClassifierRulePriority :0x%02X ",
1342                         psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority);
1343                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPTypeOfServiceLength          :0x%02X",
1344                         psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
1345
1346                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPTypeOfService[3]             :0x%02X %02X %02X",
1347                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
1348                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
1349                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
1350                 for(uiLoopIndex=0; uiLoopIndex < 1; uiLoopIndex++)
1351                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8Protocol: 0x%02X ",
1352                         psfCSType->cCPacketClassificationRule.u8Protocol);
1353
1354                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPMaskedSourceAddressLength    :0x%02X ",
1355                         psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength);
1356
1357                 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1358                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPMaskedSourceAddress[32] : 0x%02X ",
1359                         psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress[uiLoopIndex]);
1360
1361                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPDestinationAddressLength     : 0x%02X ",
1362                         psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength);
1363
1364                 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1365                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPDestinationAddress[32] : 0x%02X ",
1366                         psfCSType->cCPacketClassificationRule.u8IPDestinationAddress[uiLoopIndex]);
1367
1368                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolSourcePortRangeLength  : 0x%02X ",
1369                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
1370
1371                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolSourcePortRange[4] : 0x %02X %02X %02X %02X ",
1372                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
1373                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
1374                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
1375                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[3]);
1376
1377                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolDestPortRangeLength : 0x%02X ",
1378                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
1379
1380                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ProtocolDestPortRange[4] : 0x %02X %02X %02X %02X ",
1381                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
1382                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
1383                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
1384                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[3]);
1385
1386                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetDestMacAddressLength : 0x%02X ",
1387                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1388
1389                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetDestMacAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1390                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
1391                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
1392                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
1393                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[3],
1394                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[4],
1395                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[5]);
1396
1397                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetSourceMACAddressLength : 0x%02X ",
1398                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1399
1400                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetSourceMACAddress[6] : 0x %02X %02X %02X %02X %02X %02X",
1401                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
1402                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
1403                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
1404                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[3],
1405                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[4],
1406                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[5]);
1407
1408                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthertypeLength        : 0x%02X ",
1409                         psfCSType->cCPacketClassificationRule.u8EthertypeLength);
1410                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8Ethertype[3]           : 0x%02X %02X %02X",
1411                         psfCSType->cCPacketClassificationRule.u8Ethertype[0],
1412                         psfCSType->cCPacketClassificationRule.u8Ethertype[1],
1413                         psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
1414
1415                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16UserPriority  : 0x%X ",
1416                         psfCSType->cCPacketClassificationRule.u16UserPriority);
1417                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16VLANID                        : 0x%X ",
1418                         psfCSType->cCPacketClassificationRule.u16VLANID);
1419                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8AssociatedPHSI : 0x%02X ",
1420                         psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
1421                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16PacketClassificationRuleIndex : 0x%X ",
1422                         psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
1423
1424                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificClassifierParamLength    : 0x%02X",
1425                         psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParamLength);
1426                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificClassifierParam[1]       : 0x%02X ",
1427                         psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParam[0]);
1428 #ifdef VERSION_D5
1429                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPv6FlowLableLength                            : 0x%X ",
1430                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
1431                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPv6FlowLable[6]       : 0x %02X %02X %02X %02X %02X %02X ",
1432                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
1433                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
1434                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
1435                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[3],
1436                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[4],
1437                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[5]);
1438 #endif
1439         }
1440
1441         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "bValid           : 0x%X",pstAddIndication->sfAdmittedSet.bValid);
1442
1443         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " ActiveSet--->");
1444         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32SFID          : 0x%X",pstAddIndication->sfActiveSet.u32SFID);
1445         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u16CID           : 0x%X",pstAddIndication->sfActiveSet.u16CID);
1446
1447         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceClassNameLength : 0x%X",
1448                 pstAddIndication->sfActiveSet.u8ServiceClassNameLength);
1449
1450         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceClassName               : 0x %02X %02X %02X %02X %02X %02X",
1451                 pstAddIndication->sfActiveSet.u8ServiceClassName[0],
1452                 pstAddIndication->sfActiveSet.u8ServiceClassName[1],
1453                 pstAddIndication->sfActiveSet.u8ServiceClassName[2],
1454                 pstAddIndication->sfActiveSet.u8ServiceClassName[3],
1455                 pstAddIndication->sfActiveSet.u8ServiceClassName[4],
1456                 pstAddIndication->sfActiveSet.u8ServiceClassName[5]);
1457
1458         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8MBSService                             : 0x%02X",
1459                 pstAddIndication->sfActiveSet.u8MBSService);
1460         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8QosParamSet                            : 0x%02X",
1461                 pstAddIndication->sfActiveSet.u8QosParamSet);
1462         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8TrafficPriority                        : 0x%02X",
1463                 pstAddIndication->sfActiveSet.u8TrafficPriority);
1464         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MaxTrafficBurst                       : 0x%X",
1465                 pstAddIndication->sfActiveSet.u32MaxTrafficBurst);
1466         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MinReservedTrafficRate        : 0x%X",
1467                 pstAddIndication->sfActiveSet.u32MinReservedTrafficRate);
1468         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificQoSParamLength   : 0x%02X",
1469                 pstAddIndication->sfActiveSet.u8VendorSpecificQoSParamLength);
1470         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8VendorSpecificQoSParam         : 0x%02X",
1471                 pstAddIndication->sfActiveSet.u8VendorSpecificQoSParam[0]);
1472         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8ServiceFlowSchedulingType              : 0x%02X",
1473                 pstAddIndication->sfActiveSet.u8ServiceFlowSchedulingType);
1474
1475         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32ToleratedJitter                               : 0x%X",
1476                 pstAddIndication->sfActiveSet.u32ToleratedJitter);
1477     BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u32MaximumLatency                            : 0x%X",
1478                 pstAddIndication->sfActiveSet.u32MaximumLatency);
1479
1480         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8FixedLengthVSVariableLengthSDUIndicator: 0x%02X",
1481            pstAddIndication->sfActiveSet.u8FixedLengthVSVariableLengthSDUIndicator);
1482
1483         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8SDUSize                                : 0x%X",
1484                 pstAddIndication->sfActiveSet.u8SDUSize);
1485         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16TargetSAID                   : 0x%X",
1486                 pstAddIndication->sfActiveSet.u16TargetSAID);
1487         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ARQEnable                     : 0x%X",
1488                 pstAddIndication->sfActiveSet.u8ARQEnable);
1489         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQWindowSize                : 0x%X",
1490                 pstAddIndication->sfActiveSet.u16ARQWindowSize);
1491         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQRetryTxTimeOut    : 0x%X",
1492                 pstAddIndication->sfActiveSet.u16ARQRetryTxTimeOut);
1493         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQRetryRxTimeOut    : 0x%X",
1494                 pstAddIndication->sfActiveSet.u16ARQRetryRxTimeOut);
1495         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQBlockLifeTime     : 0x%X",
1496                 pstAddIndication->sfActiveSet.u16ARQBlockLifeTime);
1497         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQSyncLossTimeOut   : 0x%X",
1498                 pstAddIndication->sfActiveSet.u16ARQSyncLossTimeOut);
1499         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ARQDeliverInOrder     : 0x%X",
1500                 pstAddIndication->sfActiveSet.u8ARQDeliverInOrder);
1501         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQRxPurgeTimeOut    : 0x%X",
1502                 pstAddIndication->sfActiveSet.u16ARQRxPurgeTimeOut);
1503         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16ARQBlockSize         : 0x%X",
1504                 pstAddIndication->sfActiveSet.u16ARQBlockSize);
1505         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8CSSpecification               : 0x%X",
1506                 pstAddIndication->sfActiveSet.u8CSSpecification);
1507         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8TypeOfDataDeliveryService     : 0x%X",
1508                 pstAddIndication->sfActiveSet.u8TypeOfDataDeliveryService);
1509         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16SDUInterArrivalTime  : 0x%X",
1510                 pstAddIndication->sfActiveSet.u16SDUInterArrivalTime);
1511         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16TimeBase                     : 0x%X",
1512                 pstAddIndication->sfActiveSet.u16TimeBase);
1513         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8PagingPreference              : 0x%X",
1514                 pstAddIndication->sfActiveSet.u8PagingPreference);
1515
1516
1517         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8TrafficIndicationPreference   : 0x%X",
1518                 pstAddIndication->sfActiveSet.u8TrafficIndicationPreference);
1519
1520         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " Total Classifiers Recieved              : 0x%X",pstAddIndication->sfActiveSet.u8TotalClassifiers);
1521
1522         nCurClassifierCnt = pstAddIndication->sfActiveSet.u8TotalClassifiers;
1523
1524         if(nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
1525         {
1526                 nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;
1527         }
1528
1529         for(nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex++)
1530         {
1531
1532                 stConvergenceSLTypes *psfCSType = NULL;
1533                 psfCSType =  &pstAddIndication->sfActiveSet.cConvergenceSLTypes[nIndex];
1534
1535
1536                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " CCPacketClassificationRuleSI====>");
1537
1538                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ClassifierRulePriority                :0x%X ",
1539                         psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority);
1540                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8IPTypeOfServiceLength         :0x%X ",
1541                         psfCSType->cCPacketClassificationRule.u8IPTypeOfServiceLength);
1542
1543                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8IPTypeOfService[3]                    :0x%X ,0x%X ,0x%X ",
1544                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[0],
1545                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[1],
1546                         psfCSType->cCPacketClassificationRule.u8IPTypeOfService[2]);
1547                 for(uiLoopIndex=0; uiLoopIndex < 1; uiLoopIndex++)
1548                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8Protocol      : 0x%X ",
1549                         psfCSType->cCPacketClassificationRule.u8Protocol);
1550
1551                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPMaskedSourceAddressLength    :0x%X ",
1552                         psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddressLength);
1553
1554                 for(uiLoopIndex=0; uiLoopIndex < 32; uiLoopIndex++)
1555                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPMaskedSourceAddress[32]:0x%X ",
1556                         psfCSType->cCPacketClassificationRule.u8IPMaskedSourceAddress[uiLoopIndex]);
1557
1558                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8IPDestinationAddressLength : 0x%02X ",
1559                         psfCSType->cCPacketClassificationRule.u8IPDestinationAddressLength);
1560
1561                 for(uiLoopIndex=0;uiLoopIndex<32;uiLoopIndex++)
1562                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8IPDestinationAddress[32]:0x%X ",
1563                         psfCSType->cCPacketClassificationRule.u8IPDestinationAddress[uiLoopIndex]);
1564
1565                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ProtocolSourcePortRangeLength:0x%X ",
1566                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRangeLength);
1567
1568                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ProtocolSourcePortRange[4]:0x%X ,0x%X ,0x%X ,0x%X ",
1569                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[0],
1570                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[1],
1571                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[2],
1572                         psfCSType->cCPacketClassificationRule.u8ProtocolSourcePortRange[3]);
1573
1574                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ProtocolDestPortRangeLength:0x%X ",
1575                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRangeLength);
1576
1577                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8ProtocolDestPortRange[4]:0x%X ,0x%X ,0x%X ,0x%X ",
1578                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[0],
1579                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[1],
1580                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[2],
1581                         psfCSType->cCPacketClassificationRule.u8ProtocolDestPortRange[3]);
1582
1583                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8EthernetDestMacAddressLength:0x%X ",
1584                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1585
1586                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8EthernetDestMacAddress[6]:0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X",
1587                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[0],
1588                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[1],
1589                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[2],
1590                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[3],
1591                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[4],
1592                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddress[5]);
1593
1594                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8EthernetSourceMACAddressLength:0x%X ",
1595                         psfCSType->cCPacketClassificationRule.u8EthernetDestMacAddressLength);
1596
1597                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  "u8EthernetSourceMACAddress[6]:0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X",
1598                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[0],
1599                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[1],
1600                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[2],
1601                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[3],
1602                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[4],
1603                         psfCSType->cCPacketClassificationRule.u8EthernetSourceMACAddress[5]);
1604
1605                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8EthertypeLength              :0x%X ",
1606                         psfCSType->cCPacketClassificationRule.u8EthertypeLength);
1607                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8Ethertype[3]                 :0x%X ,0x%X ,0x%X ",
1608                         psfCSType->cCPacketClassificationRule.u8Ethertype[0],
1609                         psfCSType->cCPacketClassificationRule.u8Ethertype[1],
1610                         psfCSType->cCPacketClassificationRule.u8Ethertype[2]);
1611                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16UserPriority                :0x%X ",
1612                         psfCSType->cCPacketClassificationRule.u16UserPriority);
1613                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16VLANID                      :0x%X ",
1614                         psfCSType->cCPacketClassificationRule.u16VLANID);
1615                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8AssociatedPHSI               :0x%X ",
1616                         psfCSType->cCPacketClassificationRule.u8AssociatedPHSI);
1617                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u16PacketClassificationRuleIndex:0x%X ",
1618                         psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);
1619
1620                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8VendorSpecificClassifierParamLength:0x%X ",
1621                         psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParamLength);
1622                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8VendorSpecificClassifierParam[1]:0x%X ",
1623                         psfCSType->cCPacketClassificationRule.u8VendorSpecificClassifierParam[0]);
1624 #ifdef VERSION_D5
1625                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8IPv6FlowLableLength                           :0x%X ",
1626                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLableLength);
1627                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " u8IPv6FlowLable[6]          :0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X ",
1628                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[0],
1629                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[1],
1630                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[2],
1631                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[3],
1632                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[4],
1633                         psfCSType->cCPacketClassificationRule.u8IPv6FlowLable[5]);
1634 #endif
1635         }
1636
1637         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,  " bValid                  : 0x%X",pstAddIndication->sfActiveSet.bValid);
1638
1639 }
1640
1641 static inline ULONG RestoreSFParam(PMINI_ADAPTER Adapter, ULONG ulAddrSFParamSet,PUCHAR pucDestBuffer)
1642 {
1643         UINT  nBytesToRead = sizeof(stServiceFlowParamSI);
1644
1645         if(ulAddrSFParamSet == 0 || NULL == pucDestBuffer)
1646         {
1647                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "Got Param address as 0!!");
1648                 return 0;
1649         }
1650         ulAddrSFParamSet = ntohl(ulAddrSFParamSet);
1651         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  " RestoreSFParam: Total Words of DSX Message To Read: 0x%zx  From Target At : 0x%lx ",
1652                                 nBytesToRead/sizeof(ULONG),ulAddrSFParamSet);
1653         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "sizeof(stServiceFlowParamSI) = %zx", sizeof(stServiceFlowParamSI));
1654
1655         //Read out the SF Param Set At the indicated Location
1656         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "nBytesToRead = %x", nBytesToRead);
1657         if(rdm(Adapter, ulAddrSFParamSet, (PUCHAR)pucDestBuffer, nBytesToRead) < 0)
1658                 return STATUS_FAILURE;
1659
1660         return 1;
1661 }
1662
1663
1664 static ULONG StoreSFParam(PMINI_ADAPTER Adapter,PUCHAR pucSrcBuffer,ULONG  ulAddrSFParamSet)
1665 {
1666     UINT        nBytesToWrite = sizeof(stServiceFlowParamSI);
1667         UINT    uiRetVal =0;
1668
1669         if(ulAddrSFParamSet == 0 || NULL == pucSrcBuffer)
1670         {
1671                 return 0;
1672         }
1673         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  " StoreSFParam: Total Words of DSX Message To Write: 0x%zX  To Target At : 0x%lX ",(nBytesToWrite/sizeof(ULONG)),ulAddrSFParamSet);
1674
1675         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "WRM  with %x bytes",nBytesToWrite);
1676
1677         uiRetVal = wrm(Adapter,ulAddrSFParamSet,(PUCHAR)pucSrcBuffer, nBytesToWrite);
1678         if(uiRetVal < 0) {
1679                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "%s:%d WRM failed",__FUNCTION__, __LINE__);
1680                 return uiRetVal;
1681         }
1682         return 1;
1683 }
1684
1685 ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *puBufferLength)
1686 {
1687         stLocalSFAddIndicationAlt *pstAddIndicationAlt = NULL;
1688         stLocalSFAddIndication *  pstAddIndication = NULL;
1689         stLocalSFDeleteRequest *pstDeletionRequest;
1690         UINT uiSearchRuleIndex;
1691         ULONG ulSFID;
1692
1693         pstAddIndicationAlt = (stLocalSFAddIndicationAlt *)(pvBuffer);
1694
1695         /*
1696         *       In case of DSD Req By MS, we should immediately delete this SF so that
1697         *       we can stop the further classifying the pkt for this SF.
1698         */
1699         if(pstAddIndicationAlt->u8Type == DSD_REQ)
1700         {
1701                 pstDeletionRequest = (stLocalSFDeleteRequest *)pvBuffer;
1702
1703                 ulSFID = ntohl(pstDeletionRequest->u32SFID);
1704                 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
1705
1706                 if(uiSearchRuleIndex < NO_OF_QUEUES)
1707                 {
1708                         deleteSFBySfid(Adapter,uiSearchRuleIndex);
1709                         Adapter->u32TotalDSD++;
1710                 }
1711                 return 1;
1712         }
1713
1714
1715         if(     (pstAddIndicationAlt->u8Type == DSD_RSP) ||
1716                 (pstAddIndicationAlt->u8Type == DSD_ACK))
1717         {
1718                 //No Special handling send the message as it is
1719                 return 1;
1720         }
1721         // For DSA_REQ, only upto "psfAuthorizedSet" parameter should be accessed by driver!
1722
1723         pstAddIndication=(stLocalSFAddIndication *)kmalloc(sizeof(*pstAddIndication), GFP_KERNEL);
1724         if(NULL==pstAddIndication)
1725                 return 0;
1726
1727         /* AUTHORIZED SET */
1728         pstAddIndication->psfAuthorizedSet = (stServiceFlowParamSI *)
1729                         GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
1730         if(!pstAddIndication->psfAuthorizedSet)
1731                 return 0;
1732
1733         if(StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfAuthorizedSet,
1734                                 (ULONG)pstAddIndication->psfAuthorizedSet)!= 1)
1735                 return 0;
1736
1737         /* this can't possibly be right */
1738         pstAddIndication->psfAuthorizedSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfAuthorizedSet);
1739
1740         if(pstAddIndicationAlt->u8Type == DSA_REQ)
1741         {
1742                 stLocalSFAddRequest AddRequest;
1743
1744                 AddRequest.u8Type = pstAddIndicationAlt->u8Type;
1745                 AddRequest.eConnectionDir = pstAddIndicationAlt->u8Direction;
1746                 AddRequest.u16TID = pstAddIndicationAlt->u16TID;
1747                 AddRequest.u16CID = pstAddIndicationAlt->u16CID;
1748                 AddRequest.u16VCID = pstAddIndicationAlt->u16VCID;
1749                 AddRequest.psfParameterSet =pstAddIndication->psfAuthorizedSet ;
1750                 (*puBufferLength) = sizeof(stLocalSFAddRequest);
1751                 memcpy(pvBuffer,&AddRequest,sizeof(stLocalSFAddRequest));
1752                 return 1;
1753         }
1754
1755         // Since it's not DSA_REQ, we can access all field in pstAddIndicationAlt
1756
1757         //We need to extract the structure from the buffer and pack it differently
1758
1759         pstAddIndication->u8Type = pstAddIndicationAlt->u8Type;
1760         pstAddIndication->eConnectionDir= pstAddIndicationAlt->u8Direction ;
1761         pstAddIndication->u16TID = pstAddIndicationAlt->u16TID;
1762         pstAddIndication->u16CID = pstAddIndicationAlt->u16CID;
1763         pstAddIndication->u16VCID = pstAddIndicationAlt->u16VCID;
1764         pstAddIndication->u8CC = pstAddIndicationAlt->u8CC;
1765
1766         /* ADMITTED SET */
1767         pstAddIndication->psfAdmittedSet = (stServiceFlowParamSI *)
1768                 GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
1769         if(!pstAddIndication->psfAdmittedSet)
1770                 return 0;
1771         if(StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfAdmittedSet,(ULONG)pstAddIndication->psfAdmittedSet) != 1)
1772                 return 0;
1773
1774         pstAddIndication->psfAdmittedSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfAdmittedSet);
1775
1776
1777         /* ACTIVE SET */
1778         pstAddIndication->psfActiveSet = (stServiceFlowParamSI *)
1779                 GetNextTargetBufferLocation(Adapter, pstAddIndicationAlt->u16TID);
1780         if(!pstAddIndication->psfActiveSet)
1781                 return 0;
1782         if(StoreSFParam(Adapter,(PUCHAR)&pstAddIndicationAlt->sfActiveSet,(ULONG)pstAddIndication->psfActiveSet) != 1)
1783                 return 0;
1784
1785         pstAddIndication->psfActiveSet = (stServiceFlowParamSI *)ntohl((ULONG)pstAddIndication->psfActiveSet);
1786
1787         (*puBufferLength) = sizeof(stLocalSFAddIndication);
1788         *(stLocalSFAddIndication *)pvBuffer = *pstAddIndication;
1789         kfree(pstAddIndication);
1790         return 1;
1791 }
1792
1793
1794 static inline stLocalSFAddIndicationAlt
1795 *RestoreCmControlResponseMessage(register PMINI_ADAPTER Adapter,register PVOID pvBuffer)
1796 {
1797         ULONG ulStatus=0;
1798         stLocalSFAddIndication *pstAddIndication = NULL;
1799         stLocalSFAddIndicationAlt *pstAddIndicationDest = NULL;
1800         pstAddIndication = (stLocalSFAddIndication *)(pvBuffer);
1801
1802         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "=====>" );
1803         if ((pstAddIndication->u8Type == DSD_REQ) ||
1804                 (pstAddIndication->u8Type == DSD_RSP) ||
1805                 (pstAddIndication->u8Type == DSD_ACK))
1806         {
1807                 return (stLocalSFAddIndicationAlt *)pvBuffer;
1808         }
1809
1810         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Inside RestoreCmControlResponseMessage ");
1811         /*
1812         //Need to Allocate memory to contain the SUPER Large structures
1813         //Our driver cant create these structures on Stack :(
1814         */
1815         pstAddIndicationDest=kmalloc(sizeof(stLocalSFAddIndicationAlt), GFP_KERNEL);
1816
1817         if(pstAddIndicationDest)
1818         {
1819                 memset(pstAddIndicationDest,0,sizeof(stLocalSFAddIndicationAlt));
1820         }
1821         else
1822         {
1823                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Failed to allocate memory for SF Add Indication Structure ");
1824                 return NULL;
1825         }
1826         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-u8Type : 0x%X",pstAddIndication->u8Type);
1827         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-u8Direction : 0x%X",pstAddIndication->eConnectionDir);
1828         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-u8TID : 0x%X",ntohs(pstAddIndication->u16TID));
1829         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-u8CID : 0x%X",ntohs(pstAddIndication->u16CID));
1830         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-u16VCID : 0x%X",ntohs(pstAddIndication->u16VCID));
1831         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-autorized set loc : %p",pstAddIndication->psfAuthorizedSet);
1832         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-admitted set loc : %p",pstAddIndication->psfAdmittedSet);
1833         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "AddIndication-Active set loc : %p",pstAddIndication->psfActiveSet);
1834
1835         pstAddIndicationDest->u8Type = pstAddIndication->u8Type;
1836         pstAddIndicationDest->u8Direction = pstAddIndication->eConnectionDir;
1837         pstAddIndicationDest->u16TID = pstAddIndication->u16TID;
1838         pstAddIndicationDest->u16CID = pstAddIndication->u16CID;
1839         pstAddIndicationDest->u16VCID = pstAddIndication->u16VCID;
1840         pstAddIndicationDest->u8CC = pstAddIndication->u8CC;
1841
1842         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "Restoring Active Set ");
1843         ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfActiveSet, (PUCHAR)&pstAddIndicationDest->sfActiveSet);
1844         if(ulStatus != 1)
1845         {
1846                 goto failed_restore_sf_param;
1847         }
1848         if(pstAddIndicationDest->sfActiveSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
1849                 pstAddIndicationDest->sfActiveSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
1850
1851         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "Restoring Admitted Set ");
1852         ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfAdmittedSet,(PUCHAR)&pstAddIndicationDest->sfAdmittedSet);
1853         if(ulStatus != 1)
1854         {
1855                 goto failed_restore_sf_param;
1856         }
1857         if(pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
1858                 pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
1859
1860         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "Restoring Authorized Set ");
1861         ulStatus=RestoreSFParam(Adapter,(ULONG)pstAddIndication->psfAuthorizedSet,(PUCHAR)&pstAddIndicationDest->sfAuthorizedSet);
1862         if(ulStatus != 1)
1863         {
1864                 goto failed_restore_sf_param;
1865         }
1866         if(pstAddIndicationDest->sfAuthorizedSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
1867                 pstAddIndicationDest->sfAuthorizedSet.u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF;
1868
1869         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Dumping the whole raw packet");
1870         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============================================================");
1871         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " pstAddIndicationDest->sfActiveSet size  %zx %p", sizeof(*pstAddIndicationDest), pstAddIndicationDest);
1872         //BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, (unsigned char *)pstAddIndicationDest, sizeof(*pstAddIndicationDest));
1873         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============================================================");
1874         return pstAddIndicationDest;
1875 failed_restore_sf_param:
1876         kfree(pstAddIndicationDest);
1877         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "<=====" );
1878         return NULL;
1879 }
1880
1881 ULONG SetUpTargetDsxBuffers(PMINI_ADAPTER Adapter)
1882 {
1883         ULONG ulTargetDsxBuffersBase = 0;
1884         ULONG ulCntTargetBuffers;
1885         ULONG ulIndex=0;
1886         int Status;
1887
1888         if (!Adapter) {
1889                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Adapter was NULL!!!");
1890                 return 0;
1891         }
1892
1893         if(Adapter->astTargetDsxBuffer[0].ulTargetDsxBuffer)
1894                 return 1;
1895
1896         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Size of Each DSX Buffer(Also size of ServiceFlowParamSI): %zx ",sizeof(stServiceFlowParamSI));
1897         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Reading DSX buffer From Target location %x ",DSX_MESSAGE_EXCHANGE_BUFFER);
1898
1899         Status = rdmalt(Adapter, DSX_MESSAGE_EXCHANGE_BUFFER,
1900                                         (PUINT)&ulTargetDsxBuffersBase, sizeof(UINT));
1901         if(Status < 0)
1902         {
1903                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "RDM failed!!");
1904                 return 0;
1905         }
1906
1907         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Base Address Of DSX  Target Buffer : 0x%lx",ulTargetDsxBuffersBase);
1908
1909         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "Tgt Buffer is Now %lx :",ulTargetDsxBuffersBase);
1910
1911         ulCntTargetBuffers = DSX_MESSAGE_EXCHANGE_BUFFER_SIZE/sizeof(stServiceFlowParamSI);
1912
1913         Adapter->ulTotalTargetBuffersAvailable =
1914                 ulCntTargetBuffers > MAX_TARGET_DSX_BUFFERS ?
1915                 MAX_TARGET_DSX_BUFFERS : ulCntTargetBuffers;
1916
1917         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, " Total Target DSX Buffer setup %lx ",Adapter->ulTotalTargetBuffersAvailable);
1918
1919         for(ulIndex=0; ulIndex < Adapter->ulTotalTargetBuffersAvailable ; ulIndex++)
1920         {
1921                 Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer = ulTargetDsxBuffersBase;
1922                 Adapter->astTargetDsxBuffer[ulIndex].valid=1;
1923                 Adapter->astTargetDsxBuffer[ulIndex].tid=0;
1924                 ulTargetDsxBuffersBase+=sizeof(stServiceFlowParamSI);
1925                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "  Target DSX Buffer %lx setup at 0x%lx",
1926                         ulIndex, Adapter->astTargetDsxBuffer[ulIndex].ulTargetDsxBuffer);
1927         }
1928         Adapter->ulCurrentTargetBuffer = 0;
1929         Adapter->ulFreeTargetBufferCnt = Adapter->ulTotalTargetBuffersAvailable;
1930         return 1;
1931 }
1932
1933 ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter,B_UINT16 tid)
1934 {
1935         ULONG  ulTargetDSXBufferAddress;
1936         ULONG  ulTargetDsxBufferIndexToUse,ulMaxTry;
1937
1938         if((Adapter->ulTotalTargetBuffersAvailable == 0)||
1939                         (Adapter->ulFreeTargetBufferCnt == 0))
1940         {
1941         ClearTargetDSXBuffer(Adapter,tid,FALSE);
1942                 return 0;
1943         }
1944
1945     ulTargetDsxBufferIndexToUse = Adapter->ulCurrentTargetBuffer;
1946     ulMaxTry = Adapter->ulTotalTargetBuffersAvailable;
1947         while((ulMaxTry)&&(Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].valid != 1))
1948         {
1949                  ulTargetDsxBufferIndexToUse = (ulTargetDsxBufferIndexToUse+1)%
1950                                         Adapter->ulTotalTargetBuffersAvailable;
1951                  ulMaxTry--;
1952         }
1953
1954         if(ulMaxTry==0)
1955         {
1956                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "\n GetNextTargetBufferLocation : Error No Free Target DSX Buffers FreeCnt : %lx ",Adapter->ulFreeTargetBufferCnt);
1957                 ClearTargetDSXBuffer(Adapter,tid,FALSE);
1958                 return 0;
1959         }
1960
1961
1962         ulTargetDSXBufferAddress =
1963                 Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].ulTargetDsxBuffer;
1964         Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].valid=0;
1965         Adapter->astTargetDsxBuffer[ulTargetDsxBufferIndexToUse].tid=tid;
1966         Adapter->ulFreeTargetBufferCnt--;
1967
1968
1969         ulTargetDsxBufferIndexToUse =
1970                 (ulTargetDsxBufferIndexToUse+1)%Adapter->ulTotalTargetBuffersAvailable;
1971         Adapter->ulCurrentTargetBuffer = ulTargetDsxBufferIndexToUse;
1972         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "GetNextTargetBufferLocation :Returning address %lx tid %d\n",
1973                 ulTargetDSXBufferAddress,tid);
1974         return ulTargetDSXBufferAddress;
1975 }
1976
1977
1978 INT AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter)
1979 {
1980         /*
1981         //Need to Allocate memory to contain the SUPER Large structures
1982         //Our driver cant create these structures on Stack
1983         */
1984         Adapter->caDsxReqResp=kmalloc(sizeof(stLocalSFAddIndicationAlt)+LEADER_SIZE, GFP_KERNEL);
1985         if(!Adapter->caDsxReqResp)
1986                 return -ENOMEM;
1987         return 0;
1988 }
1989
1990 INT FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter)
1991 {
1992         if(Adapter->caDsxReqResp)
1993         {
1994                 kfree(Adapter->caDsxReqResp);
1995         }
1996         return 0;
1997
1998 }
1999 /**
2000 @ingroup ctrl_pkt_functions
2001 This routinue would process the Control responses
2002 for the Connection Management.
2003 @return   - Queue index for the free SFID else returns Invalid Index.
2004 */
2005 BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,  /**<Pointer to the Adapter structure*/
2006                                                                                         PVOID pvBuffer /**Starting Address of the Buffer, that contains the AddIndication Data*/
2007                                                                                         )
2008 {
2009         stServiceFlowParamSI                    *psfLocalSet=NULL;
2010         stLocalSFAddIndicationAlt               *pstAddIndication = NULL;
2011         stLocalSFChangeIndicationAlt    *pstChangeIndication = NULL;
2012         PLEADER                                                 pLeader=NULL;
2013         /*
2014         //Otherwise the message contains a target address from where we need to
2015         //read out the rest of the service flow param structure
2016         */
2017         if((pstAddIndication = RestoreCmControlResponseMessage(Adapter,pvBuffer))
2018                         == NULL)
2019         {
2020                 ClearTargetDSXBuffer(Adapter,((stLocalSFAddIndication *)pvBuffer)->u16TID, FALSE);
2021                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "Error in restoring Service Flow param structure from DSx message");
2022                 return FALSE;
2023         }
2024
2025         DumpCmControlPacket(pstAddIndication);
2026         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "====>");
2027         pLeader = (PLEADER)Adapter->caDsxReqResp;
2028
2029         pLeader->Status =CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
2030         pLeader->Vcid = 0;
2031
2032         ClearTargetDSXBuffer(Adapter,pstAddIndication->u16TID,FALSE);
2033     BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "### TID RECEIVED %d\n",pstAddIndication->u16TID);
2034         switch(pstAddIndication->u8Type)
2035         {
2036                 case DSA_REQ:
2037                 {
2038                         pLeader->PLength = sizeof(stLocalSFAddIndicationAlt);
2039                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Sending DSA Response....\n");
2040                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  "SENDING DSA RESPONSE TO MAC %d", pLeader->PLength );
2041                         *((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))
2042                                                 = *pstAddIndication;
2043                         ((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_RSP;
2044
2045                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,  " VCID = %x", ntohs(pstAddIndication->u16VCID));
2046                         CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2047                         kfree(pstAddIndication);
2048                 }
2049                 break;
2050                 case DSA_RSP:
2051                 {
2052                         pLeader->PLength = sizeof(stLocalSFAddIndicationAlt);
2053                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA ACK TO MAC %d",
2054                                 pLeader->PLength);
2055                         *((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))
2056                                                 = *pstAddIndication;
2057                         ((stLocalSFAddIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_ACK;
2058
2059                 }//no break here..we should go down.
2060                 case DSA_ACK:
2061                 {
2062                         UINT uiSearchRuleIndex=0;
2063                         struct timeval tv = {0};
2064                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "VCID:0x%X",
2065                                 ntohs(pstAddIndication->u16VCID));
2066             uiSearchRuleIndex=SearchFreeSfid(Adapter);
2067             BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"uiSearchRuleIndex:0x%X ",
2068                                 uiSearchRuleIndex);
2069                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Direction:0x%X ",
2070                                 pstAddIndication->u8Direction);
2071                         if((uiSearchRuleIndex< NO_OF_QUEUES) )
2072                         {
2073                                 Adapter->PackInfo[uiSearchRuleIndex].ucDirection =
2074                                         pstAddIndication->u8Direction;
2075                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "bValid:0x%X ",
2076                                         pstAddIndication->sfActiveSet.bValid);
2077                                 if(pstAddIndication->sfActiveSet.bValid==TRUE)
2078                                 {
2079                                         Adapter->PackInfo[uiSearchRuleIndex].bActiveSet=TRUE;
2080                                 }
2081                                 if(pstAddIndication->sfAuthorizedSet.bValid==TRUE)
2082                                 {
2083                                         Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet=TRUE;
2084                                 }
2085                                 if(pstAddIndication->sfAdmittedSet.bValid==TRUE)
2086                                 {
2087                                         Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet=TRUE;
2088                                 }
2089                                 if(FALSE == pstAddIndication->sfActiveSet.bValid)
2090                                 {
2091                                         Adapter->PackInfo[uiSearchRuleIndex].bActive = FALSE;
2092                                         Adapter->PackInfo[uiSearchRuleIndex].bActivateRequestSent = FALSE;
2093                                         if(pstAddIndication->sfAdmittedSet.bValid)
2094                                         {
2095                                                 psfLocalSet = &pstAddIndication->sfAdmittedSet;
2096                                         }
2097                                         else if(pstAddIndication->sfAuthorizedSet.bValid)
2098                                         {
2099                                                 psfLocalSet = &pstAddIndication->sfAuthorizedSet;
2100                                         }
2101                                 }
2102                                 else
2103                                 {
2104                                         psfLocalSet = &pstAddIndication->sfActiveSet;
2105                                         Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2106                                 }
2107
2108                                 if(!psfLocalSet)
2109                                 {
2110                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "No set is valid\n");
2111                                         Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2112                     Adapter->PackInfo[uiSearchRuleIndex].bValid=FALSE;
2113                                         Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value=0;
2114                                         kfree(pstAddIndication);
2115                                 }
2116
2117                                 else if(psfLocalSet->bValid && (pstAddIndication->u8CC == 0))
2118                                 {
2119                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSA ACK");
2120                                         Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value =
2121                                                 ntohs(pstAddIndication->u16VCID);
2122                                         Adapter->PackInfo[uiSearchRuleIndex].usCID =
2123                                                 ntohs(pstAddIndication->u16CID);
2124
2125                                         if(UPLINK_DIR == pstAddIndication->u8Direction)
2126                                                 atomic_set(&Adapter->PackInfo[uiSearchRuleIndex].uiPerSFTxResourceCount, DEFAULT_PERSFCOUNT);
2127                                         CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
2128                                                                 DSA_ACK, pstAddIndication);
2129                                         // don't free pstAddIndication
2130
2131                                         /* Inside CopyToAdapter, Sorting of all the SFs take place.
2132                                             Hence any access to the newly added SF through uiSearchRuleIndex is invalid.
2133                                             SHOULD BE STRICTLY AVOIDED.
2134                                         */
2135 //                                      *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
2136                                         memcpy((((PUCHAR)pvBuffer)+1), &psfLocalSet->u32SFID, 4);
2137
2138                                         if(pstAddIndication->sfActiveSet.bValid == TRUE)
2139                                         {
2140                                                 if(UPLINK_DIR == pstAddIndication->u8Direction)
2141                                                 {
2142                                                         if(!Adapter->LinkUpStatus)
2143                                                         {
2144                                                                 netif_carrier_on(Adapter->dev);
2145                                                         netif_start_queue(Adapter->dev);
2146                                                                 Adapter->LinkUpStatus = 1;
2147                                                                 do_gettimeofday(&tv);
2148
2149                                                                 atomic_set(&Adapter->TxPktAvail, 1);
2150                                                                 wake_up(&Adapter->tx_packet_wait_queue);
2151                                                                 Adapter->liTimeSinceLastNetEntry = tv.tv_sec;
2152                                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "============Tx Service Flow Created!");
2153                                                         }
2154                                                 }
2155                                         }
2156                                 }
2157
2158                                 else
2159                                 {
2160                                         Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2161                     Adapter->PackInfo[uiSearchRuleIndex].bValid=FALSE;
2162                                         Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value=0;
2163                                         kfree(pstAddIndication);
2164                                 }
2165                         }
2166                         else
2167                         {
2168                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "DSA ACK did not get valid SFID");
2169                                 kfree(pstAddIndication);
2170                                 return FALSE;
2171                         }
2172                 }
2173                 break;
2174                 case DSC_REQ:
2175                 {
2176                         pLeader->PLength = sizeof(stLocalSFChangeIndicationAlt);
2177                         pstChangeIndication     = (stLocalSFChangeIndicationAlt*)pstAddIndication;
2178                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC RESPONSE TO MAC %d", pLeader->PLength);
2179
2180                         *((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
2181                         ((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_RSP;
2182
2183                         CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2184                         kfree(pstAddIndication);
2185                 }
2186                 break;
2187                 case DSC_RSP:
2188                 {
2189                         pLeader->PLength = sizeof(stLocalSFChangeIndicationAlt);
2190                         pstChangeIndication     = (stLocalSFChangeIndicationAlt*)pstAddIndication;
2191                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC ACK TO MAC %d", pLeader->PLength);
2192                         *((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
2193                         ((stLocalSFChangeIndicationAlt*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_ACK;
2194                 }
2195                 case DSC_ACK:
2196                 {
2197                         UINT uiSearchRuleIndex=0;
2198
2199                         pstChangeIndication = (stLocalSFChangeIndicationAlt *)pstAddIndication;
2200                         uiSearchRuleIndex=SearchSfid(Adapter,ntohl(pstChangeIndication->sfActiveSet.u32SFID));
2201                         if(uiSearchRuleIndex > NO_OF_QUEUES-1)
2202                         {
2203                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "SF doesn't exist for which DSC_ACK is received");
2204                         }
2205                         if((uiSearchRuleIndex < NO_OF_QUEUES))
2206                         {
2207                                 Adapter->PackInfo[uiSearchRuleIndex].ucDirection = pstChangeIndication->u8Direction;
2208                                 if(pstChangeIndication->sfActiveSet.bValid==TRUE)
2209                                 {
2210                                         Adapter->PackInfo[uiSearchRuleIndex].bActiveSet=TRUE;
2211                                 }
2212                                 if(pstChangeIndication->sfAuthorizedSet.bValid==TRUE)
2213                                 {
2214                                         Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet=TRUE;
2215                                 }
2216                                 if(pstChangeIndication->sfAdmittedSet.bValid==TRUE)
2217                                 {
2218                                         Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet=TRUE;
2219                                 }
2220
2221                                 if(FALSE==pstChangeIndication->sfActiveSet.bValid)
2222                                 {
2223                                         Adapter->PackInfo[uiSearchRuleIndex].bActive = FALSE;
2224                                         Adapter->PackInfo[uiSearchRuleIndex].bActivateRequestSent = FALSE;
2225                                         if(pstChangeIndication->sfAdmittedSet.bValid)
2226                                         {
2227                                                 psfLocalSet = &pstChangeIndication->sfAdmittedSet;
2228                                         }
2229                                         else if(pstChangeIndication->sfAuthorizedSet.bValid)
2230                                         {
2231                                                 psfLocalSet = &pstChangeIndication->sfAuthorizedSet;
2232                                         }
2233                                 }
2234
2235                                 else
2236                                 {
2237                                         psfLocalSet = &pstChangeIndication->sfActiveSet;
2238                                         Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2239                                 }
2240                                 if(psfLocalSet->bValid && (pstChangeIndication->u8CC == 0))
2241                                 {
2242                                         Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value =
2243                                                 ntohs(pstChangeIndication->u16VCID);
2244                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "CC field is %d bvalid = %d\n",
2245                                                         pstChangeIndication->u8CC, psfLocalSet->bValid);
2246                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "VCID= %d\n", ntohs(pstChangeIndication->u16VCID));
2247                                         Adapter->PackInfo[uiSearchRuleIndex].usCID =
2248                                                 ntohs(pstChangeIndication->u16CID);
2249                                         CopyToAdapter(Adapter,psfLocalSet,uiSearchRuleIndex,
2250                                                                 DSC_ACK, pstAddIndication);
2251
2252                                         *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID;
2253                                 }
2254                                 else if(pstChangeIndication->u8CC == 6)
2255                                 {
2256                                         deleteSFBySfid(Adapter,uiSearchRuleIndex);
2257                                         kfree(pstAddIndication);
2258                                 }
2259                         }
2260                         else
2261                         {
2262                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0, "DSC ACK did not get valid SFID");
2263                                 kfree(pstAddIndication);
2264                                 return FALSE;
2265                         }
2266                 }
2267                 break;
2268                 case DSD_REQ:
2269                 {
2270                         UINT uiSearchRuleIndex;
2271                         ULONG ulSFID;
2272
2273                         pLeader->PLength = sizeof(stLocalSFDeleteIndication);
2274                         *((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *((stLocalSFDeleteIndication*)pstAddIndication);
2275
2276                         ulSFID = ntohl(((stLocalSFDeleteIndication*)pstAddIndication)->u32SFID);
2277                         uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
2278                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD - Removing connection %x",uiSearchRuleIndex);
2279
2280                         if(uiSearchRuleIndex < NO_OF_QUEUES)
2281                         {
2282                                 //Delete All Classifiers Associated with this SFID
2283                                 deleteSFBySfid(Adapter,uiSearchRuleIndex);
2284                                 Adapter->u32TotalDSD++;
2285                         }
2286
2287                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSD RESPONSE TO MAC");
2288                         ((stLocalSFDeleteIndication*)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSD_RSP;
2289                         CopyBufferToControlPacket(Adapter,(PVOID)Adapter->caDsxReqResp);
2290                 }
2291                 case DSD_RSP:
2292                 {
2293                         //Do nothing as SF has already got Deleted
2294                 }
2295                 break;
2296         case DSD_ACK:
2297                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD ACK Rcd, let App handle it\n");
2298                         break;
2299         default:
2300                 kfree(pstAddIndication);
2301                 return FALSE ;
2302         }
2303         return TRUE;
2304 }
2305
2306 int get_dsx_sf_data_to_application(PMINI_ADAPTER Adapter, UINT uiSFId, void __user *user_buffer)
2307 {
2308         int status = 0;
2309         struct _packet_info *psSfInfo=NULL;
2310         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d",status);
2311         status = SearchSfid(Adapter, uiSFId);
2312         if (status >= NO_OF_QUEUES) {
2313                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SFID %d not present in queue !!!", uiSFId );
2314                 return -EINVAL;
2315         }
2316         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d",status);
2317         psSfInfo=&Adapter->PackInfo[status];
2318         if(psSfInfo->pstSFIndication && copy_to_user(user_buffer,
2319                 psSfInfo->pstSFIndication, sizeof(stLocalSFAddIndicationAlt)))
2320         {
2321                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy to user failed SFID %d, present in queue !!!", uiSFId );
2322                 status = -EFAULT;
2323                 return status;
2324         }
2325         return STATUS_SUCCESS;
2326 }
2327
2328 VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer)
2329 {
2330         B_UINT32 u32NumofSFsinMsg    = ntohl(*(puiBuffer + 1));
2331         stIM_SFHostNotify *pHostInfo = NULL;
2332         UINT uiSearchRuleIndex       = 0;
2333         ULONG ulSFID                 = 0;
2334
2335         puiBuffer+=2;
2336
2337         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "u32NumofSFsinMsg: 0x%x\n",u32NumofSFsinMsg);
2338
2339         while(u32NumofSFsinMsg != 0 && u32NumofSFsinMsg < NO_OF_QUEUES)
2340         {
2341                 u32NumofSFsinMsg--;
2342                 pHostInfo = (stIM_SFHostNotify *)puiBuffer;
2343                 puiBuffer = (PUINT)(pHostInfo + 1);
2344
2345                 ulSFID = ntohl(pHostInfo->SFID);
2346                 uiSearchRuleIndex=SearchSfid(Adapter,ulSFID);
2347                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"SFID: 0x%lx\n",ulSFID);
2348
2349                 if(uiSearchRuleIndex >= NO_OF_QUEUES || uiSearchRuleIndex == HiPriority)
2350                 {
2351                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"The SFID <%lx> doesn't exist in host entry or is Invalid\n", ulSFID);
2352                         continue;
2353                 }
2354
2355                 if(pHostInfo->RetainSF == FALSE)
2356                 {
2357                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"Going to Delete SF");
2358                         deleteSFBySfid(Adapter,uiSearchRuleIndex);
2359                 }
2360                 else
2361                 {
2362
2363                         Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value = ntohs(pHostInfo->VCID);
2364                         Adapter->PackInfo[uiSearchRuleIndex].usCID = ntohs(pHostInfo->newCID);
2365                         Adapter->PackInfo[uiSearchRuleIndex].bActive=FALSE;
2366
2367                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,"pHostInfo->QoSParamSet: 0x%x\n",pHostInfo->QoSParamSet);
2368
2369                         if(pHostInfo->QoSParamSet & 0x1)
2370                                 Adapter->PackInfo[uiSearchRuleIndex].bAuthorizedSet =TRUE;
2371                         if(pHostInfo->QoSParamSet & 0x2)
2372                                 Adapter->PackInfo[uiSearchRuleIndex].bAdmittedSet =TRUE;
2373                         if(pHostInfo->QoSParamSet & 0x4)
2374                         {
2375                                 Adapter->PackInfo[uiSearchRuleIndex].bActiveSet =TRUE;
2376                                 Adapter->PackInfo[uiSearchRuleIndex].bActive=TRUE;
2377                         }
2378                 }
2379         }
2380 }
2381
2382
2383