ixatmdrxcfginfo.c

有关ARM开发板上的IXP400网络驱动程序的源码以。

                /* release the NPE descriptor */
                ixAtmdAccDescNpeDescriptorRelease (npeDescriptor);
            }
        } /* end of for(descCount) */
        /* release the array of pointers */
        IX_ATMDACC_RXQ_RELEASE_RESOURCES(rxSwQueue);
    } /* end of if(IX_ATMDACC_RXQ_INITIALISED) */

    /* map the error status */
    if (returnStatus != IX_SUCCESS)
    {
        returnStatus = IX_FAIL;
    }
    return returnStatus;
}

/* ---------------------------------------------------------
* get the NpeVcId for this channel
*/
IX_STATUS
ixAtmdAccRxCfgNpeVcIdGet (IxAtmConnId connId,
                          unsigned int* npeVcIdPtr)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;
    IX_STATUS returnStatus = IX_SUCCESS;
    unsigned int npeVcId;

    npeVcId = IX_ATMDACC_RX_VC_INDEX_GET (connId);
    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];
    *npeVcIdPtr = npeVcId;

    /* check if the connection ID is valid */
    if (vcDescriptor->connId != connId)
    {
        /* check if the connection ID has been invalidated */
        if (vcDescriptor->connId != IX_ATMDACC_RX_DISCONNECTING (connId))
        {
            /* the connection ID does not correspond with the expected one */
            returnStatus = IX_FAIL;
        }
    } /* end of if(vcDescriptor) */
    return returnStatus;
}

/* ---------------------------------------------------------
*    invalidate the connection Id
*/
IX_STATUS
ixAtmdAccRxCfgConnIdInvalidate (unsigned int rxId)
{
    IX_STATUS returnStatus = IX_SUCCESS;

    IxAtmdAccRxVcDescriptor *vcDescriptor = &ixAtmdAccRxVcDescriptor[rxId];

    /* check if the connId is already invalidated */
    if (!IX_ATMDACC_RX_DISCONNECTED (vcDescriptor->connId))
    {
        vcDescriptor->connId = IX_ATMDACC_RX_DISCONNECTING (vcDescriptor->connId);
        /* connId is now invalidated : a direct comparison of the connId
        *   passed as a parameter and the connId stored in the structure
        *   will fail.
        */
    } /* end of if(IX_ATMDACC_RX_DISCONNECTED) */
    return returnStatus;
}

/* ---------------------------------------------------------
* check if all descriptors are recycled
*/
IX_STATUS
ixAtmdAccRxCfgFreeResourcesCheck (unsigned int npeVcId)
{
    IX_STATUS returnStatus = IX_SUCCESS;
    IxAtmdAccRxVcDescriptor *vcDescriptor;
    IX_ATMDACC_RX_QUEUE *rxSwQueue;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];
    rxSwQueue = &vcDescriptor->queue;

    /* check if resources are all free : this is done
    * by checking that the sw queue is in the initial
    * state (the queue is full). When the queue is full,
    * all resources are back and this mean that the
    * channel disconnect is now complete
    */

    if (!IX_ATMDACC_RXQ_ALL_RECYCLED(rxSwQueue))
    {
        returnStatus = IX_ATMDACC_RESOURCES_STILL_ALLOCATED;
    }
    return returnStatus;
}

/* ---------------------------------------------------------
* tell the NPE to start receive on this channel and
* update the lookup table
*/
IX_STATUS
ixAtmdAccRxCfgNpeVcLookupTableUpdate(unsigned int npeVcId)
{
    unsigned int npeParam0;
    unsigned int npeParam1;
    IxAtmdAccRxVcDescriptor* vcDescriptor;
    IX_STATUS returnStatus;
    IxAtmRxQueueId atmdStreamId;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];
    ixAtmdAccUtilAtmdQIdGet(vcDescriptor->rxQueueId, &atmdStreamId);
    
    npeParam0 =
        (vcDescriptor->npeAalType << NPE_MSG_RX_ENABLE_TYPE_SHIFT) |
        ((1 - atmdStreamId) << NPE_MSG_RX_ENABLE_RXQ_SHIFT) |
        (vcDescriptor->rxFreeQueueId << NPE_MSG_RX_ENABLE_RXFREEQ_SHIFT) |
        ((npeVcId) << NPE_MSG_RX_ENABLE_VCID_SHIFT);

    npeParam1 =
        (vcDescriptor->port << NPE_MSG_RX_ENABLE_PORT_SHIFT) |
        (vcDescriptor->vpi << NPE_MSG_RX_ENABLE_VPI_SHIFT) |
        (vcDescriptor->vci << NPE_MSG_RX_ENABLE_VCI_SHIFT);
    returnStatus = ixAtmdAccUtilNpeMsgSend(IX_NPE_A_MSSG_ATM_RX_ENABLE,
        npeParam0,
        npeParam1);

    return returnStatus;
}

/* ---------------------------------------------------------
* check if Rx disconnect is in progress
*/
BOOL
ixAtmdAccRxCfgVcIsDisconnecting(unsigned int npeVcId)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];

    return IX_ATMDACC_RX_DISCONNECTED (vcDescriptor->connId);
}

/* ---------------------------------------------------------
* check if Rx Traffic is enabled
*/
BOOL
ixAtmdAccRxCfgVcIsEnabled(unsigned int npeVcId)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];

    return vcDescriptor->status == IX_ATMDACC_RX_CHANNEL_UP;
}

/* ---------------------------------------------------------
* Enable Rx Traffic
*/
void
ixAtmdAccRxCfgVcEnable (unsigned int npeVcId)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];

    vcDescriptor->status = IX_ATMDACC_RX_CHANNEL_UP;

    /* update stats */
    IX_ATMDACC_FULL_STATS( ixAtmdAccRxEnableCount++; );
    
    return;
}

/* ---------------------------------------------------------
* Enable Rx Traffic
*/
void
ixAtmdAccRxCfgVcEnableRollback (unsigned int npeVcId)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];

    vcDescriptor->status = IX_ATMDACC_RX_CHANNEL_DOWN;
    
    return;
}

/* ---------------------------------------------------------
* check if Rx Traffic is stopped
*/
BOOL
ixAtmdAccRxCfgVcIsDisabled(unsigned int npeVcId)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];

    return vcDescriptor->status == IX_ATMDACC_RX_CHANNEL_DOWN;
}

/* ---------------------------------------------------------
* disable Rx Traffic
*/
void
ixAtmdAccRxCfgVcDisable(unsigned int npeVcId)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;
    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];

    vcDescriptor->status = IX_ATMDACC_RX_CHANNEL_DOWN_PENDING;

    /* update stats */
    IX_ATMDACC_FULL_STATS( ixAtmdAccRxDisableCount++; );

    return;
}

/* ---------------------------------------------------------
* set a callback for rxfree events
*/
IX_STATUS
ixAtmdAccRxCfgRxFreeCallbackSet (unsigned int npeVcId,
                                 unsigned int thresholdLevel,
                                 IxAtmdAccRxVcFreeLowCallback callback)
{
    IxAtmdAccRxVcDescriptor *vcDescriptor;
    IxQMgrQId rxFreeQueueId;
    IX_STATUS returnStatus = IX_SUCCESS;
    unsigned int numberOfEntries;

    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];
    rxFreeQueueId = vcDescriptor->rxFreeQueueId;

    /* check the threshold level is above the current queue level */
    if (thresholdLevel > (vcDescriptor->rxFreeQueueSize / 2))
    {
        returnStatus = IX_FAIL;
    }
    else
    {
        /* read the number from the queue manager */
        returnStatus = ixQMgrQNumEntriesGet (rxFreeQueueId, &numberOfEntries);
        
        /* read again the number of entries  */
        if (returnStatus == IX_QMGR_WARNING)
        {
            returnStatus = ixQMgrQNumEntriesGet (rxFreeQueueId, &numberOfEntries);
            
            if (returnStatus == IX_QMGR_WARNING)
            {
                /* the queue is empty */
                numberOfEntries = 0; 
                returnStatus = IX_SUCCESS;
            }
        } /* end of if(returnStatus) */
        
        if ((returnStatus != IX_SUCCESS) || (numberOfEntries <= thresholdLevel))
        {
        /* It will fail if the threshold level is above the current queue level 
        * because notifications will not trigger  when the first
        * traffic will be received
            */
            returnStatus = IX_FAIL;
        }
        else
        {
            /* register the user callback */
            vcDescriptor->rxFreeNotification = callback;
            
            if(ixAtmdAccUtilQmgrCallbackSet (rxFreeQueueId,
                thresholdLevel,
                thresholdLevel,
                IX_QMGR_Q_SOURCE_ID_NE,
                ixAtmdAccRxFreeCallback,
                (IxQMgrCallbackId) npeVcId,
                IX_QMGR_Q_PRIORITY_1) != IX_SUCCESS)
            {
                returnStatus = IX_FAIL;
            }
        }
    }

    return returnStatus;
}

/* ---------------------------------------------------------
* set a callback for rx events
*/
IX_STATUS
ixAtmdAccRxCfgRxCallbackSet (IxAtmRxQueueId atmRxQueueId,
                             IxQMgrQId qMgrQId,
                             IxAtmdAccRxDispatcher callback)
{
    IX_STATUS returnStatus = IX_SUCCESS;

    /* register the new user callback */
    ixAtmdAccRxUserCallback[atmRxQueueId] = callback;

    if(ixAtmdAccUtilQmgrCallbackSet (qMgrQId,
        0,
        0,
        IX_QMGR_Q_SOURCE_ID_NOT_E,
        ixAtmdAccRxCallback,
        (IxQMgrCallbackId) atmRxQueueId,
        IX_QMGR_Q_PRIORITY_0) != IX_SUCCESS)
    {
        returnStatus = IX_FAIL;
    }
    return returnStatus;
}


/* ---------------------------------------------------------
* Reset the callback for rx events
*/
IX_STATUS
ixAtmdAccRxCfgRxCallbackReset (IxAtmRxQueueId atmRxQueueId,
                             IxQMgrQId qMgrQId)
{
    /* register the new user callback */
    ixAtmdAccRxUserCallback[atmRxQueueId] = ixAtmdAccRxDummyProcessPerform;

    if (IX_SUCCESS != ixQMgrNotificationDisable (qMgrQId) )
    {
        return IX_FAIL;
    }
    return IX_SUCCESS;
}




/* ---------------------------------------------------------
* Check if any Vcs exist
*/
BOOL
ixAtmdAccRxCfgRxVcsExist (void)
{
    int vc;
    BOOL returnValue = FALSE;

    /* iterate through VC until found */
    for (vc = 0; returnValue == FALSE && vc < IX_ATM_MAX_NUM_AAL_OAM_RX_VCS; vc++)
    {
        if (IX_ATMDACC_RX_VC_INUSE (ixAtmdAccRxVcDescriptor[vc].connId))
        {
            returnValue = TRUE;
        }
    }
    return returnValue;
}

/* ---------------------------------------------------------
* release all resources in the RxFree queue for this channel
*/
IX_STATUS
ixAtmdAccRxCfgResourcesRelease (unsigned int npeVcId)
{
    IxAtmdAccNpeDescriptor *npeDescriptor;
    UINT32 rxBitField;
    IX_OSAL_MBUF *mbufPtr;
    IX_OSAL_MBUF *mbufPtrTmp;
    IX_STATUS returnStatus = IX_SUCCESS;
    unsigned int qEntry;
    IxAtmdAccRxVcDescriptor *vcDescriptor;
    IX_ATMDACC_RX_QUEUE *rxSwQueue;
   
    /* get the VC descriptor */
    vcDescriptor = &ixAtmdAccRxVcDescriptor[npeVcId];
    rxSwQueue = &vcDescriptor->queue;

    /* test unreachable conditions */
    IX_ATMDACC_ENSURE (npeVcId < IX_ATM_MAX_NUM_AAL_OAM_RX_VCS, "Invalid NpeVcId");
    IX_ATMDACC_ENSURE (IX_ATMDACC_RX_VC_INUSE (vcDescriptor->connId), "Invalid ConnId");