2010-09-08 15:46:36 -06:00
/**
@ file Qos . C
This file contains the routines related to Quality of Service .
*/
# include "headers.h"
2012-05-26 10:05:12 -06:00
static void EThCSGetPktInfo ( struct bcm_mini_adapter * Adapter , PVOID pvEthPayload , PS_ETHCS_PKT_INFO pstEthCsPktInfo ) ;
static BOOLEAN EThCSClassifyPkt ( struct bcm_mini_adapter * Adapter , struct sk_buff * skb , PS_ETHCS_PKT_INFO pstEthCsPktInfo , struct bcm_classifier_rule * pstClassifierRule , B_UINT8 EthCSCupport ) ;
2010-11-01 10:24:00 -06:00
2012-05-26 10:05:12 -06:00
static USHORT IpVersion4 ( struct bcm_mini_adapter * Adapter , struct iphdr * iphd ,
2012-05-26 10:05:03 -06:00
struct bcm_classifier_rule * pstClassifierRule ) ;
2010-11-01 10:24:00 -06:00
2012-05-26 10:05:12 -06:00
static VOID PruneQueue ( struct bcm_mini_adapter * Adapter , INT iIndex ) ;
2010-11-01 10:24:00 -06:00
2010-09-08 15:46:36 -06:00
/*******************************************************************
* 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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-05-26 10:05:03 -06:00
BOOLEAN MatchSrcIpAddress ( struct bcm_classifier_rule * pstClassifierRule , ULONG ulSrcIP )
2010-09-08 15:46:36 -06:00
{
UCHAR ucLoopIndex = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
ulSrcIP = ntohl ( ulSrcIP ) ;
if ( 0 = = pstClassifierRule - > ucIPSourceAddressLength )
return TRUE ;
for ( ucLoopIndex = 0 ; ucLoopIndex < ( pstClassifierRule - > ucIPSourceAddressLength ) ; ucLoopIndex + + )
{
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 ] ) ;
if ( ( pstClassifierRule - > stSrcIpAddress . ulIpv4Mask [ ucLoopIndex ] & ulSrcIP ) = =
( pstClassifierRule - > stSrcIpAddress . ulIpv4Addr [ ucLoopIndex ] & pstClassifierRule - > stSrcIpAddress . 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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-05-26 10:05:03 -06:00
BOOLEAN MatchDestIpAddress ( struct bcm_classifier_rule * pstClassifierRule , ULONG ulDestIP )
2010-09-08 15:46:36 -06:00
{
UCHAR ucLoopIndex = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 ) pstClassifierRule - > stDestIpAddress . ulIpv4Mask [ ucLoopIndex ] , ( UINT ) pstClassifierRule - > stDestIpAddress . ulIpv4Addr [ ucLoopIndex ] ) ;
for ( ucLoopIndex = 0 ; ucLoopIndex < ( pstClassifierRule - > ucIPDestinationAddressLength ) ; ucLoopIndex + + )
{
if ( ( pstClassifierRule - > stDestIpAddress . ulIpv4Mask [ ucLoopIndex ] & ulDestIP ) = =
( pstClassifierRule - > stDestIpAddress . ulIpv4Addr [ ucLoopIndex ] & pstClassifierRule - > stDestIpAddress . 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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-05-26 10:05:03 -06:00
BOOLEAN MatchTos ( struct bcm_classifier_rule * pstClassifierRule , UCHAR ucTypeOfService )
2010-09-08 15:46:36 -06:00
{
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-05-26 10:05:03 -06:00
BOOLEAN MatchProtocol ( struct bcm_classifier_rule * pstClassifierRule , UCHAR ucProtocol )
2010-09-08 15:46:36 -06:00
{
UCHAR ucLoopIndex = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-05-26 10:05:03 -06:00
BOOLEAN MatchSrcPort ( struct bcm_classifier_rule * pstClassifierRule , USHORT ushSrcPort )
2010-09-08 15:46:36 -06:00
{
UCHAR ucLoopIndex = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-05-26 10:05:03 -06:00
BOOLEAN MatchDestPort ( struct bcm_classifier_rule * pstClassifierRule , USHORT ushDestPort )
2010-09-08 15:46:36 -06:00
{
UCHAR ucLoopIndex = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 .
*/
2012-05-26 10:05:12 -06:00
static USHORT IpVersion4 ( struct bcm_mini_adapter * Adapter ,
2010-11-01 10:24:00 -06:00
struct iphdr * iphd ,
2012-05-26 10:05:03 -06:00
struct bcm_classifier_rule * pstClassifierRule )
2010-09-08 15:46:36 -06:00
{
xporthdr * xprt_hdr = NULL ;
BOOLEAN bClassificationSucceed = FALSE ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " ========> " ) ;
xprt_hdr = ( xporthdr * ) ( ( PUCHAR ) iphd + sizeof ( struct iphdr ) ) ;
do {
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 )
{
bClassificationSucceed = FALSE ;
break ;
}
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " is IPv6 check! " ) ;
if ( pstClassifierRule - > bIpv6Protocol )
break ;
//**************Checking IP header parameter**************************//
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " Trying to match Source IP Address " ) ;
if ( FALSE = = ( bClassificationSucceed =
MatchSrcIpAddress ( pstClassifierRule , iphd - > saddr ) ) )
break ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " Source IP Address Matched " ) ;
if ( FALSE = = ( bClassificationSucceed =
MatchDestIpAddress ( pstClassifierRule , iphd - > daddr ) ) )
break ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " Destination IP Address Matched " ) ;
if ( FALSE = = ( bClassificationSucceed =
MatchTos ( pstClassifierRule , iphd - > tos ) ) )
{
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " TOS Match failed \n " ) ;
break ;
}
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " TOS Matched " ) ;
if ( FALSE = = ( bClassificationSucceed =
MatchProtocol ( pstClassifierRule , iphd - > protocol ) ) )
break ;
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 )
break ;
//******************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 ( FALSE = = ( bClassificationSucceed =
MatchSrcPort ( pstClassifierRule ,
ntohs ( ( iphd - > protocol = = UDP ) ?
xprt_hdr - > uhdr . source : xprt_hdr - > thdr . source ) ) ) )
break ;
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 ( FALSE = = ( bClassificationSucceed =
MatchDestPort ( pstClassifierRule ,
ntohs ( ( iphd - > protocol = = UDP ) ?
xprt_hdr - > uhdr . dest : xprt_hdr - > thdr . dest ) ) ) )
break ;
} while ( 0 ) ;
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 ;
}
2012-05-26 10:05:12 -06:00
VOID PruneQueueAllSF ( struct bcm_mini_adapter * Adapter )
2010-09-08 15:46:36 -06:00
{
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 .
*/
2012-05-26 10:05:12 -06:00
static VOID PruneQueue ( struct bcm_mini_adapter * Adapter , INT iIndex )
2010-09-08 15:46:36 -06:00
{
struct sk_buff * PacketToDrop = NULL ;
2010-10-29 09:22:10 -06:00
struct net_device_stats * netstats ;
2010-09-08 15:46:36 -06:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , PRUNE_QUEUE , DBG_LVL_ALL , " =====> Index %d " , iIndex ) ;
if ( iIndex = = HiPriority )
2010-10-29 09:22:10 -06:00
return ;
2010-09-08 15:46:36 -06:00
if ( ! Adapter | | ( iIndex < 0 ) | | ( iIndex > HiPriority ) )
return ;
/* To Store the netdevice statistic */
2010-10-29 09:22:10 -06:00
netstats = & Adapter - > dev - > stats ;
2010-09-08 15:46:36 -06:00
spin_lock_bh ( & Adapter - > PackInfo [ iIndex ] . SFQueueLock ) ;
while ( 1 )
// while((UINT)Adapter->PackInfo[iIndex].uiCurrentPacketsOnHost >
// SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
{
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , PRUNE_QUEUE , DBG_LVL_ALL , " uiCurrentBytesOnHost:%x uiMaxBucketSize :%x " ,
Adapter - > PackInfo [ iIndex ] . uiCurrentBytesOnHost ,
Adapter - > PackInfo [ iIndex ] . uiMaxBucketSize ) ;
PacketToDrop = Adapter - > PackInfo [ iIndex ] . FirstTxQueue ;
if ( PacketToDrop = = NULL )
break ;
if ( ( Adapter - > PackInfo [ iIndex ] . uiCurrentPacketsOnHost < SF_MAX_ALLOWED_PACKETS_TO_BACKUP ) & &
( ( 1000 * ( jiffies - * ( ( B_UINT32 * ) ( PacketToDrop - > cb ) + SKB_CB_LATENCY_OFFSET ) ) / HZ ) < = Adapter - > PackInfo [ iIndex ] . uiMaxLatency ) )
break ;
if ( PacketToDrop )
{
2010-11-01 10:18:36 -06:00
if ( netif_msg_tx_err ( Adapter ) )
pr_info ( PFX " %s: tx queue %d overlimit \n " ,
Adapter - > dev - > name , iIndex ) ;
2011-01-17 17:11:12 -07:00
netstats - > tx_dropped + + ;
2010-11-01 11:34:35 -06:00
2010-09-08 15:46:36 -06:00
DEQUEUEPACKET ( Adapter - > PackInfo [ iIndex ] . FirstTxQueue ,
Adapter - > PackInfo [ iIndex ] . LastTxQueue ) ;
/// update current bytes and packets count
Adapter - > PackInfo [ iIndex ] . uiCurrentBytesOnHost - =
PacketToDrop - > len ;
Adapter - > PackInfo [ iIndex ] . uiCurrentPacketsOnHost - - ;
/// update dropped bytes and packets counts
Adapter - > PackInfo [ iIndex ] . uiDroppedCountBytes + = PacketToDrop - > len ;
Adapter - > PackInfo [ iIndex ] . uiDroppedCountPackets + + ;
2010-11-01 07:35:21 -06:00
dev_kfree_skb ( PacketToDrop ) ;
2010-09-08 15:46:36 -06:00
}
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , PRUNE_QUEUE , DBG_LVL_ALL , " Dropped Bytes:%x Dropped Packets:%x " ,
Adapter - > PackInfo [ iIndex ] . uiDroppedCountBytes ,
Adapter - > PackInfo [ iIndex ] . uiDroppedCountPackets ) ;
atomic_dec ( & Adapter - > TotalPacketCount ) ;
}
spin_unlock_bh ( & Adapter - > PackInfo [ iIndex ] . 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 , " <===== " ) ;
}
2012-05-26 10:05:12 -06:00
VOID flush_all_queues ( struct bcm_mini_adapter * Adapter )
2010-09-08 15:46:36 -06:00
{
INT iQIndex ;
UINT uiTotalPacketLength ;
2010-11-01 11:34:35 -06:00
struct sk_buff * PacketToDrop = NULL ;
2010-09-08 15:46:36 -06:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_INFO , DBG_LVL_ALL , " =====> " ) ;
// down(&Adapter->data_packet_queue_lock);
for ( iQIndex = LowPriority ; iQIndex < HiPriority ; iQIndex + + )
{
2011-01-17 17:11:12 -07:00
struct net_device_stats * netstats = & Adapter - > dev - > stats ;
2010-11-01 11:34:35 -06:00
2010-09-08 15:46:36 -06:00
spin_lock_bh ( & Adapter - > PackInfo [ iQIndex ] . SFQueueLock ) ;
while ( Adapter - > PackInfo [ iQIndex ] . FirstTxQueue )
{
PacketToDrop = Adapter - > PackInfo [ iQIndex ] . FirstTxQueue ;
if ( PacketToDrop )
{
uiTotalPacketLength = PacketToDrop - > len ;
2011-01-17 17:11:12 -07:00
netstats - > tx_dropped + + ;
2010-09-08 15:46:36 -06:00
}
else
uiTotalPacketLength = 0 ;
DEQUEUEPACKET ( Adapter - > PackInfo [ iQIndex ] . FirstTxQueue ,
Adapter - > PackInfo [ iQIndex ] . LastTxQueue ) ;
/* Free the skb */
2010-11-01 07:35:21 -06:00
dev_kfree_skb ( PacketToDrop ) ;
2010-09-08 15:46:36 -06:00
/// update current bytes and packets count
Adapter - > PackInfo [ iQIndex ] . uiCurrentBytesOnHost - = uiTotalPacketLength ;
Adapter - > PackInfo [ iQIndex ] . uiCurrentPacketsOnHost - - ;
/// update dropped bytes and packets counts
Adapter - > PackInfo [ iQIndex ] . uiDroppedCountBytes + = uiTotalPacketLength ;
Adapter - > PackInfo [ iQIndex ] . uiDroppedCountPackets + + ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_INFO , DBG_LVL_ALL , " Dropped Bytes:%x Dropped Packets:%x " ,
Adapter - > PackInfo [ iQIndex ] . uiDroppedCountBytes ,
Adapter - > PackInfo [ iQIndex ] . uiDroppedCountPackets ) ;
atomic_dec ( & Adapter - > TotalPacketCount ) ;
}
spin_unlock_bh ( & Adapter - > PackInfo [ iQIndex ] . SFQueueLock ) ;
}
// up(&Adapter->data_packet_queue_lock);
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_INFO , DBG_LVL_ALL , " <===== " ) ;
}
2012-05-26 10:05:12 -06:00
USHORT ClassifyPacket ( struct bcm_mini_adapter * Adapter , struct sk_buff * skb )
2010-09-08 15:46:36 -06:00
{
INT uiLoopIndex = 0 ;
2012-05-26 10:05:03 -06:00
struct bcm_classifier_rule * pstClassifierRule = NULL ;
2010-09-08 15:46:36 -06:00
S_ETHCS_PKT_INFO stEthCsPktInfo ;
PVOID pvEThPayload = NULL ;
struct iphdr * pIpHeader = NULL ;
INT uiSfIndex = 0 ;
USHORT usIndex = Adapter - > usBestEffortQueueIndex ;
BOOLEAN bFragmentedPkt = FALSE , bClassificationSucceed = FALSE ;
USHORT usCurrFragment = 0 ;
PTCP_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 ( ETH_CS_802_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 ( ETH_CS_802_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 ( ETH_CS_802_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 ( ETH_CS_ETH2_FRAME ) ;
break ;
}
default :
{
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " ClassifyPacket : Unrecognized ETH Frame \n " ) ;
pIpHeader = pvEThPayload + sizeof ( ETH_CS_ETH2_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
do
{
if ( FALSE = = Adapter - > astClassifierTable [ uiLoopIndex ] . bUsed )
{
bClassificationSucceed = FALSE ;
break ;
}
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.
break ; // it is a down link connection
}
pstClassifierRule = & Adapter - > astClassifierTable [ uiLoopIndex ] ;
uiSfIndex = SearchSfid ( Adapter , pstClassifierRule - > ulSFID ) ;
2010-10-08 07:49:04 -06:00
if ( uiSfIndex > = NO_OF_QUEUES ) {
2010-09-08 15:46:36 -06:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " Queue Not Valid. SearchSfid for this classifier Failed \n " ) ;
break ;
}
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 ;
break ;
}
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 " ) ;
break ;
}
}
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 ;
break ;
}
}
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 ;
break ;
}
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 ) ;
}
} while ( 0 ) ;
}
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 = ( PTCP_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
2012-05-26 10:05:02 -06:00
struct bcm_fragmented_packet_info stFragPktInfo ;
2010-09-08 15:46:36 -06:00
stFragPktInfo . bUsed = TRUE ;
stFragPktInfo . ulSrcIpAddress = pIpHeader - > saddr ;
stFragPktInfo . usIpIdentification = pIpHeader - > id ;
stFragPktInfo . pstMatchedClassifierEntry = pstClassifierRule ;
stFragPktInfo . bOutOfOrderFragment = FALSE ;
AddFragIPClsEntry ( Adapter , & stFragPktInfo ) ;
}
}
if ( bClassificationSucceed )
return usIndex ;
else
return INVALID_QUEUE_INDEX ;
}
2012-05-26 10:05:03 -06:00
static BOOLEAN EthCSMatchSrcMACAddress ( struct bcm_classifier_rule * pstClassifierRule , PUCHAR Mac )
2010-09-08 15:46:36 -06:00
{
UINT i = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
if ( pstClassifierRule - > ucEthCSSrcMACLen = = 0 )
return TRUE ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " %s \n " , __FUNCTION__ ) ;
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 ;
}
2012-05-26 10:05:03 -06:00
static BOOLEAN EthCSMatchDestMACAddress ( struct bcm_classifier_rule * pstClassifierRule , PUCHAR Mac )
2010-09-08 15:46:36 -06:00
{
UINT i = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
if ( pstClassifierRule - > ucEthCSDestMACLen = = 0 )
return TRUE ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " %s \n " , __FUNCTION__ ) ;
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 ;
}
2012-05-26 10:05:03 -06:00
static BOOLEAN EthCSMatchEThTypeSAP ( struct bcm_classifier_rule * pstClassifierRule , struct sk_buff * skb , PS_ETHCS_PKT_INFO pstEthCsPktInfo )
2010-09-08 15:46:36 -06:00
{
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 " , __FUNCTION__ , 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 " , __FUNCTION__ , 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 " , __FUNCTION__ , pstEthCsPktInfo - > ucDSAP , pstClassifierRule - > au8EthCSEtherType [ 2 ] ) ;
if ( pstEthCsPktInfo - > ucDSAP = = pstClassifierRule - > au8EthCSEtherType [ 2 ] )
return TRUE ;
else
return FALSE ;
}
return FALSE ;
}
2012-05-26 10:05:03 -06:00
static BOOLEAN EthCSMatchVLANRules ( struct bcm_classifier_rule * pstClassifierRule , struct sk_buff * skb , PS_ETHCS_PKT_INFO pstEthCsPktInfo )
2010-09-08 15:46:36 -06:00
{
BOOLEAN bClassificationSucceed = FALSE ;
USHORT usVLANID ;
B_UINT8 uPriority = 0 ;
2012-05-26 10:05:12 -06:00
struct bcm_mini_adapter * Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 15:46:36 -06:00
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 ) ;
2011-03-30 19:57:33 -06:00
/* In case FW didn't receive the TLV, the priority field should be ignored */
2010-09-08 15:46:36 -06:00
if ( pstClassifierRule - > usValidityBitMap & ( 1 < < PKT_CLASSIFICATION_USER_PRIORITY_VALID ) )
{
if ( pstEthCsPktInfo - > eNwpktEthFrameType ! = eEth802QVLANFrame )
return FALSE ;
2012-05-26 10:04:57 -06:00
uPriority = ( ntohs ( * ( USHORT * ) ( skb - > data + sizeof ( struct bcm_eth_header ) ) ) & 0xF000 ) > > 13 ;
2010-09-08 15:46:36 -06:00
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 ;
2012-05-26 10:04:57 -06:00
usVLANID = ntohs ( * ( USHORT * ) ( skb - > data + sizeof ( struct bcm_eth_header ) ) ) & 0xFFF ;
2010-09-08 15:46:36 -06:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " %s Pkt VLANID %x Priority: %d \n " , __FUNCTION__ , 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 ;
}
2012-05-26 10:05:12 -06:00
static BOOLEAN EThCSClassifyPkt ( struct bcm_mini_adapter * Adapter , struct sk_buff * skb ,
2010-11-01 10:24:00 -06:00
PS_ETHCS_PKT_INFO pstEthCsPktInfo ,
2012-05-26 10:05:03 -06:00
struct bcm_classifier_rule * pstClassifierRule ,
2010-11-01 10:24:00 -06:00
B_UINT8 EthCSCupport )
2010-09-08 15:46:36 -06:00
{
BOOLEAN bClassificationSucceed = FALSE ;
2012-05-26 10:04:57 -06:00
bClassificationSucceed = EthCSMatchSrcMACAddress ( pstClassifierRule , ( ( struct bcm_eth_header * ) ( skb - > data ) ) - > au8SourceAddress ) ;
2010-09-08 15:46:36 -06:00
if ( ! bClassificationSucceed )
return FALSE ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_TX , IPV4_DBG , DBG_LVL_ALL , " ETH CS SrcMAC Matched \n " ) ;
2012-05-26 10:04:57 -06:00
bClassificationSucceed = EthCSMatchDestMACAddress ( pstClassifierRule , ( ( struct bcm_eth_header * ) ( skb - > data ) ) - > au8DestinationAddress ) ;
2010-09-08 15:46:36 -06:00
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 ;
}
2012-05-26 10:05:12 -06:00
static void EThCSGetPktInfo ( struct bcm_mini_adapter * Adapter , PVOID pvEthPayload ,
2010-11-01 10:24:00 -06:00
PS_ETHCS_PKT_INFO pstEthCsPktInfo )
2010-09-08 15:46:36 -06:00
{
2012-05-26 10:04:57 -06:00
USHORT u16Etype = ntohs ( ( ( struct bcm_eth_header * ) pvEthPayload ) - > u16Etype ) ;
2010-11-01 10:24:00 -06:00
2010-09-08 15:46:36 -06:00
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 = ( ( ETH_CS_802_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 = ( ( ETH_CS_802_LLC_FRAME * ) pvEthPayload ) - > DSAP ;
if ( pstEthCsPktInfo - > ucDSAP = = 0xAA & & ( ( ETH_CS_802_LLC_FRAME * ) pvEthPayload ) - > SSAP = = 0xAA )
{
//SNAP Frame
pstEthCsPktInfo - > eNwpktEthFrameType = eEth802LLCSNAPFrame ;
u16Etype = ( ( ETH_CS_802_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 ;
2012-05-26 10:04:57 -06:00
pstEthCsPktInfo - > usEtherType = ( ( struct bcm_eth_header * ) pvEthPayload ) - > u16Etype ;
2010-09-08 15:46:36 -06:00
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 ) ;
}