path: root/drivers/staging/bcm/CmHost.c

/************************************************************
 * CMHOST.C
 * This file contains the routines for handling Connection
 * Management.
 ************************************************************/

#include "headers.h"

enum E_CLASSIFIER_ACTION {
	eInvalidClassifierAction,
	eAddClassifier,
	eReplaceClassifier,
	eDeleteClassifier
};

static ULONG GetNextTargetBufferLocation(struct bcm_mini_adapter *Adapter,
		B_UINT16 tid);
static void restore_endianess_of_pstClassifierEntry(
		struct bcm_classifier_rule *pstClassifierEntry,
		enum bcm_ipaddr_context eIpAddrContext);

static void apply_phs_rule_to_all_classifiers(
		register struct bcm_mini_adapter *Adapter,
		register UINT uiSearchRuleIndex,
		USHORT uVCID,
		struct bcm_phs_rule *sPhsRule,
		struct bcm_phs_rules *cPhsRule,
		struct bcm_add_indication_alt *pstAddIndication);

/************************************************************
 * 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(struct bcm_mini_adapter *Adapter, UINT uiSfid)
{
	int i;

	for (i = (NO_OF_QUEUES-1); i >= 0; i--)
		if (Adapter->PackInfo[i].ulSFID == uiSfid)
			return i;

	return NO_OF_QUEUES+1;
}

/***************************************************************
 * 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.
 ****************************************************************/
static int SearchFreeSfid(struct bcm_mini_adapter *Adapter)
{
	int i;

	for (i = 0; i < (NO_OF_QUEUES-1); i++)
		if (Adapter->PackInfo[i].ulSFID == 0)
			return i;

	return NO_OF_QUEUES+1;
}

/*
 * Function: SearchClsid
 * Description:	This routinue would search Classifier  having specified ClassifierID as input parameter
 * Input parameters: struct bcm_mini_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(struct bcm_mini_adapter *Adapter,
		ULONG ulSFID,
		B_UINT16 uiClassifierID)
{
	int i;

	for (i = 0; i < MAX_CLASSIFIERS; i++) {
		if ((Adapter->astClassifierTable[i].bUsed) &&
			(Adapter->astClassifierTable[i].uiClassifierRuleIndex
				== uiClassifierID) &&
			(Adapter->astClassifierTable[i].ulSFID == ulSFID))
			return i;
	}

	return MAX_CLASSIFIERS+1;
}

/*
 * @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(struct bcm_mini_adapter *Adapter /**Adapter Context*/)
{
	int i;

	for (i = 0; i < MAX_CLASSIFIERS; i++) {
		if (!Adapter->astClassifierTable[i].bUsed)
			return i;
	}

	return MAX_CLASSIFIERS+1;
}

static VOID deleteSFBySfid(struct bcm_mini_adapter *Adapter,
		UINT uiSearchRuleIndex)
{
	/* deleting all the packet held in the SF */
	flush_queue(Adapter, uiSearchRuleIndex);

	/* Deleting the all classifiers for this SF */
	DeleteAllClassifiersForSF(Adapter, uiSearchRuleIndex);

	/* Resetting only MIBS related entries in the SF */
	memset((PVOID)&Adapter->PackInfo[uiSearchRuleIndex], 0,
			sizeof(struct bcm_mibs_table));
}

static inline VOID
CopyIpAddrToClassifier(struct bcm_classifier_rule *pstClassifierEntry,
		B_UINT8 u8IpAddressLen, B_UINT8 *pu8IpAddressMaskSrc,
		bool bIpVersion6, enum bcm_ipaddr_context eIpAddrContext)
{
	int i = 0;
	UINT nSizeOfIPAddressInBytes = IP_LENGTH_OF_ADDRESS;
	UCHAR *ptrClassifierIpAddress = NULL;
	UCHAR *ptrClassifierIpMask = NULL;
	struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);

	if (bIpVersion6)
		nSizeOfIPAddressInBytes = IPV6_ADDRESS_SIZEINBYTES;

	/* 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) {

		union u_ip_address *st_dest_ip =
			&pstClassifierEntry->stDestIpAddress;

		union u_ip_address *st_src_ip =
			&pstClassifierEntry->stSrcIpAddress;

		/*
		 * 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 =
					st_dest_ip->ucIpv6Address;
				ptrClassifierIpMask =
					st_dest_ip->ucIpv6Mask;
			} else {
				ptrClassifierIpAddress =
					st_dest_ip->ucIpv4Address;
				ptrClassifierIpMask =
					st_dest_ip->ucIpv4Mask;
			}
		} else if (eIpAddrContext == eSrcIpAddress) {
			pstClassifierEntry->ucIPSourceAddressLength =
				u8IpAddressLen/(nSizeOfIPAddressInBytes * 2);
			if (bIpVersion6) {
				ptrClassifierIpAddress =
					st_src_ip->ucIpv6Address;
				ptrClassifierIpMask = st_src_ip->ucIpv6Mask;
			} else {
				ptrClassifierIpAddress =
					st_src_ip->ucIpv4Address;
				ptrClassifierIpMask = st_src_ip->ucIpv4Mask;
			}
		}
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Address Length:0x%X\n",
				pstClassifierEntry->ucIPDestinationAddressLength);
		while ((u8IpAddressLen >= nSizeOfIPAddressInBytes)
				&& (i < MAX_IP_RANGE_LENGTH)) {
			memcpy(ptrClassifierIpAddress +
				(i * nSizeOfIPAddressInBytes),
				(pu8IpAddressMaskSrc
					+ (i * nSizeOfIPAddressInBytes * 2)),
				nSizeOfIPAddressInBytes);

			if (!bIpVersion6) {
				if (eIpAddrContext == eSrcIpAddress) {
					st_src_ip->ulIpv4Addr[i] =
						ntohl(st_src_ip->ulIpv4Addr[i]);
					BCM_DEBUG_PRINT(Adapter,
							DBG_TYPE_OTHERS,
							CONN_MSG,
							DBG_LVL_ALL,
							"Src Ip Address:0x%luX ",
							st_src_ip->ulIpv4Addr[i]);
				} else if (eIpAddrContext == eDestIpAddress) {
					st_dest_ip->ulIpv4Addr[i] =
						ntohl(st_dest_ip->ulIpv4Addr[i]);
					BCM_DEBUG_PRINT(Adapter,
							DBG_TYPE_OTHERS,
							CONN_MSG,
							DBG_LVL_ALL,
							"Dest Ip Address:0x%luX ",
							st_dest_ip->ulIpv4Addr[i]);
				}
			}
			u8IpAddressLen -= nSizeOfIPAddressInBytes;
			if (u8IpAddressLen >= nSizeOfIPAddressInBytes) {
				memcpy(ptrClassifierIpMask +
					(i * nSizeOfIPAddressInBytes),
					(pu8IpAddressMaskSrc
						+ nSizeOfIPAddressInBytes
						+ (i * nSizeOfIPAddressInBytes * 2)),
					nSizeOfIPAddressInBytes);

				if (!bIpVersion6) {
					if (eIpAddrContext == eSrcIpAddress) {
						st_src_ip->ulIpv4Mask[i] =
							ntohl(st_src_ip->ulIpv4Mask[i]);
						BCM_DEBUG_PRINT(Adapter,
								DBG_TYPE_OTHERS,
								CONN_MSG,
								DBG_LVL_ALL,
								"Src Ip Mask Address:0x%luX ",
								st_src_ip->ulIpv4Mask[i]);
					} else if (eIpAddrContext == eDestIpAddress) {
						st_dest_ip->ulIpv4Mask[i] =
							ntohl(st_dest_ip->ulIpv4Mask[i]);
						BCM_DEBUG_PRINT(Adapter,
								DBG_TYPE_OTHERS,
								CONN_MSG,
								DBG_LVL_ALL,
								"Dest Ip Mask Address:0x%luX ",
								st_dest_ip->ulIpv4Mask[i]);
					}
				}
				u8IpAddressLen -= nSizeOfIPAddressInBytes;
			}
			if (u8IpAddressLen == 0)
				pstClassifierEntry->bDestIpValid = TRUE;

			i++;
		}
		if (bIpVersion6) {
			/* Restore EndianNess of Struct */
			restore_endianess_of_pstClassifierEntry(
					pstClassifierEntry,
					eIpAddrContext
					);
		}
	}
}

void ClearTargetDSXBuffer(struct bcm_mini_adapter *Adapter, B_UINT16 TID, bool bFreeAll)
{
	int i;
	struct bcm_targetdsx_buffer *curr_buf;

	for (i = 0; i < Adapter->ulTotalTargetBuffersAvailable; i++) {
		curr_buf = &Adapter->astTargetDsxBuffer[i];

		if (curr_buf->valid)
			continue;

		if ((bFreeAll) || (curr_buf->tid == TID)) {
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
					"ClearTargetDSXBuffer: found tid %d buffer cleared %lx\n",
					TID, curr_buf->ulTargetDsxBuffer);
			curr_buf->valid = 1;
			curr_buf->tid = 0;
			Adapter->ulFreeTargetBufferCnt++;
		}
	}
}

/*
 * @ingroup ctrl_pkt_functions
 * copy classifier rule into the specified SF index
 */
static inline VOID CopyClassifierRuleToSF(struct bcm_mini_adapter *Adapter,
		struct bcm_convergence_types *psfCSType,
		UINT uiSearchRuleIndex,
		UINT nClassifierIndex)
{
	struct bcm_classifier_rule *pstClassifierEntry = NULL;
	/* VOID *pvPhsContext = NULL; */
	int i;
	/* UCHAR ucProtocolLength=0; */
	/* ULONG ulPhsStatus; */

	struct bcm_packet_class_rules *pack_class_rule =
		&psfCSType->cCPacketClassificationRule;

	if (Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value == 0 ||
		nClassifierIndex > (MAX_CLASSIFIERS-1))
		return;

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"Storing Classifier Rule Index : %X",
			ntohs(pack_class_rule->u16PacketClassificationRuleIndex));

	if (nClassifierIndex > MAX_CLASSIFIERS-1)
		return;

	pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
	if (pstClassifierEntry) {
		/* Store if Ipv6 */
		pstClassifierEntry->bIpv6Protocol =
			(Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6) ? TRUE : false;

		/* Destinaiton Port */
		pstClassifierEntry->ucDestPortRangeLength =
			pack_class_rule->u8ProtocolDestPortRangeLength / 4;
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Destination Port Range Length:0x%X ",
				pstClassifierEntry->ucDestPortRangeLength);

		if (pack_class_rule->u8ProtocolDestPortRangeLength <= MAX_PORT_RANGE) {
			for (i = 0; i < (pstClassifierEntry->ucDestPortRangeLength); i++) {
				pstClassifierEntry->usDestPortRangeLo[i] =
					*((PUSHORT)(pack_class_rule->u8ProtocolDestPortRange+i));
				pstClassifierEntry->usDestPortRangeHi[i] =
					*((PUSHORT)(pack_class_rule->u8ProtocolDestPortRange+2+i));
				pstClassifierEntry->usDestPortRangeLo[i] =
					ntohs(pstClassifierEntry->usDestPortRangeLo[i]);
				BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS,
						CONN_MSG, DBG_LVL_ALL,
						"Destination Port Range Lo:0x%X ",
						pstClassifierEntry->usDestPortRangeLo[i]);
				pstClassifierEntry->usDestPortRangeHi[i] =
					ntohs(pstClassifierEntry->usDestPortRangeHi[i]);
			}
		} else {
			pstClassifierEntry->ucDestPortRangeLength = 0;
		}

		/* Source Port */
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Source Port Range Length:0x%X ",
				pack_class_rule->u8ProtocolSourcePortRangeLength);
		if (pack_class_rule->u8ProtocolSourcePortRangeLength <= MAX_PORT_RANGE) {
			pstClassifierEntry->ucSrcPortRangeLength =
				pack_class_rule->u8ProtocolSourcePortRangeLength/4;
			for (i = 0; i < (pstClassifierEntry->ucSrcPortRangeLength); i++) {
				pstClassifierEntry->usSrcPortRangeLo[i] =
					*((PUSHORT)(pack_class_rule->
							u8ProtocolSourcePortRange+i));
				pstClassifierEntry->usSrcPortRangeHi[i] =
					*((PUSHORT)(pack_class_rule->
							u8ProtocolSourcePortRange+2+i));
				pstClassifierEntry->usSrcPortRangeLo[i] =
					ntohs(pstClassifierEntry->usSrcPortRangeLo[i]);
				BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS,
						CONN_MSG, DBG_LVL_ALL,
						"Source Port Range Lo:0x%X ",
						pstClassifierEntry->usSrcPortRangeLo[i]);
				pstClassifierEntry->usSrcPortRangeHi[i] =
					ntohs(pstClassifierEntry->usSrcPortRangeHi[i]);
			}
		}
		/* Destination Ip Address and Mask */
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Ip Destination Parameters : ");
		CopyIpAddrToClassifier(pstClassifierEntry,
				pack_class_rule->u8IPDestinationAddressLength,
				pack_class_rule->u8IPDestinationAddress,
				(Adapter->PackInfo[uiSearchRuleIndex].ucIpVersion == IPV6) ?
			TRUE : false, eDestIpAddress);

		/* Source Ip Address and Mask */
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Ip Source Parameters : ");

		CopyIpAddrToClassifier(pstClassifierEntry,
				pack_class_rule->u8IPMaskedSourceAddressLength,
				pack_class_rule->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 ",
				pack_class_rule->u8IPTypeOfServiceLength);
		if (pack_class_rule->u8IPTypeOfServiceLength == 3) {
			pstClassifierEntry->ucIPTypeOfServiceLength =
				pack_class_rule->u8IPTypeOfServiceLength;
			pstClassifierEntry->ucTosLow =
				pack_class_rule->u8IPTypeOfService[0];
			pstClassifierEntry->ucTosHigh =
				pack_class_rule->u8IPTypeOfService[1];
			pstClassifierEntry->ucTosMask =
				pack_class_rule->u8IPTypeOfService[2];
			pstClassifierEntry->bTOSValid = TRUE;
		}
		if (pack_class_rule->u8Protocol == 0) {
			/* we didn't get protocol field filled in by the BS */
			pstClassifierEntry->ucProtocolLength = 0;
		} else {
			pstClassifierEntry->ucProtocolLength = 1; /* 1 valid protocol */
		}

		pstClassifierEntry->ucProtocol[0] = pack_class_rule->u8Protocol;
		pstClassifierEntry->u8ClassifierRulePriority =
			pack_class_rule->u8ClassifierRulePriority;

		/* store the classifier rule ID and set this classifier entry as valid */
		pstClassifierEntry->ucDirection =
			Adapter->PackInfo[uiSearchRuleIndex].ucDirection;
		pstClassifierEntry->uiClassifierRuleIndex =
			ntohs(pack_class_rule->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 (pack_class_rule->u8AssociatedPHSI)
			pstClassifierEntry->u8AssociatedPHSI =
				pack_class_rule->u8AssociatedPHSI;

		/* Copy ETH CS Parameters */
		pstClassifierEntry->ucEthCSSrcMACLen =
			(pack_class_rule->u8EthernetSourceMACAddressLength);
		memcpy(pstClassifierEntry->au8EThCSSrcMAC,
				pack_class_rule->u8EthernetSourceMACAddress,
				MAC_ADDRESS_SIZE);
		memcpy(pstClassifierEntry->au8EThCSSrcMACMask,
				pack_class_rule->u8EthernetSourceMACAddress
				+ MAC_ADDRESS_SIZE, MAC_ADDRESS_SIZE);
		pstClassifierEntry->ucEthCSDestMACLen =
			(pack_class_rule->u8EthernetDestMacAddressLength);
		memcpy(pstClassifierEntry->au8EThCSDestMAC,
				pack_class_rule->u8EthernetDestMacAddress,
				MAC_ADDRESS_SIZE);
		memcpy(pstClassifierEntry->au8EThCSDestMACMask,
				pack_class_rule->u8EthernetDestMacAddress
				+ MAC_ADDRESS_SIZE, MAC_ADDRESS_SIZE);
		pstClassifierEntry->ucEtherTypeLen =
			(pack_class_rule->u8EthertypeLength);
		memcpy(pstClassifierEntry->au8EthCSEtherType,
				pack_class_rule->u8Ethertype,
				NUM_ETHERTYPE_BYTES);
		memcpy(pstClassifierEntry->usUserPriority,
				&pack_class_rule->u16UserPriority, 2);
		pstClassifierEntry->usVLANID =
			ntohs(pack_class_rule->u16VLANID);
		pstClassifierEntry->usValidityBitMap =
			ntohs(pack_class_rule->u16ValidityBitMap);

		pstClassifierEntry->bUsed = TRUE;
	}
}

/*
 * @ingroup ctrl_pkt_functions
 */
static inline VOID DeleteClassifierRuleFromSF(struct bcm_mini_adapter *Adapter,
		UINT uiSearchRuleIndex, UINT nClassifierIndex)
{
	struct bcm_classifier_rule *pstClassifierEntry = NULL;
	B_UINT16 u16PacketClassificationRuleIndex;
	USHORT usVCID;
	/* VOID *pvPhsContext = NULL; */
	/*ULONG ulPhsStatus; */

	usVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;

	if (nClassifierIndex > MAX_CLASSIFIERS-1)
		return;

	if (usVCID == 0)
		return;

	u16PacketClassificationRuleIndex =
		Adapter->astClassifierTable[nClassifierIndex].uiClassifierRuleIndex;
	pstClassifierEntry = &Adapter->astClassifierTable[nClassifierIndex];
	if (pstClassifierEntry) {
		pstClassifierEntry->bUsed = false;
		pstClassifierEntry->uiClassifierRuleIndex = 0;
		memset(pstClassifierEntry, 0,
				sizeof(struct bcm_classifier_rule));

		/* Delete the PHS Rule for this classifier */
		PhsDeleteClassifierRule(&Adapter->stBCMPhsContext, usVCID,
				u16PacketClassificationRuleIndex);
	}
}

/*
 * @ingroup ctrl_pkt_functions
 */
VOID DeleteAllClassifiersForSF(struct bcm_mini_adapter *Adapter,
		UINT uiSearchRuleIndex)
{
	struct bcm_classifier_rule *pstClassifierEntry = NULL;
	int i;
	/* B_UINT16  u16PacketClassificationRuleIndex; */
	USHORT ulVCID;
	/* VOID *pvPhsContext = NULL; */
	/* ULONG ulPhsStatus; */

	ulVCID = Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value;

	if (ulVCID == 0)
		return;

	for (i = 0; i < MAX_CLASSIFIERS; i++) {
		if (Adapter->astClassifierTable[i].usVCID_Value == ulVCID) {
			pstClassifierEntry = &Adapter->astClassifierTable[i];

			if (pstClassifierEntry->bUsed)
				DeleteClassifierRuleFromSF(Adapter,
						uiSearchRuleIndex, i);
		}
	}

	/* Delete All Phs Rules Associated with this SF */
	PhsDeleteSFRules(&Adapter->stBCMPhsContext, ulVCID);
}

/*
 * This routinue  copies the Connection Management
 * related data into the Adapter structure.
 * @ingroup ctrl_pkt_functions
 */
static VOID CopyToAdapter(register struct bcm_mini_adapter *Adapter, /* <Pointer to the Adapter structure */
			register struct bcm_connect_mgr_params *psfLocalSet, /* Pointer to the connection manager parameters structure */
			register UINT uiSearchRuleIndex, /* <Index of Queue, to which this data belongs */
			register UCHAR ucDsxType,
			struct bcm_add_indication_alt *pstAddIndication) {

	/* UCHAR ucProtocolLength = 0; */
	ULONG ulSFID;
	UINT nClassifierIndex = 0;
	enum E_CLASSIFIER_ACTION eClassifierAction = eInvalidClassifierAction;
	B_UINT16 u16PacketClassificationRuleIndex = 0;
	int i;
	struct bcm_convergence_types *psfCSType = NULL;
	struct bcm_phs_rule sPhsRule;
	struct bcm_packet_info *curr_packinfo =
		&Adapter->PackInfo[uiSearchRuleIndex];
	USHORT uVCID = curr_packinfo->usVCID_Value;
	UINT UGIValue = 0;

	curr_packinfo->bValid = TRUE;
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"Search Rule Index = %d\n", uiSearchRuleIndex);
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"%s: SFID= %x ", __func__, ntohl(psfLocalSet->u32SFID));
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"Updating Queue %d", uiSearchRuleIndex);

	ulSFID = ntohl(psfLocalSet->u32SFID);
	/* Store IP Version used */
	/* Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF */

	curr_packinfo->bIPCSSupport = 0;
	curr_packinfo->bEthCSSupport = 0;

	/* 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:
		curr_packinfo->bIPCSSupport = IPV4_CS;
		break;
	case eCSPacketIPV6:
		curr_packinfo->bIPCSSupport = IPV6_CS;
		break;
	case eCS802_3PacketEthernet:
	case eCS802_1QPacketVLAN:
		curr_packinfo->bEthCSSupport = ETH_CS_802_3;
		break;
	case eCSPacketIPV4Over802_1QVLAN:
	case eCSPacketIPV4Over802_3Ethernet:
		curr_packinfo->bIPCSSupport = IPV4_CS;
		curr_packinfo->bEthCSSupport = ETH_CS_802_3;
		break;
	case eCSPacketIPV6Over802_1QVLAN:
	case eCSPacketIPV6Over802_3Ethernet:
		curr_packinfo->bIPCSSupport = IPV6_CS;
		curr_packinfo->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");
		curr_packinfo->bIPCSSupport = IPV4_CS;
		break;
	}

	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,
			curr_packinfo->bEthCSSupport,
			curr_packinfo->bIPCSSupport);

	/* Store IP Version used */
	/* Get The Version Of IP used (IPv6 or IPv4) from CSSpecification field of SF */
	if (curr_packinfo->bIPCSSupport == IPV6_CS)
		curr_packinfo->ucIpVersion = IPV6;
	else
		curr_packinfo->ucIpVersion = IPV4;

	/* To ensure that the ETH CS code doesn't gets executed if the BS doesn't supports ETH CS */
	if (!Adapter->bETHCSEnabled)
		curr_packinfo->bEthCSSupport = 0;

	if (psfLocalSet->u8ServiceClassNameLength > 0 && psfLocalSet->u8ServiceClassNameLength < 32)
		memcpy(curr_packinfo->ucServiceClassName,
				psfLocalSet->u8ServiceClassName,
				psfLocalSet->u8ServiceClassNameLength);

	curr_packinfo->u8QueueType = psfLocalSet->u8ServiceFlowSchedulingType;

	if (curr_packinfo->u8QueueType == BE && curr_packinfo->ucDirection)
		Adapter->usBestEffortQueueIndex = uiSearchRuleIndex;

	curr_packinfo->ulSFID = ntohl(psfLocalSet->u32SFID);

	curr_packinfo->u8TrafficPriority = psfLocalSet->u8TrafficPriority;

	/* copy all the classifier in the Service Flow param  structure */
	for (i = 0; i < psfLocalSet->u8TotalClassifiers; i++) {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Classifier index =%d", i);
		psfCSType = &psfLocalSet->cConvergenceSLTypes[i];
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Classifier index =%d", i);

		if (psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority)
			curr_packinfo->bClassifierPriority = TRUE;

		if (psfCSType->cCPacketClassificationRule.u8ClassifierRulePriority)
			curr_packinfo->bClassifierPriority = TRUE;

		if (ucDsxType == DSA_ACK) {
			eClassifierAction = eAddClassifier;
		} else if (ucDsxType == DSC_ACK) {
			switch (psfCSType->u8ClassfierDSCAction) {
			case 0: /* DSC Add Classifier */
				eClassifierAction = eAddClassifier;
				break;
			case 1: /* DSC Replace Classifier */
				eClassifierAction = eReplaceClassifier;
				break;
			case 2: /* DSC Delete Classifier */
				eClassifierAction = eDeleteClassifier;
				break;
			default:
				eClassifierAction = eInvalidClassifierAction;
			}
		}

		u16PacketClassificationRuleIndex = ntohs(psfCSType->cCPacketClassificationRule.u16PacketClassificationRuleIndex);

		switch (eClassifierAction) {
		case eAddClassifier:
			/* Get a Free Classifier Index From Classifier table for this SF to add the Classifier */
			/* Contained in this message */
			nClassifierIndex = SearchClsid(Adapter,
					ulSFID,
					u16PacketClassificationRuleIndex);

			if (nClassifierIndex > MAX_CLASSIFIERS) {
				nClassifierIndex = SearchFreeClsid(Adapter);
				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");
					break;
				}
				/* 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);
			}
			break;
		case eReplaceClassifier:
			/* 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");
				break;
			}
			/* Copy the Classifier Rule for this service flow into our Classifier table maintained per SF. */
			CopyClassifierRuleToSF(Adapter, psfCSType,
					uiSearchRuleIndex, nClassifierIndex);
			break;
		case eDeleteClassifier:
			/* 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");
				break;
			}

			/* Delete This classifier */
			DeleteClassifierRuleFromSF(Adapter, uiSearchRuleIndex,
					nClassifierIndex);
			break;
		default:
			/* Invalid Action for classifier */
			break;
		}
	}

	/* Repeat parsing Classification Entries to process PHS Rules */
	for (i = 0; i < psfLocalSet->u8TotalClassifiers; i++) {
		psfCSType = &psfLocalSet->cConvergenceSLTypes[i];
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"psfCSType->u8PhsDSCAction : 0x%x\n",
				psfCSType->u8PhsDSCAction);

		switch (psfCSType->u8PhsDSCAction) {
		case eDeleteAllPHSRules:
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG,
					DBG_LVL_ALL,
					"Deleting All PHS Rules For VCID: 0x%X\n",
					uVCID);

			/* Delete All the PHS rules for this Service flow */
			PhsDeleteSFRules(&Adapter->stBCMPhsContext, uVCID);
			break;
		case eDeletePHSRule:
			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);

			break;
		default:
			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 */
			}
		/* Proceed To Add PHS rule for DSA_ACK case even if PHS DSC action is unspecified */
		/* No Break Here . Intentionally! */

		case eAddPHSRule:
		case eSetPHSRule:
			if (psfCSType->cPhsRule.u8PHSI)	{
				/* Apply This PHS Rule to all classifiers whose Associated PHSI Match */
				apply_phs_rule_to_all_classifiers(Adapter,
						uiSearchRuleIndex,
						uVCID,
						&sPhsRule,
						&psfCSType->cPhsRule,
						pstAddIndication);
			}
			break;
		}
	}

	if (psfLocalSet->u32MaxSustainedTrafficRate == 0) {
		/* No Rate Limit . Set Max Sustained Traffic Rate to Maximum */
		curr_packinfo->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 */
		curr_packinfo->uiMaxAllowedRate = WIMAX_MAX_ALLOWED_RATE;
	} else {
		curr_packinfo->uiMaxAllowedRate =
			ntohl(psfLocalSet->u32MaxSustainedTrafficRate);
	}

	curr_packinfo->uiMaxLatency = ntohl(psfLocalSet->u32MaximumLatency);
	if (curr_packinfo->uiMaxLatency == 0) /* 0 should be treated as infinite */
		curr_packinfo->uiMaxLatency = MAX_LATENCY_ALLOWED;

	if ((curr_packinfo->u8QueueType == ERTPS ||
			curr_packinfo->u8QueueType == UGS))
		UGIValue = ntohs(psfLocalSet->u16UnsolicitedGrantInterval);

	if (UGIValue == 0)
		UGIValue = DEFAULT_UG_INTERVAL;

	/*
	 * 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...
	 */
	curr_packinfo->uiMaxBucketSize =
		(DEFAULT_UGI_FACTOR*curr_packinfo->uiMaxAllowedRate*UGIValue)/1000;

	if (curr_packinfo->uiMaxBucketSize < WIMAX_MAX_MTU*8) {
		UINT UGIFactor = 0;
		/* Special Handling to ensure the biggest size of packet can go out from host to FW as follows:
		 * 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
		 */
		UGIFactor = (curr_packinfo->uiMaxLatency/UGIValue + 1);

		if (UGIFactor > DEFAULT_UGI_FACTOR)
			curr_packinfo->uiMaxBucketSize =
				(UGIFactor*curr_packinfo->uiMaxAllowedRate*UGIValue)/1000;

		if (curr_packinfo->uiMaxBucketSize > WIMAX_MAX_MTU*8)
			curr_packinfo->uiMaxBucketSize = WIMAX_MAX_MTU*8;
	}

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"LAT: %d, UGI: %d\n", curr_packinfo->uiMaxLatency,
			UGIValue);
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"uiMaxAllowedRate: 0x%x, u32MaxSustainedTrafficRate: 0x%x ,uiMaxBucketSize: 0x%x",
			curr_packinfo->uiMaxAllowedRate,
			ntohl(psfLocalSet->u32MaxSustainedTrafficRate),
			curr_packinfo->uiMaxBucketSize);

	/* copy the extended SF Parameters to Support MIBS */
	CopyMIBSExtendedSFParameters(Adapter, psfLocalSet, uiSearchRuleIndex);

	/* store header suppression enabled flag per SF */
	curr_packinfo->bHeaderSuppressionEnabled =
		!(psfLocalSet->u8RequesttransmissionPolicy &
			MASK_DISABLE_HEADER_SUPPRESSION);

	kfree(curr_packinfo->pstSFIndication);
	curr_packinfo->pstSFIndication = pstAddIndication;

	/* Re Sort the SF list in PackInfo according to Traffic Priority */
	SortPackInfo(Adapter);

	/* Re Sort the Classifier Rules table and re - arrange
	 * according to Classifier Rule Priority
	 */
	SortClassifiers(Adapter);
	DumpPhsRules(&Adapter->stBCMPhsContext);
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"%s <=====", __func__);
}

/***********************************************************************
 * 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
 *************************************************************************/
static VOID DumpCmControlPacket(PVOID pvBuffer)
{
	int uiLoopIndex;
	int nIndex;
	struct bcm_add_indication_alt *pstAddIndication;
	UINT nCurClassifierCnt;
	struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);

	pstAddIndication = pvBuffer;
	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",
			pstAddIndication->sfAuthorizedSet.u8ServiceClassName[0],
			pstAddIndication->sfAuthorizedSet.u8ServiceClassName[1],
			pstAddIndication->sfAuthorizedSet.u8ServiceClassName[2],
			pstAddIndication->sfAuthorizedSet.u8ServiceClassName[3],
			pstAddIndication->sfAuthorizedSet.u8ServiceClassName[4],
			pstAddIndication->sfAuthorizedSet.u8ServiceClassName[5]);

	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,
			&pstAddIndication->sfAuthorizedSet.u32MaxSustainedTrafficRate);
	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);

	nCurClassifierCnt = pstAddIndication->sfAuthorizedSet.u8TotalClassifiers;
	if (nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
		nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;

	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++) {
		struct bcm_convergence_types *psfCSType = NULL;

		psfCSType =  &pstAddIndication->sfAuthorizedSet.cConvergenceSLTypes[nIndex];

		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]: %pM",
				psfCSType->cCPacketClassificationRule.
						u8EthernetDestMacAddress);

		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]: %pM",
				psfCSType->cCPacketClassificationRule.
						u8EthernetSourceMACAddress);

		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]);
#ifdef VERSION_D5
		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%*ph ",
				6, psfCSType->cCPacketClassificationRule.
					      u8IPv6FlowLable);
#endif
	}

	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%*ph",
			6, pstAddIndication->sfAdmittedSet.u8ServiceClassName);

	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);

	nCurClassifierCnt = pstAddIndication->sfAdmittedSet.u8TotalClassifiers;
	if (nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
		nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;

	for (nIndex = 0; nIndex < nCurClassifierCnt; nIndex++) {
		struct bcm_convergence_types *psfCSType = NULL;

		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%*ph",
				3, psfCSType->cCPacketClassificationRule.
					      u8IPTypeOfService);
		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%*ph ",
				4, psfCSType->cCPacketClassificationRule.
						u8ProtocolSourcePortRange);

		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%*ph ",
				4, psfCSType->cCPacketClassificationRule.
						u8ProtocolDestPortRange);

		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]: %pM",
				psfCSType->cCPacketClassificationRule.
						u8EthernetDestMacAddress);

		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]: %pM",
				psfCSType->cCPacketClassificationRule.
						u8EthernetSourceMACAddress);

		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%*ph",
				3, psfCSType->cCPacketClassificationRule.
					      u8Ethertype);

		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]);
#ifdef VERSION_D5
		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%*ph ",
				6, psfCSType->cCPacketClassificationRule.
					      u8IPv6FlowLable);
#endif
	}

	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%*ph",
			6, pstAddIndication->sfActiveSet.u8ServiceClassName);

	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);

	nCurClassifierCnt = pstAddIndication->sfActiveSet.u8TotalClassifiers;
	if (nCurClassifierCnt > MAX_CLASSIFIERS_IN_SF)
		nCurClassifierCnt = MAX_CLASSIFIERS_IN_SF;

	for (nIndex = 0; nIndex < nCurClassifierCnt; nIndex++)	{
		struct bcm_convergence_types *psfCSType = NULL;
		struct bcm_packet_class_rules *clsRule = NULL;

		psfCSType = &pstAddIndication->sfActiveSet.cConvergenceSLTypes[nIndex];
		clsRule	= &psfCSType->cCPacketClassificationRule;

		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 ",
				clsRule->u8ClassifierRulePriority);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL, " u8IPTypeOfServiceLength: 0x%X ",
				clsRule->u8IPTypeOfServiceLength);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8IPTypeOfService[3]: 0x%X ,0x%X ,0x%X ",
				clsRule->u8IPTypeOfService[0],
				clsRule->u8IPTypeOfService[1],
				clsRule->u8IPTypeOfService[2]);

		for (uiLoopIndex = 0; uiLoopIndex < 1; uiLoopIndex++)
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
					DBG_LVL_ALL,
					" u8Protocol: 0x%X ",
					clsRule->u8Protocol);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				"u8IPMaskedSourceAddressLength: 0x%X ",
				clsRule->u8IPMaskedSourceAddressLength);

		for (uiLoopIndex = 0; uiLoopIndex < 32; uiLoopIndex++)
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
					DBG_LVL_ALL,
					"u8IPMaskedSourceAddress[32]: 0x%X ",
					clsRule->u8IPMaskedSourceAddress[uiLoopIndex]);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				"u8IPDestinationAddressLength: 0x%02X ",
				clsRule->u8IPDestinationAddressLength);

		for (uiLoopIndex = 0; uiLoopIndex < 32; uiLoopIndex++)
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
					DBG_LVL_ALL,
					" u8IPDestinationAddress[32]:0x%X ",
					clsRule->u8IPDestinationAddress[uiLoopIndex]);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8ProtocolSourcePortRangeLength: 0x%X ",
				clsRule->u8ProtocolSourcePortRangeLength);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8ProtocolSourcePortRange[4]: 0x%X ,0x%X ,0x%X ,0x%X ",
				clsRule->u8ProtocolSourcePortRange[0],
				clsRule->u8ProtocolSourcePortRange[1],
				clsRule->u8ProtocolSourcePortRange[2],
				clsRule->u8ProtocolSourcePortRange[3]);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8ProtocolDestPortRangeLength: 0x%X ",
				clsRule->u8ProtocolDestPortRangeLength);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8ProtocolDestPortRange[4]: 0x%X ,0x%X ,0x%X ,0x%X ",
				clsRule->u8ProtocolDestPortRange[0],
				clsRule->u8ProtocolDestPortRange[1],
				clsRule->u8ProtocolDestPortRange[2],
				clsRule->u8ProtocolDestPortRange[3]);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8EthernetDestMacAddressLength: 0x%X ",
				clsRule->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",
				clsRule->u8EthernetDestMacAddress[0],
				clsRule->u8EthernetDestMacAddress[1],
				clsRule->u8EthernetDestMacAddress[2],
				clsRule->u8EthernetDestMacAddress[3],
				clsRule->u8EthernetDestMacAddress[4],
				clsRule->u8EthernetDestMacAddress[5]);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8EthernetSourceMACAddressLength: 0x%X ",
				clsRule->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",
				clsRule->u8EthernetSourceMACAddress[0],
				clsRule->u8EthernetSourceMACAddress[1],
				clsRule->u8EthernetSourceMACAddress[2],
				clsRule->u8EthernetSourceMACAddress[3],
				clsRule->u8EthernetSourceMACAddress[4],
				clsRule->u8EthernetSourceMACAddress[5]);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL, " u8EthertypeLength: 0x%X ",
				clsRule->u8EthertypeLength);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8Ethertype[3]: 0x%X ,0x%X ,0x%X ",
				clsRule->u8Ethertype[0],
				clsRule->u8Ethertype[1],
				clsRule->u8Ethertype[2]);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL, " u16UserPriority: 0x%X ",
				clsRule->u16UserPriority);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL, " u16VLANID: 0x%X ",
				clsRule->u16VLANID);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL, " u8AssociatedPHSI: 0x%X ",
				clsRule->u8AssociatedPHSI);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u16PacketClassificationRuleIndex:0x%X ",
				clsRule->u16PacketClassificationRuleIndex);

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8VendorSpecificClassifierParamLength:0x%X ",
				clsRule->u8VendorSpecificClassifierParamLength);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL,
				" u8VendorSpecificClassifierParam[1]:0x%X ",
				clsRule->u8VendorSpecificClassifierParam[0]);
#ifdef VERSION_D5
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL,
				DBG_LVL_ALL, " u8IPv6FlowLableLength: 0x%X ",
				clsRule->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 ",
				clsRule->u8IPv6FlowLable[0],
				clsRule->u8IPv6FlowLable[1],
				clsRule->u8IPv6FlowLable[2],
				clsRule->u8IPv6FlowLable[3],
				clsRule->u8IPv6FlowLable[4],
				clsRule->u8IPv6FlowLable[5]);
#endif
	}

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL,
			" bValid: 0x%X", pstAddIndication->sfActiveSet.bValid);
}

static inline ULONG RestoreSFParam(struct bcm_mini_adapter *Adapter,
		ULONG ulAddrSFParamSet, PUCHAR pucDestBuffer)
{
	UINT  nBytesToRead = sizeof(struct bcm_connect_mgr_params);

	if (ulAddrSFParamSet == 0 || NULL == pucDestBuffer) {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Got Param address as 0!!");
		return 0;
	}
	ulAddrSFParamSet = ntohl(ulAddrSFParamSet);

	/* Read out the SF Param Set At the indicated Location */
	if (rdm(Adapter, ulAddrSFParamSet, (PUCHAR)pucDestBuffer, nBytesToRead) < 0)
		return STATUS_FAILURE;

	return 1;
}

static ULONG StoreSFParam(struct bcm_mini_adapter *Adapter, PUCHAR pucSrcBuffer,
		ULONG ulAddrSFParamSet)
{
	UINT nBytesToWrite = sizeof(struct bcm_connect_mgr_params);
	int ret = 0;

	if (ulAddrSFParamSet == 0 || NULL == pucSrcBuffer)
		return 0;

	ret = wrm(Adapter, ulAddrSFParamSet, (u8 *)pucSrcBuffer, nBytesToWrite);
	if (ret < 0) {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"%s:%d WRM failed", __func__, __LINE__);
		return ret;
	}
	return 1;
}

ULONG StoreCmControlResponseMessage(struct bcm_mini_adapter *Adapter,
		PVOID pvBuffer, UINT *puBufferLength)
{
	struct bcm_add_indication_alt *pstAddIndicationAlt = NULL;
	struct bcm_add_indication *pstAddIndication = NULL;
	struct bcm_del_request *pstDeletionRequest;
	UINT uiSearchRuleIndex;
	ULONG ulSFID;

	pstAddIndicationAlt = pvBuffer;

	/*
	 * 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) {
		pstDeletionRequest = pvBuffer;

		ulSFID = ntohl(pstDeletionRequest->u32SFID);
		uiSearchRuleIndex = SearchSfid(Adapter, ulSFID);

		if (uiSearchRuleIndex < NO_OF_QUEUES) {
			deleteSFBySfid(Adapter, uiSearchRuleIndex);
			Adapter->u32TotalDSD++;
		}
		return 1;
	}

	if ((pstAddIndicationAlt->u8Type == DSD_RSP) ||
		(pstAddIndicationAlt->u8Type == DSD_ACK)) {
		/* No Special handling send the message as it is */
		return 1;
	}
	/* For DSA_REQ, only up to "psfAuthorizedSet" parameter should be accessed by driver! */

	pstAddIndication = kmalloc(sizeof(struct bcm_add_indication),
			GFP_KERNEL);
	if (pstAddIndication == NULL)
		return 0;

	/* AUTHORIZED SET */
	pstAddIndication->psfAuthorizedSet = (struct bcm_connect_mgr_params *)
			GetNextTargetBufferLocation(Adapter,
					pstAddIndicationAlt->u16TID);
	if (!pstAddIndication->psfAuthorizedSet) {
		kfree(pstAddIndication);
		return 0;
	}

	if (StoreSFParam(Adapter, (PUCHAR)&pstAddIndicationAlt->sfAuthorizedSet,
				(ULONG)pstAddIndication->psfAuthorizedSet) != 1) {
		kfree(pstAddIndication);
		return 0;
	}

	/* this can't possibly be right */
	pstAddIndication->psfAuthorizedSet =
		(struct bcm_connect_mgr_params *) ntohl(
				(ULONG)pstAddIndication->psfAuthorizedSet);

	if (pstAddIndicationAlt->u8Type == DSA_REQ) {
		struct bcm_add_request AddRequest;

		AddRequest.u8Type = pstAddIndicationAlt->u8Type;
		AddRequest.eConnectionDir = pstAddIndicationAlt->u8Direction;
		AddRequest.u16TID = pstAddIndicationAlt->u16TID;
		AddRequest.u16CID = pstAddIndicationAlt->u16CID;
		AddRequest.u16VCID = pstAddIndicationAlt->u16VCID;
		AddRequest.psfParameterSet = pstAddIndication->psfAuthorizedSet;
		(*puBufferLength) = sizeof(struct bcm_add_request);
		memcpy(pvBuffer, &AddRequest, sizeof(struct bcm_add_request));
		kfree(pstAddIndication);
		return 1;
	}

	/* 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 */

	pstAddIndication->u8Type = pstAddIndicationAlt->u8Type;
	pstAddIndication->eConnectionDir = pstAddIndicationAlt->u8Direction;
	pstAddIndication->u16TID = pstAddIndicationAlt->u16TID;
	pstAddIndication->u16CID = pstAddIndicationAlt->u16CID;
	pstAddIndication->u16VCID = pstAddIndicationAlt->u16VCID;
	pstAddIndication->u8CC = pstAddIndicationAlt->u8CC;

	/* ADMITTED SET */
	pstAddIndication->psfAdmittedSet = (struct bcm_connect_mgr_params *)
		GetNextTargetBufferLocation(Adapter,
				pstAddIndicationAlt->u16TID);
	if (!pstAddIndication->psfAdmittedSet) {
		kfree(pstAddIndication);
		return 0;
	}
	if (StoreSFParam(Adapter, (PUCHAR)&pstAddIndicationAlt->sfAdmittedSet,
				(ULONG)pstAddIndication->psfAdmittedSet) != 1) {
		kfree(pstAddIndication);
		return 0;
	}

	pstAddIndication->psfAdmittedSet =
		(struct bcm_connect_mgr_params *) ntohl(
				(ULONG) pstAddIndication->psfAdmittedSet);

	/* ACTIVE SET */
	pstAddIndication->psfActiveSet = (struct bcm_connect_mgr_params *)
		GetNextTargetBufferLocation(Adapter,
				pstAddIndicationAlt->u16TID);
	if (!pstAddIndication->psfActiveSet) {
		kfree(pstAddIndication);
		return 0;
	}
	if (StoreSFParam(Adapter, (PUCHAR)&pstAddIndicationAlt->sfActiveSet,
				(ULONG)pstAddIndication->psfActiveSet) != 1) {
		kfree(pstAddIndication);
		return 0;
	}

	pstAddIndication->psfActiveSet =
		(struct bcm_connect_mgr_params *) ntohl(
				(ULONG)pstAddIndication->psfActiveSet);

	(*puBufferLength) = sizeof(struct bcm_add_indication);
	*(struct bcm_add_indication *)pvBuffer = *pstAddIndication;
	kfree(pstAddIndication);
	return 1;
}

static inline struct bcm_add_indication_alt
*RestoreCmControlResponseMessage(register struct bcm_mini_adapter *Adapter,
		register PVOID pvBuffer)
{
	ULONG ulStatus = 0;
	struct bcm_add_indication *pstAddIndication = NULL;
	struct bcm_add_indication_alt *pstAddIndicationDest = NULL;

	pstAddIndication = pvBuffer;
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"=====>");
	if ((pstAddIndication->u8Type == DSD_REQ) ||
		(pstAddIndication->u8Type == DSD_RSP) ||
		(pstAddIndication->u8Type == DSD_ACK))
		return pvBuffer;

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"Inside RestoreCmControlResponseMessage ");
	/*
	 * Need to Allocate memory to contain the SUPER Large structures
	 * Our driver can't create these structures on Stack :(
	 */
	pstAddIndicationDest = kmalloc(sizeof(struct bcm_add_indication_alt),
			GFP_KERNEL);

	if (pstAddIndicationDest) {
		memset(pstAddIndicationDest, 0,
				sizeof(struct bcm_add_indication_alt));
	} else {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG,
				DBG_LVL_ALL,
				"Failed to allocate memory for SF Add Indication Structure ");
		return NULL;
	}
	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);

	pstAddIndicationDest->u8Type = pstAddIndication->u8Type;
	pstAddIndicationDest->u8Direction = pstAddIndication->eConnectionDir;
	pstAddIndicationDest->u16TID = pstAddIndication->u16TID;
	pstAddIndicationDest->u16CID = pstAddIndication->u16CID;
	pstAddIndicationDest->u16VCID = pstAddIndication->u16VCID;
	pstAddIndicationDest->u8CC = pstAddIndication->u8CC;

	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)
		goto failed_restore_sf_param;

	if (pstAddIndicationDest->sfActiveSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
		pstAddIndicationDest->sfActiveSet.u8TotalClassifiers =
			MAX_CLASSIFIERS_IN_SF;

	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)
		goto failed_restore_sf_param;

	if (pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
		pstAddIndicationDest->sfAdmittedSet.u8TotalClassifiers =
			MAX_CLASSIFIERS_IN_SF;

	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)
		goto failed_restore_sf_param;

	if (pstAddIndicationDest->sfAuthorizedSet.u8TotalClassifiers > MAX_CLASSIFIERS_IN_SF)
		pstAddIndicationDest->sfAuthorizedSet.u8TotalClassifiers =
			MAX_CLASSIFIERS_IN_SF;

	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,
			"============================================================");
	return pstAddIndicationDest;
failed_restore_sf_param:
	kfree(pstAddIndicationDest);
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"<=====");
	return NULL;
}

ULONG SetUpTargetDsxBuffers(struct bcm_mini_adapter *Adapter)
{
	ULONG ulTargetDsxBuffersBase = 0;
	ULONG ulCntTargetBuffers;
	ULONG i;
	int Status;

	if (!Adapter) {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"Adapter was NULL!!!");
		return 0;
	}

	if (Adapter->astTargetDsxBuffer[0].ulTargetDsxBuffer)
		return 1;

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"Size of Each DSX Buffer(Also size of connection manager parameters): %zx ",
			sizeof(struct bcm_connect_mgr_params));
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"Reading DSX buffer From Target location %x ",
			DSX_MESSAGE_EXCHANGE_BUFFER);

	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!!");
		return 0;
	}

	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(struct bcm_connect_mgr_params);

	Adapter->ulTotalTargetBuffersAvailable =
		ulCntTargetBuffers > MAX_TARGET_DSX_BUFFERS ?
		MAX_TARGET_DSX_BUFFERS : ulCntTargetBuffers;

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			" Total Target DSX Buffer setup %lx ",
			Adapter->ulTotalTargetBuffersAvailable);

	for (i = 0; i < Adapter->ulTotalTargetBuffersAvailable; i++) {
		Adapter->astTargetDsxBuffer[i].ulTargetDsxBuffer = ulTargetDsxBuffersBase;
		Adapter->astTargetDsxBuffer[i].valid = 1;
		Adapter->astTargetDsxBuffer[i].tid = 0;
		ulTargetDsxBuffersBase += sizeof(struct bcm_connect_mgr_params);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "  Target DSX Buffer %lx setup at 0x%lx",
				i, Adapter->astTargetDsxBuffer[i].ulTargetDsxBuffer);
	}
	Adapter->ulCurrentTargetBuffer = 0;
	Adapter->ulFreeTargetBufferCnt = Adapter->ulTotalTargetBuffersAvailable;
	return 1;
}

static ULONG GetNextTargetBufferLocation(struct bcm_mini_adapter *Adapter,
		B_UINT16 tid)
{
	ULONG dsx_buf;
	ULONG idx, max_try;

	if ((Adapter->ulTotalTargetBuffersAvailable == 0)
			|| (Adapter->ulFreeTargetBufferCnt == 0)) {
		ClearTargetDSXBuffer(Adapter, tid, false);
		return 0;
	}

	idx = Adapter->ulCurrentTargetBuffer;
	max_try = Adapter->ulTotalTargetBuffersAvailable;
	while ((max_try) && (Adapter->astTargetDsxBuffer[idx].valid != 1)) {
		idx = (idx+1) % Adapter->ulTotalTargetBuffersAvailable;
		max_try--;
	}

	if (max_try == 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);
		return 0;
	}

	dsx_buf = Adapter->astTargetDsxBuffer[idx].ulTargetDsxBuffer;
	Adapter->astTargetDsxBuffer[idx].valid = 0;
	Adapter->astTargetDsxBuffer[idx].tid = tid;
	Adapter->ulFreeTargetBufferCnt--;
	idx = (idx+1)%Adapter->ulTotalTargetBuffersAvailable;
	Adapter->ulCurrentTargetBuffer = idx;
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
			"GetNextTargetBufferLocation :Returning address %lx tid %d\n",
			dsx_buf, tid);

	return dsx_buf;
}

int AllocAdapterDsxBuffer(struct bcm_mini_adapter *Adapter)
{
	/*
	 * Need to Allocate memory to contain the SUPER Large structures
	 * Our driver can't create these structures on Stack
	 */
	Adapter->caDsxReqResp = kmalloc(sizeof(struct bcm_add_indication_alt)
			+ LEADER_SIZE, GFP_KERNEL);
	if (!Adapter->caDsxReqResp)
		return -ENOMEM;

	return 0;
}

int FreeAdapterDsxBuffer(struct bcm_mini_adapter *Adapter)
{
	kfree(Adapter->caDsxReqResp);
	return 0;
}

/*
 * @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.
 */
bool CmControlResponseMessage(struct bcm_mini_adapter *Adapter,  /* <Pointer to the Adapter structure */
				PVOID pvBuffer /* Starting Address of the Buffer, that contains the AddIndication Data */)
{
	struct bcm_connect_mgr_params *psfLocalSet = NULL;
	struct bcm_add_indication_alt *pstAddIndication = NULL;
	struct bcm_change_indication *pstChangeIndication = NULL;
	struct bcm_leader *pLeader = NULL;
	INT uiSearchRuleIndex = 0;
	ULONG ulSFID;

	/*
	 * Otherwise the message contains a target address from where we need to
	 * read out the rest of the service flow param structure
	 */
	pstAddIndication = RestoreCmControlResponseMessage(Adapter, pvBuffer);
	if (pstAddIndication == NULL) {
		ClearTargetDSXBuffer(Adapter, ((struct bcm_add_indication *)pvBuffer)->u16TID, false);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Error in restoring Service Flow param structure from DSx message");
		return false;
	}

	DumpCmControlPacket(pstAddIndication);
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "====>");
	pLeader = (struct bcm_leader *)Adapter->caDsxReqResp;

	pLeader->Status = CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
	pLeader->Vcid = 0;

	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:
		pLeader->PLength = sizeof(struct bcm_add_indication_alt);
		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);
		*((struct bcm_add_indication_alt *)&(Adapter->caDsxReqResp[LEADER_SIZE]))
			= *pstAddIndication;
		((struct bcm_add_indication_alt *)&(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(struct bcm_add_indication_alt);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSA ACK TO MAC %d",
				pLeader->PLength);
		*((struct bcm_add_indication_alt *)&(Adapter->caDsxReqResp[LEADER_SIZE]))
			= *pstAddIndication;
		((struct bcm_add_indication_alt *)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSA_ACK;
		/* FALLTHROUGH */
	case DSA_ACK:
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "VCID:0x%X",
				ntohs(pstAddIndication->u16VCID));
		uiSearchRuleIndex = SearchFreeSfid(Adapter);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "uiSearchRuleIndex:0x%X ",
				uiSearchRuleIndex);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "Direction:0x%X ",
				pstAddIndication->u8Direction);
		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 ",
					pstAddIndication->sfActiveSet.bValid);
			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;

			if (pstAddIndication->sfActiveSet.bValid == false) {
				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;
			}

			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();
						}
					}
				}
			} else {
				Adapter->PackInfo[uiSearchRuleIndex].bActive = false;
				Adapter->PackInfo[uiSearchRuleIndex].bValid = false;
				Adapter->PackInfo[uiSearchRuleIndex].usVCID_Value = 0;
				kfree(pstAddIndication);
			}
		} else {
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "DSA ACK did not get valid SFID");
			kfree(pstAddIndication);
			return false;
		}
		break;
	case DSC_REQ:
		pLeader->PLength = sizeof(struct bcm_change_indication);
		pstChangeIndication = (struct bcm_change_indication *)pstAddIndication;
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC RESPONSE TO MAC %d", pLeader->PLength);

		*((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
		((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_RSP;

		CopyBufferToControlPacket(Adapter, (PVOID)Adapter->caDsxReqResp);
		kfree(pstAddIndication);
		break;
	case DSC_RSP:
		pLeader->PLength = sizeof(struct bcm_change_indication);
		pstChangeIndication = (struct bcm_change_indication *)pstAddIndication;
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSC ACK TO MAC %d", pLeader->PLength);
		*((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *pstChangeIndication;
		((struct bcm_change_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSC_ACK;
		/* FALLTHROUGH */
	case DSC_ACK:
		pstChangeIndication = (struct bcm_change_indication *)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;

			if (pstChangeIndication->sfActiveSet.bValid == false) {
				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;
			}

			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 && (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);
				kfree(pstAddIndication);
			}
		} else {
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "DSC ACK did not get valid SFID");
			kfree(pstAddIndication);
			return false;
		}
		break;
	case DSD_REQ:
		pLeader->PLength = sizeof(struct bcm_del_indication);
		*((struct bcm_del_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE])) = *((struct bcm_del_indication *)pstAddIndication);

		ulSFID = ntohl(((struct bcm_del_indication *)pstAddIndication)->u32SFID);
		uiSearchRuleIndex = SearchSfid(Adapter, ulSFID);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD - Removing connection %x", uiSearchRuleIndex);

		if (uiSearchRuleIndex < NO_OF_QUEUES) {
			/* Delete All Classifiers Associated with this SFID */
			deleteSFBySfid(Adapter, uiSearchRuleIndex);
			Adapter->u32TotalDSD++;
		}

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "SENDING DSD RESPONSE TO MAC");
		((struct bcm_del_indication *)&(Adapter->caDsxReqResp[LEADER_SIZE]))->u8Type = DSD_RSP;
		CopyBufferToControlPacket(Adapter, (PVOID)Adapter->caDsxReqResp);
		/* FALLTHROUGH */
	case DSD_RSP:
		/* Do nothing as SF has already got Deleted */
		break;
	case DSD_ACK:
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "DSD ACK Rcd, let App handle it\n");
		break;
	default:
		kfree(pstAddIndication);
		return false;
	}
	return TRUE;
}

int get_dsx_sf_data_to_application(struct bcm_mini_adapter *Adapter,
		UINT uiSFId, void __user *user_buffer)
{
	int status = 0;
	struct bcm_packet_info *psSfInfo = NULL;

	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"status =%d", status);
	status = SearchSfid(Adapter, uiSFId);
	if (status >= NO_OF_QUEUES) {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"SFID %d not present in queue !!!", uiSFId);
		return -EINVAL;
	}
	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(struct bcm_add_indication_alt))) {
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
				"copy to user failed SFID %d, present in queue !!!",
				uiSFId);
		status = -EFAULT;
		return status;
	}
	return STATUS_SUCCESS;
}

VOID OverrideServiceFlowParams(struct bcm_mini_adapter *Adapter,
		PUINT puiBuffer)
{
	B_UINT32 u32NumofSFsinMsg = ntohl(*(puiBuffer + 1));
	struct bcm_stim_sfhostnotify *pHostInfo = NULL;
	UINT uiSearchRuleIndex = 0;
	ULONG ulSFID = 0;

	puiBuffer += 2;
	BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
			"u32NumofSFsinMsg: 0x%x\n", u32NumofSFsinMsg);

	while (u32NumofSFsinMsg != 0 && u32NumofSFsinMsg < NO_OF_QUEUES) {
		u32NumofSFsinMsg--;
		pHostInfo = (struct bcm_stim_sfhostnotify *)puiBuffer;
		puiBuffer = (PUINT)(pHostInfo + 1);

		ulSFID = ntohl(pHostInfo->SFID);
		uiSearchRuleIndex = SearchSfid(Adapter, ulSFID);
		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL,
				"SFID: 0x%lx\n", ulSFID);

		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);
			continue;
		}

		if (pHostInfo->RetainSF == false) {
			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG,
					DBG_LVL_ALL, "Going to Delete SF");
			deleteSFBySfid(Adapter, uiSearchRuleIndex);
		} else {
			struct bcm_packet_info *packinfo =
				&Adapter->PackInfo[uiSearchRuleIndex];

			packinfo->usVCID_Value = ntohs(pHostInfo->VCID);
			packinfo->usCID = ntohs(pHostInfo->newCID);
			packinfo->bActive = false;

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG,
					DBG_LVL_ALL,
					"pHostInfo->QoSParamSet: 0x%x\n",
					pHostInfo->QoSParamSet);

			if (pHostInfo->QoSParamSet & 0x1)
				packinfo->bAuthorizedSet = TRUE;
			if (pHostInfo->QoSParamSet & 0x2)
				packinfo->bAdmittedSet = TRUE;
			if (pHostInfo->QoSParamSet & 0x4) {
				packinfo->bActiveSet = TRUE;
				packinfo->bActive = TRUE;
			}
		}
	}
}

static void restore_endianess_of_pstClassifierEntry(
		struct bcm_classifier_rule *pstClassifierEntry,
		enum bcm_ipaddr_context eIpAddrContext)
{
	int i;
	union u_ip_address *stSrc  = &pstClassifierEntry->stSrcIpAddress;
	union u_ip_address *stDest = &pstClassifierEntry->stDestIpAddress;

	for (i = 0; i < MAX_IP_RANGE_LENGTH * 4; i++) {
		if (eIpAddrContext == eSrcIpAddress) {
			stSrc->ulIpv6Addr[i] = ntohl(stSrc->ulIpv6Addr[i]);
			stSrc->ulIpv6Mask[i] = ntohl(stSrc->ulIpv6Mask[i]);
		} else if (eIpAddrContext == eDestIpAddress) {
			stDest->ulIpv6Addr[i] = ntohl(stDest->ulIpv6Addr[i]);
			stDest->ulIpv6Mask[i] = ntohl(stDest->ulIpv6Mask[i]);
		}
	}
}

static void apply_phs_rule_to_all_classifiers(
		register struct bcm_mini_adapter *Adapter,		/* <Pointer to the Adapter structure */
		register UINT uiSearchRuleIndex,			/* <Index of Queue, to which this data belongs */
		USHORT uVCID,
		struct bcm_phs_rule *sPhsRule,
		struct bcm_phs_rules *cPhsRule,
		struct bcm_add_indication_alt *pstAddIndication)
{
	unsigned int uiClassifierIndex = 0;
	struct bcm_classifier_rule *curr_classifier = NULL;

	if (pstAddIndication->u8Direction == UPLINK_DIR) {
		for (uiClassifierIndex = 0; uiClassifierIndex < MAX_CLASSIFIERS; uiClassifierIndex++) {
			curr_classifier =
				&Adapter->astClassifierTable[uiClassifierIndex];
			if ((curr_classifier->bUsed) &&
				(curr_classifier->ulSFID == Adapter->PackInfo[uiSearchRuleIndex].ulSFID) &&
				(curr_classifier->u8AssociatedPHSI == 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",
						curr_classifier->uiClassifierRuleIndex,
						cPhsRule->u8PHSI);
				/* Update The PHS Rule for this classifier as Associated PHSI id defined */

				/* Copy the PHS Rule */
				sPhsRule->u8PHSI = cPhsRule->u8PHSI;
				sPhsRule->u8PHSFLength = cPhsRule->u8PHSFLength;
				sPhsRule->u8PHSMLength = cPhsRule->u8PHSMLength;
				sPhsRule->u8PHSS = cPhsRule->u8PHSS;
				sPhsRule->u8PHSV = cPhsRule->u8PHSV;
				memcpy(sPhsRule->u8PHSF, cPhsRule->u8PHSF, MAX_PHS_LENGTHS);
				memcpy(sPhsRule->u8PHSM, cPhsRule->u8PHSM, MAX_PHS_LENGTHS);
				sPhsRule->u8RefCnt = 0;
				sPhsRule->bUnclassifiedPHSRule = false;
				sPhsRule->PHSModifiedBytes = 0;
				sPhsRule->PHSModifiedNumPackets = 0;
				sPhsRule->PHSErrorNumPackets = 0;

				/* bPHSRuleAssociated = TRUE; */
				/* Store The PHS Rule for this classifier */

				PhsUpdateClassifierRule(
					&Adapter->stBCMPhsContext,
					uVCID,
					curr_classifier->uiClassifierRuleIndex,
					sPhsRule,
					curr_classifier->u8AssociatedPHSI);

				/* Update PHS Rule For the Classifier */
				if (sPhsRule->u8PHSI) {
					curr_classifier->u32PHSRuleID = sPhsRule->u8PHSI;
					memcpy(&curr_classifier->sPhsRule, sPhsRule, sizeof(struct bcm_phs_rule));
				}
			}
		}
	} else {
		/* Error PHS Rule specified in signaling could not be applied to any classifier */

		/* Copy the PHS Rule */
		sPhsRule->u8PHSI = cPhsRule->u8PHSI;
		sPhsRule->u8PHSFLength = cPhsRule->u8PHSFLength;
		sPhsRule->u8PHSMLength = cPhsRule->u8PHSMLength;
		sPhsRule->u8PHSS = cPhsRule->u8PHSS;
		sPhsRule->u8PHSV = cPhsRule->u8PHSV;
		memcpy(sPhsRule->u8PHSF, cPhsRule->u8PHSF, MAX_PHS_LENGTHS);
		memcpy(sPhsRule->u8PHSM, 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);
	}
}