drivers/staging/bcm/PHSModule.c

   1 #include "headers.h"
   2
   3 #define IN
   4 #define OUT
   5
   6 void DumpDataPacketHeader(PUCHAR pPkt);
   7
   8 /*
   9 Function:                               PHSTransmit
  10
  11 Description:                    This routine handle PHS(Payload Header Suppression for Tx path.
  12                                         It extracts a fragment of the NDIS_PACKET containing the header
  13                                         to be suppressed.It then supresses the header by invoking PHS exported compress routine.
  14                                         The header data after supression is copied back to the NDIS_PACKET.
  15
  16
  17 Input parameters:               IN PMINI_ADAPTER Adapter         - Miniport Adapter Context
  18                                                 IN Packet                               - NDIS packet containing data to be transmitted
  19                                                 IN USHORT Vcid        - vcid pertaining to connection on which the packet is being sent.Used to
  20                                                                                         identify PHS rule to be applied.
  21                                                 B_UINT16 uiClassifierRuleID - Classifier Rule ID
  22                                                 BOOLEAN bHeaderSuppressionEnabled - indicates if header suprression is enabled for SF.
  23
  24 Return:                                 STATUS_SUCCESS - If the send was successful.
  25                                                 Other          - If an error occured.
  26 */
  27
  28 int PHSTransmit(PMINI_ADAPTER Adapter,
  29                                          struct sk_buff **pPacket,
  30                                          USHORT Vcid,
  31                                          B_UINT16 uiClassifierRuleID,
  32                                          BOOLEAN bHeaderSuppressionEnabled,
  33                                          UINT *PacketLen,
  34                                          UCHAR bEthCSSupport)
  35 {
  36
  37         //PHS Sepcific
  38         UINT    unPHSPktHdrBytesCopied = 0;
  39         UINT    unPhsOldHdrSize = 0;
  40         UINT    unPHSNewPktHeaderLen = 0;
  41         /* Pointer to PHS IN Hdr Buffer */
  42         PUCHAR pucPHSPktHdrInBuf =
  43                                 Adapter->stPhsTxContextInfo.ucaHdrSupressionInBuf;
  44         /* Pointer to PHS OUT Hdr Buffer */
  45         PUCHAR  pucPHSPktHdrOutBuf =
  46                                         Adapter->stPhsTxContextInfo.ucaHdrSupressionOutBuf;
  47         UINT       usPacketType;
  48         UINT       BytesToRemove=0;
  49         BOOLEAN  bPHSI = 0;
  50         LONG ulPhsStatus = 0;
  51         UINT    numBytesCompressed = 0;
  52         struct sk_buff *newPacket = NULL;
  53         struct sk_buff *Packet = *pPacket;
  54
  55         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL, "In PHSTransmit");
  56
  57         if(!bEthCSSupport)
  58                 BytesToRemove=ETH_HLEN;
  59         /*
  60                 Accumulate the header upto the size we support supression
  61                 from NDIS packet
  62         */
  63
  64         usPacketType=((struct ethhdr *)(Packet->data))->h_proto;
  65
  66
  67         pucPHSPktHdrInBuf = Packet->data + BytesToRemove;
  68         //considering data after ethernet header
  69         if((*PacketLen - BytesToRemove) < MAX_PHS_LENGTHS)
  70         {
  71
  72                 unPHSPktHdrBytesCopied = (*PacketLen - BytesToRemove);
  73         }
  74         else
  75         {
  76                 unPHSPktHdrBytesCopied = MAX_PHS_LENGTHS;
  77         }
  78
  79         if( (unPHSPktHdrBytesCopied > 0 ) &&
  80                 (unPHSPktHdrBytesCopied <= MAX_PHS_LENGTHS))
  81         {
  82
  83
  84                 //DumpDataPacketHeader(pucPHSPktHdrInBuf);
  85
  86                 // Step 2 Supress Header using PHS and fill into intermediate ucaPHSPktHdrOutBuf.
  87         // Suppress only if IP Header and PHS Enabled For the Service Flow
  88                 if(((usPacketType == ETHERNET_FRAMETYPE_IPV4) ||
  89                         (usPacketType == ETHERNET_FRAMETYPE_IPV6)) &&
  90                         (bHeaderSuppressionEnabled))
  91                 {
  92                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nTrying to PHS Compress Using Classifier rule 0x%X",uiClassifierRuleID);
  93
  94
  95                                 unPHSNewPktHeaderLen = unPHSPktHdrBytesCopied;
  96                                 ulPhsStatus = PhsCompress(&Adapter->stBCMPhsContext,
  97                                         Vcid,
  98                                         uiClassifierRuleID,
  99                                         pucPHSPktHdrInBuf,
 100                                         pucPHSPktHdrOutBuf,
 101                                         &unPhsOldHdrSize,
 102                                         &unPHSNewPktHeaderLen);
 103                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nPHS Old header Size : %d New Header Size  %d\n",unPhsOldHdrSize,unPHSNewPktHeaderLen);
 104
 105                                 if(unPHSNewPktHeaderLen == unPhsOldHdrSize)
 106                                 {
 107                                         if(  ulPhsStatus == STATUS_PHS_COMPRESSED)
 108                                                         bPHSI = *pucPHSPktHdrOutBuf;
 109                                         ulPhsStatus = STATUS_PHS_NOCOMPRESSION;
 110                                 }
 111
 112                                 if(  ulPhsStatus == STATUS_PHS_COMPRESSED)
 113                                 {
 114                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"PHS Sending packet Compressed");
 115
 116                                         if(skb_cloned(Packet))
 117                                         {
 118                                                 newPacket = skb_copy(Packet, GFP_ATOMIC);
 119
 120                                                 if(newPacket == NULL)
 121                                                         return STATUS_FAILURE;
 122
 123                                                 dev_kfree_skb(Packet);
 124                                                 *pPacket = Packet = newPacket;
 125                                                 pucPHSPktHdrInBuf = Packet->data  + BytesToRemove;
 126                                         }
 127
 128                                         numBytesCompressed = unPhsOldHdrSize - (unPHSNewPktHeaderLen+PHSI_LEN);
 129
 130                                         memcpy(pucPHSPktHdrInBuf + numBytesCompressed, pucPHSPktHdrOutBuf, unPHSNewPktHeaderLen + PHSI_LEN);
 131                                         memcpy(Packet->data + numBytesCompressed, Packet->data, BytesToRemove);
 132                                         skb_pull(Packet, numBytesCompressed);
 133
 134                                         return STATUS_SUCCESS;
 135                                 }
 136
 137                                 else
 138                                 {
 139                                         //if one byte headroom is not available, increase it through skb_cow
 140                                         if(!(skb_headroom(Packet) > 0))
 141                                         {
 142                                                 if(skb_cow(Packet, 1))
 143                                                 {
 144                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "SKB Cow Failed\n");
 145                                                         return STATUS_FAILURE;
 146                                                 }
 147                                         }
 148                                         skb_push(Packet, 1);
 149
 150                                         // CAUTION: The MAC Header is getting corrupted here for IP CS - can be saved by copying 14 Bytes.  not needed .... hence corrupting it.
 151                                         *(Packet->data + BytesToRemove) = bPHSI;
 152                                         return STATUS_SUCCESS;
 153                         }
 154                 }
 155                 else
 156                 {
 157                         if(!bHeaderSuppressionEnabled)
 158                         {
 159                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nHeader Suppression Disabled For SF: No PHS\n");
 160                         }
 161
 162                         return STATUS_SUCCESS;
 163                 }
 164         }
 165
 166         //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"PHSTransmit : Dumping data packet After PHS");
 167         return STATUS_SUCCESS;
 168 }
 169
 170 int PHSRecieve(PMINI_ADAPTER Adapter,
 171                                         USHORT usVcid,
 172                                         struct sk_buff *packet,
 173                                         UINT *punPacketLen,
 174                                         UCHAR *pucEthernetHdr,
 175                                         UINT    bHeaderSuppressionEnabled)
 176 {
 177         u32   nStandardPktHdrLen                        = 0;
 178         u32   nTotalsupressedPktHdrBytes  = 0;
 179         int     ulPhsStatus             = 0;
 180         PUCHAR pucInBuff = NULL ;
 181         UINT TotalBytesAdded = 0;
 182         if(!bHeaderSuppressionEnabled)
 183         {
 184                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"\nPhs Disabled for incoming packet");
 185                 return ulPhsStatus;
 186         }
 187
 188         pucInBuff = packet->data;
 189
 190         //Restore  PHS suppressed header
 191         nStandardPktHdrLen = packet->len;
 192         ulPhsStatus = PhsDeCompress(&Adapter->stBCMPhsContext,
 193                 usVcid,
 194                 pucInBuff,
 195                 Adapter->ucaPHSPktRestoreBuf,
 196                 &nTotalsupressedPktHdrBytes,
 197                 &nStandardPktHdrLen);
 198
 199         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"\nSupressed PktHdrLen : 0x%x Restored PktHdrLen : 0x%x",
 200                                         nTotalsupressedPktHdrBytes,nStandardPktHdrLen);
 201
 202         if(ulPhsStatus != STATUS_PHS_COMPRESSED)
 203         {
 204                 skb_pull(packet, 1);
 205                 return STATUS_SUCCESS;
 206         }
 207         else
 208         {
 209                 TotalBytesAdded = nStandardPktHdrLen - nTotalsupressedPktHdrBytes - PHSI_LEN;
 210                 if(TotalBytesAdded)
 211                 {
 212                         if(skb_headroom(packet) >= (SKB_RESERVE_ETHERNET_HEADER + TotalBytesAdded))
 213                                 skb_push(packet, TotalBytesAdded);
 214                         else
 215                         {
 216                                 if(skb_cow(packet, skb_headroom(packet) + TotalBytesAdded))
 217                                 {
 218                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "cow failed in receive\n");
 219                                         return STATUS_FAILURE;
 220                                 }
 221
 222                                 skb_push(packet, TotalBytesAdded);
 223                         }
 224                 }
 225
 226                 memcpy(packet->data, Adapter->ucaPHSPktRestoreBuf, nStandardPktHdrLen);
 227         }
 228
 229         return STATUS_SUCCESS;
 230 }
 231
 232 void DumpDataPacketHeader(PUCHAR pPkt)
 233 {
 234         struct iphdr *iphd = (struct iphdr*)pPkt;
 235     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 236         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"Phs Send/Recieve : IP Packet Hdr \n");
 237         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"TOS : %x \n",iphd->tos);
 238         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"Src  IP : %x \n",iphd->saddr);
 239         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"Dest IP : %x \n \n",iphd->daddr);
 240
 241 }
 242
 243 void DumpFullPacket(UCHAR *pBuf,UINT nPktLen)
 244 {
 245         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 246     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"Dumping Data Packet");
 247     BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,pBuf,nPktLen);
 248 }
 249
 250 //-----------------------------------------------------------------------------
 251 // Procedure:   phs_init
 252 //
 253 // Description: This routine is responsible for allocating memory for classifier and
 254 // PHS rules.
 255 //
 256 // Arguments:
 257 // pPhsdeviceExtension - ptr to Device extension containing PHS Classifier rules and PHS Rules , RX, TX buffer etc
 258 //
 259 // Returns:
 260 // TRUE(1)      -If allocation of memory was success full.
 261 // FALSE        -If allocation of memory fails.
 262 //-----------------------------------------------------------------------------
 263 int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension,PMINI_ADAPTER Adapter)
 264 {
 265         int i;
 266         S_SERVICEFLOW_TABLE *pstServiceFlowTable;
 267     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nPHS:phs_init function ");
 268
 269         if(pPhsdeviceExtension->pstServiceFlowPhsRulesTable)
 270                 return -EINVAL;
 271
 272         pPhsdeviceExtension->pstServiceFlowPhsRulesTable =
 273                 kzalloc(sizeof(S_SERVICEFLOW_TABLE), GFP_KERNEL);
 274
 275     if(!pPhsdeviceExtension->pstServiceFlowPhsRulesTable)
 276         {
 277                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nAllocation ServiceFlowPhsRulesTable failed");
 278                 return -ENOMEM;
 279         }
 280
 281         pstServiceFlowTable = pPhsdeviceExtension->pstServiceFlowPhsRulesTable;
 282         for(i=0;i<MAX_SERVICEFLOWS;i++)
 283         {
 284                 S_SERVICEFLOW_ENTRY sServiceFlow = pstServiceFlowTable->stSFList[i];
 285                 sServiceFlow.pstClassifierTable = kzalloc(sizeof(S_CLASSIFIER_TABLE), GFP_KERNEL);
 286                 if(!sServiceFlow.pstClassifierTable)
 287                 {
 288                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nAllocation failed");
 289                         free_phs_serviceflow_rules(pPhsdeviceExtension->
 290                 pstServiceFlowPhsRulesTable);
 291                         pPhsdeviceExtension->pstServiceFlowPhsRulesTable = NULL;
 292                         return -ENOMEM;
 293                 }
 294         }
 295
 296         pPhsdeviceExtension->CompressedTxBuffer = kmalloc(PHS_BUFFER_SIZE, GFP_KERNEL);
 297
 298     if(pPhsdeviceExtension->CompressedTxBuffer == NULL)
 299         {
 300                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nAllocation failed");
 301                 free_phs_serviceflow_rules(pPhsdeviceExtension->pstServiceFlowPhsRulesTable);
 302                 pPhsdeviceExtension->pstServiceFlowPhsRulesTable = NULL;
 303                 return -ENOMEM;
 304         }
 305
 306     pPhsdeviceExtension->UnCompressedRxBuffer = kmalloc(PHS_BUFFER_SIZE, GFP_KERNEL);
 307         if(pPhsdeviceExtension->UnCompressedRxBuffer == NULL)
 308         {
 309                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nAllocation failed");
 310                 kfree(pPhsdeviceExtension->CompressedTxBuffer);
 311                 free_phs_serviceflow_rules(pPhsdeviceExtension->pstServiceFlowPhsRulesTable);
 312                 pPhsdeviceExtension->pstServiceFlowPhsRulesTable = NULL;
 313                 return -ENOMEM;
 314         }
 315
 316
 317
 318         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\n phs_init Successfull");
 319         return STATUS_SUCCESS;
 320 }
 321
 322
 323 int PhsCleanup(IN PPHS_DEVICE_EXTENSION pPHSDeviceExt)
 324 {
 325         if(pPHSDeviceExt->pstServiceFlowPhsRulesTable)
 326         {
 327                 free_phs_serviceflow_rules(pPHSDeviceExt->pstServiceFlowPhsRulesTable);
 328                 pPHSDeviceExt->pstServiceFlowPhsRulesTable = NULL;
 329         }
 330
 331         kfree(pPHSDeviceExt->CompressedTxBuffer);
 332         pPHSDeviceExt->CompressedTxBuffer = NULL;
 333
 334         kfree(pPHSDeviceExt->UnCompressedRxBuffer);
 335         pPHSDeviceExt->UnCompressedRxBuffer = NULL;
 336
 337         return 0;
 338 }
 339
 340
 341
 342 //PHS functions
 343 /*++
 344 PhsUpdateClassifierRule
 345
 346 Routine Description:
 347     Exported function to add or modify a PHS Rule.
 348
 349 Arguments:
 350         IN void* pvContext - PHS Driver Specific Context
 351         IN B_UINT16 uiVcid    - The Service Flow ID for which the PHS rule applies
 352         IN B_UINT16  uiClsId   - The Classifier ID within the Service Flow for which the PHS rule applies.
 353         IN S_PHS_RULE *psPhsRule - The PHS Rule strcuture to be added to the PHS Rule table.
 354
 355 Return Value:
 356
 357     0 if successful,
 358     >0 Error.
 359
 360 --*/
 361 ULONG PhsUpdateClassifierRule(IN void* pvContext,
 362                                                                 IN B_UINT16  uiVcid ,
 363                                                                 IN B_UINT16  uiClsId   ,
 364                                                                 IN S_PHS_RULE *psPhsRule,
 365                                                                 IN B_UINT8  u8AssociatedPHSI)
 366 {
 367         ULONG lStatus =0;
 368         UINT nSFIndex =0 ;
 369         S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
 370     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 371
 372
 373
 374         PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
 375
 376         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"PHS With Corr2 Changes \n");
 377
 378         if(pDeviceExtension == NULL)
 379         {
 380                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"Invalid Device Extension\n");
 381                 return ERR_PHS_INVALID_DEVICE_EXETENSION;
 382         }
 383
 384
 385         if(u8AssociatedPHSI == 0)
 386         {
 387                 return ERR_PHS_INVALID_PHS_RULE;
 388         }
 389
 390         /* Retrieve the SFID Entry Index for requested Service Flow */
 391
 392         nSFIndex = GetServiceFlowEntry(pDeviceExtension->pstServiceFlowPhsRulesTable,
 393                         uiVcid,&pstServiceFlowEntry);
 394
 395     if(nSFIndex == PHS_INVALID_TABLE_INDEX)
 396         {
 397                 /* This is a new SF. Create a mapping entry for this */
 398                 lStatus = CreateSFToClassifierRuleMapping(uiVcid, uiClsId,
 399                       pDeviceExtension->pstServiceFlowPhsRulesTable, psPhsRule, u8AssociatedPHSI);
 400                 return lStatus;
 401         }
 402
 403         /* SF already Exists Add PHS Rule to existing SF */
 404         lStatus = CreateClassiferToPHSRuleMapping(uiVcid, uiClsId,
 405                   pstServiceFlowEntry, psPhsRule, u8AssociatedPHSI);
 406
 407     return lStatus;
 408 }
 409
 410 /*++
 411 PhsDeletePHSRule
 412
 413 Routine Description:
 414    Deletes the specified phs Rule within Vcid
 415
 416 Arguments:
 417         IN void* pvContext - PHS Driver Specific Context
 418         IN B_UINT16  uiVcid    - The Service Flow ID for which the PHS rule applies
 419         IN B_UINT8  u8PHSI   - the PHS Index identifying PHS rule to be deleted.
 420
 421 Return Value:
 422
 423     0 if successful,
 424     >0 Error.
 425
 426 --*/
 427
 428 ULONG PhsDeletePHSRule(IN void* pvContext,IN B_UINT16 uiVcid,IN B_UINT8 u8PHSI)
 429 {
 430         ULONG lStatus =0;
 431         UINT nSFIndex =0, nClsidIndex =0 ;
 432         S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
 433         S_CLASSIFIER_TABLE *pstClassifierRulesTable = NULL;
 434     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 435
 436
 437         PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
 438
 439         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "======>\n");
 440
 441         if(pDeviceExtension)
 442         {
 443
 444                 //Retrieve the SFID Entry Index for requested Service Flow
 445                 nSFIndex = GetServiceFlowEntry(pDeviceExtension
 446                       ->pstServiceFlowPhsRulesTable,uiVcid,&pstServiceFlowEntry);
 447
 448        if(nSFIndex == PHS_INVALID_TABLE_INDEX)
 449                 {
 450                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "SFID Match Failed\n");
 451                         return ERR_SF_MATCH_FAIL;
 452                 }
 453
 454                 pstClassifierRulesTable=pstServiceFlowEntry->pstClassifierTable;
 455                 if(pstClassifierRulesTable)
 456                 {
 457                         for(nClsidIndex=0;nClsidIndex<MAX_PHSRULE_PER_SF;nClsidIndex++)
 458                         {
 459                                 if(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].bUsed && pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule)
 460                                 {
 461                                         if(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule->u8PHSI == u8PHSI)                                     {
 462                                                 if(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule->u8RefCnt)
 463                                                         pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule->u8RefCnt--;
 464                                                 if(0 == pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule->u8RefCnt)
 465                                                         kfree(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule);
 466                                                 memset(&pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex], 0,
 467                                                         sizeof(S_CLASSIFIER_ENTRY));
 468                                         }
 469                                 }
 470                         }
 471                 }
 472
 473         }
 474         return lStatus;
 475 }
 476
 477 /*++
 478 PhsDeleteClassifierRule
 479
 480 Routine Description:
 481     Exported function to Delete a PHS Rule for the SFID,CLSID Pair.
 482
 483 Arguments:
 484         IN void* pvContext - PHS Driver Specific Context
 485         IN B_UINT16  uiVcid    - The Service Flow ID for which the PHS rule applies
 486         IN B_UINT16  uiClsId   - The Classifier ID within the Service Flow for which the PHS rule applies.
 487
 488 Return Value:
 489
 490     0 if successful,
 491     >0 Error.
 492
 493 --*/
 494 ULONG PhsDeleteClassifierRule(IN void* pvContext,IN B_UINT16 uiVcid ,IN B_UINT16  uiClsId)
 495 {
 496         ULONG lStatus =0;
 497         UINT nSFIndex =0, nClsidIndex =0 ;
 498         S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
 499         S_CLASSIFIER_ENTRY *pstClassifierEntry = NULL;
 500     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 501         PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
 502
 503         if(pDeviceExtension)
 504         {
 505                 //Retrieve the SFID Entry Index for requested Service Flow
 506                 nSFIndex = GetServiceFlowEntry(pDeviceExtension
 507                       ->pstServiceFlowPhsRulesTable, uiVcid, &pstServiceFlowEntry);
 508                 if(nSFIndex == PHS_INVALID_TABLE_INDEX)
 509                 {
 510                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"SFID Match Failed\n");
 511                         return ERR_SF_MATCH_FAIL;
 512                 }
 513
 514                 nClsidIndex = GetClassifierEntry(pstServiceFlowEntry->pstClassifierTable,
 515                   uiClsId, eActiveClassifierRuleContext, &pstClassifierEntry);
 516                 if((nClsidIndex != PHS_INVALID_TABLE_INDEX) && (!pstClassifierEntry->bUnclassifiedPHSRule))
 517                 {
 518                         if(pstClassifierEntry->pstPhsRule)
 519                         {
 520                                 if(pstClassifierEntry->pstPhsRule->u8RefCnt)
 521                                 pstClassifierEntry->pstPhsRule->u8RefCnt--;
 522                                 if(0==pstClassifierEntry->pstPhsRule->u8RefCnt)
 523                                         kfree(pstClassifierEntry->pstPhsRule);
 524
 525                         }
 526                         memset(pstClassifierEntry, 0, sizeof(S_CLASSIFIER_ENTRY));
 527                 }
 528
 529                 nClsidIndex = GetClassifierEntry(pstServiceFlowEntry->pstClassifierTable,
 530                     uiClsId,eOldClassifierRuleContext,&pstClassifierEntry);
 531
 532            if((nClsidIndex != PHS_INVALID_TABLE_INDEX) && (!pstClassifierEntry->bUnclassifiedPHSRule))
 533                 {
 534                         kfree(pstClassifierEntry->pstPhsRule);
 535                         memset(pstClassifierEntry, 0, sizeof(S_CLASSIFIER_ENTRY));
 536                 }
 537         }
 538         return lStatus;
 539 }
 540
 541 /*++
 542 PhsDeleteSFRules
 543
 544 Routine Description:
 545     Exported function to Delete a all PHS Rules for the SFID.
 546
 547 Arguments:
 548         IN void* pvContext - PHS Driver Specific Context
 549         IN B_UINT16 uiVcid   - The Service Flow ID for which the PHS rules need to be deleted
 550
 551 Return Value:
 552
 553     0 if successful,
 554     >0 Error.
 555
 556 --*/
 557 ULONG PhsDeleteSFRules(IN void* pvContext,IN B_UINT16 uiVcid)
 558 {
 559
 560         ULONG lStatus =0;
 561         UINT nSFIndex =0, nClsidIndex =0  ;
 562         S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
 563         S_CLASSIFIER_TABLE *pstClassifierRulesTable = NULL;
 564     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 565         PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
 566     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"====> \n");
 567
 568         if(pDeviceExtension)
 569         {
 570                 //Retrieve the SFID Entry Index for requested Service Flow
 571                 nSFIndex = GetServiceFlowEntry(pDeviceExtension->pstServiceFlowPhsRulesTable,
 572                                   uiVcid,&pstServiceFlowEntry);
 573                 if(nSFIndex == PHS_INVALID_TABLE_INDEX)
 574                 {
 575                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "SFID Match Failed\n");
 576                         return ERR_SF_MATCH_FAIL;
 577                 }
 578
 579                 pstClassifierRulesTable=pstServiceFlowEntry->pstClassifierTable;
 580                 if(pstClassifierRulesTable)
 581                 {
 582                         for(nClsidIndex=0;nClsidIndex<MAX_PHSRULE_PER_SF;nClsidIndex++)
 583                         {
 584                                 if(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule)
 585                                 {
 586                                         if(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex]
 587                                                         .pstPhsRule->u8RefCnt)
 588                                                 pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex]
 589                                                                                     .pstPhsRule->u8RefCnt--;
 590                                         if(0==pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex]
 591                                                           .pstPhsRule->u8RefCnt)
 592                                                 kfree(pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex].pstPhsRule);
 593                                             pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex]
 594                                         .pstPhsRule = NULL;
 595                                 }
 596                                 memset(&pstClassifierRulesTable->stActivePhsRulesList[nClsidIndex], 0, sizeof(S_CLASSIFIER_ENTRY));
 597                                 if(pstClassifierRulesTable->stOldPhsRulesList[nClsidIndex].pstPhsRule)
 598                                 {
 599                                         if(pstClassifierRulesTable->stOldPhsRulesList[nClsidIndex]
 600                                         .pstPhsRule->u8RefCnt)
 601                                                 pstClassifierRulesTable->stOldPhsRulesList[nClsidIndex]
 602                                                                   .pstPhsRule->u8RefCnt--;
 603                                         if(0 == pstClassifierRulesTable->stOldPhsRulesList[nClsidIndex]
 604                                         .pstPhsRule->u8RefCnt)
 605                                                 kfree(pstClassifierRulesTable
 606                                                       ->stOldPhsRulesList[nClsidIndex].pstPhsRule);
 607                                         pstClassifierRulesTable->stOldPhsRulesList[nClsidIndex]
 608                               .pstPhsRule = NULL;
 609                                 }
 610                                 memset(&pstClassifierRulesTable->stOldPhsRulesList[nClsidIndex], 0, sizeof(S_CLASSIFIER_ENTRY));
 611                         }
 612                 }
 613                 pstServiceFlowEntry->bUsed = FALSE;
 614                 pstServiceFlowEntry->uiVcid = 0;
 615
 616         }
 617
 618         return lStatus;
 619 }
 620
 621
 622 /*++
 623 PhsCompress
 624
 625 Routine Description:
 626     Exported function to compress the data using PHS.
 627
 628 Arguments:
 629         IN void* pvContext - PHS Driver Specific Context.
 630         IN B_UINT16 uiVcid    - The Service Flow ID to which current packet header compression applies.
 631         IN UINT  uiClsId   - The Classifier ID to which current packet header compression applies.
 632         IN void *pvInputBuffer - The Input buffer containg packet header data
 633         IN void *pvOutputBuffer - The output buffer returned by this function after PHS
 634         IN UINT *pOldHeaderSize  - The actual size of the header before PHS
 635         IN UINT *pNewHeaderSize - The new size of the header after applying PHS
 636
 637 Return Value:
 638
 639     0 if successful,
 640     >0 Error.
 641
 642 --*/
 643 ULONG PhsCompress(IN void* pvContext,
 644                                   IN B_UINT16 uiVcid,
 645                                   IN B_UINT16 uiClsId,
 646                                   IN void *pvInputBuffer,
 647                                   OUT void *pvOutputBuffer,
 648                                   OUT UINT *pOldHeaderSize,
 649                                   OUT UINT *pNewHeaderSize )
 650 {
 651         UINT nSFIndex =0, nClsidIndex =0  ;
 652         S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
 653         S_CLASSIFIER_ENTRY *pstClassifierEntry = NULL;
 654         S_PHS_RULE *pstPhsRule = NULL;
 655         ULONG lStatus =0;
 656     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 657
 658
 659
 660         PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
 661
 662
 663         if(pDeviceExtension == NULL)
 664         {
 665                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"Invalid Device Extension\n");
 666                 lStatus =  STATUS_PHS_NOCOMPRESSION ;
 667                 return lStatus;
 668
 669         }
 670
 671         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"Suppressing header \n");
 672
 673
 674         //Retrieve the SFID Entry Index for requested Service Flow
 675         nSFIndex = GetServiceFlowEntry(pDeviceExtension->pstServiceFlowPhsRulesTable,
 676                           uiVcid,&pstServiceFlowEntry);
 677         if(nSFIndex == PHS_INVALID_TABLE_INDEX)
 678         {
 679                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"SFID Match Failed\n");
 680                 lStatus =  STATUS_PHS_NOCOMPRESSION ;
 681                 return lStatus;
 682         }
 683
 684         nClsidIndex = GetClassifierEntry(pstServiceFlowEntry->pstClassifierTable,
 685                 uiClsId,eActiveClassifierRuleContext,&pstClassifierEntry);
 686
 687     if(nClsidIndex == PHS_INVALID_TABLE_INDEX)
 688         {
 689                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"No PHS Rule Defined For Classifier\n");
 690                 lStatus =  STATUS_PHS_NOCOMPRESSION ;
 691                 return lStatus;
 692         }
 693
 694
 695         //get rule from SF id,Cls ID pair and proceed
 696         pstPhsRule =  pstClassifierEntry->pstPhsRule;
 697
 698         if(!ValidatePHSRuleComplete(pstPhsRule))
 699         {
 700                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"PHS Rule Defined For Classifier But Not Complete\n");
 701                 lStatus =  STATUS_PHS_NOCOMPRESSION ;
 702                 return lStatus;
 703         }
 704
 705         //Compress Packet
 706         lStatus = phs_compress(pstPhsRule,(PUCHAR)pvInputBuffer,
 707               (PUCHAR)pvOutputBuffer, pOldHeaderSize,pNewHeaderSize);
 708
 709         if(lStatus == STATUS_PHS_COMPRESSED)
 710         {
 711                 pstPhsRule->PHSModifiedBytes += *pOldHeaderSize - *pNewHeaderSize - 1;
 712                 pstPhsRule->PHSModifiedNumPackets++;
 713         }
 714         else
 715                 pstPhsRule->PHSErrorNumPackets++;
 716
 717         return lStatus;
 718 }
 719
 720 /*++
 721 PhsDeCompress
 722
 723 Routine Description:
 724     Exported function to restore the packet header in Rx path.
 725
 726 Arguments:
 727         IN void* pvContext - PHS Driver Specific Context.
 728         IN B_UINT16 uiVcid    - The Service Flow ID to which current packet header restoration applies.
 729         IN  void *pvInputBuffer - The Input buffer containg suppressed packet header data
 730         OUT void *pvOutputBuffer - The output buffer returned by this function after restoration
 731         OUT UINT *pHeaderSize   - The packet header size after restoration is returned in this parameter.
 732
 733 Return Value:
 734
 735     0 if successful,
 736     >0 Error.
 737
 738 --*/
 739 ULONG PhsDeCompress(IN void* pvContext,
 740                                   IN B_UINT16 uiVcid,
 741                                   IN void *pvInputBuffer,
 742                                   OUT void *pvOutputBuffer,
 743                                   OUT UINT *pInHeaderSize,
 744                                   OUT UINT *pOutHeaderSize )
 745 {
 746         UINT nSFIndex =0, nPhsRuleIndex =0 ;
 747         S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
 748         S_PHS_RULE *pstPhsRule = NULL;
 749         UINT phsi;
 750     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 751         PPHS_DEVICE_EXTENSION pDeviceExtension=
 752         (PPHS_DEVICE_EXTENSION)pvContext;
 753
 754         *pInHeaderSize = 0;
 755
 756         if(pDeviceExtension == NULL)
 757         {
 758                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"Invalid Device Extension\n");
 759                 return ERR_PHS_INVALID_DEVICE_EXETENSION;
 760         }
 761
 762         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"Restoring header \n");
 763
 764         phsi = *((unsigned char *)(pvInputBuffer));
 765     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"PHSI To Be Used For restore : %x \n",phsi);
 766     if(phsi == UNCOMPRESSED_PACKET )
 767         {
 768                 return STATUS_PHS_NOCOMPRESSION;
 769         }
 770
 771         //Retrieve the SFID Entry Index for requested Service Flow
 772         nSFIndex = GetServiceFlowEntry(pDeviceExtension->pstServiceFlowPhsRulesTable,
 773               uiVcid,&pstServiceFlowEntry);
 774         if(nSFIndex == PHS_INVALID_TABLE_INDEX)
 775         {
 776                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"SFID Match Failed During Lookup\n");
 777                 return ERR_SF_MATCH_FAIL;
 778         }
 779
 780         nPhsRuleIndex = GetPhsRuleEntry(pstServiceFlowEntry->pstClassifierTable,phsi,
 781           eActiveClassifierRuleContext,&pstPhsRule);
 782         if(nPhsRuleIndex == PHS_INVALID_TABLE_INDEX)
 783         {
 784                 //Phs Rule does not exist in  active rules table. Lets try in the old rules table.
 785                 nPhsRuleIndex = GetPhsRuleEntry(pstServiceFlowEntry->pstClassifierTable,
 786                       phsi,eOldClassifierRuleContext,&pstPhsRule);
 787                 if(nPhsRuleIndex == PHS_INVALID_TABLE_INDEX)
 788                 {
 789                         return ERR_PHSRULE_MATCH_FAIL;
 790                 }
 791
 792         }
 793
 794         *pInHeaderSize = phs_decompress((PUCHAR)pvInputBuffer,
 795             (PUCHAR)pvOutputBuffer,pstPhsRule,pOutHeaderSize);
 796
 797         pstPhsRule->PHSModifiedBytes += *pOutHeaderSize - *pInHeaderSize - 1;
 798
 799         pstPhsRule->PHSModifiedNumPackets++;
 800         return STATUS_PHS_COMPRESSED;
 801 }
 802
 803
 804 //-----------------------------------------------------------------------------
 805 // Procedure:   free_phs_serviceflow_rules
 806 //
 807 // Description: This routine is responsible for freeing memory allocated for PHS rules.
 808 //
 809 // Arguments:
 810 // rules        - ptr to S_SERVICEFLOW_TABLE structure.
 811 //
 812 // Returns:
 813 // Does not return any value.
 814 //-----------------------------------------------------------------------------
 815
 816 void free_phs_serviceflow_rules(S_SERVICEFLOW_TABLE *psServiceFlowRulesTable)
 817 {
 818         int i,j;
 819     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 820
 821         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "=======>\n");
 822     if(psServiceFlowRulesTable)
 823         {
 824                 for(i=0;i<MAX_SERVICEFLOWS;i++)
 825                 {
 826                         S_SERVICEFLOW_ENTRY stServiceFlowEntry =
 827                 psServiceFlowRulesTable->stSFList[i];
 828                         S_CLASSIFIER_TABLE *pstClassifierRulesTable =
 829                 stServiceFlowEntry.pstClassifierTable;
 830
 831                         if(pstClassifierRulesTable)
 832                         {
 833                                 for(j=0;j<MAX_PHSRULE_PER_SF;j++)
 834                                 {
 835                                         if(pstClassifierRulesTable->stActivePhsRulesList[j].pstPhsRule)
 836                                         {
 837                                                 if(pstClassifierRulesTable->stActivePhsRulesList[j].pstPhsRule
 838                                                                                         ->u8RefCnt)
 839                                                         pstClassifierRulesTable->stActivePhsRulesList[j].pstPhsRule
 840                                                                                                         ->u8RefCnt--;
 841                                                 if(0==pstClassifierRulesTable->stActivePhsRulesList[j].pstPhsRule
 842                                                                 ->u8RefCnt)
 843                                                         kfree(pstClassifierRulesTable->stActivePhsRulesList[j].pstPhsRule);
 844                                                 pstClassifierRulesTable->stActivePhsRulesList[j].pstPhsRule = NULL;
 845                                         }
 846                                         if(pstClassifierRulesTable->stOldPhsRulesList[j].pstPhsRule)
 847                                         {
 848                                                 if(pstClassifierRulesTable->stOldPhsRulesList[j].pstPhsRule
 849                                                                 ->u8RefCnt)
 850                                                         pstClassifierRulesTable->stOldPhsRulesList[j].pstPhsRule
 851                                                                                                   ->u8RefCnt--;
 852                                                 if(0==pstClassifierRulesTable->stOldPhsRulesList[j].pstPhsRule
 853                                                                       ->u8RefCnt)
 854                                                         kfree(pstClassifierRulesTable->stOldPhsRulesList[j].pstPhsRule);
 855                                                 pstClassifierRulesTable->stOldPhsRulesList[j].pstPhsRule = NULL;
 856                                         }
 857                                 }
 858                                 kfree(pstClassifierRulesTable);
 859                             stServiceFlowEntry.pstClassifierTable = pstClassifierRulesTable = NULL;
 860                         }
 861                 }
 862         }
 863
 864     kfree(psServiceFlowRulesTable);
 865     psServiceFlowRulesTable = NULL;
 866 }
 867
 868
 869
 870 BOOLEAN ValidatePHSRuleComplete(IN S_PHS_RULE *psPhsRule)
 871 {
 872         if(psPhsRule)
 873         {
 874                 if(!psPhsRule->u8PHSI)
 875                 {
 876                         // PHSI is not valid
 877                         return FALSE;
 878                 }
 879
 880                 if(!psPhsRule->u8PHSS)
 881                 {
 882                         //PHSS Is Undefined
 883                         return FALSE;
 884                 }
 885
 886                 //Check if PHSF is defines for the PHS Rule
 887                 if(!psPhsRule->u8PHSFLength) // If any part of PHSF is valid then Rule contains valid PHSF
 888                 {
 889                         return FALSE;
 890                 }
 891                 return TRUE;
 892         }
 893         else
 894         {
 895                 return FALSE;
 896         }
 897 }
 898
 899 UINT GetServiceFlowEntry(IN S_SERVICEFLOW_TABLE *psServiceFlowTable,
 900     IN B_UINT16 uiVcid,S_SERVICEFLOW_ENTRY **ppstServiceFlowEntry)
 901 {
 902         int  i;
 903         for(i=0;i<MAX_SERVICEFLOWS;i++)
 904         {
 905                 if(psServiceFlowTable->stSFList[i].bUsed)
 906                 {
 907                         if(psServiceFlowTable->stSFList[i].uiVcid == uiVcid)
 908                         {
 909                                 *ppstServiceFlowEntry = &psServiceFlowTable->stSFList[i];
 910                                 return i;
 911                         }
 912                 }
 913         }
 914
 915         *ppstServiceFlowEntry = NULL;
 916         return PHS_INVALID_TABLE_INDEX;
 917 }
 918
 919
 920 UINT GetClassifierEntry(IN S_CLASSIFIER_TABLE *pstClassifierTable,
 921         IN B_UINT32 uiClsid,E_CLASSIFIER_ENTRY_CONTEXT eClsContext,
 922         OUT S_CLASSIFIER_ENTRY **ppstClassifierEntry)
 923 {
 924         int  i;
 925         S_CLASSIFIER_ENTRY *psClassifierRules = NULL;
 926         for(i=0;i<MAX_PHSRULE_PER_SF;i++)
 927         {
 928
 929                 if(eClsContext == eActiveClassifierRuleContext)
 930                 {
 931                         psClassifierRules = &pstClassifierTable->stActivePhsRulesList[i];
 932                 }
 933                 else
 934                 {
 935                         psClassifierRules = &pstClassifierTable->stOldPhsRulesList[i];
 936                 }
 937
 938                 if(psClassifierRules->bUsed)
 939                 {
 940                         if(psClassifierRules->uiClassifierRuleId == uiClsid)
 941                         {
 942                                 *ppstClassifierEntry = psClassifierRules;
 943                                 return i;
 944                         }
 945                 }
 946
 947         }
 948
 949         *ppstClassifierEntry = NULL;
 950         return PHS_INVALID_TABLE_INDEX;
 951 }
 952
 953 UINT GetPhsRuleEntry(IN S_CLASSIFIER_TABLE *pstClassifierTable,
 954       IN B_UINT32 uiPHSI,E_CLASSIFIER_ENTRY_CONTEXT eClsContext,
 955       OUT S_PHS_RULE **ppstPhsRule)
 956 {
 957         int  i;
 958         S_CLASSIFIER_ENTRY *pstClassifierRule = NULL;
 959         for(i=0;i<MAX_PHSRULE_PER_SF;i++)
 960         {
 961                 if(eClsContext == eActiveClassifierRuleContext)
 962                 {
 963                         pstClassifierRule = &pstClassifierTable->stActivePhsRulesList[i];
 964                 }
 965                 else
 966                 {
 967                         pstClassifierRule = &pstClassifierTable->stOldPhsRulesList[i];
 968                 }
 969                 if(pstClassifierRule->bUsed)
 970                 {
 971                         if(pstClassifierRule->u8PHSI == uiPHSI)
 972                         {
 973                                 *ppstPhsRule = pstClassifierRule->pstPhsRule;
 974                                 return i;
 975                         }
 976                 }
 977
 978         }
 979
 980         *ppstPhsRule = NULL;
 981         return PHS_INVALID_TABLE_INDEX;
 982 }
 983
 984 UINT CreateSFToClassifierRuleMapping(IN B_UINT16 uiVcid,IN B_UINT16  uiClsId,
 985                       IN S_SERVICEFLOW_TABLE *psServiceFlowTable,S_PHS_RULE *psPhsRule,
 986                       B_UINT8 u8AssociatedPHSI)
 987 {
 988
 989     S_CLASSIFIER_TABLE *psaClassifiertable = NULL;
 990         UINT uiStatus = 0;
 991         int iSfIndex;
 992         BOOLEAN bFreeEntryFound =FALSE;
 993         //Check for a free entry in SFID table
 994         for(iSfIndex=0;iSfIndex < MAX_SERVICEFLOWS;iSfIndex++)
 995         {
 996                 if(!psServiceFlowTable->stSFList[iSfIndex].bUsed)
 997                 {
 998                         bFreeEntryFound = TRUE;
 999                         break;
1000                 }
1001         }
1002
1003         if(!bFreeEntryFound)
1004                 return ERR_SFTABLE_FULL;
1005
1006
1007         psaClassifiertable = psServiceFlowTable->stSFList[iSfIndex].pstClassifierTable;
1008         uiStatus = CreateClassifierPHSRule(uiClsId,psaClassifiertable,psPhsRule,
1009                               eActiveClassifierRuleContext,u8AssociatedPHSI);
1010         if(uiStatus == PHS_SUCCESS)
1011         {
1012                 //Add entry at free index to the SF
1013                 psServiceFlowTable->stSFList[iSfIndex].bUsed = TRUE;
1014                 psServiceFlowTable->stSFList[iSfIndex].uiVcid = uiVcid;
1015         }
1016
1017         return uiStatus;
1018
1019 }
1020
1021 UINT CreateClassiferToPHSRuleMapping(IN B_UINT16 uiVcid,
1022             IN B_UINT16  uiClsId,IN S_SERVICEFLOW_ENTRY *pstServiceFlowEntry,
1023               S_PHS_RULE *psPhsRule,B_UINT8 u8AssociatedPHSI)
1024 {
1025         S_CLASSIFIER_ENTRY *pstClassifierEntry = NULL;
1026         UINT uiStatus =PHS_SUCCESS;
1027         UINT nClassifierIndex = 0;
1028         S_CLASSIFIER_TABLE *psaClassifiertable = NULL;
1029     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1030     psaClassifiertable = pstServiceFlowEntry->pstClassifierTable;
1031
1032         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "==>");
1033
1034         /* Check if the supplied Classifier already exists */
1035         nClassifierIndex =GetClassifierEntry(
1036                     pstServiceFlowEntry->pstClassifierTable,uiClsId,
1037                     eActiveClassifierRuleContext,&pstClassifierEntry);
1038         if(nClassifierIndex == PHS_INVALID_TABLE_INDEX)
1039         {
1040                 /*
1041                     The Classifier doesn't exist. So its a new classifier being added.
1042                      Add new entry to associate PHS Rule to the Classifier
1043                 */
1044
1045                 uiStatus = CreateClassifierPHSRule(uiClsId,psaClassifiertable,
1046                     psPhsRule,eActiveClassifierRuleContext,u8AssociatedPHSI);
1047                 return uiStatus;
1048         }
1049
1050         /*
1051           The Classifier exists.The PHS Rule for this classifier
1052           is being modified
1053           */
1054         if(pstClassifierEntry->u8PHSI == psPhsRule->u8PHSI)
1055         {
1056                 if(pstClassifierEntry->pstPhsRule == NULL)
1057                         return ERR_PHS_INVALID_PHS_RULE;
1058
1059                 /*
1060                     This rule already exists if any fields are changed for this PHS
1061                     rule update them.
1062                  */
1063                  /* If any part of PHSF is valid then we update PHSF */
1064                 if(psPhsRule->u8PHSFLength)
1065                 {
1066                         //update PHSF
1067                         memcpy(pstClassifierEntry->pstPhsRule->u8PHSF,
1068                             psPhsRule->u8PHSF , MAX_PHS_LENGTHS);
1069                 }
1070                 if(psPhsRule->u8PHSFLength)
1071                 {
1072                         //update PHSFLen
1073                         pstClassifierEntry->pstPhsRule->u8PHSFLength =
1074                             psPhsRule->u8PHSFLength;
1075                 }
1076                 if(psPhsRule->u8PHSMLength)
1077                 {
1078                         //update PHSM
1079                         memcpy(pstClassifierEntry->pstPhsRule->u8PHSM,
1080                             psPhsRule->u8PHSM, MAX_PHS_LENGTHS);
1081                 }
1082                 if(psPhsRule->u8PHSMLength)
1083                 {
1084                         //update PHSM Len
1085                         pstClassifierEntry->pstPhsRule->u8PHSMLength =
1086                             psPhsRule->u8PHSMLength;
1087                 }
1088                 if(psPhsRule->u8PHSS)
1089                 {
1090                         //update PHSS
1091                         pstClassifierEntry->pstPhsRule->u8PHSS = psPhsRule->u8PHSS;
1092                 }
1093
1094                 //update PHSV
1095                 pstClassifierEntry->pstPhsRule->u8PHSV = psPhsRule->u8PHSV;
1096
1097         }
1098         else
1099         {
1100                 /*
1101                   A new rule is being set for this classifier.
1102                 */
1103                 uiStatus=UpdateClassifierPHSRule( uiClsId,  pstClassifierEntry,
1104                       psaClassifiertable,  psPhsRule, u8AssociatedPHSI);
1105         }
1106
1107
1108
1109         return uiStatus;
1110 }
1111
1112 UINT CreateClassifierPHSRule(IN B_UINT16  uiClsId,
1113     S_CLASSIFIER_TABLE *psaClassifiertable ,S_PHS_RULE *psPhsRule,
1114     E_CLASSIFIER_ENTRY_CONTEXT eClsContext,B_UINT8 u8AssociatedPHSI)
1115 {
1116         UINT iClassifierIndex = 0;
1117         BOOLEAN bFreeEntryFound = FALSE;
1118         S_CLASSIFIER_ENTRY *psClassifierRules = NULL;
1119         UINT nStatus = PHS_SUCCESS;
1120     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1121         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"Inside CreateClassifierPHSRule");
1122     if(psaClassifiertable == NULL)
1123         {
1124                 return ERR_INVALID_CLASSIFIERTABLE_FOR_SF;
1125         }
1126
1127         if(eClsContext == eOldClassifierRuleContext)
1128         {
1129                 /* If An Old Entry for this classifier ID already exists in the
1130                     old rules table replace it. */
1131
1132                 iClassifierIndex =
1133                 GetClassifierEntry(psaClassifiertable, uiClsId,
1134                             eClsContext,&psClassifierRules);
1135                 if(iClassifierIndex != PHS_INVALID_TABLE_INDEX)
1136                 {
1137                         /*
1138                             The Classifier already exists in the old rules table
1139                         Lets replace the old classifier with the new one.
1140                         */
1141                         bFreeEntryFound = TRUE;
1142                 }
1143         }
1144
1145         if(!bFreeEntryFound)
1146         {
1147                 /*
1148                   Continue to search for a free location to add the rule
1149                 */
1150                 for(iClassifierIndex = 0; iClassifierIndex <
1151             MAX_PHSRULE_PER_SF; iClassifierIndex++)
1152                 {
1153                         if(eClsContext == eActiveClassifierRuleContext)
1154                         {
1155                                 psClassifierRules =
1156               &psaClassifiertable->stActivePhsRulesList[iClassifierIndex];
1157                         }
1158                         else
1159                         {
1160                                 psClassifierRules =
1161                 &psaClassifiertable->stOldPhsRulesList[iClassifierIndex];
1162                         }
1163
1164                         if(!psClassifierRules->bUsed)
1165                         {
1166                                 bFreeEntryFound = TRUE;
1167                                 break;
1168                         }
1169                 }
1170         }
1171
1172         if(!bFreeEntryFound)
1173         {
1174                 if(eClsContext == eActiveClassifierRuleContext)
1175                 {
1176                         return ERR_CLSASSIFIER_TABLE_FULL;
1177                 }
1178                 else
1179                 {
1180                         //Lets replace the oldest rule if we are looking in old Rule table
1181                         if(psaClassifiertable->uiOldestPhsRuleIndex >=
1182                 MAX_PHSRULE_PER_SF)
1183                         {
1184                                 psaClassifiertable->uiOldestPhsRuleIndex =0;
1185                         }
1186
1187                         iClassifierIndex = psaClassifiertable->uiOldestPhsRuleIndex;
1188                         psClassifierRules =
1189               &psaClassifiertable->stOldPhsRulesList[iClassifierIndex];
1190
1191           (psaClassifiertable->uiOldestPhsRuleIndex)++;
1192                 }
1193         }
1194
1195         if(eClsContext == eOldClassifierRuleContext)
1196         {
1197                 if(psClassifierRules->pstPhsRule == NULL)
1198                 {
1199                         psClassifierRules->pstPhsRule = kmalloc(sizeof(S_PHS_RULE),GFP_KERNEL);
1200
1201           if(NULL == psClassifierRules->pstPhsRule)
1202                                 return ERR_PHSRULE_MEMALLOC_FAIL;
1203                 }
1204
1205                 psClassifierRules->bUsed = TRUE;
1206                 psClassifierRules->uiClassifierRuleId = uiClsId;
1207                 psClassifierRules->u8PHSI = psPhsRule->u8PHSI;
1208                 psClassifierRules->bUnclassifiedPHSRule = psPhsRule->bUnclassifiedPHSRule;
1209
1210         /* Update The PHS rule */
1211                 memcpy(psClassifierRules->pstPhsRule,
1212                     psPhsRule, sizeof(S_PHS_RULE));
1213         }
1214         else
1215         {
1216                 nStatus = UpdateClassifierPHSRule(uiClsId,psClassifierRules,
1217             psaClassifiertable,psPhsRule,u8AssociatedPHSI);
1218         }
1219         return nStatus;
1220 }
1221
1222
1223 UINT UpdateClassifierPHSRule(IN B_UINT16  uiClsId,
1224       IN S_CLASSIFIER_ENTRY *pstClassifierEntry,
1225       S_CLASSIFIER_TABLE *psaClassifiertable ,S_PHS_RULE *psPhsRule,
1226       B_UINT8 u8AssociatedPHSI)
1227 {
1228         S_PHS_RULE *pstAddPhsRule = NULL;
1229         UINT              nPhsRuleIndex = 0;
1230         BOOLEAN       bPHSRuleOrphaned = FALSE;
1231     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1232         psPhsRule->u8RefCnt =0;
1233
1234         /* Step 1 Deref Any Exisiting PHS Rule in this classifier Entry*/
1235         bPHSRuleOrphaned = DerefPhsRule( uiClsId, psaClassifiertable,
1236             pstClassifierEntry->pstPhsRule);
1237
1238         //Step 2 Search if there is a PHS Rule with u8AssociatedPHSI in Classifier table for this SF
1239         nPhsRuleIndex =GetPhsRuleEntry(psaClassifiertable,u8AssociatedPHSI,
1240             eActiveClassifierRuleContext, &pstAddPhsRule);
1241         if(PHS_INVALID_TABLE_INDEX == nPhsRuleIndex)
1242         {
1243                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nAdding New PHSRuleEntry For Classifier");
1244
1245                 if(psPhsRule->u8PHSI == 0)
1246                 {
1247                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nError PHSI is Zero\n");
1248                         return ERR_PHS_INVALID_PHS_RULE;
1249                 }
1250                 //Step 2.a PHS Rule Does Not Exist .Create New PHS Rule for uiClsId
1251                 if(FALSE == bPHSRuleOrphaned)
1252                 {
1253                         pstClassifierEntry->pstPhsRule = kmalloc(sizeof(S_PHS_RULE), GFP_KERNEL);
1254                         if(NULL == pstClassifierEntry->pstPhsRule)
1255                         {
1256                                 return ERR_PHSRULE_MEMALLOC_FAIL;
1257                         }
1258                 }
1259                 memcpy(pstClassifierEntry->pstPhsRule, psPhsRule, sizeof(S_PHS_RULE));
1260
1261         }
1262         else
1263         {
1264                 //Step 2.b PHS Rule  Exists Tie uiClsId with the existing PHS Rule
1265                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\nTying Classifier to Existing PHS Rule");
1266                 if(bPHSRuleOrphaned)
1267                 {
1268                         kfree(pstClassifierEntry->pstPhsRule);
1269                         pstClassifierEntry->pstPhsRule = NULL;
1270                 }
1271                 pstClassifierEntry->pstPhsRule = pstAddPhsRule;
1272
1273         }
1274         pstClassifierEntry->bUsed = TRUE;
1275         pstClassifierEntry->u8PHSI = pstClassifierEntry->pstPhsRule->u8PHSI;
1276         pstClassifierEntry->uiClassifierRuleId = uiClsId;
1277         pstClassifierEntry->pstPhsRule->u8RefCnt++;
1278         pstClassifierEntry->bUnclassifiedPHSRule = pstClassifierEntry->pstPhsRule->bUnclassifiedPHSRule;
1279
1280         return PHS_SUCCESS;
1281
1282 }
1283
1284 BOOLEAN DerefPhsRule(IN B_UINT16  uiClsId,S_CLASSIFIER_TABLE *psaClassifiertable,S_PHS_RULE *pstPhsRule)
1285 {
1286         if(pstPhsRule==NULL)
1287                 return FALSE;
1288         if(pstPhsRule->u8RefCnt)
1289                 pstPhsRule->u8RefCnt--;
1290         if(0==pstPhsRule->u8RefCnt)
1291         {
1292                 /*if(pstPhsRule->u8PHSI)
1293                 //Store the currently active rule into the old rules list
1294                 CreateClassifierPHSRule(uiClsId,psaClassifiertable,pstPhsRule,eOldClassifierRuleContext,pstPhsRule->u8PHSI);*/
1295                 return TRUE;
1296         }
1297         else
1298         {
1299                 return FALSE;
1300         }
1301 }
1302
1303 static void DumpBuffer(PVOID BuffVAddress, int xferSize)
1304 {
1305         int i;
1306         int iPrintLength;
1307         PUCHAR temp=(PUCHAR)BuffVAddress;
1308     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1309         iPrintLength=(xferSize<32?xferSize:32);
1310         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\n");
1311
1312         for (i=0;i < iPrintLength;i++) {
1313                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "%x|",temp[i]);
1314         }
1315         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "\n");
1316 }
1317
1318
1319 void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension)
1320 {
1321         int i,j,k,l;
1322     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1323     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\n Dumping PHS Rules : \n");
1324         for(i=0;i<MAX_SERVICEFLOWS;i++)
1325         {
1326                 S_SERVICEFLOW_ENTRY stServFlowEntry =
1327                                 pDeviceExtension->pstServiceFlowPhsRulesTable->stSFList[i];
1328                 if(stServFlowEntry.bUsed)
1329                 {
1330                         for(j=0;j<MAX_PHSRULE_PER_SF;j++)
1331                         {
1332                                 for(l=0;l<2;l++)
1333                                 {
1334                                         S_CLASSIFIER_ENTRY stClsEntry;
1335                                         if(l==0)
1336                                         {
1337                                                 stClsEntry = stServFlowEntry.pstClassifierTable->stActivePhsRulesList[j];
1338                                                 if(stClsEntry.bUsed)
1339                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n Active PHS Rule : \n");
1340                                         }
1341                                         else
1342                                         {
1343                                                 stClsEntry = stServFlowEntry.pstClassifierTable->stOldPhsRulesList[j];
1344                                                 if(stClsEntry.bUsed)
1345                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n Old PHS Rule : \n");
1346                                         }
1347                                         if(stClsEntry.bUsed)
1348                                         {
1349
1350                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\n VCID  : %#X",stServFlowEntry.uiVcid);
1351                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n ClassifierID  : %#X",stClsEntry.uiClassifierRuleId);
1352                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSRuleID  : %#X",stClsEntry.u8PHSI);
1353                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n****************PHS Rule********************\n");
1354                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSI  : %#X",stClsEntry.pstPhsRule->u8PHSI);
1355                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSFLength : %#X ",stClsEntry.pstPhsRule->u8PHSFLength);
1356                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSF : ");
1357                                                 for(k=0;k<stClsEntry.pstPhsRule->u8PHSFLength;k++)
1358                                                 {
1359                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "%#X  ",stClsEntry.pstPhsRule->u8PHSF[k]);
1360                                                 }
1361                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSMLength  : %#X",stClsEntry.pstPhsRule->u8PHSMLength);
1362                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSM :");
1363                                                 for(k=0;k<stClsEntry.pstPhsRule->u8PHSMLength;k++)
1364                                                 {
1365                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "%#X  ",stClsEntry.pstPhsRule->u8PHSM[k]);
1366                                                 }
1367                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSS : %#X ",stClsEntry.pstPhsRule->u8PHSS);
1368                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, (DBG_LVL_ALL|DBG_NO_FUNC_PRINT), "\n PHSV  : %#X",stClsEntry.pstPhsRule->u8PHSV);
1369                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\n********************************************\n");
1370                                         }
1371                                 }
1372                         }
1373                 }
1374         }
1375 }
1376
1377
1378 //-----------------------------------------------------------------------------
1379 // Procedure:   phs_decompress
1380 //
1381 // Description: This routine restores the static fields within the packet.
1382 //
1383 // Arguments:
1384 //      in_buf                  - ptr to incoming packet buffer.
1385 //      out_buf                 - ptr to output buffer where the suppressed header is copied.
1386 //      decomp_phs_rules - ptr to PHS rule.
1387 //      header_size             - ptr to field which holds the phss or phsf_length.
1388 //
1389 // Returns:
1390 //      size -The number of bytes of dynamic fields present with in the incoming packet
1391 //                      header.
1392 //      0       -If PHS rule is NULL.If PHSI is 0 indicateing packet as uncompressed.
1393 //-----------------------------------------------------------------------------
1394
1395 int phs_decompress(unsigned char *in_buf,unsigned char *out_buf,
1396  S_PHS_RULE   *decomp_phs_rules,UINT *header_size)
1397 {
1398         int phss,size=0;
1399          S_PHS_RULE   *tmp_memb;
1400         int bit,i=0;
1401         unsigned char *phsf,*phsm;
1402         int in_buf_len = *header_size-1;
1403     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1404         in_buf++;
1405     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"====>\n");
1406         *header_size = 0;
1407
1408         if((decomp_phs_rules == NULL ))
1409                 return 0;
1410
1411
1412         tmp_memb = decomp_phs_rules;
1413         //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"\nDECOMP:In phs_decompress PHSI 1  %d",phsi));
1414         //*header_size = tmp_memb->u8PHSFLength;
1415         phss         = tmp_memb->u8PHSS;
1416         phsf         = tmp_memb->u8PHSF;
1417         phsm         = tmp_memb->u8PHSM;
1418
1419         if(phss > MAX_PHS_LENGTHS)
1420                 phss = MAX_PHS_LENGTHS;
1421         //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"\nDECOMP:In phs_decompress PHSI  %d phss %d index %d",phsi,phss,index));
1422         while((phss > 0) && (size < in_buf_len))
1423         {
1424                 bit =  ((*phsm << i)& SUPPRESS);
1425
1426                 if(bit == SUPPRESS)
1427                 {
1428                         *out_buf = *phsf;
1429                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"\nDECOMP:In phss  %d phsf %d ouput %d",
1430               phss,*phsf,*out_buf);
1431                 }
1432                 else
1433                 {
1434                         *out_buf = *in_buf;
1435                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECIEVE,DBG_LVL_ALL,"\nDECOMP:In phss  %d input %d ouput %d",
1436             phss,*in_buf,*out_buf);
1437                         in_buf++;
1438                         size++;
1439                 }
1440                 out_buf++;
1441                 phsf++;
1442                 phss--;
1443                 i++;
1444                 *header_size=*header_size + 1;
1445
1446                 if(i > MAX_NO_BIT)
1447                 {
1448                         i=0;
1449                         phsm++;
1450                 }
1451         }
1452         return size;
1453 }
1454
1455
1456
1457
1458 //-----------------------------------------------------------------------------
1459 // Procedure:   phs_compress
1460 //
1461 // Description: This routine suppresses the static fields within the packet.Before
1462 // that it will verify the fields to be suppressed with the corresponding fields in the
1463 // phsf. For verification it checks the phsv field of PHS rule. If set and verification
1464 // succeeds it suppresses the field.If any one static field is found different none of
1465 // the static fields are suppressed then the packet is sent as uncompressed packet with
1466 // phsi=0.
1467 //
1468 // Arguments:
1469 //      phs_rule - ptr to PHS rule.
1470 //      in_buf          - ptr to incoming packet buffer.
1471 //      out_buf         - ptr to output buffer where the suppressed header is copied.
1472 //      header_size     - ptr to field which holds the phss.
1473 //
1474 // Returns:
1475 //      size-The number of bytes copied into the output buffer i.e dynamic fields
1476 //      0       -If PHS rule is NULL.If PHSV field is not set.If the verification fails.
1477 //-----------------------------------------------------------------------------
1478 int phs_compress(S_PHS_RULE  *phs_rule,unsigned char *in_buf
1479                                                 ,unsigned char *out_buf,UINT *header_size,UINT *new_header_size)
1480 {
1481         unsigned char *old_addr = out_buf;
1482         int supress = 0;
1483     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1484     if(phs_rule == NULL)
1485         {
1486                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nphs_compress(): phs_rule null!");
1487                 *out_buf = ZERO_PHSI;
1488                 return STATUS_PHS_NOCOMPRESSION;
1489         }
1490
1491
1492         if(phs_rule->u8PHSS <= *new_header_size)
1493         {
1494                 *header_size = phs_rule->u8PHSS;
1495         }
1496         else
1497         {
1498                 *header_size = *new_header_size;
1499         }
1500         //To copy PHSI
1501         out_buf++;
1502         supress = verify_suppress_phsf(in_buf,out_buf,phs_rule->u8PHSF,
1503         phs_rule->u8PHSM, phs_rule->u8PHSS, phs_rule->u8PHSV,new_header_size);
1504
1505         if(supress == STATUS_PHS_COMPRESSED)
1506         {
1507                 *old_addr = (unsigned char)phs_rule->u8PHSI;
1508                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In phs_compress phsi %d",phs_rule->u8PHSI);
1509         }
1510         else
1511         {
1512                 *old_addr = ZERO_PHSI;
1513                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In phs_compress PHSV Verification failed");
1514         }
1515         return supress;
1516 }
1517
1518
1519 //-----------------------------------------------------------------------------
1520 // Procedure:   verify_suppress_phsf
1521 //
1522 // Description: This routine verifies the fields of the packet and if all the
1523 // static fields are equal it adds the phsi of that PHS rule.If any static
1524 // field differs it woun't suppress any field.
1525 //
1526 // Arguments:
1527 // rules_set    - ptr to classifier_rules.
1528 // in_buffer    - ptr to incoming packet buffer.
1529 // out_buffer   - ptr to output buffer where the suppressed header is copied.
1530 // phsf                 - ptr to phsf.
1531 // phsm                 - ptr to phsm.
1532 // phss                 - variable holding phss.
1533 //
1534 // Returns:
1535 //      size-The number of bytes copied into the output buffer i.e dynamic fields.
1536 //      0       -Packet has failed the verification.
1537 //-----------------------------------------------------------------------------
1538
1539  int verify_suppress_phsf(unsigned char *in_buffer,unsigned char *out_buffer,
1540                                                                 unsigned char *phsf,unsigned char *phsm,unsigned int phss,
1541                                                                 unsigned int phsv,UINT* new_header_size)
1542 {
1543         unsigned int size=0;
1544         int bit,i=0;
1545     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
1546     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In verify_phsf PHSM - 0x%X",*phsm);
1547
1548
1549         if(phss>(*new_header_size))
1550         {
1551                 phss=*new_header_size;
1552         }
1553         while(phss > 0)
1554         {
1555                 bit = ((*phsm << i)& SUPPRESS);
1556                 if(bit == SUPPRESS)
1557                 {
1558
1559                         if(*in_buffer != *phsf)
1560                         {
1561                                 if(phsv == VERIFY)
1562                                 {
1563                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In verify_phsf failed for field  %d buf  %d phsf %d",phss,*in_buffer,*phsf);
1564                                         return STATUS_PHS_NOCOMPRESSION;
1565                                 }
1566                         }
1567                         else
1568                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In verify_phsf success for field  %d buf  %d phsf %d",phss,*in_buffer,*phsf);
1569                 }
1570                 else
1571                 {
1572                         *out_buffer = *in_buffer;
1573                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In copying_header input %d  out %d",*in_buffer,*out_buffer);
1574                         out_buffer++;
1575                         size++;
1576                 }
1577                 in_buffer++;
1578                 phsf++;
1579                 phss--;
1580                 i++;
1581                 if(i > MAX_NO_BIT)
1582                 {
1583                         i=0;
1584                         phsm++;
1585                 }
1586         }
1587         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In verify_phsf success");
1588         *new_header_size = size;
1589         return STATUS_PHS_COMPRESSED;
1590 }
1591
1592
1593
1594
1595
1596