3 This file contains the routines related to Quality of Service.
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);
10 static USHORT IpVersion4(PMINI_ADAPTER Adapter, struct iphdr *iphd,
11 S_CLASSIFIER_RULE *pstClassifierRule );
13 static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex);
16 /*******************************************************************
17 * Function - MatchSrcIpAddress()
19 * Description - Checks whether the Source IP address from the packet
20 * matches with that of Queue.
22 * Parameters - pstClassifierRule: Pointer to the packet info structure.
23 * - ulSrcIP : Source IP address from the packet.
25 * Returns - TRUE(If address matches) else FAIL .
26 *********************************************************************/
27 BOOLEAN MatchSrcIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulSrcIP)
31 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
33 ulSrcIP=ntohl(ulSrcIP);
34 if(0 == pstClassifierRule->ucIPSourceAddressLength)
36 for(ucLoopIndex=0; ucLoopIndex < (pstClassifierRule->ucIPSourceAddressLength);ucLoopIndex++)
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] ))
45 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Ip Address Not Matched");
50 /*******************************************************************
51 * Function - MatchDestIpAddress()
53 * Description - Checks whether the Destination IP address from the packet
54 * matches with that of Queue.
56 * Parameters - pstClassifierRule: Pointer to the packet info structure.
57 * - ulDestIP : Destination IP address from the packet.
59 * Returns - TRUE(If address matches) else FAIL .
60 *********************************************************************/
61 BOOLEAN MatchDestIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulDestIP)
64 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
66 ulDestIP=ntohl(ulDestIP);
67 if(0 == pstClassifierRule->ucIPDestinationAddressLength)
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]);
71 for(ucLoopIndex=0;ucLoopIndex<(pstClassifierRule->ucIPDestinationAddressLength);ucLoopIndex++)
73 if((pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex] & ulDestIP)==
74 (pstClassifierRule->stDestIpAddress.ulIpv4Addr[ucLoopIndex] & pstClassifierRule->stDestIpAddress.ulIpv4Mask[ucLoopIndex]))
79 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination Ip Address Not Matched");
84 /************************************************************************
85 * Function - MatchTos()
87 * Description - Checks the TOS from the packet matches with that of queue.
89 * Parameters - pstClassifierRule : Pointer to the packet info structure.
90 * - ucTypeOfService: TOS from the packet.
92 * Returns - TRUE(If address matches) else FAIL.
93 **************************************************************************/
94 BOOLEAN MatchTos(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucTypeOfService)
97 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
98 if( 3 != pstClassifierRule->ucIPTypeOfServiceLength )
101 if(((pstClassifierRule->ucTosMask & ucTypeOfService)<=pstClassifierRule->ucTosHigh) && ((pstClassifierRule->ucTosMask & ucTypeOfService)>=pstClassifierRule->ucTosLow))
105 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Type Of Service Not Matched");
110 /***************************************************************************
111 * Function - MatchProtocol()
113 * Description - Checks the protocol from the packet matches with that of queue.
115 * Parameters - pstClassifierRule: Pointer to the packet info structure.
116 * - ucProtocol : Protocol from the packet.
118 * Returns - TRUE(If address matches) else FAIL.
119 ****************************************************************************/
120 BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol)
123 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
124 if(0 == pstClassifierRule->ucProtocolLength)
126 for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucProtocolLength;ucLoopIndex++)
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)
134 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol Not Matched");
139 /***********************************************************************
140 * Function - MatchSrcPort()
142 * Description - Checks, Source port from the packet matches with that of queue.
144 * Parameters - pstClassifierRule: Pointer to the packet info structure.
145 * - ushSrcPort : Source port from the packet.
147 * Returns - TRUE(If address matches) else FAIL.
148 ***************************************************************************/
149 BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort)
153 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
156 if(0 == pstClassifierRule->ucSrcPortRangeLength)
158 for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucSrcPortRangeLength;ucLoopIndex++)
160 if(ushSrcPort <= pstClassifierRule->usSrcPortRangeHi[ucLoopIndex] &&
161 ushSrcPort >= pstClassifierRule->usSrcPortRangeLo[ucLoopIndex])
166 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Port: %x Not Matched ",ushSrcPort);
171 /***********************************************************************
172 * Function - MatchDestPort()
174 * Description - Checks, Destination port from packet matches with that of queue.
176 * Parameters - pstClassifierRule: Pointer to the packet info structure.
177 * - ushDestPort : Destination port from the packet.
179 * Returns - TRUE(If address matches) else FAIL.
180 ***************************************************************************/
181 BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushDestPort)
184 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
186 if(0 == pstClassifierRule->ucDestPortRangeLength)
189 for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucDestPortRangeLength;ucLoopIndex++)
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]);
193 if(ushDestPort <= pstClassifierRule->usDestPortRangeHi[ucLoopIndex] &&
194 ushDestPort >= pstClassifierRule->usDestPortRangeLo[ucLoopIndex])
199 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Dest Port: %x Not Matched",ushDestPort);
203 @ingroup tx_functions
204 Compares IPV4 Ip address and port number
207 static USHORT IpVersion4(PMINI_ADAPTER Adapter,
209 S_CLASSIFIER_RULE *pstClassifierRule )
211 xporthdr *xprt_hdr=NULL;
212 BOOLEAN bClassificationSucceed=FALSE;
214 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "========>");
216 xprt_hdr=(xporthdr *)((PUCHAR)iphd + sizeof(struct iphdr));
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);
223 //Checking classifier validity
224 if(!pstClassifierRule->bUsed || pstClassifierRule->ucDirection == DOWNLINK_DIR)
226 bClassificationSucceed = FALSE;
230 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "is IPv6 check!");
231 if(pstClassifierRule->bIpv6Protocol)
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)))
239 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Source IP Address Matched");
241 if(FALSE == (bClassificationSucceed =
242 MatchDestIpAddress(pstClassifierRule, iphd->daddr)))
244 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Destination IP Address Matched");
246 if(FALSE == (bClassificationSucceed =
247 MatchTos(pstClassifierRule, iphd->tos)))
249 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "TOS Match failed\n");
252 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "TOS Matched");
254 if(FALSE == (bClassificationSucceed =
255 MatchProtocol(pstClassifierRule,iphd->protocol)))
257 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Protocol Matched");
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)
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);
266 if(FALSE == (bClassificationSucceed =
267 MatchSrcPort(pstClassifierRule,
268 ntohs((iphd->protocol == UDP)?
269 xprt_hdr->uhdr.source:xprt_hdr->thdr.source))))
271 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Src Port Matched");
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))))
283 if(TRUE==bClassificationSucceed)
285 INT iMatchedSFQueueIndex = 0;
286 iMatchedSFQueueIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
287 if(iMatchedSFQueueIndex >= NO_OF_QUEUES)
289 bClassificationSucceed = FALSE;
293 if(FALSE == Adapter->PackInfo[iMatchedSFQueueIndex].bActive)
295 bClassificationSucceed = FALSE;
300 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "IpVersion4 <==========");
302 return bClassificationSucceed;
305 VOID PruneQueueAllSF(PMINI_ADAPTER Adapter)
309 for(iIndex = 0; iIndex < HiPriority; iIndex++)
311 if(!Adapter->PackInfo[iIndex].bValid)
314 PruneQueue(Adapter, iIndex);
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.
326 static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex)
328 struct sk_buff* PacketToDrop=NULL;
329 struct net_device_stats *netstats;
331 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "=====> Index %d",iIndex);
333 if(iIndex == HiPriority)
336 if(!Adapter || (iIndex < 0) || (iIndex > HiPriority))
339 /* To Store the netdevice statistic */
340 netstats = &Adapter->dev->stats;
342 spin_lock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
345 // while((UINT)Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost >
346 // SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
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);
352 PacketToDrop = Adapter->PackInfo[iIndex].FirstTxQueue;
354 if(PacketToDrop == NULL)
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))
362 if (netif_msg_tx_err(Adapter))
363 pr_info(PFX "%s: tx queue %d overlimit\n",
364 Adapter->dev->name, iIndex);
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 -=
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);
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);
385 atomic_dec(&Adapter->TotalPacketCount);
386 Adapter->bcm_jiffies = jiffies;
389 spin_unlock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
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, "<=====");
396 VOID flush_all_queues(PMINI_ADAPTER Adapter)
399 UINT uiTotalPacketLength;
400 struct sk_buff* PacketToDrop=NULL;
401 struct net_device_stats* netstats=&Adapter->dev->stats;
403 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "=====>");
405 // down(&Adapter->data_packet_queue_lock);
406 for(iQIndex=LowPriority; iQIndex<HiPriority; iQIndex++)
408 spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
409 while(Adapter->PackInfo[iQIndex].FirstTxQueue)
411 PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
414 uiTotalPacketLength = PacketToDrop->len;
415 netstats->tx_dropped++;
416 atomic_inc(&Adapter->TxDroppedPacketCount);
419 uiTotalPacketLength = 0;
421 DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue,
422 Adapter->PackInfo[iQIndex].LastTxQueue);
425 dev_kfree_skb(PacketToDrop);
427 /// update current bytes and packets count
428 Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= uiTotalPacketLength;
429 Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
431 /// update dropped bytes and packets counts
432 Adapter->PackInfo[iQIndex].uiDroppedCountBytes += uiTotalPacketLength;
433 Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
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);
440 spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
442 // up(&Adapter->data_packet_queue_lock);
443 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "<=====");
446 USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
449 S_CLASSIFIER_RULE *pstClassifierRule = NULL;
450 S_ETHCS_PKT_INFO stEthCsPktInfo;
451 PVOID pvEThPayload = NULL;
452 struct iphdr *pIpHeader = NULL;
454 USHORT usIndex=Adapter->usBestEffortQueueIndex;
455 BOOLEAN bFragmentedPkt=FALSE,bClassificationSucceed=FALSE;
456 USHORT usCurrFragment =0;
458 PTCP_HEADER pTcpHeader;
459 UCHAR IpHeaderLength;
460 UCHAR TcpHeaderLength;
462 pvEThPayload = skb->data;
463 *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = 0;
464 EThCSGetPktInfo(Adapter,pvEThPayload,&stEthCsPktInfo);
466 switch(stEthCsPktInfo.eNwpktEthFrameType)
468 case eEth802LLCFrame:
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);
475 case eEth802LLCSNAPFrame:
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);
481 case eEth802QVLANFrame:
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);
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);
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);
501 if(stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
503 usCurrFragment = (ntohs(pIpHeader->frag_off) & IP_OFFSET);
504 if((ntohs(pIpHeader->frag_off) & IP_MF) || usCurrFragment)
505 bFragmentedPkt = TRUE;
509 //Fragmented Packet. Get Frag Classifier Entry.
510 pstClassifierRule = GetFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
511 if(pstClassifierRule)
513 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"It is next Fragmented pkt");
514 bClassificationSucceed=TRUE;
516 if(!(ntohs(pIpHeader->frag_off) & IP_MF))
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);
525 for(uiLoopIndex = MAX_CLASSIFIERS - 1; uiLoopIndex >= 0; uiLoopIndex--)
527 if (Adapter->device_removed)
529 bClassificationSucceed = FALSE;
533 if(bClassificationSucceed)
535 //Iterate through all classifiers which are already in order of priority
536 //to classify the packet until match found
539 if(FALSE==Adapter->astClassifierTable[uiLoopIndex].bUsed)
541 bClassificationSucceed=FALSE;
544 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Adapter->PackInfo[%d].bvalid=True\n",uiLoopIndex);
546 if(0 == Adapter->astClassifierTable[uiLoopIndex].ucDirection)
548 bClassificationSucceed=FALSE;//cannot be processed for classification.
549 break; // it is a down link connection
552 pstClassifierRule = &Adapter->astClassifierTable[uiLoopIndex];
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");
560 if(Adapter->PackInfo[uiSfIndex].bEthCSSupport)
563 if(eEthUnsupportedFrame==stEthCsPktInfo.eNwpktEthFrameType)
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;
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);
575 if(!bClassificationSucceed)
577 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : Ethernet CS Classification Failed\n");
582 else // No ETH Supported on this SF
584 if(eEthOtherFrame != stEthCsPktInfo.eNwpktEthFrameType)
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;
592 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Proceeding to IP CS Clasification");
594 if(Adapter->PackInfo[uiSfIndex].bIPCSSupport)
597 if(stEthCsPktInfo.eNwpktIPFrameType == eNonIPPacket)
599 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, " ClassifyPacket : Packet is Not an IP Packet \n");
600 bClassificationSucceed = FALSE;
603 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Dump IP Header : \n");
604 DumpFullPacket((PUCHAR)pIpHeader,20);
606 if(stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
607 bClassificationSucceed = IpVersion4(Adapter,pIpHeader,pstClassifierRule);
608 else if(stEthCsPktInfo.eNwpktIPFrameType == eIPv6Packet)
609 bClassificationSucceed = IpVersion6(Adapter,pIpHeader,pstClassifierRule);
615 if(bClassificationSucceed == TRUE)
617 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "CF id : %d, SF ID is =%lu",pstClassifierRule->uiClassifierRuleIndex, pstClassifierRule->ulSFID);
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) )
623 IpHeaderLength = pIpHeader->ihl;
624 pTcpHeader = (PTCP_HEADER)(((PUCHAR)pIpHeader)+(IpHeaderLength*4));
625 TcpHeaderLength = GET_TCP_HEADER_LEN(pTcpHeader->HeaderLength);
627 if((pTcpHeader->ucFlags & TCP_ACK) &&
628 (ntohs(pIpHeader->tot_len) == (IpHeaderLength*4)+(TcpHeaderLength*4)))
630 *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = TCP_ACK;
634 usIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
635 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "index is =%d", usIndex);
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))
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);
653 if(bClassificationSucceed)
656 return INVALID_QUEUE_INDEX;
659 static BOOLEAN EthCSMatchSrcMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
662 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
663 if(pstClassifierRule->ucEthCSSrcMACLen==0)
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++)
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]))
676 static BOOLEAN EthCSMatchDestMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
679 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
680 if(pstClassifierRule->ucEthCSDestMACLen==0)
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++)
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]))
693 static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
695 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
696 if((pstClassifierRule->ucEtherTypeLen==0)||
697 (pstClassifierRule->au8EthCSEtherType[0] == 0))
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)
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]);
705 if(memcmp(&pstEthCsPktInfo->usEtherType,&pstClassifierRule->au8EthCSEtherType[1],2)==0)
711 if(pstClassifierRule->au8EthCSEtherType[0] == 2)
713 if(eEth802LLCFrame != pstEthCsPktInfo->eNwpktEthFrameType)
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])
728 static BOOLEAN EthCSMatchVLANRules(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
730 BOOLEAN bClassificationSucceed = FALSE;
732 B_UINT8 uPriority = 0;
733 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
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);
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))
740 if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
743 uPriority = (ntohs(*(USHORT *)(skb->data + sizeof(ETH_HEADER_STRUC))) & 0xF000) >> 13;
745 if((uPriority >= pstClassifierRule->usUserPriority[0]) && (uPriority <= pstClassifierRule->usUserPriority[1]))
746 bClassificationSucceed = TRUE;
748 if(!bClassificationSucceed)
752 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 D User Priority Rule Matched\n");
754 bClassificationSucceed = FALSE;
756 if(pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_VLANID_VALID))
758 if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
761 usVLANID = ntohs(*(USHORT *)(skb->data + sizeof(ETH_HEADER_STRUC))) & 0xFFF;
763 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s Pkt VLANID %x Priority: %d\n",__FUNCTION__,usVLANID, uPriority);
765 if(usVLANID == ((pstClassifierRule->usVLANID & 0xFFF0) >> 4))
766 bClassificationSucceed = TRUE;
768 if(!bClassificationSucceed)
772 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 Q VLAN ID Rule Matched\n");
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)
783 BOOLEAN bClassificationSucceed = FALSE;
784 bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,((ETH_HEADER_STRUC *)(skb->data))->au8SourceAddress);
785 if(!bClassificationSucceed)
787 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS SrcMAC Matched\n");
789 bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,((ETH_HEADER_STRUC*)(skb->data))->au8DestinationAddress);
790 if(!bClassificationSucceed)
792 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS DestMAC Matched\n");
794 //classify on ETHType/802.2SAP TLV
795 bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule,skb,pstEthCsPktInfo);
796 if(!bClassificationSucceed)
799 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS EthType/802.2SAP Matched\n");
801 //classify on 802.1VLAN Header Parameters
803 bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule,skb,pstEthCsPktInfo);
804 if(!bClassificationSucceed)
806 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 VLAN Rules Matched\n");
808 return bClassificationSucceed;
811 static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,
812 PS_ETHCS_PKT_INFO pstEthCsPktInfo)
814 USHORT u16Etype = ntohs(((ETH_HEADER_STRUC*)pvEthPayload)->u16Etype);
816 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : Eth Hdr Type : %X\n",u16Etype);
819 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : ETH2 Frame \n");
821 if(u16Etype == ETHERNET_FRAMETYPE_802QVLAN)
824 pstEthCsPktInfo->eNwpktEthFrameType = eEth802QVLANFrame;
825 u16Etype = ((ETH_CS_802_Q_FRAME*)pvEthPayload)->EthType;
826 //((ETH_CS_802_Q_FRAME*)pvEthPayload)->UserPriority
830 pstEthCsPktInfo->eNwpktEthFrameType = eEthOtherFrame;
831 u16Etype = ntohs(u16Etype);
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)
844 pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCSNAPFrame;
845 u16Etype = ((ETH_CS_802_LLC_SNAP_FRAME*)pvEthPayload)->usEtherType;
848 if(u16Etype == ETHERNET_FRAMETYPE_IPV4)
849 pstEthCsPktInfo->eNwpktIPFrameType = eIPv4Packet;
850 else if(u16Etype == ETHERNET_FRAMETYPE_IPV6)
851 pstEthCsPktInfo->eNwpktIPFrameType = eIPv6Packet;
853 pstEthCsPktInfo->eNwpktIPFrameType = eNonIPPacket;
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);