/**
* @file Qos.C
* This file contains the routines related to Quality of Service.
*/
#include "headers.h"
static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter,
PVOID pvEthPayload,
struct bcm_eth_packet_info *pstEthCsPktInfo);
static bool EThCSClassifyPkt(struct bcm_mini_adapter *Adapter,
struct sk_buff *skb,
struct bcm_eth_packet_info *pstEthCsPktInfo,
struct bcm_classifier_rule *pstClassifierRule,
B_UINT8 EthCSCupport);
static USHORT IpVersion4(struct bcm_mini_adapter *Adapter, struct iphdr *iphd,
struct bcm_classifier_rule *pstClassifierRule);
static VOID PruneQueue(struct bcm_mini_adapter *Adapter, INT iIndex);
/*******************************************************************
* Function - MatchSrcIpAddress()
*
* Description - Checks whether the Source IP address from the packet
* matches with that of Queue.
*
* Parameters - pstClassifierRule: Pointer to the packet info structure.
* - ulSrcIP : Source IP address from the packet.
*
* Returns - TRUE(If address matches) else FAIL .
*********************************************************************/
static bool MatchSrcIpAddress(struct bcm_classifier_rule *pstClassifierRule,
ULONG ulSrcIP)
{
UCHAR ucLoopIndex = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
union u_ip_address *src_addr;
ulSrcIP = ntohl(ulSrcIP);
if (0 == pstClassifierRule->ucIPSourceAddressLength)
return TRUE;
for (ucLoopIndex = 0;
ucLoopIndex < (pstClassifierRule->ucIPSourceAddressLength);
ucLoopIndex++) {
src_addr = &pstClassifierRule->stSrcIpAddress;
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)src_addr->ulIpv4Mask[ucLoopIndex],
(UINT)ulSrcIP,
(UINT)src_addr->ulIpv6Addr[ucLoopIndex]);
if ((src_addr->ulIpv4Mask[ucLoopIndex] & ulSrcIP) ==
(src_addr->ulIpv4Addr[ucLoopIndex] &
src_addr->ulIpv4Mask[ucLoopIndex]))
return TRUE;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Src Ip Address Not Matched");
return false;
}
/*******************************************************************
* Function - MatchDestIpAddress()
*
* Description - Checks whether the Destination IP address from the packet
* matches with that of Queue.
*
* Parameters - pstClassifierRule: Pointer to the packet info structure.
* - ulDestIP : Destination IP address from the packet.
*
* Returns - TRUE(If address matches) else FAIL .
*********************************************************************/
static bool MatchDestIpAddress(struct bcm_classifier_rule *pstClassifierRule, ULONG ulDestIP)
{
UCHAR ucLoopIndex = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
union u_ip_address *dest_addr = &pstClassifierRule->stDestIpAddress;
ulDestIP = ntohl(ulDestIP);
if (0 == pstClassifierRule->ucIPDestinationAddressLength)
return TRUE;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Destination Ip Address 0x%x 0x%x 0x%x ",
(UINT)ulDestIP,
(UINT)dest_addr->ulIpv4Mask[ucLoopIndex],
(UINT)dest_addr->ulIpv4Addr[ucLoopIndex]);
for (ucLoopIndex = 0;
ucLoopIndex < (pstClassifierRule->ucIPDestinationAddressLength);
ucLoopIndex++) {
if ((dest_addr->ulIpv4Mask[ucLoopIndex] & ulDestIP) ==
(dest_addr->ulIpv4Addr[ucLoopIndex] &
dest_addr->ulIpv4Mask[ucLoopIndex]))
return TRUE;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Destination Ip Address Not Matched");
return false;
}
/************************************************************************
* Function - MatchTos()
*
* Description - Checks the TOS from the packet matches with that of queue.
*
* Parameters - pstClassifierRule : Pointer to the packet info structure.
* - ucTypeOfService: TOS from the packet.
*
* Returns - TRUE(If address matches) else FAIL.
**************************************************************************/
static bool MatchTos(struct bcm_classifier_rule *pstClassifierRule,
UCHAR ucTypeOfService)
{
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (3 != pstClassifierRule->ucIPTypeOfServiceLength)
return TRUE;
if (((pstClassifierRule->ucTosMask & ucTypeOfService) <=
pstClassifierRule->ucTosHigh) &&
((pstClassifierRule->ucTosMask & ucTypeOfService) >=
pstClassifierRule->ucTosLow))
return TRUE;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Type Of Service Not Matched");
return false;
}
/***************************************************************************
* Function - MatchProtocol()
*
* Description - Checks the protocol from the packet matches with that of queue.
*
* Parameters - pstClassifierRule: Pointer to the packet info structure.
* - ucProtocol : Protocol from the packet.
*
* Returns - TRUE(If address matches) else FAIL.
****************************************************************************/
bool MatchProtocol(struct bcm_classifier_rule *pstClassifierRule,
UCHAR ucProtocol)
{
UCHAR ucLoopIndex = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (0 == pstClassifierRule->ucProtocolLength)
return TRUE;
for (ucLoopIndex = 0;
ucLoopIndex < pstClassifierRule->ucProtocolLength;
ucLoopIndex++) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Protocol:0x%X Classification Protocol:0x%X",
ucProtocol,
pstClassifierRule->ucProtocol[ucLoopIndex]);
if (pstClassifierRule->ucProtocol[ucLoopIndex] == ucProtocol)
return TRUE;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Protocol Not Matched");
return false;
}
/***********************************************************************
* Function - MatchSrcPort()
*
* Description - Checks, Source port from the packet matches with that of queue.
*
* Parameters - pstClassifierRule: Pointer to the packet info structure.
* - ushSrcPort : Source port from the packet.
*
* Returns - TRUE(If address matches) else FAIL.
***************************************************************************/
bool MatchSrcPort(struct bcm_classifier_rule *pstClassifierRule,
USHORT ushSrcPort)
{
UCHAR ucLoopIndex = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (0 == pstClassifierRule->ucSrcPortRangeLength)
return TRUE;
for (ucLoopIndex = 0;
ucLoopIndex < pstClassifierRule->ucSrcPortRangeLength;
ucLoopIndex++) {
if (ushSrcPort <= pstClassifierRule->usSrcPortRangeHi[ucLoopIndex] &&
ushSrcPort >= pstClassifierRule->usSrcPortRangeLo[ucLoopIndex])
return TRUE;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Src Port: %x Not Matched ",
ushSrcPort);
return false;
}
/***********************************************************************
* Function - MatchDestPort()
*
* Description - Checks, Destination port from packet matches with that of queue.
*
* Parameters - pstClassifierRule: Pointer to the packet info structure.
* - ushDestPort : Destination port from the packet.
*
* Returns - TRUE(If address matches) else FAIL.
***************************************************************************/
bool MatchDestPort(struct bcm_classifier_rule *pstClassifierRule,
USHORT ushDestPort)
{
UCHAR ucLoopIndex = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (0 == pstClassifierRule->ucDestPortRangeLength)
return TRUE;
for (ucLoopIndex = 0;
ucLoopIndex < pstClassifierRule->ucDestPortRangeLength;
ucLoopIndex++) {
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]);
if (ushDestPort <= pstClassifierRule->usDestPortRangeHi[ucLoopIndex] &&
ushDestPort >= pstClassifierRule->usDestPortRangeLo[ucLoopIndex])
return TRUE;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Dest Port: %x Not Matched",
ushDestPort);
return false;
}
/**
* @ingroup tx_functions
* Compares IPV4 Ip address and port number
* @return Queue Index.
*/
static USHORT IpVersion4(struct bcm_mini_adapter *Adapter,
struct iphdr *iphd,
struct bcm_classifier_rule *pstClassifierRule)
{
struct bcm_transport_header *xprt_hdr = NULL;
bool bClassificationSucceed = false;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"========>");
xprt_hdr = (struct bcm_transport_header *)((PUCHAR)iphd + sizeof(struct iphdr));
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Trying to see Direction = %d %d",
pstClassifierRule->ucDirection,
pstClassifierRule->usVCID_Value);
/* Checking classifier validity */
if (!pstClassifierRule->bUsed ||
pstClassifierRule->ucDirection == DOWNLINK_DIR)
goto out;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"is IPv6 check!");
if (pstClassifierRule->bIpv6Protocol)
goto out;
/* Checking IP header parameter */
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Trying to match Source IP Address");
if (!MatchSrcIpAddress(pstClassifierRule, iphd->saddr))
goto out;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Source IP Address Matched");
if (!MatchDestIpAddress(pstClassifierRule, iphd->daddr))
goto out;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Destination IP Address Matched");
if (!MatchTos(pstClassifierRule, iphd->tos)) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"TOS Match failed\n");
goto out;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"TOS Matched");
if (!MatchProtocol(pstClassifierRule, iphd->protocol))
goto out;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Protocol Matched");
/*
* if protocol is not TCP or UDP then no
* need of comparing source port and destination port
*/
if (iphd->protocol != TCP && iphd->protocol != UDP) {
bClassificationSucceed = TRUE;
goto out;
}
/* Checking Transport Layer Header field if present */
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Source Port %04x",
(iphd->protocol == UDP) ? xprt_hdr->uhdr.source : xprt_hdr->thdr.source);
if (!MatchSrcPort(pstClassifierRule,
ntohs((iphd->protocol == UDP) ?
xprt_hdr->uhdr.source : xprt_hdr->thdr.source)))
goto out;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Src Port Matched");
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Destination Port %04x",
(iphd->protocol == UDP) ? xprt_hdr->uhdr.dest :
xprt_hdr->thdr.dest);
if (!MatchDestPort(pstClassifierRule,
ntohs((iphd->protocol == UDP) ?
xprt_hdr->uhdr.dest : xprt_hdr->thdr.dest)))
goto out;
bClassificationSucceed = TRUE;
out:
if (TRUE == bClassificationSucceed) {
INT iMatchedSFQueueIndex = 0;
iMatchedSFQueueIndex =
SearchSfid(Adapter, pstClassifierRule->ulSFID);
if (iMatchedSFQueueIndex >= NO_OF_QUEUES)
bClassificationSucceed = false;
else if (false == Adapter->PackInfo[iMatchedSFQueueIndex].bActive)
bClassificationSucceed = false;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"IpVersion4 <==========");
return bClassificationSucceed;
}
VOID PruneQueueAllSF(struct bcm_mini_adapter *Adapter)
{
UINT iIndex = 0;
for (iIndex = 0; iIndex < HiPriority; iIndex++) {
if (!Adapter->PackInfo[iIndex].bValid)
continue;
PruneQueue(Adapter, iIndex);
}
}
/**
* @ingroup tx_functions
* This function checks if the max queue size for a queue
* is less than number of bytes in the queue. If so -
* drops packets from the Head till the number of bytes is
* less than or equal to max queue size for the queue.
*/
static VOID PruneQueue(struct bcm_mini_adapter *Adapter, INT iIndex)
{
struct sk_buff *PacketToDrop = NULL;
struct net_device_stats *netstats;
struct bcm_packet_info *curr_pack_info = &Adapter->PackInfo[iIndex];
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
PRUNE_QUEUE,
DBG_LVL_ALL,
"=====> Index %d",
iIndex);
if (iIndex == HiPriority)
return;
if (!Adapter || (iIndex < 0) || (iIndex > HiPriority))
return;
/* To Store the netdevice statistic */
netstats = &Adapter->dev->stats;
spin_lock_bh(&curr_pack_info->SFQueueLock);
while (1) {
/* while((UINT)curr_pack_info->uiCurrentPacketsOnHost >
SF_MAX_ALLOWED_PACKETS_TO_BACKUP) { */
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
PRUNE_QUEUE,
DBG_LVL_ALL,
"uiCurrentBytesOnHost:%x uiMaxBucketSize :%x",
curr_pack_info->uiCurrentBytesOnHost,
curr_pack_info->uiMaxBucketSize);
PacketToDrop = curr_pack_info->FirstTxQueue;
if (PacketToDrop == NULL)
break;
if ((curr_pack_info->uiCurrentPacketsOnHost <
SF_MAX_ALLOWED_PACKETS_TO_BACKUP) &&
((1000*(jiffies - *((B_UINT32 *)(PacketToDrop->cb) +
SKB_CB_LATENCY_OFFSET))/HZ) <=
curr_pack_info->uiMaxLatency))
break;
if (PacketToDrop) {
if (netif_msg_tx_err(Adapter))
pr_info(PFX "%s: tx queue %d overlimit\n",
Adapter->dev->name, iIndex);
netstats->tx_dropped++;
DEQUEUEPACKET(curr_pack_info->FirstTxQueue,
curr_pack_info->LastTxQueue);
/* update current bytes and packets count */
curr_pack_info->uiCurrentBytesOnHost -=
PacketToDrop->len;
curr_pack_info->uiCurrentPacketsOnHost--;
/* update dropped bytes and packets counts */
curr_pack_info->uiDroppedCountBytes += PacketToDrop->len;
curr_pack_info->uiDroppedCountPackets++;
dev_kfree_skb(PacketToDrop);
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
PRUNE_QUEUE,
DBG_LVL_ALL,
"Dropped Bytes:%x Dropped Packets:%x",
curr_pack_info->uiDroppedCountBytes,
curr_pack_info->uiDroppedCountPackets);
atomic_dec(&Adapter->TotalPacketCount);
}
spin_unlock_bh(&curr_pack_info->SFQueueLock);
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
PRUNE_QUEUE,
DBG_LVL_ALL,
"TotalPacketCount:%x",
atomic_read(&Adapter->TotalPacketCount));
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
PRUNE_QUEUE,
DBG_LVL_ALL,
"<=====");
}
VOID flush_all_queues(struct bcm_mini_adapter *Adapter)
{
INT iQIndex;
UINT uiTotalPacketLength;
struct sk_buff *PacketToDrop = NULL;
struct bcm_packet_info *curr_packet_info;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_OTHERS,
DUMP_INFO,
DBG_LVL_ALL,
"=====>");
/* down(&Adapter->data_packet_queue_lock); */
for (iQIndex = LowPriority; iQIndex < HiPriority; iQIndex++) {
struct net_device_stats *netstats = &Adapter->dev->stats;
curr_packet_info = &Adapter->PackInfo[iQIndex];
spin_lock_bh(&curr_packet_info->SFQueueLock);
while (curr_packet_info->FirstTxQueue) {
PacketToDrop = curr_packet_info->FirstTxQueue;
if (PacketToDrop) {
uiTotalPacketLength = PacketToDrop->len;
netstats->tx_dropped++;
} else
uiTotalPacketLength = 0;
DEQUEUEPACKET(curr_packet_info->FirstTxQueue,
curr_packet_info->LastTxQueue);
/* Free the skb */
dev_kfree_skb(PacketToDrop);
/* update current bytes and packets count */
curr_packet_info->uiCurrentBytesOnHost -= uiTotalPacketLength;
curr_packet_info->uiCurrentPacketsOnHost--;
/* update dropped bytes and packets counts */
curr_packet_info->uiDroppedCountBytes += uiTotalPacketLength;
curr_packet_info->uiDroppedCountPackets++;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_OTHERS,
DUMP_INFO,
DBG_LVL_ALL,
"Dropped Bytes:%x Dropped Packets:%x",
curr_packet_info->uiDroppedCountBytes,
curr_packet_info->uiDroppedCountPackets);
atomic_dec(&Adapter->TotalPacketCount);
}
spin_unlock_bh(&curr_packet_info->SFQueueLock);
}
/* up(&Adapter->data_packet_queue_lock); */
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_OTHERS,
DUMP_INFO,
DBG_LVL_ALL,
"<=====");
}
USHORT ClassifyPacket(struct bcm_mini_adapter *Adapter, struct sk_buff *skb)
{
INT uiLoopIndex = 0;
struct bcm_classifier_rule *pstClassifierRule = NULL;
struct bcm_eth_packet_info stEthCsPktInfo;
PVOID pvEThPayload = NULL;
struct iphdr *pIpHeader = NULL;
INT uiSfIndex = 0;
USHORT usIndex = Adapter->usBestEffortQueueIndex;
bool bFragmentedPkt = false, bClassificationSucceed = false;
USHORT usCurrFragment = 0;
struct bcm_tcp_header *pTcpHeader;
UCHAR IpHeaderLength;
UCHAR TcpHeaderLength;
pvEThPayload = skb->data;
*((UINT32 *) (skb->cb) + SKB_CB_TCPACK_OFFSET) = 0;
EThCSGetPktInfo(Adapter, pvEThPayload, &stEthCsPktInfo);
switch (stEthCsPktInfo.eNwpktEthFrameType) {
case eEth802LLCFrame:
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ClassifyPacket : 802LLCFrame\n");
pIpHeader = pvEThPayload + sizeof(struct bcm_eth_llc_frame);
break;
case eEth802LLCSNAPFrame:
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ClassifyPacket : 802LLC SNAP Frame\n");
pIpHeader = pvEThPayload +
sizeof(struct bcm_eth_llc_snap_frame);
break;
case eEth802QVLANFrame:
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ClassifyPacket : 802.1Q VLANFrame\n");
pIpHeader = pvEThPayload + sizeof(struct bcm_eth_q_frame);
break;
case eEthOtherFrame:
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ClassifyPacket : ETH Other Frame\n");
pIpHeader = pvEThPayload + sizeof(struct bcm_ethernet2_frame);
break;
default:
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ClassifyPacket : Unrecognized ETH Frame\n");
pIpHeader = pvEThPayload + sizeof(struct bcm_ethernet2_frame);
break;
}
if (stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet) {
usCurrFragment = (ntohs(pIpHeader->frag_off) & IP_OFFSET);
if ((ntohs(pIpHeader->frag_off) & IP_MF) || usCurrFragment)
bFragmentedPkt = TRUE;
if (bFragmentedPkt) {
/* Fragmented Packet. Get Frag Classifier Entry. */
pstClassifierRule = GetFragIPClsEntry(Adapter,
pIpHeader->id,
pIpHeader->saddr);
if (pstClassifierRule) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"It is next Fragmented pkt");
bClassificationSucceed = TRUE;
}
if (!(ntohs(pIpHeader->frag_off) & IP_MF)) {
/* Fragmented Last packet . Remove Frag Classifier Entry */
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"This is the last fragmented Pkt");
DelFragIPClsEntry(Adapter,
pIpHeader->id,
pIpHeader->saddr);
}
}
}
for (uiLoopIndex = MAX_CLASSIFIERS - 1; uiLoopIndex >= 0; uiLoopIndex--) {
if (bClassificationSucceed)
break;
/*
* Iterate through all classifiers which are already in order of priority
* to classify the packet until match found
*/
if (false == Adapter->astClassifierTable[uiLoopIndex].bUsed) {
bClassificationSucceed = false;
continue;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Adapter->PackInfo[%d].bvalid=True\n",
uiLoopIndex);
if (0 == Adapter->astClassifierTable[uiLoopIndex].ucDirection) {
bClassificationSucceed = false; /* cannot be processed for classification. */
continue; /* it is a down link connection */
}
pstClassifierRule = &Adapter->astClassifierTable[uiLoopIndex];
uiSfIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
if (uiSfIndex >= NO_OF_QUEUES) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Queue Not Valid. SearchSfid for this classifier Failed\n");
continue;
}
if (Adapter->PackInfo[uiSfIndex].bEthCSSupport) {
if (eEthUnsupportedFrame == stEthCsPktInfo.eNwpktEthFrameType) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
" ClassifyPacket : Packet Not a Valid Supported Ethernet Frame\n");
bClassificationSucceed = false;
continue;
}
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);
bClassificationSucceed = EThCSClassifyPkt(Adapter,
skb,
&stEthCsPktInfo,
pstClassifierRule,
Adapter->PackInfo[uiSfIndex].bEthCSSupport);
if (!bClassificationSucceed) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ClassifyPacket : Ethernet CS Classification Failed\n");
continue;
}
} else { /* No ETH Supported on this SF */
if (eEthOtherFrame != stEthCsPktInfo.eNwpktEthFrameType) {
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");
bClassificationSucceed = false;
continue;
}
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Proceeding to IP CS Clasification");
if (Adapter->PackInfo[uiSfIndex].bIPCSSupport) {
if (stEthCsPktInfo.eNwpktIPFrameType == eNonIPPacket) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
" ClassifyPacket : Packet is Not an IP Packet\n");
bClassificationSucceed = false;
continue;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"Dump IP Header :\n");
DumpFullPacket((PUCHAR)pIpHeader, 20);
if (stEthCsPktInfo.eNwpktIPFrameType == eIPv4Packet)
bClassificationSucceed = IpVersion4(Adapter,
pIpHeader,
pstClassifierRule);
else if (stEthCsPktInfo.eNwpktIPFrameType == eIPv6Packet)
bClassificationSucceed = IpVersion6(Adapter,
pIpHeader,
pstClassifierRule);
}
}
if (bClassificationSucceed == TRUE) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"CF id : %d, SF ID is =%lu",
pstClassifierRule->uiClassifierRuleIndex,
pstClassifierRule->ulSFID);
/* Store The matched Classifier in SKB */
*((UINT32 *)(skb->cb)+SKB_CB_CLASSIFICATION_OFFSET) =
pstClassifierRule->uiClassifierRuleIndex;
if ((TCP == pIpHeader->protocol) && !bFragmentedPkt &&
(ETH_AND_IP_HEADER_LEN + TCP_HEADER_LEN <=
skb->len)) {
IpHeaderLength = pIpHeader->ihl;
pTcpHeader =
(struct bcm_tcp_header *)(((PUCHAR)pIpHeader) +
(IpHeaderLength*4));
TcpHeaderLength = GET_TCP_HEADER_LEN(pTcpHeader->HeaderLength);
if ((pTcpHeader->ucFlags & TCP_ACK) &&
(ntohs(pIpHeader->tot_len) ==
(IpHeaderLength*4)+(TcpHeaderLength*4)))
*((UINT32 *) (skb->cb) + SKB_CB_TCPACK_OFFSET) =
TCP_ACK;
}
usIndex = SearchSfid(Adapter, pstClassifierRule->ulSFID);
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"index is =%d",
usIndex);
/*
* 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.
*/
if (bFragmentedPkt && (usCurrFragment == 0)) {
/*
* First Fragment of Fragmented Packet.
* Create Frag CLS Entry
*/
struct bcm_fragmented_packet_info stFragPktInfo;
stFragPktInfo.bUsed = TRUE;
stFragPktInfo.ulSrcIpAddress = pIpHeader->saddr;
stFragPktInfo.usIpIdentification = pIpHeader->id;
stFragPktInfo.pstMatchedClassifierEntry =
pstClassifierRule;
stFragPktInfo.bOutOfOrderFragment = false;
AddFragIPClsEntry(Adapter, &stFragPktInfo);
}
}
return bClassificationSucceed ? usIndex : INVALID_QUEUE_INDEX;
}
static bool EthCSMatchSrcMACAddress(struct bcm_classifier_rule *pstClassifierRule,
PUCHAR Mac)
{
UINT i = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (pstClassifierRule->ucEthCSSrcMACLen == 0)
return TRUE;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s\n", __func__);
for (i = 0; i < MAC_ADDRESS_SIZE; i++) {
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]);
if ((pstClassifierRule->au8EThCSSrcMAC[i] &
pstClassifierRule->au8EThCSSrcMACMask[i]) !=
(Mac[i] & pstClassifierRule->au8EThCSSrcMACMask[i]))
return false;
}
return TRUE;
}
static bool EthCSMatchDestMACAddress(struct bcm_classifier_rule *pstClassifierRule,
PUCHAR Mac)
{
UINT i = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (pstClassifierRule->ucEthCSDestMACLen == 0)
return TRUE;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s\n",
__func__);
for (i = 0; i < MAC_ADDRESS_SIZE; i++) {
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]);
if ((pstClassifierRule->au8EThCSDestMAC[i] &
pstClassifierRule->au8EThCSDestMACMask[i]) !=
(Mac[i] & pstClassifierRule->au8EThCSDestMACMask[i]))
return false;
}
return TRUE;
}
static bool EthCSMatchEThTypeSAP(struct bcm_classifier_rule *pstClassifierRule,
struct sk_buff *skb,
struct bcm_eth_packet_info *pstEthCsPktInfo)
{
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if ((pstClassifierRule->ucEtherTypeLen == 0) ||
(pstClassifierRule->au8EthCSEtherType[0] == 0))
return TRUE;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s SrcEtherType:%x CLS EtherType[0]:%x\n",
__func__,
pstEthCsPktInfo->usEtherType,
pstClassifierRule->au8EthCSEtherType[0]);
if (pstClassifierRule->au8EthCSEtherType[0] == 1) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s CLS EtherType[1]:%x EtherType[2]:%x\n",
__func__,
pstClassifierRule->au8EthCSEtherType[1],
pstClassifierRule->au8EthCSEtherType[2]);
if (memcmp(&pstEthCsPktInfo->usEtherType,
&pstClassifierRule->au8EthCSEtherType[1],
2) == 0)
return TRUE;
else
return false;
}
if (pstClassifierRule->au8EthCSEtherType[0] == 2) {
if (eEth802LLCFrame != pstEthCsPktInfo->eNwpktEthFrameType)
return false;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s EthCS DSAP:%x EtherType[2]:%x\n",
__func__,
pstEthCsPktInfo->ucDSAP,
pstClassifierRule->au8EthCSEtherType[2]);
if (pstEthCsPktInfo->ucDSAP ==
pstClassifierRule->au8EthCSEtherType[2])
return TRUE;
else
return false;
}
return false;
}
static bool EthCSMatchVLANRules(struct bcm_classifier_rule *pstClassifierRule,
struct sk_buff *skb,
struct bcm_eth_packet_info *pstEthCsPktInfo)
{
bool bClassificationSucceed = false;
USHORT usVLANID;
B_UINT8 uPriority = 0;
struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s CLS UserPrio:%x CLS VLANID:%x\n",
__func__,
ntohs(*((USHORT *)pstClassifierRule->usUserPriority)),
pstClassifierRule->usVLANID);
/*
* In case FW didn't receive the TLV,
* the priority field should be ignored
*/
if (pstClassifierRule->usValidityBitMap &
(1<<PKT_CLASSIFICATION_USER_PRIORITY_VALID)) {
if (pstEthCsPktInfo->eNwpktEthFrameType != eEth802QVLANFrame)
return false;
uPriority = (ntohs(*(USHORT *)(skb->data +
sizeof(struct bcm_eth_header))) &
0xF000) >> 13;
if ((uPriority >= pstClassifierRule->usUserPriority[0]) &&
(uPriority <=
pstClassifierRule->usUserPriority[1]))
bClassificationSucceed = TRUE;
if (!bClassificationSucceed)
return false;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ETH CS 802.1 D User Priority Rule Matched\n");
bClassificationSucceed = false;
if (pstClassifierRule->usValidityBitMap &
(1<<PKT_CLASSIFICATION_VLANID_VALID)) {
if (pstEthCsPktInfo->eNwpktEthFrameType != eEth802QVLANFrame)
return false;
usVLANID = ntohs(*(USHORT *)(skb->data +
sizeof(struct bcm_eth_header))) & 0xFFF;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"%s Pkt VLANID %x Priority: %d\n",
__func__,
usVLANID,
uPriority);
if (usVLANID == ((pstClassifierRule->usVLANID & 0xFFF0) >> 4))
bClassificationSucceed = TRUE;
if (!bClassificationSucceed)
return false;
}
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ETH CS 802.1 Q VLAN ID Rule Matched\n");
return TRUE;
}
static bool EThCSClassifyPkt(struct bcm_mini_adapter *Adapter,
struct sk_buff *skb,
struct bcm_eth_packet_info *pstEthCsPktInfo,
struct bcm_classifier_rule *pstClassifierRule,
B_UINT8 EthCSCupport)
{
bool bClassificationSucceed = false;
bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,
((struct bcm_eth_header *)(skb->data))->au8SourceAddress);
if (!bClassificationSucceed)
return false;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ETH CS SrcMAC Matched\n");
bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,
((struct bcm_eth_header *)(skb->data))->au8DestinationAddress);
if (!bClassificationSucceed)
return false;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ETH CS DestMAC Matched\n");
/* classify on ETHType/802.2SAP TLV */
bClassificationSucceed = EthCSMatchEThTypeSAP(pstClassifierRule,
skb,
pstEthCsPktInfo);
if (!bClassificationSucceed)
return false;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ETH CS EthType/802.2SAP Matched\n");
/* classify on 802.1VLAN Header Parameters */
bClassificationSucceed = EthCSMatchVLANRules(pstClassifierRule,
skb,
pstEthCsPktInfo);
if (!bClassificationSucceed)
return false;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"ETH CS 802.1 VLAN Rules Matched\n");
return bClassificationSucceed;
}
static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter,
PVOID pvEthPayload,
struct bcm_eth_packet_info *pstEthCsPktInfo)
{
USHORT u16Etype = ntohs(
((struct bcm_eth_header *)pvEthPayload)->u16Etype);
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"EthCSGetPktInfo : Eth Hdr Type : %X\n",
u16Etype);
if (u16Etype > 0x5dc) {
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"EthCSGetPktInfo : ETH2 Frame\n");
/* ETH2 Frame */
if (u16Etype == ETHERNET_FRAMETYPE_802QVLAN) {
/* 802.1Q VLAN Header */
pstEthCsPktInfo->eNwpktEthFrameType = eEth802QVLANFrame;
u16Etype = ((struct bcm_eth_q_frame *)pvEthPayload)->EthType;
/* ((ETH_CS_802_Q_FRAME*)pvEthPayload)->UserPriority */
} else {
pstEthCsPktInfo->eNwpktEthFrameType = eEthOtherFrame;
u16Etype = ntohs(u16Etype);
}
} else {
/* 802.2 LLC */
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"802.2 LLC Frame\n");
pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCFrame;
pstEthCsPktInfo->ucDSAP =
((struct bcm_eth_llc_frame *)pvEthPayload)->DSAP;
if (pstEthCsPktInfo->ucDSAP == 0xAA && ((struct bcm_eth_llc_frame *)pvEthPayload)->SSAP == 0xAA) {
/* SNAP Frame */
pstEthCsPktInfo->eNwpktEthFrameType = eEth802LLCSNAPFrame;
u16Etype = ((struct bcm_eth_llc_snap_frame *)pvEthPayload)->usEtherType;
}
}
if (u16Etype == ETHERNET_FRAMETYPE_IPV4)
pstEthCsPktInfo->eNwpktIPFrameType = eIPv4Packet;
else if (u16Etype == ETHERNET_FRAMETYPE_IPV6)
pstEthCsPktInfo->eNwpktIPFrameType = eIPv6Packet;
else
pstEthCsPktInfo->eNwpktIPFrameType = eNonIPPacket;
pstEthCsPktInfo->usEtherType = ((struct bcm_eth_header *)pvEthPayload)->u16Etype;
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"EthCsPktInfo->eNwpktIPFrameType : %x\n",
pstEthCsPktInfo->eNwpktIPFrameType);
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"EthCsPktInfo->eNwpktEthFrameType : %x\n",
pstEthCsPktInfo->eNwpktEthFrameType);
BCM_DEBUG_PRINT(Adapter,
DBG_TYPE_TX,
IPV4_DBG,
DBG_LVL_ALL,
"EthCsPktInfo->usEtherType : %x\n",
pstEthCsPktInfo->usEtherType);
}