2010-09-08 21:46:36 +00:00
/************************************************************
2012-01-05 01:29:00 +00:00
* CMHOST . C
* This file contains the routines for handling Connection
* Management .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* #define CONN_MSG */
2010-09-08 21:46:36 +00:00
# include "headers.h"
2012-01-05 01:29:02 +00:00
enum E_CLASSIFIER_ACTION {
2010-09-08 21:46:36 +00:00
eInvalidClassifierAction ,
eAddClassifier ,
eReplaceClassifier ,
eDeleteClassifier
2012-01-05 01:29:02 +00:00
} ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
static ULONG GetNextTargetBufferLocation ( PMINI_ADAPTER Adapter , B_UINT16 tid ) ;
2010-09-08 21:46:36 +00:00
/************************************************************
2012-01-05 01:29:00 +00:00
* Function - SearchSfid
*
* Description - This routinue would search QOS queues having
* specified SFID as input parameter .
*
* Parameters - Adapter : Pointer to the Adapter structure
* uiSfid : Given SFID for matching
*
* Returns - Queue index for this SFID ( If matched )
* Else Invalid Queue Index ( If Not matched )
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
INT SearchSfid ( PMINI_ADAPTER Adapter , UINT uiSfid )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
INT iIndex = 0 ;
for ( iIndex = ( NO_OF_QUEUES - 1 ) ; iIndex > = 0 ; iIndex - - )
if ( Adapter - > PackInfo [ iIndex ] . ulSFID = = uiSfid )
2010-09-08 21:46:36 +00:00
return iIndex ;
2012-01-05 01:29:00 +00:00
2010-09-08 21:46:36 +00:00
return NO_OF_QUEUES + 1 ;
}
/***************************************************************
2012-01-05 01:29:00 +00:00
* Function - SearchFreeSfid
*
* Description - This routinue would search Free available SFID .
*
* Parameter - Adapter : Pointer to the Adapter structure
*
* Returns - Queue index for the free SFID
* Else returns Invalid Index .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-11-01 03:52:36 +00:00
static INT SearchFreeSfid ( PMINI_ADAPTER Adapter )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
UINT uiIndex = 0 ;
2010-11-01 03:52:36 +00:00
2012-01-05 01:29:00 +00:00
for ( uiIndex = 0 ; uiIndex < ( NO_OF_QUEUES - 1 ) ; uiIndex + + )
if ( Adapter - > PackInfo [ uiIndex ] . ulSFID = = 0 )
2010-09-08 21:46:36 +00:00
return uiIndex ;
2012-01-05 01:29:00 +00:00
2010-09-08 21:46:36 +00:00
return NO_OF_QUEUES + 1 ;
}
/*
2012-01-05 01:29:00 +00:00
* Function : SearchClsid
* Description : This routinue would search Classifier having specified ClassifierID as input parameter
* Input parameters : PMINI_ADAPTER Adapter - Adapter Context
* unsigned int uiSfid - The SF in which the classifier is to searched
* B_UINT16 uiClassifierID - The classifier ID to be searched
* Return : int : Classifier table index of matching entry
*/
static int SearchClsid ( PMINI_ADAPTER Adapter , ULONG ulSFID , B_UINT16 uiClassifierID )
2010-09-08 21:46:36 +00:00
{
unsigned int uiClassifierIndex = 0 ;
2012-01-05 01:29:00 +00:00
for ( uiClassifierIndex = 0 ; uiClassifierIndex < MAX_CLASSIFIERS ; uiClassifierIndex + + ) {
if ( ( Adapter - > astClassifierTable [ uiClassifierIndex ] . bUsed ) & &
( Adapter - > astClassifierTable [ uiClassifierIndex ] . uiClassifierRuleIndex = = uiClassifierID ) & &
2010-09-08 21:46:36 +00:00
( Adapter - > astClassifierTable [ uiClassifierIndex ] . ulSFID = = ulSFID ) )
return uiClassifierIndex ;
}
2012-01-05 01:29:00 +00:00
2010-09-08 21:46:36 +00:00
return MAX_CLASSIFIERS + 1 ;
}
2012-01-05 01:29:00 +00:00
/*
* @ ingroup ctrl_pkt_functions
* This routinue would search Free available Classifier entry in classifier table .
* @ return free Classifier Entry index in classifier table for specified SF
*/
static int SearchFreeClsid ( PMINI_ADAPTER Adapter /**Adapter Context*/ )
2010-09-08 21:46:36 +00:00
{
unsigned int uiClassifierIndex = 0 ;
2012-01-05 01:29:00 +00:00
for ( uiClassifierIndex = 0 ; uiClassifierIndex < MAX_CLASSIFIERS ; uiClassifierIndex + + ) {
if ( ! Adapter - > astClassifierTable [ uiClassifierIndex ] . bUsed )
2010-09-08 21:46:36 +00:00
return uiClassifierIndex ;
}
2012-01-05 01:29:00 +00:00
2010-09-08 21:46:36 +00:00
return MAX_CLASSIFIERS + 1 ;
}
2010-11-01 16:24:00 +00:00
static VOID deleteSFBySfid ( PMINI_ADAPTER Adapter , UINT uiSearchRuleIndex )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
/* deleting all the packet held in the SF */
flush_queue ( Adapter , uiSearchRuleIndex ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* Deleting the all classifiers for this SF */
DeleteAllClassifiersForSF ( Adapter , uiSearchRuleIndex ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* Resetting only MIBS related entries in the SF */
2010-09-08 21:46:36 +00:00
memset ( ( PVOID ) & Adapter - > PackInfo [ uiSearchRuleIndex ] , 0 , sizeof ( S_MIBS_SERVICEFLOW_TABLE ) ) ;
}
static inline VOID
2012-01-05 01:29:00 +00:00
CopyIpAddrToClassifier ( S_CLASSIFIER_RULE * pstClassifierEntry ,
B_UINT8 u8IpAddressLen , B_UINT8 * pu8IpAddressMaskSrc ,
BOOLEAN bIpVersion6 , E_IPADDR_CONTEXT eIpAddrContext )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
UINT ucLoopIndex = 0 ;
UINT nSizeOfIPAddressInBytes = IP_LENGTH_OF_ADDRESS ;
UCHAR * ptrClassifierIpAddress = NULL ;
UCHAR * ptrClassifierIpMask = NULL ;
PMINI_ADAPTER Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( bIpVersion6 )
2010-09-08 21:46:36 +00:00
nSizeOfIPAddressInBytes = IPV6_ADDRESS_SIZEINBYTES ;
2012-01-05 01:29:00 +00:00
/* Destination Ip Address */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Ip Address Range Length:0x%X " , u8IpAddressLen ) ;
if ( ( bIpVersion6 ? ( IPV6_ADDRESS_SIZEINBYTES * MAX_IP_RANGE_LENGTH * 2 ) :
( TOTAL_MASKED_ADDRESS_IN_BYTES ) ) > = u8IpAddressLen ) {
2010-09-08 21:46:36 +00:00
/*
2012-01-05 01:29:00 +00:00
* checking both the mask and address togethor in Classification .
* So length will be : TotalLengthInBytes / nSizeOfIPAddressInBytes * 2
* ( nSizeOfIPAddressInBytes for address and nSizeOfIPAddressInBytes for mask )
*/
if ( eIpAddrContext = = eDestIpAddress ) {
pstClassifierEntry - > ucIPDestinationAddressLength = u8IpAddressLen / ( nSizeOfIPAddressInBytes * 2 ) ;
if ( bIpVersion6 ) {
ptrClassifierIpAddress = pstClassifierEntry - > stDestIpAddress . ucIpv6Address ;
ptrClassifierIpMask = pstClassifierEntry - > stDestIpAddress . ucIpv6Mask ;
} else {
ptrClassifierIpAddress = pstClassifierEntry - > stDestIpAddress . ucIpv4Address ;
ptrClassifierIpMask = pstClassifierEntry - > stDestIpAddress . ucIpv4Mask ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
} else if ( eIpAddrContext = = eSrcIpAddress ) {
pstClassifierEntry - > ucIPSourceAddressLength = u8IpAddressLen / ( nSizeOfIPAddressInBytes * 2 ) ;
if ( bIpVersion6 ) {
ptrClassifierIpAddress = pstClassifierEntry - > stSrcIpAddress . ucIpv6Address ;
ptrClassifierIpMask = pstClassifierEntry - > stSrcIpAddress . ucIpv6Mask ;
} else {
ptrClassifierIpAddress = pstClassifierEntry - > stSrcIpAddress . ucIpv4Address ;
ptrClassifierIpMask = pstClassifierEntry - > stSrcIpAddress . ucIpv4Mask ;
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Address Length:0x%X \n " , pstClassifierEntry - > ucIPDestinationAddressLength ) ;
while ( ( u8IpAddressLen > = nSizeOfIPAddressInBytes ) & & ( ucLoopIndex < MAX_IP_RANGE_LENGTH ) ) {
2010-09-08 21:46:36 +00:00
memcpy ( ptrClassifierIpAddress +
( ucLoopIndex * nSizeOfIPAddressInBytes ) ,
( pu8IpAddressMaskSrc + ( ucLoopIndex * nSizeOfIPAddressInBytes * 2 ) ) ,
nSizeOfIPAddressInBytes ) ;
2012-01-05 01:29:00 +00:00
if ( ! bIpVersion6 ) {
if ( eIpAddrContext = = eSrcIpAddress ) {
pstClassifierEntry - > stSrcIpAddress . ulIpv4Addr [ ucLoopIndex ] = ntohl ( pstClassifierEntry - > stSrcIpAddress . ulIpv4Addr [ ucLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Src Ip Address:0x%luX " ,
pstClassifierEntry - > stSrcIpAddress . ulIpv4Addr [ ucLoopIndex ] ) ;
} else if ( eIpAddrContext = = eDestIpAddress ) {
pstClassifierEntry - > stDestIpAddress . ulIpv4Addr [ ucLoopIndex ] = ntohl ( pstClassifierEntry - > stDestIpAddress . ulIpv4Addr [ ucLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Dest Ip Address:0x%luX " ,
pstClassifierEntry - > stDestIpAddress . ulIpv4Addr [ ucLoopIndex ] ) ;
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
u8IpAddressLen - = nSizeOfIPAddressInBytes ;
if ( u8IpAddressLen > = nSizeOfIPAddressInBytes ) {
2010-09-08 21:46:36 +00:00
memcpy ( ptrClassifierIpMask +
( ucLoopIndex * nSizeOfIPAddressInBytes ) ,
( pu8IpAddressMaskSrc + nSizeOfIPAddressInBytes +
2012-01-05 01:29:00 +00:00
( ucLoopIndex * nSizeOfIPAddressInBytes * 2 ) ) ,
2010-09-08 21:46:36 +00:00
nSizeOfIPAddressInBytes ) ;
2012-01-05 01:29:00 +00:00
if ( ! bIpVersion6 ) {
if ( eIpAddrContext = = eSrcIpAddress ) {
pstClassifierEntry - > stSrcIpAddress . ulIpv4Mask [ ucLoopIndex ] =
ntohl ( pstClassifierEntry - > stSrcIpAddress . ulIpv4Mask [ ucLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Src Ip Mask Address:0x%luX " ,
pstClassifierEntry - > stSrcIpAddress . ulIpv4Mask [ ucLoopIndex ] ) ;
} else if ( eIpAddrContext = = eDestIpAddress ) {
pstClassifierEntry - > stDestIpAddress . ulIpv4Mask [ ucLoopIndex ] =
ntohl ( pstClassifierEntry - > stDestIpAddress . ulIpv4Mask [ ucLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Dest Ip Mask Address:0x%luX " ,
pstClassifierEntry - > stDestIpAddress . ulIpv4Mask [ ucLoopIndex ] ) ;
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
u8IpAddressLen - = nSizeOfIPAddressInBytes ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:03 +00:00
if ( u8IpAddressLen = = 0 )
2012-01-05 01:29:00 +00:00
pstClassifierEntry - > bDestIpValid = TRUE ;
2010-09-08 21:46:36 +00:00
ucLoopIndex + + ;
}
2012-01-05 01:29:00 +00:00
if ( bIpVersion6 ) {
/* Restore EndianNess of Struct */
for ( ucLoopIndex = 0 ; ucLoopIndex < MAX_IP_RANGE_LENGTH * 4 ; ucLoopIndex + + ) {
if ( eIpAddrContext = = eSrcIpAddress ) {
pstClassifierEntry - > stSrcIpAddress . ulIpv6Addr [ ucLoopIndex ] = ntohl ( pstClassifierEntry - > stSrcIpAddress . ulIpv6Addr [ ucLoopIndex ] ) ;
pstClassifierEntry - > stSrcIpAddress . ulIpv6Mask [ ucLoopIndex ] = ntohl ( pstClassifierEntry - > stSrcIpAddress . ulIpv6Mask [ ucLoopIndex ] ) ;
} else if ( eIpAddrContext = = eDestIpAddress ) {
pstClassifierEntry - > stDestIpAddress . ulIpv6Addr [ ucLoopIndex ] = ntohl ( pstClassifierEntry - > stDestIpAddress . ulIpv6Addr [ ucLoopIndex ] ) ;
pstClassifierEntry - > stDestIpAddress . ulIpv6Mask [ ucLoopIndex ] = ntohl ( pstClassifierEntry - > stDestIpAddress . ulIpv6Mask [ ucLoopIndex ] ) ;
2010-09-08 21:46:36 +00:00
}
}
}
}
}
2012-01-05 01:29:00 +00:00
void ClearTargetDSXBuffer ( PMINI_ADAPTER Adapter , B_UINT16 TID , BOOLEAN bFreeAll )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
ULONG ulIndex ;
for ( ulIndex = 0 ; ulIndex < Adapter - > ulTotalTargetBuffersAvailable ; ulIndex + + ) {
if ( Adapter - > astTargetDsxBuffer [ ulIndex ] . valid )
2010-09-08 21:46:36 +00:00
continue ;
2012-01-05 01:29:00 +00:00
if ( ( bFreeAll ) | | ( Adapter - > astTargetDsxBuffer [ ulIndex ] . tid = = TID ) ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " ClearTargetDSXBuffer: found tid %d buffer cleared %lx \n " ,
TID , Adapter - > astTargetDsxBuffer [ ulIndex ] . ulTargetDsxBuffer ) ;
Adapter - > astTargetDsxBuffer [ ulIndex ] . valid = 1 ;
Adapter - > astTargetDsxBuffer [ ulIndex ] . tid = 0 ;
2010-09-08 21:46:36 +00:00
Adapter - > ulFreeTargetBufferCnt + + ;
2012-01-05 01:29:00 +00:00
}
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
/*
* @ ingroup ctrl_pkt_functions
* copy classifier rule into the specified SF index
*/
static inline VOID CopyClassifierRuleToSF ( PMINI_ADAPTER Adapter , stConvergenceSLTypes * psfCSType , UINT uiSearchRuleIndex , UINT nClassifierIndex )
2010-09-08 21:46:36 +00:00
{
S_CLASSIFIER_RULE * pstClassifierEntry = NULL ;
2012-01-05 01:29:00 +00:00
/* VOID *pvPhsContext = NULL; */
UINT ucLoopIndex = 0 ;
/* UCHAR ucProtocolLength=0; */
/* ULONG ulPhsStatus; */
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value = = 0 | |
2010-09-08 21:46:36 +00:00
nClassifierIndex > ( MAX_CLASSIFIERS - 1 ) )
return ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Storing Classifier Rule Index : %X " ,
ntohs ( psfCSType - > cCPacketClassificationRule . u16PacketClassificationRuleIndex ) ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( nClassifierIndex > MAX_CLASSIFIERS - 1 )
2010-09-08 21:46:36 +00:00
return ;
pstClassifierEntry = & Adapter - > astClassifierTable [ nClassifierIndex ] ;
2012-01-05 01:29:00 +00:00
if ( pstClassifierEntry ) {
/* Store if Ipv6 */
pstClassifierEntry - > bIpv6Protocol = ( Adapter - > PackInfo [ uiSearchRuleIndex ] . ucIpVersion = = IPV6 ) ? TRUE : FALSE ;
/* Destinaiton Port */
pstClassifierEntry - > ucDestPortRangeLength = psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRangeLength / 4 ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Destination Port Range Length:0x%X " , pstClassifierEntry - > ucDestPortRangeLength ) ;
2012-01-05 01:29:03 +00:00
if ( psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRangeLength < = MAX_PORT_RANGE ) {
2012-01-05 01:29:00 +00:00
for ( ucLoopIndex = 0 ; ucLoopIndex < ( pstClassifierEntry - > ucDestPortRangeLength ) ; ucLoopIndex + + ) {
pstClassifierEntry - > usDestPortRangeLo [ ucLoopIndex ] = * ( ( PUSHORT ) ( psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange + ucLoopIndex ) ) ;
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > usDestPortRangeHi [ ucLoopIndex ] =
* ( ( PUSHORT ) ( psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange + 2 + ucLoopIndex ) ) ;
2012-01-05 01:29:00 +00:00
pstClassifierEntry - > usDestPortRangeLo [ ucLoopIndex ] = ntohs ( pstClassifierEntry - > usDestPortRangeLo [ ucLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Destination Port Range Lo:0x%X " ,
pstClassifierEntry - > usDestPortRangeLo [ ucLoopIndex ] ) ;
pstClassifierEntry - > usDestPortRangeHi [ ucLoopIndex ] = ntohs ( pstClassifierEntry - > usDestPortRangeHi [ ucLoopIndex ] ) ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
} else {
pstClassifierEntry - > ucDestPortRangeLength = 0 ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
/* Source Port */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Source Port Range Length:0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRangeLength ) ;
2012-01-05 01:29:03 +00:00
if ( psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRangeLength < = MAX_PORT_RANGE ) {
2012-01-05 01:29:00 +00:00
pstClassifierEntry - > ucSrcPortRangeLength = psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRangeLength / 4 ;
for ( ucLoopIndex = 0 ; ucLoopIndex < ( pstClassifierEntry - > ucSrcPortRangeLength ) ; ucLoopIndex + + ) {
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > usSrcPortRangeLo [ ucLoopIndex ] =
2012-01-05 01:29:00 +00:00
* ( ( PUSHORT ) ( psfCSType - > cCPacketClassificationRule .
2010-09-08 21:46:36 +00:00
u8ProtocolSourcePortRange + ucLoopIndex ) ) ;
pstClassifierEntry - > usSrcPortRangeHi [ ucLoopIndex ] =
2012-01-05 01:29:00 +00:00
* ( ( PUSHORT ) ( psfCSType - > cCPacketClassificationRule .
2010-09-08 21:46:36 +00:00
u8ProtocolSourcePortRange + 2 + ucLoopIndex ) ) ;
pstClassifierEntry - > usSrcPortRangeLo [ ucLoopIndex ] =
ntohs ( pstClassifierEntry - > usSrcPortRangeLo [ ucLoopIndex ] ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Source Port Range Lo:0x%X " ,
pstClassifierEntry - > usSrcPortRangeLo [ ucLoopIndex ] ) ;
pstClassifierEntry - > usSrcPortRangeHi [ ucLoopIndex ] = ntohs ( pstClassifierEntry - > usSrcPortRangeHi [ ucLoopIndex ] ) ;
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
/* Destination Ip Address and Mask */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Ip Destination Parameters : " ) ;
2010-09-08 21:46:36 +00:00
CopyIpAddrToClassifier ( pstClassifierEntry ,
2012-01-05 01:29:00 +00:00
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddressLength ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddress ,
( Adapter - > PackInfo [ uiSearchRuleIndex ] . ucIpVersion = = IPV6 ) ?
TRUE : FALSE , eDestIpAddress ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* Source Ip Address and Mask */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Ip Source Parameters : " ) ;
2010-09-08 21:46:36 +00:00
CopyIpAddrToClassifier ( pstClassifierEntry ,
2012-01-05 01:29:00 +00:00
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddressLength ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddress ,
( Adapter - > PackInfo [ uiSearchRuleIndex ] . ucIpVersion = = IPV6 ) ? TRUE : FALSE ,
eSrcIpAddress ) ;
/* TOS */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " TOS Length:0x%X " , psfCSType - > cCPacketClassificationRule . u8IPTypeOfServiceLength ) ;
2012-01-05 01:29:03 +00:00
if ( psfCSType - > cCPacketClassificationRule . u8IPTypeOfServiceLength = = 3 ) {
2012-01-05 01:29:00 +00:00
pstClassifierEntry - > ucIPTypeOfServiceLength = psfCSType - > cCPacketClassificationRule . u8IPTypeOfServiceLength ;
pstClassifierEntry - > ucTosLow = psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 0 ] ;
pstClassifierEntry - > ucTosHigh = psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 1 ] ;
pstClassifierEntry - > ucTosMask = psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 2 ] ;
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > bTOSValid = TRUE ;
}
2012-01-05 01:29:00 +00:00
if ( psfCSType - > cCPacketClassificationRule . u8Protocol = = 0 ) {
/* we didn't get protocol field filled in by the BS */
pstClassifierEntry - > ucProtocolLength = 0 ;
} else {
pstClassifierEntry - > ucProtocolLength = 1 ; /* 1 valid protocol */
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
pstClassifierEntry - > ucProtocol [ 0 ] = psfCSType - > cCPacketClassificationRule . u8Protocol ;
pstClassifierEntry - > u8ClassifierRulePriority = psfCSType - > cCPacketClassificationRule . u8ClassifierRulePriority ;
/* store the classifier rule ID and set this classifier entry as valid */
pstClassifierEntry - > ucDirection = Adapter - > PackInfo [ uiSearchRuleIndex ] . ucDirection ;
pstClassifierEntry - > uiClassifierRuleIndex = ntohs ( psfCSType - > cCPacketClassificationRule . u16PacketClassificationRuleIndex ) ;
pstClassifierEntry - > usVCID_Value = Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value ;
pstClassifierEntry - > ulSFID = Adapter - > PackInfo [ uiSearchRuleIndex ] . ulSFID ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Search Index %d Dir: %d, Index: %d, Vcid: %d \n " ,
uiSearchRuleIndex , pstClassifierEntry - > ucDirection ,
pstClassifierEntry - > uiClassifierRuleIndex ,
pstClassifierEntry - > usVCID_Value ) ;
if ( psfCSType - > cCPacketClassificationRule . u8AssociatedPHSI )
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > u8AssociatedPHSI = psfCSType - > cCPacketClassificationRule . u8AssociatedPHSI ;
2012-01-05 01:29:00 +00:00
/* Copy ETH CS Parameters */
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > ucEthCSSrcMACLen = ( psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddressLength ) ;
2012-01-05 01:29:00 +00:00
memcpy ( pstClassifierEntry - > au8EThCSSrcMAC , psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress , MAC_ADDRESS_SIZE ) ;
memcpy ( pstClassifierEntry - > au8EThCSSrcMACMask , psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress + MAC_ADDRESS_SIZE , MAC_ADDRESS_SIZE ) ;
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > ucEthCSDestMACLen = ( psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
2012-01-05 01:29:00 +00:00
memcpy ( pstClassifierEntry - > au8EThCSDestMAC , psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress , MAC_ADDRESS_SIZE ) ;
memcpy ( pstClassifierEntry - > au8EThCSDestMACMask , psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress + MAC_ADDRESS_SIZE , MAC_ADDRESS_SIZE ) ;
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > ucEtherTypeLen = ( psfCSType - > cCPacketClassificationRule . u8EthertypeLength ) ;
2012-01-05 01:29:00 +00:00
memcpy ( pstClassifierEntry - > au8EthCSEtherType , psfCSType - > cCPacketClassificationRule . u8Ethertype , NUM_ETHERTYPE_BYTES ) ;
2010-09-08 21:46:36 +00:00
memcpy ( pstClassifierEntry - > usUserPriority , & psfCSType - > cCPacketClassificationRule . u16UserPriority , 2 ) ;
pstClassifierEntry - > usVLANID = ntohs ( psfCSType - > cCPacketClassificationRule . u16VLANID ) ;
pstClassifierEntry - > usValidityBitMap = ntohs ( psfCSType - > cCPacketClassificationRule . u16ValidityBitMap ) ;
pstClassifierEntry - > bUsed = TRUE ;
}
}
2012-01-05 01:29:00 +00:00
/*
* @ ingroup ctrl_pkt_functions
*/
static inline VOID DeleteClassifierRuleFromSF ( PMINI_ADAPTER Adapter , UINT uiSearchRuleIndex , UINT nClassifierIndex )
2010-09-08 21:46:36 +00:00
{
S_CLASSIFIER_RULE * pstClassifierEntry = NULL ;
2012-01-05 01:29:00 +00:00
B_UINT16 u16PacketClassificationRuleIndex ;
USHORT usVCID ;
/* VOID *pvPhsContext = NULL; */
/*ULONG ulPhsStatus; */
2010-09-08 21:46:36 +00:00
usVCID = Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value ;
2012-01-05 01:29:00 +00:00
if ( nClassifierIndex > MAX_CLASSIFIERS - 1 )
2010-09-08 21:46:36 +00:00
return ;
2012-01-05 01:29:00 +00:00
if ( usVCID = = 0 )
2010-09-08 21:46:36 +00:00
return ;
u16PacketClassificationRuleIndex = Adapter - > astClassifierTable [ nClassifierIndex ] . uiClassifierRuleIndex ;
pstClassifierEntry = & Adapter - > astClassifierTable [ nClassifierIndex ] ;
2012-01-05 01:29:00 +00:00
if ( pstClassifierEntry ) {
2010-09-08 21:46:36 +00:00
pstClassifierEntry - > bUsed = FALSE ;
pstClassifierEntry - > uiClassifierRuleIndex = 0 ;
2012-01-05 01:29:00 +00:00
memset ( pstClassifierEntry , 0 , sizeof ( S_CLASSIFIER_RULE ) ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* Delete the PHS Rule for this classifier */
PhsDeleteClassifierRule ( & Adapter - > stBCMPhsContext , usVCID , u16PacketClassificationRuleIndex ) ;
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
/*
* @ ingroup ctrl_pkt_functions
*/
VOID DeleteAllClassifiersForSF ( PMINI_ADAPTER Adapter , UINT uiSearchRuleIndex )
2010-09-08 21:46:36 +00:00
{
S_CLASSIFIER_RULE * pstClassifierEntry = NULL ;
UINT nClassifierIndex ;
2012-01-05 01:29:00 +00:00
/* B_UINT16 u16PacketClassificationRuleIndex; */
USHORT ulVCID ;
/* VOID *pvPhsContext = NULL; */
/* ULONG ulPhsStatus; */
2010-09-08 21:46:36 +00:00
ulVCID = Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value ;
2012-01-05 01:29:00 +00:00
if ( ulVCID = = 0 )
2010-09-08 21:46:36 +00:00
return ;
2012-01-05 01:29:00 +00:00
for ( nClassifierIndex = 0 ; nClassifierIndex < MAX_CLASSIFIERS ; nClassifierIndex + + ) {
if ( Adapter - > astClassifierTable [ nClassifierIndex ] . usVCID_Value = = ulVCID ) {
2010-09-08 21:46:36 +00:00
pstClassifierEntry = & Adapter - > astClassifierTable [ nClassifierIndex ] ;
2012-01-05 01:29:00 +00:00
if ( pstClassifierEntry - > bUsed )
DeleteClassifierRuleFromSF ( Adapter , uiSearchRuleIndex , nClassifierIndex ) ;
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
/* Delete All Phs Rules Associated with this SF */
PhsDeleteSFRules ( & Adapter - > stBCMPhsContext , ulVCID ) ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
/*
* This routinue copies the Connection Management
* related data into the Adapter structure .
* @ ingroup ctrl_pkt_functions
*/
static VOID CopyToAdapter ( register PMINI_ADAPTER Adapter , /* <Pointer to the Adapter structure */
register pstServiceFlowParamSI psfLocalSet , /* <Pointer to the ServiceFlowParamSI structure */
register UINT uiSearchRuleIndex , /* <Index of Queue, to which this data belongs */
register UCHAR ucDsxType ,
stLocalSFAddIndicationAlt * pstAddIndication ) {
/* UCHAR ucProtocolLength = 0; */
ULONG ulSFID ;
UINT nClassifierIndex = 0 ;
2012-01-05 01:29:02 +00:00
enum E_CLASSIFIER_ACTION eClassifierAction = eInvalidClassifierAction ;
2012-01-05 01:29:00 +00:00
B_UINT16 u16PacketClassificationRuleIndex = 0 ;
UINT nIndex = 0 ;
2010-09-08 21:46:36 +00:00
stConvergenceSLTypes * psfCSType = NULL ;
S_PHS_RULE sPhsRule ;
USHORT uVCID = Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value ;
UINT UGIValue = 0 ;
2012-01-05 01:29:00 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bValid = TRUE ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Search Rule Index = %d \n " , uiSearchRuleIndex ) ;
2012-01-05 01:29:01 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " %s: SFID= %x " , __func__ , ntohl ( psfLocalSet - > u32SFID ) ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Updating Queue %d " , uiSearchRuleIndex ) ;
2010-09-08 21:46:36 +00:00
ulSFID = ntohl ( psfLocalSet - > u32SFID ) ;
2012-01-05 01:29:00 +00:00
/* Store IP Version used */
/* Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF */
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = 0 ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bEthCSSupport = 0 ;
2012-01-05 01:29:00 +00:00
/* Enable IP/ETh CS Support As Required */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " CopyToAdapter : u8CSSpecification : %X \n " , psfLocalSet - > u8CSSpecification ) ;
switch ( psfLocalSet - > u8CSSpecification ) {
case eCSPacketIPV4 :
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = IPV4_CS ;
break ;
}
case eCSPacketIPV6 :
{
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = IPV6_CS ;
break ;
}
case eCS802_3PacketEthernet :
case eCS802_1QPacketVLAN :
{
Adapter - > PackInfo [ uiSearchRuleIndex ] . bEthCSSupport = ETH_CS_802_3 ;
break ;
}
case eCSPacketIPV4Over802_1QVLAN :
case eCSPacketIPV4Over802_3Ethernet :
{
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = IPV4_CS ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bEthCSSupport = ETH_CS_802_3 ;
break ;
}
case eCSPacketIPV6Over802_1QVLAN :
case eCSPacketIPV6Over802_3Ethernet :
{
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = IPV6_CS ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bEthCSSupport = ETH_CS_802_3 ;
break ;
}
default :
{
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Error in value of CS Classification.. setting default to IP CS \n " ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = IPV4_CS ;
break ;
}
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " CopyToAdapter : Queue No : %X ETH CS Support : %X , IP CS Support : %X \n " ,
uiSearchRuleIndex ,
Adapter - > PackInfo [ uiSearchRuleIndex ] . bEthCSSupport ,
Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* Store IP Version used */
/* Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF */
if ( Adapter - > PackInfo [ uiSearchRuleIndex ] . bIPCSSupport = = IPV6_CS )
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . ucIpVersion = IPV6 ;
else
Adapter - > PackInfo [ uiSearchRuleIndex ] . ucIpVersion = IPV4 ;
/* To ensure that the ETH CS code doesn't gets executed if the BS doesn't supports ETH CS */
2012-01-05 01:29:00 +00:00
if ( ! Adapter - > bETHCSEnabled )
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bEthCSSupport = 0 ;
2012-01-05 01:29:00 +00:00
if ( psfLocalSet - > u8ServiceClassNameLength > 0 & & psfLocalSet - > u8ServiceClassNameLength < 32 )
memcpy ( Adapter - > PackInfo [ uiSearchRuleIndex ] . ucServiceClassName , psfLocalSet - > u8ServiceClassName , psfLocalSet - > u8ServiceClassNameLength ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . u8QueueType = psfLocalSet - > u8ServiceFlowSchedulingType ;
if ( Adapter - > PackInfo [ uiSearchRuleIndex ] . u8QueueType = = BE & & Adapter - > PackInfo [ uiSearchRuleIndex ] . ucDirection )
Adapter - > usBestEffortQueueIndex = uiSearchRuleIndex ;
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . ulSFID = ntohl ( psfLocalSet - > u32SFID ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . u8TrafficPriority = psfLocalSet - > u8TrafficPriority ;
2012-01-05 01:29:00 +00:00
/* copy all the classifier in the Service Flow param structure */
for ( nIndex = 0 ; nIndex < psfLocalSet - > u8TotalClassifiers ; nIndex + + ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Classifier index =%d " , nIndex ) ;
psfCSType = & psfLocalSet - > cConvergenceSLTypes [ nIndex ] ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Classifier index =%d " , nIndex ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( psfCSType - > cCPacketClassificationRule . u8ClassifierRulePriority )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bClassifierPriority = TRUE ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( psfCSType - > cCPacketClassificationRule . u8ClassifierRulePriority )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bClassifierPriority = TRUE ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( ucDsxType = = DSA_ACK ) {
2010-09-08 21:46:36 +00:00
eClassifierAction = eAddClassifier ;
2012-01-05 01:29:00 +00:00
} else if ( ucDsxType = = DSC_ACK ) {
switch ( psfCSType - > u8ClassfierDSCAction ) {
case 0 : /* DSC Add Classifier */
2010-09-08 21:46:36 +00:00
{
eClassifierAction = eAddClassifier ;
}
break ;
2012-01-05 01:29:00 +00:00
case 1 : /* DSC Replace Classifier */
2010-09-08 21:46:36 +00:00
{
eClassifierAction = eReplaceClassifier ;
}
break ;
2012-01-05 01:29:00 +00:00
case 2 : /* DSC Delete Classifier */
2010-09-08 21:46:36 +00:00
{
eClassifierAction = eDeleteClassifier ;
}
break ;
default :
{
eClassifierAction = eInvalidClassifierAction ;
}
}
}
u16PacketClassificationRuleIndex = ntohs ( psfCSType - > cCPacketClassificationRule . u16PacketClassificationRuleIndex ) ;
2012-01-05 01:29:00 +00:00
switch ( eClassifierAction ) {
2010-09-08 21:46:36 +00:00
case eAddClassifier :
{
2012-01-05 01:29:00 +00:00
/* Get a Free Classifier Index From Classifier table for this SF to add the Classifier */
/* Contained in this message */
nClassifierIndex = SearchClsid ( Adapter , ulSFID , u16PacketClassificationRuleIndex ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( nClassifierIndex > MAX_CLASSIFIERS ) {
2010-09-08 21:46:36 +00:00
nClassifierIndex = SearchFreeClsid ( Adapter ) ;
2012-01-05 01:29:00 +00:00
if ( nClassifierIndex > MAX_CLASSIFIERS ) {
/* Failed To get a free Entry */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Error Failed To get a free Classifier Entry " ) ;
2010-09-08 21:46:36 +00:00
break ;
}
2012-01-05 01:29:00 +00:00
/* Copy the Classifier Rule for this service flow into our Classifier table maintained per SF. */
CopyClassifierRuleToSF ( Adapter , psfCSType , uiSearchRuleIndex , nClassifierIndex ) ;
} else {
/* This Classifier Already Exists and it is invalid to Add Classifier with existing PCRI */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL ,
" CopyToAdapter: Error The Specified Classifier Already Exists and attempted To Add Classifier with Same PCRI : 0x%x \n " ,
u16PacketClassificationRuleIndex ) ;
2010-09-08 21:46:36 +00:00
}
}
break ;
case eReplaceClassifier :
{
2012-01-05 01:29:00 +00:00
/* Get the Classifier Index From Classifier table for this SF and replace existing Classifier */
/* with the new classifier Contained in this message */
nClassifierIndex = SearchClsid ( Adapter , ulSFID , u16PacketClassificationRuleIndex ) ;
if ( nClassifierIndex > MAX_CLASSIFIERS ) {
/* Failed To search the classifier */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Error Search for Classifier To be replaced failed " ) ;
2010-09-08 21:46:36 +00:00
break ;
}
2012-01-05 01:29:00 +00:00
/* Copy the Classifier Rule for this service flow into our Classifier table maintained per SF. */
CopyClassifierRuleToSF ( Adapter , psfCSType , uiSearchRuleIndex , nClassifierIndex ) ;
2010-09-08 21:46:36 +00:00
}
break ;
case eDeleteClassifier :
{
2012-01-05 01:29:00 +00:00
/* Get the Classifier Index From Classifier table for this SF and replace existing Classifier */
/* with the new classifier Contained in this message */
nClassifierIndex = SearchClsid ( Adapter , ulSFID , u16PacketClassificationRuleIndex ) ;
if ( nClassifierIndex > MAX_CLASSIFIERS ) {
/* Failed To search the classifier */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Error Search for Classifier To be deleted failed " ) ;
2010-09-08 21:46:36 +00:00
break ;
}
2012-01-05 01:29:00 +00:00
/* Delete This classifier */
DeleteClassifierRuleFromSF ( Adapter , uiSearchRuleIndex , nClassifierIndex ) ;
2010-09-08 21:46:36 +00:00
}
break ;
default :
{
2012-01-05 01:29:00 +00:00
/* Invalid Action for classifier */
2010-09-08 21:46:36 +00:00
break ;
}
}
}
2012-01-05 01:29:00 +00:00
/* Repeat parsing Classification Entries to process PHS Rules */
for ( nIndex = 0 ; nIndex < psfLocalSet - > u8TotalClassifiers ; nIndex + + ) {
psfCSType = & psfLocalSet - > cConvergenceSLTypes [ nIndex ] ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " psfCSType->u8PhsDSCAction : 0x%x \n " , psfCSType - > u8PhsDSCAction ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
switch ( psfCSType - > u8PhsDSCAction ) {
2010-09-08 21:46:36 +00:00
case eDeleteAllPHSRules :
{
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Deleting All PHS Rules For VCID: 0x%X \n " , uVCID ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* Delete All the PHS rules for this Service flow */
PhsDeleteSFRules ( & Adapter - > stBCMPhsContext , uVCID ) ;
2010-09-08 21:46:36 +00:00
break ;
}
case eDeletePHSRule :
{
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " PHS DSC Action = Delete PHS Rule \n " ) ;
if ( psfCSType - > cPhsRule . u8PHSI )
PhsDeletePHSRule ( & Adapter - > stBCMPhsContext , uVCID , psfCSType - > cCPacketClassificationRule . u8AssociatedPHSI ) ;
2010-09-08 21:46:36 +00:00
break ;
}
2012-01-05 01:29:00 +00:00
default :
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
if ( ucDsxType = = DSC_ACK ) {
/* BCM_DEBUG_PRINT(CONN_MSG,("Invalid PHS DSC Action For DSC\n",psfCSType->cPhsRule.u8PHSI)); */
break ; /* FOr DSC ACK Case PHS DSC Action must be in valid set */
2010-09-08 21:46:36 +00:00
}
}
2012-01-05 01:29:00 +00:00
/* Proceed To Add PHS rule for DSA_ACK case even if PHS DSC action is unspecified */
/* No Break Here . Intentionally! */
2010-09-08 21:46:36 +00:00
case eAddPHSRule :
case eSetPHSRule :
{
2012-01-05 01:29:00 +00:00
if ( psfCSType - > cPhsRule . u8PHSI ) {
/* Apply This PHS Rule to all classifiers whose Associated PHSI Match */
2010-09-08 21:46:36 +00:00
unsigned int uiClassifierIndex = 0 ;
2012-01-05 01:29:00 +00:00
if ( pstAddIndication - > u8Direction = = UPLINK_DIR ) {
for ( uiClassifierIndex = 0 ; uiClassifierIndex < MAX_CLASSIFIERS ; uiClassifierIndex + + ) {
if ( ( Adapter - > astClassifierTable [ uiClassifierIndex ] . bUsed ) & &
2010-09-08 21:46:36 +00:00
( Adapter - > astClassifierTable [ uiClassifierIndex ] . ulSFID = = Adapter - > PackInfo [ uiSearchRuleIndex ] . ulSFID ) & &
2012-01-05 01:29:00 +00:00
( Adapter - > astClassifierTable [ uiClassifierIndex ] . u8AssociatedPHSI = = psfCSType - > cPhsRule . u8PHSI ) ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL ,
" Adding PHS Rule For Classifier: 0x%x cPhsRule.u8PHSI: 0x%x \n " ,
Adapter - > astClassifierTable [ uiClassifierIndex ] . uiClassifierRuleIndex ,
psfCSType - > cPhsRule . u8PHSI ) ;
/* Update The PHS Rule for this classifier as Associated PHSI id defined */
/* Copy the PHS Rule */
sPhsRule . u8PHSI = psfCSType - > cPhsRule . u8PHSI ;
sPhsRule . u8PHSFLength = psfCSType - > cPhsRule . u8PHSFLength ;
2010-09-08 21:46:36 +00:00
sPhsRule . u8PHSMLength = psfCSType - > cPhsRule . u8PHSMLength ;
sPhsRule . u8PHSS = psfCSType - > cPhsRule . u8PHSS ;
sPhsRule . u8PHSV = psfCSType - > cPhsRule . u8PHSV ;
2012-01-05 01:29:00 +00:00
memcpy ( sPhsRule . u8PHSF , psfCSType - > cPhsRule . u8PHSF , MAX_PHS_LENGTHS ) ;
memcpy ( sPhsRule . u8PHSM , psfCSType - > cPhsRule . u8PHSM , MAX_PHS_LENGTHS ) ;
2010-09-08 21:46:36 +00:00
sPhsRule . u8RefCnt = 0 ;
sPhsRule . bUnclassifiedPHSRule = FALSE ;
sPhsRule . PHSModifiedBytes = 0 ;
sPhsRule . PHSModifiedNumPackets = 0 ;
sPhsRule . PHSErrorNumPackets = 0 ;
2012-01-05 01:29:00 +00:00
/* bPHSRuleAssociated = TRUE; */
/* Store The PHS Rule for this classifier */
2010-09-08 21:46:36 +00:00
PhsUpdateClassifierRule (
& Adapter - > stBCMPhsContext ,
uVCID ,
Adapter - > astClassifierTable [ uiClassifierIndex ] . uiClassifierRuleIndex ,
& sPhsRule ,
Adapter - > astClassifierTable [ uiClassifierIndex ] . u8AssociatedPHSI ) ;
2012-01-05 01:29:00 +00:00
/* Update PHS Rule For the Classifier */
if ( sPhsRule . u8PHSI ) {
2010-09-08 21:46:36 +00:00
Adapter - > astClassifierTable [ uiClassifierIndex ] . u32PHSRuleID = sPhsRule . u8PHSI ;
2012-01-05 01:29:00 +00:00
memcpy ( & Adapter - > astClassifierTable [ uiClassifierIndex ] . sPhsRule , & sPhsRule , sizeof ( S_PHS_RULE ) ) ;
2010-09-08 21:46:36 +00:00
}
}
}
2012-01-05 01:29:00 +00:00
} else {
/* Error PHS Rule specified in signaling could not be applied to any classifier */
/* Copy the PHS Rule */
sPhsRule . u8PHSI = psfCSType - > cPhsRule . u8PHSI ;
sPhsRule . u8PHSFLength = psfCSType - > cPhsRule . u8PHSFLength ;
sPhsRule . u8PHSMLength = psfCSType - > cPhsRule . u8PHSMLength ;
sPhsRule . u8PHSS = psfCSType - > cPhsRule . u8PHSS ;
sPhsRule . u8PHSV = psfCSType - > cPhsRule . u8PHSV ;
memcpy ( sPhsRule . u8PHSF , psfCSType - > cPhsRule . u8PHSF , MAX_PHS_LENGTHS ) ;
memcpy ( sPhsRule . u8PHSM , psfCSType - > cPhsRule . u8PHSM , MAX_PHS_LENGTHS ) ;
sPhsRule . u8RefCnt = 0 ;
sPhsRule . bUnclassifiedPHSRule = TRUE ;
sPhsRule . PHSModifiedBytes = 0 ;
sPhsRule . PHSModifiedNumPackets = 0 ;
sPhsRule . PHSErrorNumPackets = 0 ;
/* Store The PHS Rule for this classifier */
/*
* Passing the argument u8PHSI instead of clsid . Because for DL with no classifier rule ,
* clsid will be zero hence we can ' t have multiple PHS rules for the same SF .
* To support multiple PHS rule , passing u8PHSI .
*/
PhsUpdateClassifierRule (
& Adapter - > stBCMPhsContext ,
uVCID ,
sPhsRule . u8PHSI ,
& sPhsRule ,
sPhsRule . u8PHSI ) ;
2010-09-08 21:46:36 +00:00
}
}
}
break ;
}
}
2012-01-05 01:29:00 +00:00
if ( psfLocalSet - > u32MaxSustainedTrafficRate = = 0 ) {
/* No Rate Limit . Set Max Sustained Traffic Rate to Maximum */
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxAllowedRate = WIMAX_MAX_ALLOWED_RATE ;
} else if ( ntohl ( psfLocalSet - > u32MaxSustainedTrafficRate ) > WIMAX_MAX_ALLOWED_RATE ) {
/* Too large Allowed Rate specified. Limiting to Wi Max Allowed rate */
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxAllowedRate = WIMAX_MAX_ALLOWED_RATE ;
} else {
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxAllowedRate = ntohl ( psfLocalSet - > u32MaxSustainedTrafficRate ) ;
2010-09-08 21:46:36 +00:00
}
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxLatency = ntohl ( psfLocalSet - > u32MaximumLatency ) ;
2012-01-05 01:29:00 +00:00
if ( Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxLatency = = 0 ) /* 0 should be treated as infinite */
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxLatency = MAX_LATENCY_ALLOWED ;
2012-01-05 01:29:00 +00:00
if ( ( Adapter - > PackInfo [ uiSearchRuleIndex ] . u8QueueType = = ERTPS | |
Adapter - > PackInfo [ uiSearchRuleIndex ] . u8QueueType = = UGS ) )
UGIValue = ntohs ( psfLocalSet - > u16UnsolicitedGrantInterval ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( UGIValue = = 0 )
2010-09-08 21:46:36 +00:00
UGIValue = DEFAULT_UG_INTERVAL ;
/*
2012-01-05 01:29:00 +00:00
* For UGI based connections . . .
* DEFAULT_UGI_FACTOR * UGIInterval worth of data is the max token count at host . . .
* The extra amount of token is to ensure that a large amount of jitter won ' t have loss in throughput . . .
* In case of non - UGI based connection , 200 frames worth of data is the max token count at host . . .
*/
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxBucketSize =
2012-01-05 01:29:00 +00:00
( DEFAULT_UGI_FACTOR * Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxAllowedRate * UGIValue ) / 1000 ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxBucketSize < WIMAX_MAX_MTU * 8 ) {
2010-09-08 21:46:36 +00:00
UINT UGIFactor = 0 ;
/* Special Handling to ensure the biggest size of packet can go out from host to FW as follows:
2012-01-05 01:29:00 +00:00
* 1. Any packet from Host to FW can go out in different packet size .
* 2. So in case the Bucket count is smaller than MTU , the packets of size ( Size > TokenCount ) , will get dropped .
* 3. We can allow packets of MaxSize from Host - > FW that can go out from FW in multiple SDUs by fragmentation at Wimax Layer
*/
2010-09-08 21:46:36 +00:00
UGIFactor = ( Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxLatency / UGIValue + 1 ) ;
2012-01-05 01:29:00 +00:00
if ( UGIFactor > DEFAULT_UGI_FACTOR )
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxBucketSize =
( UGIFactor * Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxAllowedRate * UGIValue ) / 1000 ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxBucketSize > WIMAX_MAX_MTU * 8 )
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxBucketSize = WIMAX_MAX_MTU * 8 ;
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " LAT: %d, UGI: %d \n " , Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxLatency , UGIValue ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " uiMaxAllowedRate: 0x%x, u32MaxSustainedTrafficRate: 0x%x ,uiMaxBucketSize: 0x%x " ,
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxAllowedRate ,
ntohl ( psfLocalSet - > u32MaxSustainedTrafficRate ) ,
Adapter - > PackInfo [ uiSearchRuleIndex ] . uiMaxBucketSize ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* copy the extended SF Parameters to Support MIBS */
CopyMIBSExtendedSFParameters ( Adapter , psfLocalSet , uiSearchRuleIndex ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
/* store header suppression enabled flag per SF */
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bHeaderSuppressionEnabled =
2012-01-05 01:29:00 +00:00
! ( psfLocalSet - > u8RequesttransmissionPolicy &
MASK_DISABLE_HEADER_SUPPRESSION ) ;
2010-09-08 21:46:36 +00:00
2011-03-13 05:28:55 +00:00
kfree ( Adapter - > PackInfo [ uiSearchRuleIndex ] . pstSFIndication ) ;
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . pstSFIndication = pstAddIndication ;
2012-01-05 01:29:00 +00:00
/* Re Sort the SF list in PackInfo according to Traffic Priority */
2010-09-08 21:46:36 +00:00
SortPackInfo ( Adapter ) ;
/* Re Sort the Classifier Rules table and re - arrange
2012-01-05 01:29:00 +00:00
* according to Classifier Rule Priority
*/
2010-09-08 21:46:36 +00:00
SortClassifiers ( Adapter ) ;
DumpPhsRules ( & Adapter - > stBCMPhsContext ) ;
2012-01-05 01:29:01 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " %s <===== " , __func__ ) ;
2010-09-08 21:46:36 +00:00
}
/***********************************************************************
2012-01-05 01:29:00 +00:00
* Function - DumpCmControlPacket
*
* Description - This routinue Dumps the Contents of the AddIndication
* Structure in the Connection Management Control Packet
*
* Parameter - pvBuffer : Pointer to the buffer containing the
* AddIndication data .
*
* Returns - None
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-09-30 08:24:12 +00:00
static VOID DumpCmControlPacket ( PVOID pvBuffer )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
UINT uiLoopIndex ;
UINT nIndex ;
stLocalSFAddIndicationAlt * pstAddIndication ;
UINT nCurClassifierCnt ;
PMINI_ADAPTER Adapter = GET_BCM_ADAPTER ( gblpnetdev ) ;
2010-09-08 21:46:36 +00:00
pstAddIndication = ( stLocalSFAddIndicationAlt * ) pvBuffer ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " ======> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Type: 0x%X " , pstAddIndication - > u8Type ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Direction: 0x%X " , pstAddIndication - > u8Direction ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TID: 0x%X " , ntohs ( pstAddIndication - > u16TID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16CID: 0x%X " , ntohs ( pstAddIndication - > u16CID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16VCID: 0x%X " , ntohs ( pstAddIndication - > u16VCID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " AuthorizedSet---> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32SFID: 0x%X " , htonl ( pstAddIndication - > sfAuthorizedSet . u32SFID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16CID: 0x%X " , htons ( pstAddIndication - > sfAuthorizedSet . u16CID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceClassNameLength: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8ServiceClassNameLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceClassName: 0x%X ,0x%X , 0x%X, 0x%X, 0x%X, 0x%X " ,
2010-09-08 21:46:36 +00:00
pstAddIndication - > sfAuthorizedSet . u8ServiceClassName [ 0 ] ,
pstAddIndication - > sfAuthorizedSet . u8ServiceClassName [ 1 ] ,
pstAddIndication - > sfAuthorizedSet . u8ServiceClassName [ 2 ] ,
pstAddIndication - > sfAuthorizedSet . u8ServiceClassName [ 3 ] ,
pstAddIndication - > sfAuthorizedSet . u8ServiceClassName [ 4 ] ,
pstAddIndication - > sfAuthorizedSet . u8ServiceClassName [ 5 ] ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8MBSService: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8MBSService ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8QosParamSet: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8QosParamSet ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TrafficPriority: 0x%X, %p " ,
pstAddIndication - > sfAuthorizedSet . u8TrafficPriority , & pstAddIndication - > sfAuthorizedSet . u8TrafficPriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaxSustainedTrafficRate: 0x%X 0x%p " ,
pstAddIndication - > sfAuthorizedSet . u32MaxSustainedTrafficRate ,
2010-09-08 21:46:36 +00:00
& pstAddIndication - > sfAuthorizedSet . u32MaxSustainedTrafficRate ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaxTrafficBurst: 0x%X " , pstAddIndication - > sfAuthorizedSet . u32MaxTrafficBurst ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MinReservedTrafficRate : 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u32MinReservedTrafficRate ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificQoSParamLength: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8VendorSpecificQoSParamLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificQoSParam: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8VendorSpecificQoSParam [ 0 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceFlowSchedulingType: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8ServiceFlowSchedulingType ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32ToleratedJitter: 0x%X " , pstAddIndication - > sfAuthorizedSet . u32ToleratedJitter ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaximumLatency: 0x%X " , pstAddIndication - > sfAuthorizedSet . u32MaximumLatency ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8FixedLengthVSVariableLengthSDUIndicator: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8FixedLengthVSVariableLengthSDUIndicator ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8SDUSize: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8SDUSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TargetSAID: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16TargetSAID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ARQEnable: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8ARQEnable ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQWindowSize: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQWindowSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRetryTxTimeOut: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQRetryTxTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRetryRxTimeOut: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQRetryRxTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQBlockLifeTime: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQBlockLifeTime ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQSyncLossTimeOut: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQSyncLossTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ARQDeliverInOrder: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8ARQDeliverInOrder ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRxPurgeTimeOut: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQRxPurgeTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQBlockSize: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16ARQBlockSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8CSSpecification: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8CSSpecification ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TypeOfDataDeliveryService: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8TypeOfDataDeliveryService ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16SDUInterArrivalTime: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16SDUInterArrivalTime ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TimeBase: 0x%X " , pstAddIndication - > sfAuthorizedSet . u16TimeBase ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8PagingPreference: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8PagingPreference ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16UnsolicitedPollingInterval: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u16UnsolicitedPollingInterval ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " sfAuthorizedSet.u8HARQChannelMapping %x %x %x " ,
* ( unsigned int * ) pstAddIndication - > sfAuthorizedSet . u8HARQChannelMapping ,
* ( unsigned int * ) & pstAddIndication - > sfAuthorizedSet . u8HARQChannelMapping [ 4 ] ,
* ( USHORT * ) & pstAddIndication - > sfAuthorizedSet . u8HARQChannelMapping [ 8 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TrafficIndicationPreference: 0x%X " ,
pstAddIndication - > sfAuthorizedSet . u8TrafficIndicationPreference ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " Total Classifiers Received: 0x%X " , pstAddIndication - > sfAuthorizedSet . u8TotalClassifiers ) ;
2010-09-08 21:46:36 +00:00
nCurClassifierCnt = pstAddIndication - > sfAuthorizedSet . u8TotalClassifiers ;
2012-01-05 01:29:00 +00:00
if ( nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF )
2010-09-08 21:46:36 +00:00
nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " pstAddIndication->sfAuthorizedSet.bValid %d " , pstAddIndication - > sfAuthorizedSet . bValid ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " pstAddIndication->sfAuthorizedSet.u16MacOverhead %x " , pstAddIndication - > sfAuthorizedSet . u16MacOverhead ) ;
if ( ! pstAddIndication - > sfAuthorizedSet . bValid )
pstAddIndication - > sfAuthorizedSet . bValid = 1 ;
for ( nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex + + ) {
2010-09-08 21:46:36 +00:00
stConvergenceSLTypes * psfCSType = NULL ;
psfCSType = & pstAddIndication - > sfAuthorizedSet . cConvergenceSLTypes [ nIndex ] ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " psfCSType = %p " , psfCSType ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " CCPacketClassificationRuleSI====> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ClassifierRulePriority: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ClassifierRulePriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPTypeOfServiceLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfServiceLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPTypeOfService[3]: 0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 2 ] ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 1 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Protocol: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8Protocol ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPMaskedSourceAddressLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddressLength ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 32 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPMaskedSourceAddress[32]: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddress [ uiLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPDestinationAddressLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddressLength ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 32 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPDestinationAddress[32]: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddress [ uiLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolSourcePortRangeLength:0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRangeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolSourcePortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 3 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolDestPortRangeLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRangeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolDestPortRange[4]: 0x%02X ,0x%02X ,0x%02X ,0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 3 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetDestMacAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetDestMacAddress[6]: 0x %02X %02X %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetSourceMACAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetSourceMACAddress[6]: 0x %02X %02X %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthertypeLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8EthertypeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Ethertype[3]: 0x%02X ,0x%02X ,0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 2 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16UserPriority: 0x%X " , psfCSType - > cCPacketClassificationRule . u16UserPriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16VLANID: 0x%X " , psfCSType - > cCPacketClassificationRule . u16VLANID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8AssociatedPHSI: 0x%02X " , psfCSType - > cCPacketClassificationRule . u8AssociatedPHSI ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16PacketClassificationRuleIndex: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u16PacketClassificationRuleIndex ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificClassifierParamLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8VendorSpecificClassifierParamLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificClassifierParam[1]: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8VendorSpecificClassifierParam [ 0 ] ) ;
2010-09-08 21:46:36 +00:00
# ifdef VERSION_D5
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPv6FlowLableLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLableLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPv6FlowLable[6]: 0x %02X %02X %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 5 ] ) ;
2010-09-08 21:46:36 +00:00
# endif
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " bValid: 0x%02X " , pstAddIndication - > sfAuthorizedSet . bValid ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " AdmittedSet---> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32SFID: 0x%X " , pstAddIndication - > sfAdmittedSet . u32SFID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16CID: 0x%X " , pstAddIndication - > sfAdmittedSet . u16CID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceClassNameLength: 0x%X " ,
pstAddIndication - > sfAdmittedSet . u8ServiceClassNameLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceClassName: 0x %02X %02X %02X %02X %02X %02X " ,
2010-09-08 21:46:36 +00:00
pstAddIndication - > sfAdmittedSet . u8ServiceClassName [ 0 ] ,
pstAddIndication - > sfAdmittedSet . u8ServiceClassName [ 1 ] ,
pstAddIndication - > sfAdmittedSet . u8ServiceClassName [ 2 ] ,
pstAddIndication - > sfAdmittedSet . u8ServiceClassName [ 3 ] ,
pstAddIndication - > sfAdmittedSet . u8ServiceClassName [ 4 ] ,
pstAddIndication - > sfAdmittedSet . u8ServiceClassName [ 5 ] ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8MBSService: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8MBSService ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8QosParamSet: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8QosParamSet ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TrafficPriority: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8TrafficPriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaxTrafficBurst: 0x%X " , pstAddIndication - > sfAdmittedSet . u32MaxTrafficBurst ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MinReservedTrafficRate: 0x%X " ,
pstAddIndication - > sfAdmittedSet . u32MinReservedTrafficRate ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificQoSParamLength: 0x%02X " ,
pstAddIndication - > sfAdmittedSet . u8VendorSpecificQoSParamLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificQoSParam: 0x%02X " ,
pstAddIndication - > sfAdmittedSet . u8VendorSpecificQoSParam [ 0 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceFlowSchedulingType: 0x%02X " ,
pstAddIndication - > sfAdmittedSet . u8ServiceFlowSchedulingType ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32ToleratedJitter: 0x%X " , pstAddIndication - > sfAdmittedSet . u32ToleratedJitter ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaximumLatency: 0x%X " , pstAddIndication - > sfAdmittedSet . u32MaximumLatency ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8FixedLengthVSVariableLengthSDUIndicator: 0x%02X " ,
pstAddIndication - > sfAdmittedSet . u8FixedLengthVSVariableLengthSDUIndicator ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8SDUSize: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8SDUSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TargetSAID: 0x%02X " , pstAddIndication - > sfAdmittedSet . u16TargetSAID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ARQEnable: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8ARQEnable ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQWindowSize: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQWindowSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRetryTxTimeOut: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQRetryTxTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRetryRxTimeOut: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQRetryRxTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQBlockLifeTime: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQBlockLifeTime ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQSyncLossTimeOut: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQSyncLossTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ARQDeliverInOrder: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8ARQDeliverInOrder ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRxPurgeTimeOut: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQRxPurgeTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQBlockSize: 0x%X " , pstAddIndication - > sfAdmittedSet . u16ARQBlockSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8CSSpecification: 0x%02X " , pstAddIndication - > sfAdmittedSet . u8CSSpecification ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TypeOfDataDeliveryService: 0x%02X " ,
pstAddIndication - > sfAdmittedSet . u8TypeOfDataDeliveryService ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16SDUInterArrivalTime: 0x%X " , pstAddIndication - > sfAdmittedSet . u16SDUInterArrivalTime ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TimeBase: 0x%X " , pstAddIndication - > sfAdmittedSet . u16TimeBase ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8PagingPreference: 0x%X " , pstAddIndication - > sfAdmittedSet . u8PagingPreference ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TrafficIndicationPreference: 0x%02X " ,
pstAddIndication - > sfAdmittedSet . u8TrafficIndicationPreference ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " Total Classifiers Received: 0x%X " , pstAddIndication - > sfAdmittedSet . u8TotalClassifiers ) ;
2010-09-08 21:46:36 +00:00
nCurClassifierCnt = pstAddIndication - > sfAdmittedSet . u8TotalClassifiers ;
2012-01-05 01:29:00 +00:00
if ( nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF )
2010-09-08 21:46:36 +00:00
nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF ;
2012-01-05 01:29:00 +00:00
for ( nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex + + ) {
2010-09-08 21:46:36 +00:00
stConvergenceSLTypes * psfCSType = NULL ;
2012-01-05 01:29:00 +00:00
psfCSType = & pstAddIndication - > sfAdmittedSet . cConvergenceSLTypes [ nIndex ] ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " CCPacketClassificationRuleSI====> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ClassifierRulePriority: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8ClassifierRulePriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPTypeOfServiceLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfServiceLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPTypeOfService[3]: 0x%02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 2 ] ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 1 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Protocol: 0x%02X " , psfCSType - > cCPacketClassificationRule . u8Protocol ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPMaskedSourceAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddressLength ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 32 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPMaskedSourceAddress[32]: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddress [ uiLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPDestinationAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddressLength ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 32 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPDestinationAddress[32]: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddress [ uiLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolSourcePortRangeLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRangeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolSourcePortRange[4]: 0x %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 3 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolDestPortRangeLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRangeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolDestPortRange[4]: 0x %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 3 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetDestMacAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetDestMacAddress[6]: 0x %02X %02X %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetSourceMACAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetSourceMACAddress[6]: 0x %02X %02X %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthertypeLength: 0x%02X " , psfCSType - > cCPacketClassificationRule . u8EthertypeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Ethertype[3]: 0x%02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 2 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16UserPriority: 0x%X " , psfCSType - > cCPacketClassificationRule . u16UserPriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16VLANID: 0x%X " , psfCSType - > cCPacketClassificationRule . u16VLANID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8AssociatedPHSI: 0x%02X " , psfCSType - > cCPacketClassificationRule . u8AssociatedPHSI ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16PacketClassificationRuleIndex: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u16PacketClassificationRuleIndex ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificClassifierParamLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8VendorSpecificClassifierParamLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificClassifierParam[1]: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8VendorSpecificClassifierParam [ 0 ] ) ;
2010-09-08 21:46:36 +00:00
# ifdef VERSION_D5
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPv6FlowLableLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLableLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPv6FlowLable[6]: 0x %02X %02X %02X %02X %02X %02X " ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 5 ] ) ;
2010-09-08 21:46:36 +00:00
# endif
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " bValid: 0x%X " , pstAddIndication - > sfAdmittedSet . bValid ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " ActiveSet---> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32SFID: 0x%X " , pstAddIndication - > sfActiveSet . u32SFID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16CID: 0x%X " , pstAddIndication - > sfActiveSet . u16CID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceClassNameLength: 0x%X " , pstAddIndication - > sfActiveSet . u8ServiceClassNameLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceClassName: 0x %02X %02X %02X %02X %02X %02X " ,
pstAddIndication - > sfActiveSet . u8ServiceClassName [ 0 ] ,
pstAddIndication - > sfActiveSet . u8ServiceClassName [ 1 ] ,
pstAddIndication - > sfActiveSet . u8ServiceClassName [ 2 ] ,
pstAddIndication - > sfActiveSet . u8ServiceClassName [ 3 ] ,
pstAddIndication - > sfActiveSet . u8ServiceClassName [ 4 ] ,
pstAddIndication - > sfActiveSet . u8ServiceClassName [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8MBSService: 0x%02X " , pstAddIndication - > sfActiveSet . u8MBSService ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8QosParamSet: 0x%02X " , pstAddIndication - > sfActiveSet . u8QosParamSet ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TrafficPriority: 0x%02X " , pstAddIndication - > sfActiveSet . u8TrafficPriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaxTrafficBurst: 0x%X " , pstAddIndication - > sfActiveSet . u32MaxTrafficBurst ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MinReservedTrafficRate: 0x%X " ,
pstAddIndication - > sfActiveSet . u32MinReservedTrafficRate ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificQoSParamLength: 0x%02X " ,
pstAddIndication - > sfActiveSet . u8VendorSpecificQoSParamLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificQoSParam: 0x%02X " ,
pstAddIndication - > sfActiveSet . u8VendorSpecificQoSParam [ 0 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ServiceFlowSchedulingType: 0x%02X " ,
pstAddIndication - > sfActiveSet . u8ServiceFlowSchedulingType ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32ToleratedJitter: 0x%X " , pstAddIndication - > sfActiveSet . u32ToleratedJitter ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u32MaximumLatency: 0x%X " , pstAddIndication - > sfActiveSet . u32MaximumLatency ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8FixedLengthVSVariableLengthSDUIndicator: 0x%02X " ,
pstAddIndication - > sfActiveSet . u8FixedLengthVSVariableLengthSDUIndicator ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8SDUSize: 0x%X " , pstAddIndication - > sfActiveSet . u8SDUSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TargetSAID: 0x%X " , pstAddIndication - > sfActiveSet . u16TargetSAID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ARQEnable: 0x%X " , pstAddIndication - > sfActiveSet . u8ARQEnable ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQWindowSize: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQWindowSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRetryTxTimeOut: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQRetryTxTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRetryRxTimeOut: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQRetryRxTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQBlockLifeTime: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQBlockLifeTime ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQSyncLossTimeOut: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQSyncLossTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ARQDeliverInOrder: 0x%X " , pstAddIndication - > sfActiveSet . u8ARQDeliverInOrder ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQRxPurgeTimeOut: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQRxPurgeTimeOut ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16ARQBlockSize: 0x%X " , pstAddIndication - > sfActiveSet . u16ARQBlockSize ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8CSSpecification: 0x%X " , pstAddIndication - > sfActiveSet . u8CSSpecification ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TypeOfDataDeliveryService: 0x%X " ,
pstAddIndication - > sfActiveSet . u8TypeOfDataDeliveryService ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16SDUInterArrivalTime: 0x%X " , pstAddIndication - > sfActiveSet . u16SDUInterArrivalTime ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16TimeBase: 0x%X " , pstAddIndication - > sfActiveSet . u16TimeBase ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8PagingPreference: 0x%X " , pstAddIndication - > sfActiveSet . u8PagingPreference ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8TrafficIndicationPreference: 0x%X " ,
pstAddIndication - > sfActiveSet . u8TrafficIndicationPreference ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " Total Classifiers Received: 0x%X " , pstAddIndication - > sfActiveSet . u8TotalClassifiers ) ;
2010-09-08 21:46:36 +00:00
nCurClassifierCnt = pstAddIndication - > sfActiveSet . u8TotalClassifiers ;
2012-01-05 01:29:00 +00:00
if ( nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF )
2010-09-08 21:46:36 +00:00
nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF ;
2012-01-05 01:29:00 +00:00
for ( nIndex = 0 ; nIndex < nCurClassifierCnt ; nIndex + + ) {
2010-09-08 21:46:36 +00:00
stConvergenceSLTypes * psfCSType = NULL ;
2012-01-05 01:29:00 +00:00
psfCSType = & pstAddIndication - > sfActiveSet . cConvergenceSLTypes [ nIndex ] ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " CCPacketClassificationRuleSI====> " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ClassifierRulePriority: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ClassifierRulePriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPTypeOfServiceLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfServiceLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPTypeOfService[3]: 0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8IPTypeOfService [ 2 ] ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 1 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Protocol: 0x%X " , psfCSType - > cCPacketClassificationRule . u8Protocol ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPMaskedSourceAddressLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddressLength ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 32 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPMaskedSourceAddress[32]: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPMaskedSourceAddress [ uiLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPDestinationAddressLength: 0x%02X " ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddressLength ) ;
for ( uiLoopIndex = 0 ; uiLoopIndex < 32 ; uiLoopIndex + + )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPDestinationAddress[32]:0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPDestinationAddress [ uiLoopIndex ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolSourcePortRangeLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRangeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolSourcePortRange[4]: 0x%X ,0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolSourcePortRange [ 3 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolDestPortRangeLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRangeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8ProtocolDestPortRange[4]: 0x%X ,0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8ProtocolDestPortRange [ 3 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetDestMacAddressLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetDestMacAddress[6]: 0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddress [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetSourceMACAddressLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetDestMacAddressLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthernetSourceMACAddress[6]: 0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8EthernetSourceMACAddress [ 5 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8EthertypeLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8EthertypeLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8Ethertype[3]: 0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8Ethertype [ 2 ] ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16UserPriority: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u16UserPriority ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16VLANID: 0x%X " , psfCSType - > cCPacketClassificationRule . u16VLANID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8AssociatedPHSI: 0x%X " , psfCSType - > cCPacketClassificationRule . u8AssociatedPHSI ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u16PacketClassificationRuleIndex:0x%X " ,
psfCSType - > cCPacketClassificationRule . u16PacketClassificationRuleIndex ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificClassifierParamLength:0x%X " ,
psfCSType - > cCPacketClassificationRule . u8VendorSpecificClassifierParamLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8VendorSpecificClassifierParam[1]:0x%X " ,
psfCSType - > cCPacketClassificationRule . u8VendorSpecificClassifierParam [ 0 ] ) ;
2010-09-08 21:46:36 +00:00
# ifdef VERSION_D5
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPv6FlowLableLength: 0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLableLength ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " u8IPv6FlowLable[6]: 0x%X ,0x%X ,0x%X ,0x%X ,0x%X ,0x%X " ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 0 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 1 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 2 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 3 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 4 ] ,
psfCSType - > cCPacketClassificationRule . u8IPv6FlowLable [ 5 ] ) ;
2010-09-08 21:46:36 +00:00
# endif
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , DUMP_CONTROL , DBG_LVL_ALL , " bValid: 0x%X " , pstAddIndication - > sfActiveSet . bValid ) ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
static inline ULONG RestoreSFParam ( PMINI_ADAPTER Adapter , ULONG ulAddrSFParamSet , PUCHAR pucDestBuffer )
2010-09-08 21:46:36 +00:00
{
UINT nBytesToRead = sizeof ( stServiceFlowParamSI ) ;
2012-01-05 01:29:00 +00:00
if ( ulAddrSFParamSet = = 0 | | NULL = = pucDestBuffer ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Got Param address as 0!! " ) ;
2010-09-08 21:46:36 +00:00
return 0 ;
}
ulAddrSFParamSet = ntohl ( ulAddrSFParamSet ) ;
2012-01-05 01:29:00 +00:00
/* Read out the SF Param Set At the indicated Location */
if ( rdm ( Adapter , ulAddrSFParamSet , ( PUCHAR ) pucDestBuffer , nBytesToRead ) < 0 )
2010-09-08 21:46:36 +00:00
return STATUS_FAILURE ;
return 1 ;
}
2012-01-05 01:29:00 +00:00
static ULONG StoreSFParam ( PMINI_ADAPTER Adapter , PUCHAR pucSrcBuffer , ULONG ulAddrSFParamSet )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
UINT nBytesToWrite = sizeof ( stServiceFlowParamSI ) ;
2010-11-13 04:37:49 +00:00
int ret = 0 ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( ulAddrSFParamSet = = 0 | | NULL = = pucSrcBuffer )
2010-09-08 21:46:36 +00:00
return 0 ;
2010-11-13 04:37:49 +00:00
ret = wrm ( Adapter , ulAddrSFParamSet , ( u8 * ) pucSrcBuffer , nBytesToWrite ) ;
if ( ret < 0 ) {
2012-01-05 01:29:01 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " %s:%d WRM failed " , __func__ , __LINE__ ) ;
2010-11-13 04:37:49 +00:00
return ret ;
2010-09-08 21:46:36 +00:00
}
return 1 ;
}
2012-01-05 01:29:00 +00:00
ULONG StoreCmControlResponseMessage ( PMINI_ADAPTER Adapter , PVOID pvBuffer , UINT * puBufferLength )
2010-09-08 21:46:36 +00:00
{
stLocalSFAddIndicationAlt * pstAddIndicationAlt = NULL ;
2012-01-05 01:29:00 +00:00
stLocalSFAddIndication * pstAddIndication = NULL ;
2010-09-08 21:46:36 +00:00
stLocalSFDeleteRequest * pstDeletionRequest ;
UINT uiSearchRuleIndex ;
ULONG ulSFID ;
pstAddIndicationAlt = ( stLocalSFAddIndicationAlt * ) ( pvBuffer ) ;
/*
2012-01-05 01:29:00 +00:00
* In case of DSD Req By MS , we should immediately delete this SF so that
* we can stop the further classifying the pkt for this SF .
*/
if ( pstAddIndicationAlt - > u8Type = = DSD_REQ ) {
2010-09-08 21:46:36 +00:00
pstDeletionRequest = ( stLocalSFDeleteRequest * ) pvBuffer ;
ulSFID = ntohl ( pstDeletionRequest - > u32SFID ) ;
2012-01-05 01:29:00 +00:00
uiSearchRuleIndex = SearchSfid ( Adapter , ulSFID ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( uiSearchRuleIndex < NO_OF_QUEUES ) {
deleteSFBySfid ( Adapter , uiSearchRuleIndex ) ;
2010-09-08 21:46:36 +00:00
Adapter - > u32TotalDSD + + ;
}
return 1 ;
}
2012-01-05 01:29:00 +00:00
if ( ( pstAddIndicationAlt - > u8Type = = DSD_RSP ) | |
( pstAddIndicationAlt - > u8Type = = DSD_ACK ) ) {
/* No Special handling send the message as it is */
2010-09-08 21:46:36 +00:00
return 1 ;
}
2012-01-05 01:29:00 +00:00
/* For DSA_REQ, only up to "psfAuthorizedSet" parameter should be accessed by driver! */
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
pstAddIndication = kmalloc ( sizeof ( * pstAddIndication ) , GFP_KERNEL ) ;
2012-01-05 01:29:03 +00:00
if ( pstAddIndication = = NULL )
2010-09-08 21:46:36 +00:00
return 0 ;
/* AUTHORIZED SET */
pstAddIndication - > psfAuthorizedSet = ( stServiceFlowParamSI * )
GetNextTargetBufferLocation ( Adapter , pstAddIndicationAlt - > u16TID ) ;
2012-01-05 01:29:00 +00:00
if ( ! pstAddIndication - > psfAuthorizedSet )
2010-09-08 21:46:36 +00:00
return 0 ;
2012-01-05 01:29:00 +00:00
if ( StoreSFParam ( Adapter , ( PUCHAR ) & pstAddIndicationAlt - > sfAuthorizedSet ,
( ULONG ) pstAddIndication - > psfAuthorizedSet ) ! = 1 )
2010-09-08 21:46:36 +00:00
return 0 ;
2010-09-30 08:24:11 +00:00
/* this can't possibly be right */
pstAddIndication - > psfAuthorizedSet = ( stServiceFlowParamSI * ) ntohl ( ( ULONG ) pstAddIndication - > psfAuthorizedSet ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( pstAddIndicationAlt - > u8Type = = DSA_REQ ) {
2010-09-08 21:46:36 +00:00
stLocalSFAddRequest AddRequest ;
AddRequest . u8Type = pstAddIndicationAlt - > u8Type ;
AddRequest . eConnectionDir = pstAddIndicationAlt - > u8Direction ;
AddRequest . u16TID = pstAddIndicationAlt - > u16TID ;
AddRequest . u16CID = pstAddIndicationAlt - > u16CID ;
AddRequest . u16VCID = pstAddIndicationAlt - > u16VCID ;
2012-01-05 01:29:00 +00:00
AddRequest . psfParameterSet = pstAddIndication - > psfAuthorizedSet ;
2010-09-08 21:46:36 +00:00
( * puBufferLength ) = sizeof ( stLocalSFAddRequest ) ;
2012-01-05 01:29:00 +00:00
memcpy ( pvBuffer , & AddRequest , sizeof ( stLocalSFAddRequest ) ) ;
2010-09-08 21:46:36 +00:00
return 1 ;
}
2012-01-05 01:29:00 +00:00
/* Since it's not DSA_REQ, we can access all field in pstAddIndicationAlt */
/* We need to extract the structure from the buffer and pack it differently */
2010-09-08 21:46:36 +00:00
pstAddIndication - > u8Type = pstAddIndicationAlt - > u8Type ;
2012-01-05 01:29:00 +00:00
pstAddIndication - > eConnectionDir = pstAddIndicationAlt - > u8Direction ;
2010-09-08 21:46:36 +00:00
pstAddIndication - > u16TID = pstAddIndicationAlt - > u16TID ;
pstAddIndication - > u16CID = pstAddIndicationAlt - > u16CID ;
pstAddIndication - > u16VCID = pstAddIndicationAlt - > u16VCID ;
pstAddIndication - > u8CC = pstAddIndicationAlt - > u8CC ;
/* ADMITTED SET */
pstAddIndication - > psfAdmittedSet = ( stServiceFlowParamSI * )
GetNextTargetBufferLocation ( Adapter , pstAddIndicationAlt - > u16TID ) ;
2012-01-05 01:29:00 +00:00
if ( ! pstAddIndication - > psfAdmittedSet )
2010-09-08 21:46:36 +00:00
return 0 ;
2012-01-05 01:29:00 +00:00
if ( StoreSFParam ( Adapter , ( PUCHAR ) & pstAddIndicationAlt - > sfAdmittedSet , ( ULONG ) pstAddIndication - > psfAdmittedSet ) ! = 1 )
2010-09-08 21:46:36 +00:00
return 0 ;
pstAddIndication - > psfAdmittedSet = ( stServiceFlowParamSI * ) ntohl ( ( ULONG ) pstAddIndication - > psfAdmittedSet ) ;
/* ACTIVE SET */
pstAddIndication - > psfActiveSet = ( stServiceFlowParamSI * )
GetNextTargetBufferLocation ( Adapter , pstAddIndicationAlt - > u16TID ) ;
2012-01-05 01:29:00 +00:00
if ( ! pstAddIndication - > psfActiveSet )
2010-09-08 21:46:36 +00:00
return 0 ;
2012-01-05 01:29:00 +00:00
if ( StoreSFParam ( Adapter , ( PUCHAR ) & pstAddIndicationAlt - > sfActiveSet , ( ULONG ) pstAddIndication - > psfActiveSet ) ! = 1 )
2010-09-08 21:46:36 +00:00
return 0 ;
pstAddIndication - > psfActiveSet = ( stServiceFlowParamSI * ) ntohl ( ( ULONG ) pstAddIndication - > psfActiveSet ) ;
( * puBufferLength ) = sizeof ( stLocalSFAddIndication ) ;
* ( stLocalSFAddIndication * ) pvBuffer = * pstAddIndication ;
2010-11-01 13:35:21 +00:00
kfree ( pstAddIndication ) ;
2010-09-08 21:46:36 +00:00
return 1 ;
}
static inline stLocalSFAddIndicationAlt
2012-01-05 01:29:00 +00:00
* RestoreCmControlResponseMessage ( register PMINI_ADAPTER Adapter , register PVOID pvBuffer )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
ULONG ulStatus = 0 ;
2010-09-08 21:46:36 +00:00
stLocalSFAddIndication * pstAddIndication = NULL ;
stLocalSFAddIndicationAlt * pstAddIndicationDest = NULL ;
2012-01-05 01:29:00 +00:00
pstAddIndication = ( stLocalSFAddIndication * ) ( pvBuffer ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " =====> " ) ;
2010-09-08 21:46:36 +00:00
if ( ( pstAddIndication - > u8Type = = DSD_REQ ) | |
( pstAddIndication - > u8Type = = DSD_RSP ) | |
( pstAddIndication - > u8Type = = DSD_ACK ) )
return ( stLocalSFAddIndicationAlt * ) pvBuffer ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Inside RestoreCmControlResponseMessage " ) ;
2010-09-08 21:46:36 +00:00
/*
2012-01-05 01:29:00 +00:00
* Need to Allocate memory to contain the SUPER Large structures
* Our driver can ' t create these structures on Stack : (
*/
pstAddIndicationDest = kmalloc ( sizeof ( stLocalSFAddIndicationAlt ) , GFP_KERNEL ) ;
if ( pstAddIndicationDest ) {
memset ( pstAddIndicationDest , 0 , sizeof ( stLocalSFAddIndicationAlt ) ) ;
} else {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Failed to allocate memory for SF Add Indication Structure " ) ;
2010-09-08 21:46:36 +00:00
return NULL ;
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-u8Type : 0x%X " , pstAddIndication - > u8Type ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-u8Direction : 0x%X " , pstAddIndication - > eConnectionDir ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-u8TID : 0x%X " , ntohs ( pstAddIndication - > u16TID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-u8CID : 0x%X " , ntohs ( pstAddIndication - > u16CID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-u16VCID : 0x%X " , ntohs ( pstAddIndication - > u16VCID ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-autorized set loc : %p " , pstAddIndication - > psfAuthorizedSet ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-admitted set loc : %p " , pstAddIndication - > psfAdmittedSet ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " AddIndication-Active set loc : %p " , pstAddIndication - > psfActiveSet ) ;
2010-09-08 21:46:36 +00:00
pstAddIndicationDest - > u8Type = pstAddIndication - > u8Type ;
pstAddIndicationDest - > u8Direction = pstAddIndication - > eConnectionDir ;
pstAddIndicationDest - > u16TID = pstAddIndication - > u16TID ;
pstAddIndicationDest - > u16CID = pstAddIndication - > u16CID ;
pstAddIndicationDest - > u16VCID = pstAddIndication - > u16VCID ;
pstAddIndicationDest - > u8CC = pstAddIndication - > u8CC ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Restoring Active Set " ) ;
ulStatus = RestoreSFParam ( Adapter , ( ULONG ) pstAddIndication - > psfActiveSet , ( PUCHAR ) & pstAddIndicationDest - > sfActiveSet ) ;
if ( ulStatus ! = 1 )
2010-09-08 21:46:36 +00:00
goto failed_restore_sf_param ;
2012-01-05 01:29:00 +00:00
if ( pstAddIndicationDest - > sfActiveSet . u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF )
2010-09-08 21:46:36 +00:00
pstAddIndicationDest - > sfActiveSet . u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Restoring Admitted Set " ) ;
ulStatus = RestoreSFParam ( Adapter , ( ULONG ) pstAddIndication - > psfAdmittedSet , ( PUCHAR ) & pstAddIndicationDest - > sfAdmittedSet ) ;
if ( ulStatus ! = 1 )
2010-09-08 21:46:36 +00:00
goto failed_restore_sf_param ;
2012-01-05 01:29:00 +00:00
if ( pstAddIndicationDest - > sfAdmittedSet . u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF )
2010-09-08 21:46:36 +00:00
pstAddIndicationDest - > sfAdmittedSet . u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Restoring Authorized Set " ) ;
ulStatus = RestoreSFParam ( Adapter , ( ULONG ) pstAddIndication - > psfAuthorizedSet , ( PUCHAR ) & pstAddIndicationDest - > sfAuthorizedSet ) ;
if ( ulStatus ! = 1 )
2010-09-08 21:46:36 +00:00
goto failed_restore_sf_param ;
2012-01-05 01:29:00 +00:00
if ( pstAddIndicationDest - > sfAuthorizedSet . u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF )
2010-09-08 21:46:36 +00:00
pstAddIndicationDest - > sfAuthorizedSet . u8TotalClassifiers = MAX_CLASSIFIERS_IN_SF ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Dumping the whole raw packet " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " ============================================================ " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " pstAddIndicationDest->sfActiveSet size %zx %p " , sizeof ( * pstAddIndicationDest ) , pstAddIndicationDest ) ;
/* BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, (unsigned char *)pstAddIndicationDest, sizeof(*pstAddIndicationDest)); */
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " ============================================================ " ) ;
2010-09-08 21:46:36 +00:00
return pstAddIndicationDest ;
failed_restore_sf_param :
2010-11-01 13:35:21 +00:00
kfree ( pstAddIndicationDest ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " <===== " ) ;
2010-09-08 21:46:36 +00:00
return NULL ;
}
ULONG SetUpTargetDsxBuffers ( PMINI_ADAPTER Adapter )
{
ULONG ulTargetDsxBuffersBase = 0 ;
ULONG ulCntTargetBuffers ;
2012-01-05 01:29:00 +00:00
ULONG ulIndex = 0 ;
2010-09-08 21:46:36 +00:00
int Status ;
2010-10-08 12:56:35 +00:00
if ( ! Adapter ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Adapter was NULL!!! " ) ;
return 0 ;
}
2012-01-05 01:29:00 +00:00
if ( Adapter - > astTargetDsxBuffer [ 0 ] . ulTargetDsxBuffer )
2010-09-08 21:46:36 +00:00
return 1 ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Size of Each DSX Buffer(Also size of ServiceFlowParamSI): %zx " , sizeof ( stServiceFlowParamSI ) ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Reading DSX buffer From Target location %x " , DSX_MESSAGE_EXCHANGE_BUFFER ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
Status = rdmalt ( Adapter , DSX_MESSAGE_EXCHANGE_BUFFER , ( PUINT ) & ulTargetDsxBuffersBase , sizeof ( UINT ) ) ;
if ( Status < 0 ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " RDM failed!! " ) ;
2010-09-08 21:46:36 +00:00
return 0 ;
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Base Address Of DSX Target Buffer : 0x%lx " , ulTargetDsxBuffersBase ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Tgt Buffer is Now %lx : " , ulTargetDsxBuffersBase ) ;
ulCntTargetBuffers = DSX_MESSAGE_EXCHANGE_BUFFER_SIZE / sizeof ( stServiceFlowParamSI ) ;
2010-09-08 21:46:36 +00:00
Adapter - > ulTotalTargetBuffersAvailable =
ulCntTargetBuffers > MAX_TARGET_DSX_BUFFERS ?
MAX_TARGET_DSX_BUFFERS : ulCntTargetBuffers ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Total Target DSX Buffer setup %lx " , Adapter - > ulTotalTargetBuffersAvailable ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
for ( ulIndex = 0 ; ulIndex < Adapter - > ulTotalTargetBuffersAvailable ; ulIndex + + ) {
2010-09-08 21:46:36 +00:00
Adapter - > astTargetDsxBuffer [ ulIndex ] . ulTargetDsxBuffer = ulTargetDsxBuffersBase ;
2012-01-05 01:29:00 +00:00
Adapter - > astTargetDsxBuffer [ ulIndex ] . valid = 1 ;
Adapter - > astTargetDsxBuffer [ ulIndex ] . tid = 0 ;
ulTargetDsxBuffersBase + = sizeof ( stServiceFlowParamSI ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Target DSX Buffer %lx setup at 0x%lx " ,
ulIndex , Adapter - > astTargetDsxBuffer [ ulIndex ] . ulTargetDsxBuffer ) ;
2010-09-08 21:46:36 +00:00
}
Adapter - > ulCurrentTargetBuffer = 0 ;
Adapter - > ulFreeTargetBufferCnt = Adapter - > ulTotalTargetBuffersAvailable ;
return 1 ;
}
2012-01-05 01:29:00 +00:00
static ULONG GetNextTargetBufferLocation ( PMINI_ADAPTER Adapter , B_UINT16 tid )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
ULONG ulTargetDSXBufferAddress ;
ULONG ulTargetDsxBufferIndexToUse , ulMaxTry ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( ( Adapter - > ulTotalTargetBuffersAvailable = = 0 ) | | ( Adapter - > ulFreeTargetBufferCnt = = 0 ) ) {
ClearTargetDSXBuffer ( Adapter , tid , FALSE ) ;
2010-09-08 21:46:36 +00:00
return 0 ;
}
2012-01-05 01:29:00 +00:00
ulTargetDsxBufferIndexToUse = Adapter - > ulCurrentTargetBuffer ;
ulMaxTry = Adapter - > ulTotalTargetBuffersAvailable ;
while ( ( ulMaxTry ) & & ( Adapter - > astTargetDsxBuffer [ ulTargetDsxBufferIndexToUse ] . valid ! = 1 ) ) {
ulTargetDsxBufferIndexToUse = ( ulTargetDsxBufferIndexToUse + 1 ) % Adapter - > ulTotalTargetBuffersAvailable ;
ulMaxTry - - ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
if ( ulMaxTry = = 0 ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " \n GetNextTargetBufferLocation : Error No Free Target DSX Buffers FreeCnt : %lx " , Adapter - > ulFreeTargetBufferCnt ) ;
ClearTargetDSXBuffer ( Adapter , tid , FALSE ) ;
2010-09-08 21:46:36 +00:00
return 0 ;
}
2012-01-05 01:29:00 +00:00
ulTargetDSXBufferAddress = Adapter - > astTargetDsxBuffer [ ulTargetDsxBufferIndexToUse ] . ulTargetDsxBuffer ;
Adapter - > astTargetDsxBuffer [ ulTargetDsxBufferIndexToUse ] . valid = 0 ;
Adapter - > astTargetDsxBuffer [ ulTargetDsxBufferIndexToUse ] . tid = tid ;
2010-09-08 21:46:36 +00:00
Adapter - > ulFreeTargetBufferCnt - - ;
2012-01-05 01:29:00 +00:00
ulTargetDsxBufferIndexToUse = ( ulTargetDsxBufferIndexToUse + 1 ) % Adapter - > ulTotalTargetBuffersAvailable ;
2010-09-08 21:46:36 +00:00
Adapter - > ulCurrentTargetBuffer = ulTargetDsxBufferIndexToUse ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " GetNextTargetBufferLocation :Returning address %lx tid %d \n " , ulTargetDSXBufferAddress , tid ) ;
2010-09-08 21:46:36 +00:00
return ulTargetDSXBufferAddress ;
}
INT AllocAdapterDsxBuffer ( PMINI_ADAPTER Adapter )
{
/*
2012-01-05 01:29:00 +00:00
* Need to Allocate memory to contain the SUPER Large structures
* Our driver can ' t create these structures on Stack
*/
Adapter - > caDsxReqResp = kmalloc ( sizeof ( stLocalSFAddIndicationAlt ) + LEADER_SIZE , GFP_KERNEL ) ;
if ( ! Adapter - > caDsxReqResp )
2010-09-08 21:46:36 +00:00
return - ENOMEM ;
2012-01-05 01:29:00 +00:00
2010-09-08 21:46:36 +00:00
return 0 ;
}
INT FreeAdapterDsxBuffer ( PMINI_ADAPTER Adapter )
{
2011-03-13 05:28:55 +00:00
kfree ( Adapter - > caDsxReqResp ) ;
2010-09-08 21:46:36 +00:00
return 0 ;
}
2012-01-05 01:29:00 +00:00
/*
* @ ingroup ctrl_pkt_functions
* This routinue would process the Control responses
* for the Connection Management .
* @ return - Queue index for the free SFID else returns Invalid Index .
*/
BOOLEAN CmControlResponseMessage ( PMINI_ADAPTER Adapter , /* <Pointer to the Adapter structure */
PVOID pvBuffer /* Starting Address of the Buffer, that contains the AddIndication Data */ )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
stServiceFlowParamSI * psfLocalSet = NULL ;
stLocalSFAddIndicationAlt * pstAddIndication = NULL ;
stLocalSFChangeIndicationAlt * pstChangeIndication = NULL ;
PLEADER pLeader = NULL ;
2010-09-08 21:46:36 +00:00
/*
2012-01-05 01:29:00 +00:00
* Otherwise the message contains a target address from where we need to
* read out the rest of the service flow param structure
*/
2012-01-05 01:29:03 +00:00
pstAddIndication = RestoreCmControlResponseMessage ( Adapter , pvBuffer ) ;
if ( pstAddIndication = = NULL ) {
2012-01-05 01:29:00 +00:00
ClearTargetDSXBuffer ( Adapter , ( ( stLocalSFAddIndication * ) pvBuffer ) - > u16TID , FALSE ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " Error in restoring Service Flow param structure from DSx message " ) ;
2010-09-08 21:46:36 +00:00
return FALSE ;
}
DumpCmControlPacket ( pstAddIndication ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " ====> " ) ;
2010-09-08 21:46:36 +00:00
pLeader = ( PLEADER ) Adapter - > caDsxReqResp ;
2012-01-05 01:29:00 +00:00
pLeader - > Status = CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ ;
2010-09-08 21:46:36 +00:00
pLeader - > Vcid = 0 ;
2012-01-05 01:29:00 +00:00
ClearTargetDSXBuffer ( Adapter , pstAddIndication - > u16TID , FALSE ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " ### TID RECEIVED %d \n " , pstAddIndication - > u16TID ) ;
switch ( pstAddIndication - > u8Type ) {
case DSA_REQ :
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
pLeader - > PLength = sizeof ( stLocalSFAddIndicationAlt ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Sending DSA Response.... \n " ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SENDING DSA RESPONSE TO MAC %d " , pLeader - > PLength ) ;
* ( ( stLocalSFAddIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) )
= * pstAddIndication ;
( ( stLocalSFAddIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) - > u8Type = DSA_RSP ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " VCID = %x " , ntohs ( pstAddIndication - > u16VCID ) ) ;
CopyBufferToControlPacket ( Adapter , ( PVOID ) Adapter - > caDsxReqResp ) ;
kfree ( pstAddIndication ) ;
}
break ;
case DSA_RSP :
{
pLeader - > PLength = sizeof ( stLocalSFAddIndicationAlt ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SENDING DSA ACK TO MAC %d " ,
2010-09-08 21:46:36 +00:00
pLeader - > PLength ) ;
2012-01-05 01:29:00 +00:00
* ( ( stLocalSFAddIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) )
= * pstAddIndication ;
( ( stLocalSFAddIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) - > u8Type = DSA_ACK ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
} /* no break here..we should go down. */
case DSA_ACK :
{
UINT uiSearchRuleIndex = 0 ;
2010-11-01 15:39:05 +00:00
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " VCID:0x%X " ,
2010-09-08 21:46:36 +00:00
ntohs ( pstAddIndication - > u16VCID ) ) ;
2012-01-05 01:29:00 +00:00
uiSearchRuleIndex = SearchFreeSfid ( Adapter ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " uiSearchRuleIndex:0x%X " ,
2010-09-08 21:46:36 +00:00
uiSearchRuleIndex ) ;
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Direction:0x%X " ,
2010-09-08 21:46:36 +00:00
pstAddIndication - > u8Direction ) ;
2012-01-05 01:29:00 +00:00
if ( ( uiSearchRuleIndex < NO_OF_QUEUES ) ) {
Adapter - > PackInfo [ uiSearchRuleIndex ] . ucDirection =
pstAddIndication - > u8Direction ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " bValid:0x%X " ,
2010-09-08 21:46:36 +00:00
pstAddIndication - > sfActiveSet . bValid ) ;
2012-01-05 01:29:00 +00:00
if ( pstAddIndication - > sfActiveSet . bValid = = TRUE )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActiveSet = TRUE ;
if ( pstAddIndication - > sfAuthorizedSet . bValid = = TRUE )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bAuthorizedSet = TRUE ;
if ( pstAddIndication - > sfAdmittedSet . bValid = = TRUE )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bAdmittedSet = TRUE ;
2012-01-05 01:29:03 +00:00
if ( pstAddIndication - > sfActiveSet . bValid = = FALSE ) {
2012-01-05 01:29:00 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = FALSE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActivateRequestSent = FALSE ;
if ( pstAddIndication - > sfAdmittedSet . bValid )
psfLocalSet = & pstAddIndication - > sfAdmittedSet ;
else if ( pstAddIndication - > sfAuthorizedSet . bValid )
psfLocalSet = & pstAddIndication - > sfAuthorizedSet ;
} else {
psfLocalSet = & pstAddIndication - > sfActiveSet ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = TRUE ;
}
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( ! psfLocalSet ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " No set is valid \n " ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = FALSE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bValid = FALSE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value = 0 ;
kfree ( pstAddIndication ) ;
} else if ( psfLocalSet - > bValid & & ( pstAddIndication - > u8CC = = 0 ) ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " DSA ACK " ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value = ntohs ( pstAddIndication - > u16VCID ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . usCID = ntohs ( pstAddIndication - > u16CID ) ;
if ( UPLINK_DIR = = pstAddIndication - > u8Direction )
atomic_set ( & Adapter - > PackInfo [ uiSearchRuleIndex ] . uiPerSFTxResourceCount , DEFAULT_PERSFCOUNT ) ;
CopyToAdapter ( Adapter , psfLocalSet , uiSearchRuleIndex , DSA_ACK , pstAddIndication ) ;
/* don't free pstAddIndication */
/* Inside CopyToAdapter, Sorting of all the SFs take place.
* Hence any access to the newly added SF through uiSearchRuleIndex is invalid .
* SHOULD BE STRICTLY AVOIDED .
*/
/* *(PULONG)(((PUCHAR)pvBuffer)+1)=psfLocalSet->u32SFID; */
memcpy ( ( ( ( PUCHAR ) pvBuffer ) + 1 ) , & psfLocalSet - > u32SFID , 4 ) ;
if ( pstAddIndication - > sfActiveSet . bValid = = TRUE ) {
if ( UPLINK_DIR = = pstAddIndication - > u8Direction ) {
if ( ! Adapter - > LinkUpStatus ) {
netif_carrier_on ( Adapter - > dev ) ;
netif_start_queue ( Adapter - > dev ) ;
Adapter - > LinkUpStatus = 1 ;
if ( netif_msg_link ( Adapter ) )
pr_info ( PFX " %s: link up \n " , Adapter - > dev - > name ) ;
atomic_set ( & Adapter - > TxPktAvail , 1 ) ;
wake_up ( & Adapter - > tx_packet_wait_queue ) ;
Adapter - > liTimeSinceLastNetEntry = get_seconds ( ) ;
2010-09-08 21:46:36 +00:00
}
}
}
2012-01-05 01:29:00 +00:00
} else {
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = FALSE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bValid = FALSE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value = 0 ;
2010-11-01 13:35:21 +00:00
kfree ( pstAddIndication ) ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
} else {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " DSA ACK did not get valid SFID " ) ;
2010-11-01 13:35:21 +00:00
kfree ( pstAddIndication ) ;
2012-01-05 01:29:00 +00:00
return FALSE ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
}
break ;
case DSC_REQ :
{
pLeader - > PLength = sizeof ( stLocalSFChangeIndicationAlt ) ;
pstChangeIndication = ( stLocalSFChangeIndicationAlt * ) pstAddIndication ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SENDING DSC RESPONSE TO MAC %d " , pLeader - > PLength ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
* ( ( stLocalSFChangeIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) = * pstChangeIndication ;
( ( stLocalSFChangeIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) - > u8Type = DSC_RSP ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
CopyBufferToControlPacket ( Adapter , ( PVOID ) Adapter - > caDsxReqResp ) ;
kfree ( pstAddIndication ) ;
}
break ;
case DSC_RSP :
{
pLeader - > PLength = sizeof ( stLocalSFChangeIndicationAlt ) ;
pstChangeIndication = ( stLocalSFChangeIndicationAlt * ) pstAddIndication ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SENDING DSC ACK TO MAC %d " , pLeader - > PLength ) ;
* ( ( stLocalSFChangeIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) = * pstChangeIndication ;
( ( stLocalSFChangeIndicationAlt * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) - > u8Type = DSC_ACK ;
}
case DSC_ACK :
{
UINT uiSearchRuleIndex = 0 ;
pstChangeIndication = ( stLocalSFChangeIndicationAlt * ) pstAddIndication ;
uiSearchRuleIndex = SearchSfid ( Adapter , ntohl ( pstChangeIndication - > sfActiveSet . u32SFID ) ) ;
if ( uiSearchRuleIndex > NO_OF_QUEUES - 1 )
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " SF doesn't exist for which DSC_ACK is received " ) ;
if ( ( uiSearchRuleIndex < NO_OF_QUEUES ) ) {
Adapter - > PackInfo [ uiSearchRuleIndex ] . ucDirection = pstChangeIndication - > u8Direction ;
if ( pstChangeIndication - > sfActiveSet . bValid = = TRUE )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActiveSet = TRUE ;
if ( pstChangeIndication - > sfAuthorizedSet . bValid = = TRUE )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bAuthorizedSet = TRUE ;
if ( pstChangeIndication - > sfAdmittedSet . bValid = = TRUE )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bAdmittedSet = TRUE ;
2012-01-05 01:29:03 +00:00
if ( pstChangeIndication - > sfActiveSet . bValid = = FALSE ) {
2012-01-05 01:29:00 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = FALSE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActivateRequestSent = FALSE ;
if ( pstChangeIndication - > sfAdmittedSet . bValid )
psfLocalSet = & pstChangeIndication - > sfAdmittedSet ;
else if ( pstChangeIndication - > sfAuthorizedSet . bValid )
psfLocalSet = & pstChangeIndication - > sfAuthorizedSet ;
} else {
psfLocalSet = & pstChangeIndication - > sfActiveSet ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = TRUE ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
if ( psfLocalSet - > bValid & & ( pstChangeIndication - > u8CC = = 0 ) ) {
Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value = ntohs ( pstChangeIndication - > u16VCID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " CC field is %d bvalid = %d \n " ,
pstChangeIndication - > u8CC , psfLocalSet - > bValid ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " VCID= %d \n " , ntohs ( pstChangeIndication - > u16VCID ) ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . usCID = ntohs ( pstChangeIndication - > u16CID ) ;
CopyToAdapter ( Adapter , psfLocalSet , uiSearchRuleIndex , DSC_ACK , pstAddIndication ) ;
* ( PULONG ) ( ( ( PUCHAR ) pvBuffer ) + 1 ) = psfLocalSet - > u32SFID ;
} else if ( pstChangeIndication - > u8CC = = 6 ) {
deleteSFBySfid ( Adapter , uiSearchRuleIndex ) ;
2010-11-01 13:35:21 +00:00
kfree ( pstAddIndication ) ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
} else {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " DSC ACK did not get valid SFID " ) ;
kfree ( pstAddIndication ) ;
return FALSE ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
}
break ;
case DSD_REQ :
{
UINT uiSearchRuleIndex ;
ULONG ulSFID ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
pLeader - > PLength = sizeof ( stLocalSFDeleteIndication ) ;
* ( ( stLocalSFDeleteIndication * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) = * ( ( stLocalSFDeleteIndication * ) pstAddIndication ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
ulSFID = ntohl ( ( ( stLocalSFDeleteIndication * ) pstAddIndication ) - > u32SFID ) ;
uiSearchRuleIndex = SearchSfid ( Adapter , ulSFID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " DSD - Removing connection %x " , uiSearchRuleIndex ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( uiSearchRuleIndex < NO_OF_QUEUES ) {
/* Delete All Classifiers Associated with this SFID */
deleteSFBySfid ( Adapter , uiSearchRuleIndex ) ;
Adapter - > u32TotalDSD + + ;
2010-09-08 21:46:36 +00:00
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SENDING DSD RESPONSE TO MAC " ) ;
( ( stLocalSFDeleteIndication * ) & ( Adapter - > caDsxReqResp [ LEADER_SIZE ] ) ) - > u8Type = DSD_RSP ;
CopyBufferToControlPacket ( Adapter , ( PVOID ) Adapter - > caDsxReqResp ) ;
}
case DSD_RSP :
{
/* Do nothing as SF has already got Deleted */
}
break ;
2010-09-08 21:46:36 +00:00
case DSD_ACK :
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " DSD ACK Rcd, let App handle it \n " ) ;
break ;
2010-09-08 21:46:36 +00:00
default :
2010-11-01 13:35:21 +00:00
kfree ( pstAddIndication ) ;
2012-01-05 01:29:00 +00:00
return FALSE ;
2010-09-08 21:46:36 +00:00
}
return TRUE ;
}
2010-09-30 08:24:12 +00:00
int get_dsx_sf_data_to_application ( PMINI_ADAPTER Adapter , UINT uiSFId , void __user * user_buffer )
2010-09-08 21:46:36 +00:00
{
int status = 0 ;
2012-01-05 01:29:00 +00:00
struct _packet_info * psSfInfo = NULL ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " status =%d " , status ) ;
2010-09-08 21:46:36 +00:00
status = SearchSfid ( Adapter , uiSFId ) ;
2010-10-08 13:49:04 +00:00
if ( status > = NO_OF_QUEUES ) {
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SFID %d not present in queue !!! " , uiSFId ) ;
2010-09-08 21:46:36 +00:00
return - EINVAL ;
}
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " status =%d " , status ) ;
psSfInfo = & Adapter - > PackInfo [ status ] ;
if ( psSfInfo - > pstSFIndication & & copy_to_user ( user_buffer ,
psSfInfo - > pstSFIndication , sizeof ( stLocalSFAddIndicationAlt ) ) ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_PRINTK , 0 , 0 , " copy to user failed SFID %d, present in queue !!! " , uiSFId ) ;
2010-09-08 21:46:36 +00:00
status = - EFAULT ;
return status ;
}
return STATUS_SUCCESS ;
}
2012-01-05 01:29:00 +00:00
VOID OverrideServiceFlowParams ( PMINI_ADAPTER Adapter , PUINT puiBuffer )
2010-09-08 21:46:36 +00:00
{
2012-01-05 01:29:00 +00:00
B_UINT32 u32NumofSFsinMsg = ntohl ( * ( puiBuffer + 1 ) ) ;
2010-09-08 21:46:36 +00:00
stIM_SFHostNotify * pHostInfo = NULL ;
2012-01-05 01:29:00 +00:00
UINT uiSearchRuleIndex = 0 ;
ULONG ulSFID = 0 ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
puiBuffer + = 2 ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " u32NumofSFsinMsg: 0x%x \n " , u32NumofSFsinMsg ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
while ( u32NumofSFsinMsg ! = 0 & & u32NumofSFsinMsg < NO_OF_QUEUES ) {
2010-09-08 21:46:36 +00:00
u32NumofSFsinMsg - - ;
pHostInfo = ( stIM_SFHostNotify * ) puiBuffer ;
puiBuffer = ( PUINT ) ( pHostInfo + 1 ) ;
ulSFID = ntohl ( pHostInfo - > SFID ) ;
2012-01-05 01:29:00 +00:00
uiSearchRuleIndex = SearchSfid ( Adapter , ulSFID ) ;
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " SFID: 0x%lx \n " , ulSFID ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( uiSearchRuleIndex > = NO_OF_QUEUES | | uiSearchRuleIndex = = HiPriority ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " The SFID <%lx> doesn't exist in host entry or is Invalid \n " , ulSFID ) ;
2010-09-08 21:46:36 +00:00
continue ;
}
2012-01-05 01:29:00 +00:00
if ( pHostInfo - > RetainSF = = FALSE ) {
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " Going to Delete SF " ) ;
deleteSFBySfid ( Adapter , uiSearchRuleIndex ) ;
} else {
2010-09-08 21:46:36 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . usVCID_Value = ntohs ( pHostInfo - > VCID ) ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . usCID = ntohs ( pHostInfo - > newCID ) ;
2012-01-05 01:29:00 +00:00
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = FALSE ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
BCM_DEBUG_PRINT ( Adapter , DBG_TYPE_OTHERS , CONN_MSG , DBG_LVL_ALL , " pHostInfo->QoSParamSet: 0x%x \n " , pHostInfo - > QoSParamSet ) ;
2010-09-08 21:46:36 +00:00
2012-01-05 01:29:00 +00:00
if ( pHostInfo - > QoSParamSet & 0x1 )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bAuthorizedSet = TRUE ;
if ( pHostInfo - > QoSParamSet & 0x2 )
Adapter - > PackInfo [ uiSearchRuleIndex ] . bAdmittedSet = TRUE ;
if ( pHostInfo - > QoSParamSet & 0x4 ) {
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActiveSet = TRUE ;
Adapter - > PackInfo [ uiSearchRuleIndex ] . bActive = TRUE ;
2010-09-08 21:46:36 +00:00
}
}
}
}