tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/**
2@file Qos.C
3This file contains the routines related to Quality of Service.
4*/
5#include "headers.h"
6
7static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter,PVOID pvEthPayload, struct bcm_eth_packet_info *pstEthCsPktInfo);
8static BOOLEAN EThCSClassifyPkt(struct bcm_mini_adapter *Adapter,struct sk_buff* skb, struct bcm_eth_packet_info *pstEthCsPktInfo,struct bcm_classifier_rule *pstClassifierRule, B_UINT8 EthCSCupport);
9
10static USHORT IpVersion4(struct bcm_mini_adapter *Adapter, struct iphdr *iphd,
11 struct bcm_classifier_rule *pstClassifierRule );
12
13static VOID PruneQueue(struct bcm_mini_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*********************************************************************/
27BOOLEAN MatchSrcIpAddress(struct bcm_classifier_rule *pstClassifierRule,ULONG ulSrcIP)
28{
29 UCHAR ucLoopIndex=0;
30
31 struct bcm_mini_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*********************************************************************/
61BOOLEAN MatchDestIpAddress(struct bcm_classifier_rule *pstClassifierRule,ULONG ulDestIP)
62{
63 UCHAR ucLoopIndex=0;
64 struct bcm_mini_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**************************************************************************/
94BOOLEAN MatchTos(struct bcm_classifier_rule *pstClassifierRule,UCHAR ucTypeOfService)
95{
96
97 struct bcm_mini_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****************************************************************************/
120bool MatchProtocol(struct bcm_classifier_rule *pstClassifierRule,UCHAR ucProtocol)
121{
122 UCHAR ucLoopIndex=0;
123 struct bcm_mini_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***************************************************************************/
149bool MatchSrcPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushSrcPort)
150{
151 UCHAR ucLoopIndex=0;
152
153 struct bcm_mini_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***************************************************************************/
181bool MatchDestPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushDestPort)
182{
183 UCHAR ucLoopIndex=0;
184 struct bcm_mini_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
204Compares IPV4 Ip address and port number
205@return Queue Index.
206*/
207static USHORT IpVersion4(struct bcm_mini_adapter *Adapter,
208 struct iphdr *iphd,
209 struct bcm_classifier_rule *pstClassifierRule)
210{
211 struct bcm_transport_header *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=(struct bcm_transport_header *)((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
305VOID PruneQueueAllSF(struct bcm_mini_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
321This function checks if the max queue size for a queue
322is less than number of bytes in the queue. If so -
323drops packets from the Head till the number of bytes is
324less than or equal to max queue size for the queue.
325*/
326static VOID PruneQueue(struct bcm_mini_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
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 }
387
388 spin_unlock_bh(&Adapter->PackInfo[iIndex].SFQueueLock);
389
390 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "TotalPacketCount:%x",
391 atomic_read(&Adapter->TotalPacketCount));
392 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "<=====");
393}
394
395VOID flush_all_queues(struct bcm_mini_adapter *Adapter)
396{
397 INT iQIndex;
398 UINT uiTotalPacketLength;
399 struct sk_buff* PacketToDrop=NULL;
400
401 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "=====>");
402
403// down(&Adapter->data_packet_queue_lock);
404 for(iQIndex=LowPriority; iQIndex<HiPriority; iQIndex++)
405 {
406 struct net_device_stats *netstats = &Adapter->dev->stats;
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 }
417 else
418 uiTotalPacketLength = 0;
419
420 DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue,
421 Adapter->PackInfo[iQIndex].LastTxQueue);
422
423 /* Free the skb */
424 dev_kfree_skb(PacketToDrop);
425
426 /// update current bytes and packets count
427 Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= uiTotalPacketLength;
428 Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
429
430 /// update dropped bytes and packets counts
431 Adapter->PackInfo[iQIndex].uiDroppedCountBytes += uiTotalPacketLength;
432 Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
433
434 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Dropped Bytes:%x Dropped Packets:%x",
435 Adapter->PackInfo[iQIndex].uiDroppedCountBytes,
436 Adapter->PackInfo[iQIndex].uiDroppedCountPackets);
437 atomic_dec(&Adapter->TotalPacketCount);
438 }
439 spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
440 }
441// up(&Adapter->data_packet_queue_lock);
442 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "<=====");
443}
444
445USHORT ClassifyPacket(struct bcm_mini_adapter *Adapter,struct sk_buff* skb)
446{
447 INT uiLoopIndex=0;
448 struct bcm_classifier_rule *pstClassifierRule = NULL;
449 struct bcm_eth_packet_info stEthCsPktInfo;
450 PVOID pvEThPayload = NULL;
451 struct iphdr *pIpHeader = NULL;
452 INT uiSfIndex=0;
453 USHORT usIndex=Adapter->usBestEffortQueueIndex;
454 BOOLEAN bFragmentedPkt=FALSE,bClassificationSucceed=FALSE;
455 USHORT usCurrFragment =0;
456
457 struct bcm_tcp_header *pTcpHeader;
458 UCHAR IpHeaderLength;
459 UCHAR TcpHeaderLength;
460
461 pvEThPayload = skb->data;
462 *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = 0;
463 EThCSGetPktInfo(Adapter,pvEThPayload,&stEthCsPktInfo);
464
465 switch(stEthCsPktInfo.eNwpktEthFrameType)
466 {
467 case eEth802LLCFrame:
468 {
469 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802LLCFrame\n");
470 pIpHeader = pvEThPayload + sizeof(struct bcm_eth_llc_frame);
471 break;
472 }
473
474 case eEth802LLCSNAPFrame:
475 {
476 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802LLC SNAP Frame\n");
477 pIpHeader = pvEThPayload + sizeof(struct bcm_eth_llc_snap_frame);
478 break;
479 }
480 case eEth802QVLANFrame:
481 {
482 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : 802.1Q VLANFrame\n");
483 pIpHeader = pvEThPayload + sizeof(struct bcm_eth_q_frame);
484 break;
485 }
486 case eEthOtherFrame:
487 {
488 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : ETH Other Frame\n");
489 pIpHeader = pvEThPayload + sizeof(struct bcm_ethernet2_frame);
490 break;
491 }
492 default:
493 {
494 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : Unrecognized ETH Frame\n");
495 pIpHeader = pvEThPayload + sizeof(struct bcm_ethernet2_frame);
496 break;
497 }
498 }
499
500 if(stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
501 {
502 usCurrFragment = (ntohs(pIpHeader->frag_off) & IP_OFFSET);
503 if((ntohs(pIpHeader->frag_off) & IP_MF) || usCurrFragment)
504 bFragmentedPkt = TRUE;
505
506 if(bFragmentedPkt)
507 {
508 //Fragmented Packet. Get Frag Classifier Entry.
509 pstClassifierRule = GetFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
510 if(pstClassifierRule)
511 {
512 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"It is next Fragmented pkt");
513 bClassificationSucceed=TRUE;
514 }
515 if(!(ntohs(pIpHeader->frag_off) & IP_MF))
516 {
517 //Fragmented Last packet . Remove Frag Classifier Entry
518 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"This is the last fragmented Pkt");
519 DelFragIPClsEntry(Adapter,pIpHeader->id, pIpHeader->saddr);
520 }
521 }
522 }
523
524 for(uiLoopIndex = MAX_CLASSIFIERS - 1; uiLoopIndex >= 0; uiLoopIndex--)
525 {
526 if(bClassificationSucceed)
527 break;
528 //Iterate through all classifiers which are already in order of priority
529 //to classify the packet until match found
530 do
531 {
532 if(FALSE==Adapter->astClassifierTable[uiLoopIndex].bUsed)
533 {
534 bClassificationSucceed=FALSE;
535 break;
536 }
537 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Adapter->PackInfo[%d].bvalid=True\n",uiLoopIndex);
538
539 if(0 == Adapter->astClassifierTable[uiLoopIndex].ucDirection)
540 {
541 bClassificationSucceed=FALSE;//cannot be processed for classification.
542 break; // it is a down link connection
543 }
544
545 pstClassifierRule = &Adapter->astClassifierTable[uiLoopIndex];
546
547 uiSfIndex = SearchSfid(Adapter,pstClassifierRule->ulSFID);
548 if (uiSfIndex >= NO_OF_QUEUES) {
549 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Queue Not Valid. SearchSfid for this classifier Failed\n");
550 break;
551 }
552
553 if(Adapter->PackInfo[uiSfIndex].bEthCSSupport)
554 {
555
556 if(eEthUnsupportedFrame==stEthCsPktInfo.eNwpktEthFrameType)
557 {
558 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, " ClassifyPacket : Packet Not a Valid Supported Ethernet Frame \n");
559 bClassificationSucceed = FALSE;
560 break;
561 }
562
563
564
565 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);
566 bClassificationSucceed = EThCSClassifyPkt(Adapter,skb,&stEthCsPktInfo,pstClassifierRule, Adapter->PackInfo[uiSfIndex].bEthCSSupport);
567
568 if(!bClassificationSucceed)
569 {
570 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ClassifyPacket : Ethernet CS Classification Failed\n");
571 break;
572 }
573 }
574
575 else // No ETH Supported on this SF
576 {
577 if(eEthOtherFrame != stEthCsPktInfo.eNwpktEthFrameType)
578 {
579 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");
580 bClassificationSucceed = FALSE;
581 break;
582 }
583 }
584
585 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Proceeding to IP CS Clasification");
586
587 if(Adapter->PackInfo[uiSfIndex].bIPCSSupport)
588 {
589
590 if(stEthCsPktInfo.eNwpktIPFrameType == eNonIPPacket)
591 {
592 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, " ClassifyPacket : Packet is Not an IP Packet \n");
593 bClassificationSucceed = FALSE;
594 break;
595 }
596 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "Dump IP Header : \n");
597 DumpFullPacket((PUCHAR)pIpHeader,20);
598
599 if(stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
600 bClassificationSucceed = IpVersion4(Adapter,pIpHeader,pstClassifierRule);
601 else if(stEthCsPktInfo.eNwpktIPFrameType == eIPv6Packet)
602 bClassificationSucceed = IpVersion6(Adapter,pIpHeader,pstClassifierRule);
603 }
604
605 }while(0);
606 }
607
608 if(bClassificationSucceed == TRUE)
609 {
610 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "CF id : %d, SF ID is =%lu",pstClassifierRule->uiClassifierRuleIndex, pstClassifierRule->ulSFID);
611
612 //Store The matched Classifier in SKB
613 *((UINT32*)(skb->cb)+SKB_CB_CLASSIFICATION_OFFSET) = pstClassifierRule->uiClassifierRuleIndex;
614 if((TCP == pIpHeader->protocol ) && !bFragmentedPkt && (ETH_AND_IP_HEADER_LEN + TCP_HEADER_LEN <= skb->len) )
615 {
616 IpHeaderLength = pIpHeader->ihl;
617 pTcpHeader = (struct bcm_tcp_header *)(((PUCHAR)pIpHeader)+(IpHeaderLength*4));
618 TcpHeaderLength = GET_TCP_HEADER_LEN(pTcpHeader->HeaderLength);
619
620 if((pTcpHeader->ucFlags & TCP_ACK) &&
621 (ntohs(pIpHeader->tot_len) == (IpHeaderLength*4)+(TcpHeaderLength*4)))
622 {
623 *((UINT32*) (skb->cb) +SKB_CB_TCPACK_OFFSET ) = TCP_ACK;
624 }
625 }
626
627 usIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
628 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "index is =%d", usIndex);
629
630 //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.
631 if(bFragmentedPkt && (usCurrFragment == 0))
632 {
633 //First Fragment of Fragmented Packet. Create Frag CLS Entry
634 struct bcm_fragmented_packet_info stFragPktInfo;
635 stFragPktInfo.bUsed = TRUE;
636 stFragPktInfo.ulSrcIpAddress = pIpHeader->saddr;
637 stFragPktInfo.usIpIdentification = pIpHeader->id;
638 stFragPktInfo.pstMatchedClassifierEntry = pstClassifierRule;
639 stFragPktInfo.bOutOfOrderFragment = FALSE;
640 AddFragIPClsEntry(Adapter,&stFragPktInfo);
641 }
642
643
644 }
645
646 if(bClassificationSucceed)
647 return usIndex;
648 else
649 return INVALID_QUEUE_INDEX;
650}
651
652static BOOLEAN EthCSMatchSrcMACAddress(struct bcm_classifier_rule *pstClassifierRule,PUCHAR Mac)
653{
654 UINT i=0;
655 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
656 if(pstClassifierRule->ucEthCSSrcMACLen==0)
657 return TRUE;
658 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s \n",__FUNCTION__);
659 for(i=0;i<MAC_ADDRESS_SIZE;i++)
660 {
661 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]);
662 if((pstClassifierRule->au8EThCSSrcMAC[i] & pstClassifierRule->au8EThCSSrcMACMask[i])!=
663 (Mac[i] & pstClassifierRule->au8EThCSSrcMACMask[i]))
664 return FALSE;
665 }
666 return TRUE;
667}
668
669static BOOLEAN EthCSMatchDestMACAddress(struct bcm_classifier_rule *pstClassifierRule,PUCHAR Mac)
670{
671 UINT i=0;
672 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
673 if(pstClassifierRule->ucEthCSDestMACLen==0)
674 return TRUE;
675 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s \n",__FUNCTION__);
676 for(i=0;i<MAC_ADDRESS_SIZE;i++)
677 {
678 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]);
679 if((pstClassifierRule->au8EThCSDestMAC[i] & pstClassifierRule->au8EThCSDestMACMask[i])!=
680 (Mac[i] & pstClassifierRule->au8EThCSDestMACMask[i]))
681 return FALSE;
682 }
683 return TRUE;
684}
685
686static BOOLEAN EthCSMatchEThTypeSAP(struct bcm_classifier_rule *pstClassifierRule,struct sk_buff* skb, struct bcm_eth_packet_info *pstEthCsPktInfo)
687{
688 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
689 if((pstClassifierRule->ucEtherTypeLen==0)||
690 (pstClassifierRule->au8EthCSEtherType[0] == 0))
691 return TRUE;
692
693 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]);
694 if(pstClassifierRule->au8EthCSEtherType[0] == 1)
695 {
696 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]);
697
698 if(memcmp(&pstEthCsPktInfo->usEtherType,&pstClassifierRule->au8EthCSEtherType[1],2)==0)
699 return TRUE;
700 else
701 return FALSE;
702 }
703
704 if(pstClassifierRule->au8EthCSEtherType[0] == 2)
705 {
706 if(eEth802LLCFrame != pstEthCsPktInfo->eNwpktEthFrameType)
707 return FALSE;
708
709 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]);
710 if(pstEthCsPktInfo->ucDSAP == pstClassifierRule->au8EthCSEtherType[2])
711 return TRUE;
712 else
713 return FALSE;
714
715 }
716
717 return FALSE;
718
719}
720
721static BOOLEAN EthCSMatchVLANRules(struct bcm_classifier_rule *pstClassifierRule,struct sk_buff* skb, struct bcm_eth_packet_info *pstEthCsPktInfo)
722{
723 BOOLEAN bClassificationSucceed = FALSE;
724 USHORT usVLANID;
725 B_UINT8 uPriority = 0;
726 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
727
728 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);
729
730 /* In case FW didn't receive the TLV, the priority field should be ignored */
731 if(pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_USER_PRIORITY_VALID))
732 {
733 if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
734 return FALSE;
735
736 uPriority = (ntohs(*(USHORT *)(skb->data + sizeof(struct bcm_eth_header))) & 0xF000) >> 13;
737
738 if((uPriority >= pstClassifierRule->usUserPriority[0]) && (uPriority <= pstClassifierRule->usUserPriority[1]))
739 bClassificationSucceed = TRUE;
740
741 if(!bClassificationSucceed)
742 return FALSE;
743 }
744
745 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 D User Priority Rule Matched\n");
746
747 bClassificationSucceed = FALSE;
748
749 if(pstClassifierRule->usValidityBitMap & (1<<PKT_CLASSIFICATION_VLANID_VALID))
750 {
751 if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
752 return FALSE;
753
754 usVLANID = ntohs(*(USHORT *)(skb->data + sizeof(struct bcm_eth_header))) & 0xFFF;
755
756 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s Pkt VLANID %x Priority: %d\n",__FUNCTION__,usVLANID, uPriority);
757
758 if(usVLANID == ((pstClassifierRule->usVLANID & 0xFFF0) >> 4))
759 bClassificationSucceed = TRUE;
760
761 if(!bClassificationSucceed)
762 return FALSE;
763 }
764
765 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 Q VLAN ID Rule Matched\n");
766
767 return TRUE;
768}
769
770
771static BOOLEAN EThCSClassifyPkt(struct bcm_mini_adapter *Adapter,struct sk_buff* skb,
772 struct bcm_eth_packet_info *pstEthCsPktInfo,
773 struct bcm_classifier_rule *pstClassifierRule,
774 B_UINT8 EthCSCupport)
775{
776 BOOLEAN bClassificationSucceed = FALSE;
777 bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,((struct bcm_eth_header *)(skb->data))->au8SourceAddress);
778 if(!bClassificationSucceed)
779 return FALSE;
780 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS SrcMAC Matched\n");
781
782 bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,((struct bcm_eth_header *)(skb->data))->au8DestinationAddress);
783 if(!bClassificationSucceed)
784 return FALSE;
785 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS DestMAC Matched\n");
786
787 //classify on ETHType/802.2SAP TLV
788 bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule,skb,pstEthCsPktInfo);
789 if(!bClassificationSucceed)
790 return FALSE;
791
792 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS EthType/802.2SAP Matched\n");
793
794 //classify on 802.1VLAN Header Parameters
795
796 bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule,skb,pstEthCsPktInfo);
797 if(!bClassificationSucceed)
798 return FALSE;
799 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS 802.1 VLAN Rules Matched\n");
800
801 return bClassificationSucceed;
802}
803
804static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter,PVOID pvEthPayload,
805 struct bcm_eth_packet_info *pstEthCsPktInfo)
806{
807 USHORT u16Etype = ntohs(((struct bcm_eth_header *)pvEthPayload)->u16Etype);
808
809 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : Eth Hdr Type : %X\n",u16Etype);
810 if(u16Etype > 0x5dc)
811 {
812 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : ETH2 Frame \n");
813 //ETH2 Frame
814 if(u16Etype == ETHERNET_FRAMETYPE_802QVLAN)
815 {
816 //802.1Q VLAN Header
817 pstEthCsPktInfo->eNwpktEthFrameType = eEth802QVLANFrame;
818 u16Etype = ((struct bcm_eth_q_frame *)pvEthPayload)->EthType;
819 //((ETH_CS_802_Q_FRAME*)pvEthPayload)->UserPriority
820 }
821 else
822 {
823 pstEthCsPktInfo->eNwpktEthFrameType = eEthOtherFrame;
824 u16Etype = ntohs(u16Etype);
825 }
826
827 }
828 else
829 {
830 //802.2 LLC
831 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "802.2 LLC Frame \n");
832 pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCFrame;
833 pstEthCsPktInfo->ucDSAP = ((struct bcm_eth_llc_frame *)pvEthPayload)->DSAP;
834 if(pstEthCsPktInfo->ucDSAP == 0xAA && ((struct bcm_eth_llc_frame *)pvEthPayload)->SSAP == 0xAA)
835 {
836 //SNAP Frame
837 pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCSNAPFrame;
838 u16Etype = ((struct bcm_eth_llc_snap_frame *)pvEthPayload)->usEtherType;
839 }
840 }
841 if(u16Etype == ETHERNET_FRAMETYPE_IPV4)
842 pstEthCsPktInfo->eNwpktIPFrameType = eIPv4Packet;
843 else if(u16Etype == ETHERNET_FRAMETYPE_IPV6)
844 pstEthCsPktInfo->eNwpktIPFrameType = eIPv6Packet;
845 else
846 pstEthCsPktInfo->eNwpktIPFrameType = eNonIPPacket;
847
848 pstEthCsPktInfo->usEtherType = ((struct bcm_eth_header *)pvEthPayload)->u16Etype;
849 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->eNwpktIPFrameType : %x\n",pstEthCsPktInfo->eNwpktIPFrameType);
850 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->eNwpktEthFrameType : %x\n",pstEthCsPktInfo->eNwpktEthFrameType);
851 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->usEtherType : %x\n",pstEthCsPktInfo->usEtherType);
852}
853
854
855