/*
* TxDataClsfr.c
*
* Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name Texas Instruments nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** \file txDataClsfr.c
* \brief The Tx Data Classifier sub-module (under txDataQueue module).
*
* \see txDataQueue.h (the classifier uses the same object as txDataQueue)
*/
#define __FILE_ID__ FILE_ID_59
#include "paramOut.h"
#include "osApi.h"
#include "report.h"
#include "context.h"
#include "Ethernet.h"
#include "TWDriver.h"
#include "txDataQueue.h"
/**
* \fn txDataClsfr_Config
* \brief Configure the classifier paramters
*
* Configure the classifier parameters according to the init parameters.
* Called from the txDataQueue configuration function.
*
* \note
* \param hTxDataQ - The object handle
* \param pClsfrInitParams - Pointer to the classifier init params
* \return TI_OK on success or TI_NOK on failure
* \sa
*/
TI_STATUS txDataClsfr_Config (TI_HANDLE hTxDataQ, TClsfrParams *pClsfrInitParams)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TClsfrParams *pParams = &pTxDataQ->tClsfrParams; /* where to save the new params */
TI_UINT32 uActualEntryCount;
TI_UINT32 i, j;
TI_BOOL bConflictFound;
/* Active classification algorithm */
pParams->eClsfrType = pClsfrInitParams->eClsfrType;
/* the number of active entries */
if (pClsfrInitParams->uNumActiveEntries <= NUM_OF_CLSFR_TABLE_ENTRIES)
pParams->uNumActiveEntries = pClsfrInitParams->uNumActiveEntries;
else
pParams->uNumActiveEntries = NUM_OF_CLSFR_TABLE_ENTRIES;
/* Initialization of the classification table */
switch (pParams->eClsfrType)
{
case D_TAG_CLSFR:
pParams->uNumActiveEntries = 0;
break;
case DSCP_CLSFR:
uActualEntryCount=0;
for (i = 0; i < pParams->uNumActiveEntries; i++)
{
bConflictFound = TI_FALSE;
/* check conflict */
for (j = 0; j < i; j++)
{
/* Detect both duplicate and conflicting entries */
if (pParams->ClsfrTable[j].Dscp.CodePoint == pClsfrInitParams->ClsfrTable[i].Dscp.CodePoint)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_WARNING , "ERROR: txDataClsfr_Config(): duplicate/conflicting classifier entries\n");
bConflictFound = TI_TRUE;
}
}
if (bConflictFound == TI_FALSE)
{
pParams->ClsfrTable[uActualEntryCount].Dscp.CodePoint = pClsfrInitParams->ClsfrTable[i].Dscp.CodePoint;
pParams->ClsfrTable[uActualEntryCount].DTag = pClsfrInitParams->ClsfrTable[i].DTag;
uActualEntryCount++;
}
}
pParams->uNumActiveEntries = uActualEntryCount;
break;
case PORT_CLSFR:
uActualEntryCount=0;
for (i = 0; (i < pParams->uNumActiveEntries) ; i++)
{
bConflictFound = TI_FALSE;
/* check conflict */
for (j = 0; j < i; j++)
{
/* Detect both duplicate and conflicting entries */
if (pParams->ClsfrTable[j].Dscp.DstPortNum == pClsfrInitParams->ClsfrTable[i].Dscp.DstPortNum)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_WARNING , "ERROR: txDataClsfr_Config(): classifier entries conflict\n");
bConflictFound = TI_TRUE;
}
}
if (bConflictFound == TI_FALSE)
{
pParams->ClsfrTable[uActualEntryCount].Dscp.DstPortNum = pClsfrInitParams->ClsfrTable[i].Dscp.DstPortNum;
pParams->ClsfrTable[uActualEntryCount].DTag = pClsfrInitParams->ClsfrTable[i].DTag;
uActualEntryCount++;
}
}
pParams->uNumActiveEntries = uActualEntryCount;
break;
case IPPORT_CLSFR:
uActualEntryCount=0;
for (i=0; (i < pParams->uNumActiveEntries ) ; i++)
{
bConflictFound = TI_FALSE;
/* check conflict */
for (j = 0; j < i; j++)
{
/* Detect both duplicate and conflicting entries */
if ((pParams->ClsfrTable[j].Dscp.DstIPPort.DstIPAddress == pClsfrInitParams->ClsfrTable[i].Dscp.DstIPPort.DstIPAddress)&&
(pParams->ClsfrTable[j].Dscp.DstIPPort.DstPortNum == pClsfrInitParams->ClsfrTable[i].Dscp.DstIPPort.DstPortNum))
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_WARNING , "ERROR: txDataClsfr_Config(): classifier entries conflict\n");
bConflictFound = TI_TRUE;
}
}
if (bConflictFound == TI_FALSE)
{
pParams->ClsfrTable[uActualEntryCount].Dscp.DstIPPort.DstIPAddress = pClsfrInitParams->ClsfrTable[i].Dscp.DstIPPort.DstIPAddress;
pParams->ClsfrTable[uActualEntryCount].Dscp.DstIPPort.DstPortNum = pClsfrInitParams->ClsfrTable[i].Dscp.DstIPPort.DstPortNum;
pParams->ClsfrTable[uActualEntryCount].DTag = pClsfrInitParams->ClsfrTable[i].DTag;
uActualEntryCount++;
}
}
pParams->uNumActiveEntries = uActualEntryCount;
break;
default:
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_WARNING , "ERROR: txDataClsfr_Config(): Classifier type -- unknown --> set to D-Tag\n");
pParams->eClsfrType = D_TAG_CLSFR;
pParams->uNumActiveEntries = 0;
break;
}
return TI_OK;
}
/**
* \fn getIpAndUdpHeader
* \brief Get IP & UDP headers addresses if exist
*
* This function gets the addresses of the IP and UDP headers
*
* \note A local inline function!
* \param pTxDataQ - The object handle
* \param pPktCtrlBlk - Pointer to the packet
* \param pIpHeader - Pointer to pointer to IP header
* \param pUdpHeader - Pointer to pointer to UDP header
* \return TI_OK on success, TI_NOK if it's not an IP packet
* \sa
*/
static inline TI_STATUS getIpAndUdpHeader(TTxDataQ *pTxDataQ,
TTxCtrlBlk *pPktCtrlBlk,
TI_UINT8 **pIpHeader,
TI_UINT8 **pUdpHeader)
{
TI_UINT8 *pEthHead = pPktCtrlBlk->tTxnStruct.aBuf[0];
TI_UINT8 ipHeaderLen = 0;
/* check if frame is IP according to ether type */
if( ( HTOWLANS(((TEthernetHeader *)pEthHead)->type) ) != ETHERTYPE_IP)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION, " getIpAndUdpHeader: EthTypeLength is not 0x0800 \n");
return TI_NOK;
}
/* set the pointer to the beginning of the IP header and calculate it's size */
*pIpHeader = pPktCtrlBlk->tTxnStruct.aBuf[1];
ipHeaderLen = ((*(unsigned char*)(*pIpHeader) & 0x0f) * 4);
/* Set the pointer to the beggining of the TCP/UDP header */
if (ipHeaderLen == pPktCtrlBlk->tTxnStruct.aLen[1])
{
*pUdpHeader = pPktCtrlBlk->tTxnStruct.aBuf[2];
}
else
{
*pUdpHeader = *pIpHeader + ipHeaderLen;
}
return TI_OK;
}
/**
* \fn txDataClsfr_ClassifyTxPacket
* \brief Configure the classifier paramters
*
* This function classifies the given Tx packet according to the classifier parameters.
* It sets the TID field with the classification result.
* The classification is according to one of the following methods:
* - D-Tag - Transparent (TID = Dtag)
* - DSCP - According to the DSCP field in the IP header - the default method!
* - Dest UDP-Port
* - Dest IP-Addr & UDP-Port
*
* \note
* \param hTxDataQ - The object handle
* \param pPktCtrlBlk - Pointer to the classified packet
* \param uPacketDtag - The packet priority optionaly set by the OAL
* \return TI_OK on success, PARAM_VALUE_NOT_VALID in case of input parameters problems.
* \sa
*/
TI_STATUS txDataClsfr_ClassifyTxPacket (TI_HANDLE hTxDataQ, TTxCtrlBlk *pPktCtrlBlk, TI_UINT8 uPacketDtag)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TClsfrParams *pClsfrParams = &pTxDataQ->tClsfrParams;
TI_UINT8 *pUdpHeader = NULL;
TI_UINT8 *pIpHeader = NULL;
TI_UINT8 uDscp;
TI_UINT16 uDstUdpPort;
TI_UINT32 uDstIpAdd;
TI_UINT32 i;
pPktCtrlBlk->tTxDescriptor.tid = 0;
switch(pClsfrParams->eClsfrType)
{
/* Trivial mapping D-tag to D-tag */
case D_TAG_CLSFR:
if (uPacketDtag > MAX_NUM_OF_802_1d_TAGS)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR , "txDataClsfr_ClassifyTxPacket(): uPacketDtag error\n");
return PARAM_VALUE_NOT_VALID;
}
pPktCtrlBlk->tTxDescriptor.tid = uPacketDtag;
TRACE1(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION , "Classifier D_TAG_CLSFR. uPacketDtag = %d\n", uPacketDtag);
break;
case DSCP_CLSFR:
if( (getIpAndUdpHeader(pTxDataQ, pPktCtrlBlk, &pIpHeader, &pUdpHeader) != TI_OK)
|| (pIpHeader == NULL) )
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION , "txDataClsfr_ClassifyTxPacket(): DSCP clsfr, getIpAndUdpHeader mismatch\n");
return PARAM_VALUE_NOT_VALID;
}
/* DSCP to D-tag mapping */
uDscp = *((TI_UINT8 *)(pIpHeader + 1)); /* Fetching the DSCP from the header */
uDscp = (uDscp >> 2);
/* looking for the specific DSCP, if found, its corresponding D-tag is set to the TID */
for(i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
if (pClsfrParams->ClsfrTable[i].Dscp.CodePoint == uDscp)
{
pPktCtrlBlk->tTxDescriptor.tid = pClsfrParams->ClsfrTable[i].DTag;
TRACE2(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION , "Classifier DSCP_CLSFR found match - entry %d - Tid = %d\n",i,pPktCtrlBlk->tTxDescriptor.tid);
break;
}
}
break;
case PORT_CLSFR:
if( (getIpAndUdpHeader(pTxDataQ, pPktCtrlBlk, &pIpHeader, &pUdpHeader) != TI_OK) ||
(pUdpHeader == NULL) )
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION, " txDataClsfr_ClassifyTxPacket() : DstPort clsfr, getIpAndUdpHeader error\n");
return PARAM_VALUE_NOT_VALID;
}
uDstUdpPort = *((TI_UINT16 *)(pUdpHeader + 2));
uDstUdpPort = HTOWLANS(uDstUdpPort);
/* Looking for the specific port number. If found, its corresponding D-tag is set to the TID. */
for(i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
if (pClsfrParams->ClsfrTable[i].Dscp.DstPortNum == uDstUdpPort)
{
pPktCtrlBlk->tTxDescriptor.tid = pClsfrParams->ClsfrTable[i].DTag;
TRACE2(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION , "Classifier PORT_CLSFR found match - entry %d - Tid = %d\n", i, pPktCtrlBlk->tTxDescriptor.tid);
break;
}
}
break;
case IPPORT_CLSFR:
if ( (getIpAndUdpHeader(pTxDataQ, pPktCtrlBlk, &pIpHeader, &pUdpHeader) != TI_OK)
|| (pIpHeader == NULL) || (pUdpHeader == NULL) )
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION, "txDataClsfr_ClassifyTxPacket(): Dst IP&Port clsfr, getIpAndUdpHeader error\n");
return PARAM_VALUE_NOT_VALID;
}
uDstUdpPort = *((TI_UINT16 *)(pUdpHeader + 2));
uDstUdpPort = HTOWLANS(uDstUdpPort);
uDstIpAdd = *((TI_UINT32 *)(pIpHeader + 16));
/*
* Looking for the specific pair of dst IP address and dst port number.
* If found, its corresponding D-tag is set to the TID.
*/
for(i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
if ((pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstIPAddress == uDstIpAdd) &&
(pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstPortNum == uDstUdpPort))
{
pPktCtrlBlk->tTxDescriptor.tid = pClsfrParams->ClsfrTable[i].DTag;
TRACE2(pTxDataQ->hReport, REPORT_SEVERITY_INFORMATION , "Classifier IPPORT_CLSFR found match - entry %d - Tid = %d\n", i, pPktCtrlBlk->tTxDescriptor.tid);
break;
}
}
break;
default:
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "txDataClsfr_ClassifyTxPacket(): eClsfrType error\n");
}
return TI_OK;
}
/**
* \fn txDataClsfr_InsertClsfrEntry
* \brief Insert a new entry to classifier table
*
* Add a new entry to the classification table.
* If the new entry is invalid or conflicts with existing entries, the operation is canceled.
*
* \note
* \param hTxDataQ - The object handle
* \param pNewEntry - Pointer to the new entry to insert
* \return TI_OK on success, PARAM_VALUE_NOT_VALID in case of input parameters problems.
* \sa txDataClsfr_RemoveClsfrEntry
*/
TI_STATUS txDataClsfr_InsertClsfrEntry(TI_HANDLE hTxDataQ, TClsfrTableEntry *pNewEntry)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TClsfrParams *pClsfrParams = &pTxDataQ->tClsfrParams;
TI_UINT32 i;
if(pNewEntry == NULL)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): NULL ConfigBuffer pointer Error - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* If no available entries, exit */
if (pClsfrParams->uNumActiveEntries == NUM_OF_CLSFR_TABLE_ENTRIES)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): Bad Number Of Entries - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
if (pClsfrParams->eClsfrType == D_TAG_CLSFR)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): D-Tag classifier - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Check new entry and conflict with existing entries and if OK, insert to classifier table */
switch (pClsfrParams->eClsfrType)
{
case DSCP_CLSFR:
/* Check entry */
if ( (pNewEntry->Dscp.CodePoint > CLASSIFIER_CODE_POINT_MAX) ||
(pNewEntry->DTag > CLASSIFIER_DTAG_MAX) )
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): bad parameter - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Check conflict*/
for (i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
/* Detect both duplicate and conflicting entries */
if (pClsfrParams->ClsfrTable[i].Dscp.CodePoint == pNewEntry->Dscp.CodePoint)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): classifier entries conflict - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
}
/* Insert new entry to classifier table. */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].Dscp.CodePoint = pNewEntry->Dscp.CodePoint;
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].DTag = pNewEntry->DTag;
context_LeaveCriticalSection (pTxDataQ->hContext);
break;
case PORT_CLSFR:
/* Check entry */
if ((pNewEntry->DTag > CLASSIFIER_DTAG_MAX) ||
(pNewEntry->Dscp.DstPortNum > CLASSIFIER_PORT_MAX-1) ||
(pNewEntry->Dscp.DstPortNum < CLASSIFIER_PORT_MIN) )
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): bad parameter - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Check conflict*/
for (i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
/* Detect both duplicate and conflicting entries */
if ((pClsfrParams->ClsfrTable[i].Dscp.DstPortNum == pNewEntry->Dscp.DstPortNum))
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): classifier entries conflict - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
}
/* Insert new entry to classifier table. */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].Dscp.DstPortNum = pNewEntry->Dscp.DstPortNum;
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].DTag = pNewEntry->DTag;
context_LeaveCriticalSection (pTxDataQ->hContext);
break;
case IPPORT_CLSFR:
/* Check entry */
if ( (pNewEntry->DTag > CLASSIFIER_DTAG_MAX) ||
(pNewEntry->Dscp.DstIPPort.DstPortNum > CLASSIFIER_PORT_MAX-1) ||
(pNewEntry->Dscp.DstIPPort.DstPortNum < CLASSIFIER_PORT_MIN) ||
(pNewEntry->Dscp.DstIPPort.DstIPAddress > CLASSIFIER_IPADDRESS_MAX-1) ||
(pNewEntry->Dscp.DstIPPort.DstIPAddress < CLASSIFIER_IPADDRESS_MIN+1) )
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): bad parameter - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Check conflict*/
for (i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
/* Detect both duplicate and conflicting entries */
if ( (pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstIPAddress == pNewEntry->Dscp.DstIPPort.DstIPAddress) &&
(pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstPortNum == pNewEntry->Dscp.DstIPPort.DstPortNum))
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): classifier entries conflict - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
}
/* Insert new entry to classifier table */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].Dscp.DstIPPort.DstIPAddress = pNewEntry->Dscp.DstIPPort.DstIPAddress;
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].Dscp.DstIPPort.DstPortNum = pNewEntry->Dscp.DstIPPort.DstPortNum;
pClsfrParams->ClsfrTable[pClsfrParams->uNumActiveEntries].DTag = pNewEntry->DTag;
context_LeaveCriticalSection (pTxDataQ->hContext);
break;
default:
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): Classifier type -- unknown - Aborting\n");
}
/* Increment the number of classifier active entries */
pClsfrParams->uNumActiveEntries++;
return TI_OK;
}
/**
* \fn txDataClsfr_RemoveClsfrEntry
* \brief Remove an entry from classifier table
*
* Remove an entry from classifier table.
*
* \note
* \param hTxDataQ - The object handle
* \param pRemEntry - Pointer to the entry to remove
* \return TI_OK on success, PARAM_VALUE_NOT_VALID in case of input parameters problems.
* \sa txDataClsfr_InsertClsfrEntry
*/
TI_STATUS txDataClsfr_RemoveClsfrEntry(TI_HANDLE hTxDataQ, TClsfrTableEntry *pRemEntry)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TClsfrParams *pClsfrParams = &pTxDataQ->tClsfrParams;
TI_UINT32 i, j;
if(pRemEntry == NULL)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): NULL ConfigBuffer pointer Error - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
if (pClsfrParams->uNumActiveEntries == 0)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): Classifier table is empty - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
if (pClsfrParams->eClsfrType == D_TAG_CLSFR)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): D-Tag classifier - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Check conflicts with classifier table entries */
/* check all conflicts, if all entries are TI_OK --> insert to classifier table*/
switch (pClsfrParams->eClsfrType)
{
case DSCP_CLSFR:
/* Find the classifier entry */
i = 0;
while ((i < pClsfrParams->uNumActiveEntries) &&
((pClsfrParams->ClsfrTable[i].Dscp.CodePoint != pRemEntry->Dscp.CodePoint) ||
(pClsfrParams->ClsfrTable[i].DTag != pRemEntry->DTag)))
{
i++;
}
/* If we have reached the number of active entries, it means we couldn't find the requested entry */
if (i == pClsfrParams->uNumActiveEntries)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): Entry not found - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Shift all entries above the removed one downward */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
for (j = i; j < pClsfrParams->uNumActiveEntries - 1; j++)
{
/* Move entries */
pClsfrParams->ClsfrTable[j].Dscp.CodePoint = pClsfrParams->ClsfrTable[j+1].Dscp.CodePoint;
pClsfrParams->ClsfrTable[j].DTag = pClsfrParams->ClsfrTable[j+1].DTag;
}
context_LeaveCriticalSection (pTxDataQ->hContext);
break;
case PORT_CLSFR:
/* Find the classifier entry */
i = 0;
while ((i < pClsfrParams->uNumActiveEntries) &&
((pClsfrParams->ClsfrTable[i].Dscp.DstPortNum != pRemEntry->Dscp.DstPortNum) ||
(pClsfrParams->ClsfrTable[i].DTag != pRemEntry->DTag)))
{
i++;
}
/* If we have reached the number of active entries, it means we couldn't find the requested entry */
if (i == pClsfrParams->uNumActiveEntries)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): Entry not found - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Shift all entries above the removed one downward */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
for (j = i; j < pClsfrParams->uNumActiveEntries - 1; j++)
{
pClsfrParams->ClsfrTable[j].Dscp.DstPortNum = pClsfrParams->ClsfrTable[j+1].Dscp.DstPortNum;
pClsfrParams->ClsfrTable[j].DTag = pClsfrParams->ClsfrTable[j+1].DTag;
}
context_LeaveCriticalSection (pTxDataQ->hContext);
break;
case IPPORT_CLSFR:
/* Find the classifier entry */
i = 0;
while ((i < pClsfrParams->uNumActiveEntries) &&
((pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstIPAddress != pRemEntry->Dscp.DstIPPort.DstIPAddress) ||
(pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstPortNum != pRemEntry->Dscp.DstIPPort.DstPortNum) ||
(pClsfrParams->ClsfrTable[i].DTag != pRemEntry->DTag)))
{
i++;
}
/* If we have reached the number of active entries, it means we couldn't find the requested entry */
if (i == pClsfrParams->uNumActiveEntries)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): Entry not found - Aborting\n");
return PARAM_VALUE_NOT_VALID;
}
/* Shift all entries above the removed one downward. */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
for (j = i; j < pClsfrParams->uNumActiveEntries - 1; j++)
{
pClsfrParams->ClsfrTable[j].Dscp.DstIPPort.DstIPAddress = pClsfrParams->ClsfrTable[j+1].Dscp.DstIPPort.DstIPAddress;
pClsfrParams->ClsfrTable[j].Dscp.DstIPPort.DstPortNum = pClsfrParams->ClsfrTable[j+1].Dscp.DstIPPort.DstPortNum;
pClsfrParams->ClsfrTable[j].DTag = pClsfrParams->ClsfrTable[j+1].DTag;
}
context_LeaveCriticalSection (pTxDataQ->hContext);
break;
default:
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "classifier_RemoveClsfrEntry(): Classifier type -- unknown - Aborting\n");
}
/* Decrement the number of classifier active entries */
pClsfrParams->uNumActiveEntries--;
return TI_OK;
}
/**
* \fn txDataClsfr_SetClsfrType & txDataClsfr_GetClsfrType
* \brief Set / Get classifier type
*
* Set / Get classifier type.
* When setting type, the table is emptied!
*
* \note
* \param hTxDataQ - The object handle
* \param eNewClsfrType - New type
* \return TI_OK on success, PARAM_VALUE_NOT_VALID in case of input parameters problems.
* \sa
*/
TI_STATUS txDataClsfr_SetClsfrType (TI_HANDLE hTxDataQ, EClsfrType eNewClsfrType)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
if (eNewClsfrType > CLSFR_TYPE_MAX)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_setClsfrType(): classifier type exceed its MAX \n");
return PARAM_VALUE_NOT_VALID;
}
if (pTxDataQ->tClsfrParams.eClsfrType == eNewClsfrType)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_WARNING, "Classifier_setClsfrType(): equal classifier type --> will empty classifier table \n");
}
/* Update type and empty table. */
/* Note: Protect from txDataClsfr_ClassifyTxPacket context preemption. */
context_EnterCriticalSection (pTxDataQ->hContext);
pTxDataQ->tClsfrParams.eClsfrType = eNewClsfrType;
pTxDataQ->tClsfrParams.uNumActiveEntries = 0;
context_LeaveCriticalSection (pTxDataQ->hContext);
return TI_OK;
}
TI_STATUS txDataClsfr_GetClsfrType (TI_HANDLE hTxDataQ, EClsfrType *pClsfrType)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
*pClsfrType = pTxDataQ->tClsfrParams.eClsfrType;
return TI_OK;
}
#ifdef TI_DBG
/**
* \fn txDataClsfr_PrintClsfrTable
* \brief Print classifier table
*
* Print the classifier table for debug
*
* \note
* \param hTxDataQ - The object handle
* \return void
* \sa
*/
void txDataClsfr_PrintClsfrTable (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TClsfrParams *pClsfrParams = &pTxDataQ->tClsfrParams;
TI_UINT32 uIpAddr, i;
if (pClsfrParams->eClsfrType == D_TAG_CLSFR)
{
WLAN_OS_REPORT (("D_TAG classifier type selected...Nothing to print...\n"));
return;
}
WLAN_OS_REPORT (("Number of active entries in classifier table : %d\n",pClsfrParams->uNumActiveEntries));
switch (pClsfrParams->eClsfrType)
{
case DSCP_CLSFR:
WLAN_OS_REPORT (("+------+-------+\n"));
WLAN_OS_REPORT (("| Code | D-Tag |\n"));
WLAN_OS_REPORT (("+------+-------+\n"));
for (i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
WLAN_OS_REPORT (("| %5d | %5d |\n",
pClsfrParams->ClsfrTable[i].Dscp.CodePoint,pClsfrParams->ClsfrTable[i].DTag));
}
WLAN_OS_REPORT (("+-------+-------+\n"));
break;
case PORT_CLSFR:
WLAN_OS_REPORT (("+-------+-------+\n"));
WLAN_OS_REPORT (("| Port | D-Tag |\n"));
WLAN_OS_REPORT (("+-------+-------+\n"));
for (i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
WLAN_OS_REPORT (("| %5d | %5d |\n",
pClsfrParams->ClsfrTable[i].Dscp.DstPortNum,pClsfrParams->ClsfrTable[i].DTag));
}
WLAN_OS_REPORT (("+-------+-------+\n"));
break;
case IPPORT_CLSFR:
WLAN_OS_REPORT (("+-------------+-------+-------+\n"));
WLAN_OS_REPORT (("| IP Address | Port | D-Tag |\n"));
WLAN_OS_REPORT (("+-------------+-------+-------+\n"));
for (i = 0; i < pClsfrParams->uNumActiveEntries; i++)
{
uIpAddr = pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstIPAddress;
WLAN_OS_REPORT (("| %02x.%02x.%02x.%02x | %5d | %5d |\n",
(uIpAddr & 0xFF),((uIpAddr >> 8) & (0xFF)),((uIpAddr >> 16) & (0xFF)),((uIpAddr >> 24) & (0xFF)),
pClsfrParams->ClsfrTable[i].Dscp.DstIPPort.DstPortNum, pClsfrParams->ClsfrTable[i].DTag));
}
WLAN_OS_REPORT (("+-------------+-------+-------+\n"));
break;
default:
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "Classifier_InsertClsfrEntry(): Classifier type -- unknown - Aborting\n");
break;
}
}
#endif /* TI_DBG */