drivers/staging/bcm/Qos.c

   1 /**
   2 @file Qos.C
   3 This file contains the routines related to Quality of Service.
   4 */
   5 #include "headers.h"
   6
   7 static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,PS_ETHCS_PKT_INFO pstEthCsPktInfo);
   8 static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo,S_CLASSIFIER_RULE *pstClassifierRule, B_UINT8 EthCSCupport);
   9
  10 static USHORT   IpVersion4(PMINI_ADAPTER Adapter, struct iphdr *iphd,
  11                            S_CLASSIFIER_RULE *pstClassifierRule );
  12
  13 static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex);
  14
  15
  16 /*******************************************************************
  17 * Function    - MatchSrcIpAddress()
  18 *
  19 * Description - Checks whether the Source IP address from the packet
  20 *                               matches with that of Queue.
  21 *
  22 * Parameters  - pstClassifierRule: Pointer to the packet info structure.
  23 *                         - ulSrcIP         : Source IP address from the packet.
  24 *
  25 * Returns     - TRUE(If address matches) else FAIL .
  26 *********************************************************************/
  27 BOOLEAN MatchSrcIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulSrcIP)
  28 {
  29     UCHAR       ucLoopIndex=0;
  30
  31     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
  32
  33     ulSrcIP=ntohl(ulSrcIP);
  34     if(0 == pstClassifierRule->ucIPSourceAddressLength)
  35         return TRUE;
  36     for(ucLoopIndex=0; ucLoopIndex < (pstClassifierRule->ucIPSourceAddressLength);ucLoopIndex++)
  37     {
  38                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Ip Address Mask:0x%x PacketIp:0x%x and Classification:0x%x", (UINT)pstClassifierRule->stSrcIpAddress.ulIpv4Mask[ucLoopIndex], (UINT)ulSrcIP, (UINT)pstClassifierRule->stSrcIpAddress.ulIpv6Addr[ucLoopIndex]);
  39                 if((pstClassifierRule->stSrcIpAddress.ulIpv4Mask[ucLoopIndex] & ulSrcIP)==
  40                                 (pstClassifierRule->stSrcIpAddress.ulIpv4Addr[ucLoopIndex] & pstClassifierRule->stSrcIpAddress.ulIpv4Mask[ucLoopIndex] ))
  41         {
  42                 return TRUE;
  43         }
  44     }
  45     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Ip Address Not Matched");
  46         return FALSE;
  47 }
  48
  49
  50 /*******************************************************************
  51 * Function    - MatchDestIpAddress()
  52 *
  53 * Description - Checks whether the Destination IP address from the packet
  54 *                               matches with that of Queue.
  55 *
  56 * Parameters  - pstClassifierRule: Pointer to the packet info structure.
  57 *                         - ulDestIP    : Destination IP address from the packet.
  58 *
  59 * Returns     - TRUE(If address matches) else FAIL .
  60 *********************************************************************/
  61 BOOLEAN MatchDestIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulDestIP)
  62 {
  63         UCHAR   ucLoopIndex=0;
  64     PMINI_ADAPTER       Adapter = GET_BCM_ADAPTER(gblpnetdev);
  65
  66         ulDestIP=ntohl(ulDestIP);
  67     if(0 == pstClassifierRule->ucIPDestinationAddressLength)
  68         return TRUE;
  69         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Ip Address 0x%x 0x%x 0x%x  ", (UINT)ulDestIP, (UINT)pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex], (UINT)pstClassifierRule->stDestIpAddress.ulIpv4Addr[ucLoopIndex]);
  70
  71     for(ucLoopIndex=0;ucLoopIndex<(pstClassifierRule->ucIPDestinationAddressLength);ucLoopIndex++)
  72     {
  73                 if((pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex] & ulDestIP)==
  74                                         (pstClassifierRule->stDestIpAddress.ulIpv4Addr[ucLoopIndex] & pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex]))
  75         {
  76                 return TRUE;
  77         }
  78     }
  79         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Ip Address Not Matched");
  80     return FALSE;
  81 }
  82
  83
  84 /************************************************************************
  85 * Function    - MatchTos()
  86 *
  87 * Description - Checks the TOS from the packet matches with that of queue.
  88 *
  89 * Parameters  - pstClassifierRule   : Pointer to the packet info structure.
  90 *                         - ucTypeOfService: TOS from the packet.
  91 *
  92 * Returns     - TRUE(If address matches) else FAIL.
  93 **************************************************************************/
  94 BOOLEAN MatchTos(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucTypeOfService)
  95 {
  96
  97         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
  98     if( 3 != pstClassifierRule->ucIPTypeOfServiceLength )
  99         return TRUE;
 100
 101     if(((pstClassifierRule->ucTosMask & ucTypeOfService)<=pstClassifierRule->ucTosHigh) && ((pstClassifierRule->ucTosMask & ucTypeOfService)>=pstClassifierRule->ucTosLow))
 102     {
 103         return TRUE;
 104     }
 105     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Type Of Service Not Matched");
 106     return FALSE;
 107 }
 108
 109
 110 /***************************************************************************
 111 * Function    - MatchProtocol()
 112 *
 113 * Description - Checks the protocol from the packet matches with that of queue.
 114 *
 115 * Parameters  - pstClassifierRule: Pointer to the packet info structure.
 116 *                         - ucProtocol  : Protocol from the packet.
 117 *
 118 * Returns     - TRUE(If address matches) else FAIL.
 119 ****************************************************************************/
 120 BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol)
 121 {
 122         UCHAR   ucLoopIndex=0;
 123         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 124         if(0 == pstClassifierRule->ucProtocolLength)
 125         return TRUE;
 126         for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucProtocolLength;ucLoopIndex++)
 127     {
 128         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol:0x%X Classification Protocol:0x%X",ucProtocol,pstClassifierRule->ucProtocol[ucLoopIndex]);
 129         if(pstClassifierRule->ucProtocol[ucLoopIndex]==ucProtocol)
 130         {
 131                 return TRUE;
 132         }
 133     }
 134     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol Not Matched");
 135         return FALSE;
 136 }
 137
 138
 139 /***********************************************************************
 140 * Function    - MatchSrcPort()
 141 *
 142 * Description - Checks, Source port from the packet matches with that of queue.
 143 *
 144 * Parameters  - pstClassifierRule: Pointer to the packet info structure.
 145 *                         - ushSrcPort  : Source port from the packet.
 146 *
 147 * Returns     - TRUE(If address matches) else FAIL.
 148 ***************************************************************************/
 149 BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort)
 150 {
 151         UCHAR   ucLoopIndex=0;
 152
 153                 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 154
 155
 156         if(0 == pstClassifierRule->ucSrcPortRangeLength)
 157                 return TRUE;
 158         for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucSrcPortRangeLength;ucLoopIndex++)
 159         {
 160                 if(ushSrcPort <= pstClassifierRule->usSrcPortRangeHi[ucLoopIndex] &&
 161                     ushSrcPort >= pstClassifierRule->usSrcPortRangeLo[ucLoopIndex])
 162                 {
 163                         return TRUE;
 164                 }
 165         }
 166                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Port: %x Not Matched ",ushSrcPort);
 167         return FALSE;
 168 }
 169
 170
 171 /***********************************************************************
 172 * Function    - MatchDestPort()
 173 *
 174 * Description - Checks, Destination port from packet matches with that of queue.
 175 *
 176 * Parameters  - pstClassifierRule: Pointer to the packet info structure.
 177 *                         - ushDestPort : Destination port from the packet.
 178 *
 179 * Returns     - TRUE(If address matches) else FAIL.
 180 ***************************************************************************/
 181 BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushDestPort)
 182 {
 183         UCHAR   ucLoopIndex=0;
 184                 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 185
 186         if(0 == pstClassifierRule->ucDestPortRangeLength)
 187                 return TRUE;
 188
 189         for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucDestPortRangeLength;ucLoopIndex++)
 190         {
 191                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Matching Port:0x%X   0x%X  0x%X",ushDestPort,pstClassifierRule->usDestPortRangeLo[ucLoopIndex],pstClassifierRule->usDestPortRangeHi[ucLoopIndex]);
 192
 193                 if(ushDestPort <= pstClassifierRule->usDestPortRangeHi[ucLoopIndex] &&
 194                     ushDestPort >= pstClassifierRule->usDestPortRangeLo[ucLoopIndex])
 195                 {
 196                     return TRUE;
 197                 }
 198         }
 199                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Dest Port: %x Not Matched",ushDestPort);
 200         return FALSE;
 201 }
 202 /**
 203 @ingroup tx_functions
 204 Compares IPV4 Ip address and port number
 205 @return Queue Index.
 206 */
 207 static USHORT   IpVersion4(PMINI_ADAPTER Adapter,
 208                            struct iphdr *iphd,
 209                            S_CLASSIFIER_RULE *pstClassifierRule )
 210 {
 211         xporthdr                *xprt_hdr=NULL;
 212         BOOLEAN bClassificationSucceed=FALSE;
 213
 214         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "========>");
 215
 216         xprt_hdr=(xporthdr *)((PUCHAR)iphd + sizeof(struct iphdr));
 217
 218         do {
 219                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Trying to see Direction = %d %d",
 220                         pstClassifierRule->ucDirection,
 221                         pstClassifierRule->usVCID_Value);
 222
 223                 //Checking classifier validity
 224                 if(!pstClassifierRule->bUsed || pstClassifierRule->ucDirection == DOWNLINK_DIR)
 225                 {
 226                         bClassificationSucceed = FALSE;
 227                         break;
 228                 }
 229
 230                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "is IPv6 check!");
 231                 if(pstClassifierRule->bIpv6Protocol)
 232                         break;
 233
 234                 //**************Checking IP header parameter**************************//
 235                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Trying to match Source IP Address");
 236                 if(FALSE == (bClassificationSucceed =
 237                         MatchSrcIpAddress(pstClassifierRule, iphd->saddr)))
 238                         break;
 239                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Source IP Address Matched");
 240
 241                 if(FALSE == (bClassificationSucceed =
 242                         MatchDestIpAddress(pstClassifierRule, iphd->daddr)))
 243                         break;
 244                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination IP Address Matched");
 245
 246                 if(FALSE == (bClassificationSucceed =
 247                         MatchTos(pstClassifierRule, iphd->tos)))
 248                 {
 249                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "TOS Match failed\n");
 250                         break;
 251                 }
 252                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "TOS Matched");
 253
 254                 if(FALSE == (bClassificationSucceed =
 255                         MatchProtocol(pstClassifierRule,iphd->protocol)))
 256                         break;
 257                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol Matched");
 258
 259                 //if protocol is not TCP or UDP then no need of comparing source port and destination port
 260                 if(iphd->protocol!=TCP && iphd->protocol!=UDP)
 261                         break;
 262                 //******************Checking Transport Layer Header field if present *****************//
 263                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Source Port %04x",
 264                         (iphd->protocol==UDP)?xprt_hdr->uhdr.source:xprt_hdr->thdr.source);
 265
 266                 if(FALSE == (bClassificationSucceed =
 267                         MatchSrcPort(pstClassifierRule,
 268                                 ntohs((iphd->protocol == UDP)?
 269                                 xprt_hdr->uhdr.source:xprt_hdr->thdr.source))))
 270                         break;
 271                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Port Matched");
 272
 273                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Port %04x",
 274                         (iphd->protocol==UDP)?xprt_hdr->uhdr.dest:
 275                         xprt_hdr->thdr.dest);
 276                 if(FALSE == (bClassificationSucceed =
 277                         MatchDestPort(pstClassifierRule,
 278                         ntohs((iphd->protocol == UDP)?
 279                         xprt_hdr->uhdr.dest:xprt_hdr->thdr.dest))))
 280                         break;
 281         } while(0);
 282
 283         if(TRUE==bClassificationSucceed)
 284         {
 285                 INT iMatchedSFQueueIndex = 0;
 286                 iMatchedSFQueueIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
 287                 if(iMatchedSFQueueIndex >= NO_OF_QUEUES)
 288                 {
 289                         bClassificationSucceed = FALSE;
 290                 }
 291                 else
 292                 {
 293                         if(FALSE == Adapter->PackInfo[iMatchedSFQueueIndex].bActive)
 294                         {
 295                                 bClassificationSucceed = FALSE;
 296                         }
 297                 }
 298         }
 299
 300         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "IpVersion4 <==========");
 301
 302         return bClassificationSucceed;
 303 }
 304
 305 VOID PruneQueueAllSF(PMINI_ADAPTER Adapter)
 306 {
 307         UINT iIndex = 0;
 308
 309         for(iIndex = 0; iIndex < HiPriority; iIndex++)
 310         {
 311                 if(!Adapter->PackInfo[iIndex].bValid)
 312                         continue;
 313
 314                 PruneQueue(Adapter, iIndex);
 315         }
 316 }
 317
 318
 319 /**
 320 @ingroup tx_functions
 321 This function checks if the max queue size for a queue
 322 is less than number of bytes in the queue. If so -
 323 drops packets from the Head till the number of bytes is
 324 less than or equal to max queue size for the queue.
 325 */
 326 static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex)
 327 {
 328         struct sk_buff* PacketToDrop=NULL;
 329         struct net_device_stats *netstats;
 330
 331         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "=====> Index %d",iIndex);
 332
 333         if(iIndex == HiPriority)
 334                 return;
 335
 336         if(!Adapter || (iIndex < 0) || (iIndex > HiPriority))
 337                 return;
 338
 339         /* To Store the netdevice statistic */
 340         netstats = &Adapter->dev->stats;
 341
 342         spin_lock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
 343
 344         while(1)
 345 //      while((UINT)Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost >
 346 //              SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
 347         {
 348                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "uiCurrentBytesOnHost:%x uiMaxBucketSize :%x",
 349                 Adapter->PackInfo[iIndex].uiCurrentBytesOnHost,
 350                 Adapter->PackInfo[iIndex].uiMaxBucketSize);
 351
 352                 PacketToDrop = Adapter->PackInfo[iIndex].FirstTxQueue;
 353
 354                 if(PacketToDrop == NULL)
 355                         break;
 356                 if((Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost < SF_MAX_ALLOWED_PACKETS_TO_BACKUP) &&
 357                         ((1000*(jiffies - *((B_UINT32 *)(PacketToDrop->cb)+SKB_CB_LATENCY_OFFSET))/HZ) <= Adapter->PackInfo[iIndex].uiMaxLatency))
 358                         break;
 359
 360                 if(PacketToDrop)
 361                 {
 362                         if (netif_msg_tx_err(Adapter))
 363                                 pr_info(PFX "%s: tx queue %d overlimit\n",
 364                                         Adapter->dev->name, iIndex);
 365
 366                         netstats->tx_dropped++;
 367                         atomic_inc(&Adapter->TxDroppedPacketCount);
 368                         DEQUEUEPACKET(Adapter->PackInfo[iIndex].FirstTxQueue,
 369                                                 Adapter->PackInfo[iIndex].LastTxQueue);
 370                         /// update current bytes and packets count
 371                         Adapter->PackInfo[iIndex].uiCurrentBytesOnHost -=
 372                                 PacketToDrop->len;
 373                         Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost--;
 374                         /// update dropped bytes and packets counts
 375                         Adapter->PackInfo[iIndex].uiDroppedCountBytes += PacketToDrop->len;
 376                         Adapter->PackInfo[iIndex].uiDroppedCountPackets++;
 377                         dev_kfree_skb(PacketToDrop);
 378
 379                 }
 380
 381                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "Dropped Bytes:%x Dropped Packets:%x",
 382                         Adapter->PackInfo[iIndex].uiDroppedCountBytes,
 383                         Adapter->PackInfo[iIndex].uiDroppedCountPackets);
 384
 385                 atomic_dec(&Adapter->TotalPacketCount);
 386                 Adapter->bcm_jiffies = jiffies;
 387         }
 388
 389         spin_unlock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
 390
 391         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "TotalPacketCount:%x",
 392                 atomic_read(&Adapter->TotalPacketCount));
 393         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "<=====");
 394 }
 395
 396 VOID flush_all_queues(PMINI_ADAPTER Adapter)
 397 {
 398         INT             iQIndex;
 399         UINT    uiTotalPacketLength;
 400         struct sk_buff*                         PacketToDrop=NULL;
 401         struct net_device_stats*        netstats=&Adapter->dev->stats;
 402
 403         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "=====>");
 404
 405 //      down(&Adapter->data_packet_queue_lock);
 406         for(iQIndex=LowPriority; iQIndex<HiPriority; iQIndex++)
 407         {
 408                 spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
 409                 while(Adapter->PackInfo[iQIndex].FirstTxQueue)
 410                 {
 411                         PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
 412                         if(PacketToDrop)
 413                         {
 414                                 uiTotalPacketLength = PacketToDrop->len;
 415                                 netstats->tx_dropped++;
 416                                 atomic_inc(&Adapter->TxDroppedPacketCount);
 417                         }
 418                         else
 419                                 uiTotalPacketLength = 0;
 420
 421                         DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue,
 422                                                 Adapter->PackInfo[iQIndex].LastTxQueue);
 423
 424                         /* Free the skb */
 425                         dev_kfree_skb(PacketToDrop);
 426
 427                         /// update current bytes and packets count
 428                         Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= uiTotalPacketLength;
 429                         Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
 430
 431                         /// update dropped bytes and packets counts
 432                         Adapter->PackInfo[iQIndex].uiDroppedCountBytes += uiTotalPacketLength;
 433                         Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
 434
 435                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Dropped Bytes:%x Dropped Packets:%x",
 436                                         Adapter->PackInfo[iQIndex].uiDroppedCountBytes,
 437                                         Adapter->PackInfo[iQIndex].uiDroppedCountPackets);
 438                         atomic_dec(&Adapter->TotalPacketCount);
 439                 }
 440                 spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
 441         }
 442 //      up(&Adapter->data_packet_queue_lock);
 443         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "<=====");
 444 }
 445
 446 USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
 447 {
 448         INT                     uiLoopIndex=0;
 449         S_CLASSIFIER_RULE *pstClassifierRule = NULL;
 450         S_ETHCS_PKT_INFO stEthCsPktInfo;
 451         PVOID pvEThPayload = NULL;
 452         struct iphdr            *pIpHeader = NULL;
 453         INT       uiSfIndex=0;
 454         USHORT  usIndex=Adapter->usBestEffortQueueIndex;
 455         BOOLEAN bFragmentedPkt=FALSE,bClassificationSucceed=FALSE;
 456         USHORT  usCurrFragment =0;
 457
 458         PTCP_HEADER pTcpHeader;
 459         UCHAR IpHeaderLength;
 460         UCHAR TcpHeaderLength;
 461
 462         pvEThPayload = skb->data;
 463         *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = 0;
 464         EThCSGetPktInfo(Adapter,pvEThPayload,&stEthCsPktInfo);
 465
 466         switch(stEthCsPktInfo.eNwpktEthFrameType)
 467         {
 468                 case eEth802LLCFrame:
 469                 {
 470                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802LLCFrame\n");
 471             pIpHeader = pvEThPayload + sizeof(ETH_CS_802_LLC_FRAME);
 472                         break;
 473                 }
 474
 475                 case eEth802LLCSNAPFrame:
 476                 {
 477                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802LLC SNAP Frame\n");
 478                         pIpHeader = pvEThPayload + sizeof(ETH_CS_802_LLC_SNAP_FRAME);
 479                         break;
 480                 }
 481                 case eEth802QVLANFrame:
 482                 {
 483                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802.1Q VLANFrame\n");
 484                         pIpHeader = pvEThPayload + sizeof(ETH_CS_802_Q_FRAME);
 485                         break;
 486                 }
 487                 case eEthOtherFrame:
 488                 {
 489                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : ETH Other Frame\n");
 490                         pIpHeader = pvEThPayload + sizeof(ETH_CS_ETH2_FRAME);
 491                         break;
 492                 }
 493                 default:
 494                 {
 495                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : Unrecognized ETH Frame\n");
 496                         pIpHeader = pvEThPayload + sizeof(ETH_CS_ETH2_FRAME);
 497                         break;
 498                 }
 499         }
 500
 501         if(stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
 502         {
 503                 usCurrFragment = (ntohs(pIpHeader->frag_off) & IP_OFFSET);
 504                 if((ntohs(pIpHeader->frag_off) & IP_MF) || usCurrFragment)
 505                         bFragmentedPkt = TRUE;
 506
 507                 if(bFragmentedPkt)
 508                 {
 509                                 //Fragmented  Packet. Get Frag Classifier Entry.
 510                         pstClassifierRule = GetFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
 511                         if(pstClassifierRule)
 512                         {
 513                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"It is next Fragmented pkt");
 514                                         bClassificationSucceed=TRUE;
 515                         }
 516                         if(!(ntohs(pIpHeader->frag_off) & IP_MF))
 517                         {
 518                                 //Fragmented Last packet . Remove Frag Classifier Entry
 519                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"This is the last fragmented Pkt");
 520                                 DelFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
 521                         }
 522                 }
 523         }
 524
 525         for(uiLoopIndex = MAX_CLASSIFIERS - 1; uiLoopIndex >= 0; uiLoopIndex--)
 526         {
 527                 if (Adapter->device_removed)
 528                 {
 529                         bClassificationSucceed = FALSE;
 530                         break;
 531                 }
 532
 533                 if(bClassificationSucceed)
 534                         break;
 535                 //Iterate through all classifiers which are already in order of priority
 536                 //to classify the packet until match found
 537                 do
 538                 {
 539                         if(FALSE==Adapter->astClassifierTable[uiLoopIndex].bUsed)
 540                         {
 541                                 bClassificationSucceed=FALSE;
 542                                 break;
 543                         }
 544                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "Adapter->PackInfo[%d].bvalid=True\n",uiLoopIndex);
 545
 546                         if(0 == Adapter->astClassifierTable[uiLoopIndex].ucDirection)
 547                         {
 548                                 bClassificationSucceed=FALSE;//cannot be processed for classification.
 549                                 break;                                          // it is a down link connection
 550                         }
 551
 552                         pstClassifierRule = &Adapter->astClassifierTable[uiLoopIndex];
 553
 554                         uiSfIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
 555                         if (uiSfIndex >= NO_OF_QUEUES) {
 556                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "Queue Not Valid. SearchSfid for this classifier Failed\n");
 557                                 break;
 558                         }
 559
 560                         if(Adapter->PackInfo[uiSfIndex].bEthCSSupport)
 561                         {
 562
 563                                 if(eEthUnsupportedFrame==stEthCsPktInfo.eNwpktEthFrameType)
 564                                 {
 565                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  " ClassifyPacket : Packet Not a Valid Supported Ethernet Frame \n");
 566                                         bClassificationSucceed = FALSE;
 567                                         break;
 568                                 }
 569
 570
 571
 572                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "Performing ETH CS Classification on Classifier Rule ID : %x Service Flow ID : %lx\n",pstClassifierRule->uiClassifierRuleIndex,Adapter->PackInfo[uiSfIndex].ulSFID);
 573                                 bClassificationSucceed = EThCSClassifyPkt(Adapter,skb,&stEthCsPktInfo,pstClassifierRule, Adapter->PackInfo[uiSfIndex].bEthCSSupport);
 574
 575                                 if(!bClassificationSucceed)
 576                                 {
 577                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ClassifyPacket : Ethernet CS Classification Failed\n");
 578                                         break;
 579                                 }
 580                         }
 581
 582                         else // No ETH Supported on this SF
 583                         {
 584                                 if(eEthOtherFrame != stEthCsPktInfo.eNwpktEthFrameType)
 585                                 {
 586                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  " ClassifyPacket : Packet Not a 802.3 Ethernet Frame... hence not allowed over non-ETH CS SF \n");
 587                                         bClassificationSucceed = FALSE;
 588                                         break;
 589                                 }
 590                         }
 591
 592                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "Proceeding to IP CS Clasification");
 593
 594                         if(Adapter->PackInfo[uiSfIndex].bIPCSSupport)
 595                         {
 596
 597                                 if(stEthCsPktInfo.eNwpktIPFrameType == eNonIPPacket)
 598                                 {
 599                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  " ClassifyPacket : Packet is Not an IP Packet \n");
 600                                         bClassificationSucceed = FALSE;
 601                                         break;
 602                                 }
 603                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "Dump IP Header : \n");
 604                                 DumpFullPacket((PUCHAR)pIpHeader,20);
 605
 606                                 if(stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
 607                                         bClassificationSucceed = IpVersion4(Adapter,pIpHeader,pstClassifierRule);
 608                                 else if(stEthCsPktInfo.eNwpktIPFrameType == eIPv6Packet)
 609                                         bClassificationSucceed = IpVersion6(Adapter,pIpHeader,pstClassifierRule);
 610                         }
 611
 612                 }while(0);
 613         }
 614
 615         if(bClassificationSucceed == TRUE)
 616         {
 617                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "CF id : %d, SF ID is =%lu",pstClassifierRule->uiClassifierRuleIndex, pstClassifierRule->ulSFID);
 618
 619                 //Store The matched Classifier in SKB
 620                 *((UINT32*)(skb->cb)+SKB_CB_CLASSIFICATION_OFFSET) = pstClassifierRule->uiClassifierRuleIndex;
 621                 if((TCP == pIpHeader->protocol ) && !bFragmentedPkt && (ETH_AND_IP_HEADER_LEN + TCP_HEADER_LEN <= skb->len) )
 622                 {
 623                          IpHeaderLength   = pIpHeader->ihl;
 624                          pTcpHeader = (PTCP_HEADER)(((PUCHAR)pIpHeader)+(IpHeaderLength*4));
 625                          TcpHeaderLength  = GET_TCP_HEADER_LEN(pTcpHeader->HeaderLength);
 626
 627                         if((pTcpHeader->ucFlags & TCP_ACK) &&
 628                            (ntohs(pIpHeader->tot_len) == (IpHeaderLength*4)+(TcpHeaderLength*4)))
 629                         {
 630                         *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = TCP_ACK;
 631                         }
 632                 }
 633
 634                 usIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
 635                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "index is   =%d", usIndex);
 636
 637                 //If this is the first fragment of a Fragmented pkt, add this CF. Only This CF should be used for all other fragment of this Pkt.
 638                 if(bFragmentedPkt && (usCurrFragment == 0))
 639                 {
 640                         //First Fragment of Fragmented Packet. Create Frag CLS Entry
 641                         S_FRAGMENTED_PACKET_INFO stFragPktInfo;
 642                         stFragPktInfo.bUsed = TRUE;
 643                         stFragPktInfo.ulSrcIpAddress = pIpHeader->saddr;
 644                         stFragPktInfo.usIpIdentification = pIpHeader->id;
 645                         stFragPktInfo.pstMatchedClassifierEntry = pstClassifierRule;
 646                         stFragPktInfo.bOutOfOrderFragment = FALSE;
 647                         AddFragIPClsEntry(Adapter,&stFragPktInfo);
 648                 }
 649
 650
 651         }
 652
 653         if(bClassificationSucceed)
 654                 return usIndex;
 655         else
 656                 return INVALID_QUEUE_INDEX;
 657 }
 658
 659 static BOOLEAN EthCSMatchSrcMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
 660 {
 661         UINT i=0;
 662     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 663         if(pstClassifierRule->ucEthCSSrcMACLen==0)
 664                 return TRUE;
 665         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s \n",__FUNCTION__);
 666         for(i=0;i<MAC_ADDRESS_SIZE;i++)
 667         {
 668                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "SRC MAC[%x] = %x ClassifierRuleSrcMAC = %x Mask : %x\n",i,Mac[i],pstClassifierRule->au8EThCSSrcMAC[i],pstClassifierRule->au8EThCSSrcMACMask[i]);
 669                 if((pstClassifierRule->au8EThCSSrcMAC[i] & pstClassifierRule->au8EThCSSrcMACMask[i])!=
 670                         (Mac[i] & pstClassifierRule->au8EThCSSrcMACMask[i]))
 671                         return FALSE;
 672         }
 673         return TRUE;
 674 }
 675
 676 static BOOLEAN EthCSMatchDestMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
 677 {
 678         UINT i=0;
 679     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 680         if(pstClassifierRule->ucEthCSDestMACLen==0)
 681                 return TRUE;
 682         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s \n",__FUNCTION__);
 683         for(i=0;i<MAC_ADDRESS_SIZE;i++)
 684         {
 685                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "SRC MAC[%x] = %x ClassifierRuleSrcMAC = %x Mask : %x\n",i,Mac[i],pstClassifierRule->au8EThCSDestMAC[i],pstClassifierRule->au8EThCSDestMACMask[i]);
 686                 if((pstClassifierRule->au8EThCSDestMAC[i] & pstClassifierRule->au8EThCSDestMACMask[i])!=
 687                         (Mac[i] & pstClassifierRule->au8EThCSDestMACMask[i]))
 688                         return FALSE;
 689         }
 690         return TRUE;
 691 }
 692
 693 static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
 694 {
 695     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 696         if((pstClassifierRule->ucEtherTypeLen==0)||
 697                 (pstClassifierRule->au8EthCSEtherType[0] == 0))
 698                 return TRUE;
 699
 700         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s SrcEtherType:%x CLS EtherType[0]:%x\n",__FUNCTION__,pstEthCsPktInfo->usEtherType,pstClassifierRule->au8EthCSEtherType[0]);
 701         if(pstClassifierRule->au8EthCSEtherType[0] == 1)
 702         {
 703                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s  CLS EtherType[1]:%x EtherType[2]:%x\n",__FUNCTION__,pstClassifierRule->au8EthCSEtherType[1],pstClassifierRule->au8EthCSEtherType[2]);
 704
 705                 if(memcmp(&pstEthCsPktInfo->usEtherType,&pstClassifierRule->au8EthCSEtherType[1],2)==0)
 706                         return TRUE;
 707                 else
 708                         return FALSE;
 709         }
 710
 711         if(pstClassifierRule->au8EthCSEtherType[0] == 2)
 712         {
 713                 if(eEth802LLCFrame != pstEthCsPktInfo->eNwpktEthFrameType)
 714                         return FALSE;
 715
 716                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s  EthCS DSAP:%x EtherType[2]:%x\n",__FUNCTION__,pstEthCsPktInfo->ucDSAP,pstClassifierRule->au8EthCSEtherType[2]);
 717                 if(pstEthCsPktInfo->ucDSAP == pstClassifierRule->au8EthCSEtherType[2])
 718                         return TRUE;
 719                 else
 720                         return FALSE;
 721
 722         }
 723
 724         return FALSE;
 725
 726 }
 727
 728 static BOOLEAN EthCSMatchVLANRules(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
 729 {
 730         BOOLEAN bClassificationSucceed = FALSE;
 731         USHORT usVLANID;
 732         B_UINT8 uPriority = 0;
 733     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 734
 735         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s  CLS UserPrio:%x CLS VLANID:%x\n",__FUNCTION__,ntohs(*((USHORT *)pstClassifierRule->usUserPriority)),pstClassifierRule->usVLANID);
 736
 737         /* In case FW didn't recieve the TLV, the priority field should be ignored */
 738         if(pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_USER_PRIORITY_VALID))
 739         {
 740                 if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
 741                                 return FALSE;
 742
 743                 uPriority = (ntohs(*(USHORT *)(skb->data + sizeof(ETH_HEADER_STRUC))) & 0xF000) >> 13;
 744
 745                 if((uPriority >= pstClassifierRule->usUserPriority[0]) && (uPriority <= pstClassifierRule->usUserPriority[1]))
 746                                 bClassificationSucceed = TRUE;
 747
 748                 if(!bClassificationSucceed)
 749                         return FALSE;
 750         }
 751
 752         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ETH CS 802.1 D  User Priority Rule Matched\n");
 753
 754         bClassificationSucceed = FALSE;
 755
 756         if(pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_VLANID_VALID))
 757         {
 758                 if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
 759                                 return FALSE;
 760
 761                 usVLANID = ntohs(*(USHORT *)(skb->data + sizeof(ETH_HEADER_STRUC))) & 0xFFF;
 762
 763                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "%s  Pkt VLANID %x Priority: %d\n",__FUNCTION__,usVLANID, uPriority);
 764
 765                 if(usVLANID == ((pstClassifierRule->usVLANID & 0xFFF0) >> 4))
 766                         bClassificationSucceed = TRUE;
 767
 768                 if(!bClassificationSucceed)
 769                         return FALSE;
 770         }
 771
 772         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ETH CS 802.1 Q VLAN ID Rule Matched\n");
 773
 774         return TRUE;
 775 }
 776
 777
 778 static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,
 779                                 PS_ETHCS_PKT_INFO pstEthCsPktInfo,
 780                                 S_CLASSIFIER_RULE *pstClassifierRule,
 781                                 B_UINT8 EthCSCupport)
 782 {
 783         BOOLEAN bClassificationSucceed = FALSE;
 784         bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,((ETH_HEADER_STRUC *)(skb->data))->au8SourceAddress);
 785         if(!bClassificationSucceed)
 786                 return FALSE;
 787         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ETH CS SrcMAC Matched\n");
 788
 789         bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,((ETH_HEADER_STRUC*)(skb->data))->au8DestinationAddress);
 790         if(!bClassificationSucceed)
 791                 return FALSE;
 792         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ETH CS DestMAC Matched\n");
 793
 794         //classify on ETHType/802.2SAP TLV
 795         bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule,skb,pstEthCsPktInfo);
 796         if(!bClassificationSucceed)
 797                 return FALSE;
 798
 799         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ETH CS EthType/802.2SAP Matched\n");
 800
 801         //classify on 802.1VLAN Header Parameters
 802
 803         bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule,skb,pstEthCsPktInfo);
 804         if(!bClassificationSucceed)
 805                 return FALSE;
 806         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "ETH CS 802.1 VLAN Rules Matched\n");
 807
 808         return bClassificationSucceed;
 809 }
 810
 811 static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,
 812                             PS_ETHCS_PKT_INFO pstEthCsPktInfo)
 813 {
 814         USHORT u16Etype = ntohs(((ETH_HEADER_STRUC*)pvEthPayload)->u16Etype);
 815
 816         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "EthCSGetPktInfo : Eth Hdr Type : %X\n",u16Etype);
 817         if(u16Etype > 0x5dc)
 818         {
 819                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "EthCSGetPktInfo : ETH2 Frame \n");
 820                 //ETH2 Frame
 821                 if(u16Etype == ETHERNET_FRAMETYPE_802QVLAN)
 822                 {
 823                         //802.1Q VLAN Header
 824                         pstEthCsPktInfo->eNwpktEthFrameType = eEth802QVLANFrame;
 825                         u16Etype = ((ETH_CS_802_Q_FRAME*)pvEthPayload)->EthType;
 826                         //((ETH_CS_802_Q_FRAME*)pvEthPayload)->UserPriority
 827                 }
 828                 else
 829                 {
 830                         pstEthCsPktInfo->eNwpktEthFrameType = eEthOtherFrame;
 831                         u16Etype = ntohs(u16Etype);
 832                 }
 833
 834         }
 835         else
 836         {
 837                 //802.2 LLC
 838                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "802.2 LLC Frame \n");
 839                 pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCFrame;
 840                 pstEthCsPktInfo->ucDSAP = ((ETH_CS_802_LLC_FRAME*)pvEthPayload)->DSAP;
 841                 if(pstEthCsPktInfo->ucDSAP == 0xAA && ((ETH_CS_802_LLC_FRAME*)pvEthPayload)->SSAP == 0xAA)
 842                 {
 843                         //SNAP Frame
 844                         pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCSNAPFrame;
 845                         u16Etype = ((ETH_CS_802_LLC_SNAP_FRAME*)pvEthPayload)->usEtherType;
 846                 }
 847         }
 848         if(u16Etype == ETHERNET_FRAMETYPE_IPV4)
 849                 pstEthCsPktInfo->eNwpktIPFrameType = eIPv4Packet;
 850         else if(u16Etype == ETHERNET_FRAMETYPE_IPV6)
 851                 pstEthCsPktInfo->eNwpktIPFrameType = eIPv6Packet;
 852         else
 853                 pstEthCsPktInfo->eNwpktIPFrameType = eNonIPPacket;
 854
 855         pstEthCsPktInfo->usEtherType = ((ETH_HEADER_STRUC*)pvEthPayload)->u16Etype;
 856         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "EthCsPktInfo->eNwpktIPFrameType : %x\n",pstEthCsPktInfo->eNwpktIPFrameType);
 857         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "EthCsPktInfo->eNwpktEthFrameType : %x\n",pstEthCsPktInfo->eNwpktEthFrameType);
 858         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,  "EthCsPktInfo->usEtherType : %x\n",pstEthCsPktInfo->usEtherType);
 859 }
 860
 861
 862