ixatmdtxcfgif.c

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

        return IX_FAIL;
        break;
    }
    return IX_SUCCESS;
}

/* ---------------------------------------------------
*   do the real function of ixAtmdAccTxVcConnect
*/
PRIVATE IX_STATUS
ixAtmdAccTxVcConnectPerform (IxAtmLogicalPort port,
                             unsigned int vpi,
                             unsigned int vci,
                             IxAtmdAccAalType aalServiceType,
                             IxAtmdAccUserId userId,
                             IxAtmdAccTxVcBufferReturnCallback txDoneCallback,
                             IxAtmConnId * connIdPtr)
{
    IxAtmSchedulerVcId schedulerId;
    IX_STATUS returnStatus =IX_FAIL;

    /* check that the port has been configured and is UP */
    if (ixAtmdAccTxPortEnabledQuery (port))
    {
        /* check if this VC is already in use */
        if (!ixAtmdAccTxCfgVcConfigured (port, vpi, vci))
        {
            /* allocate a channel and get a connection Id for this connection */
            if(ixAtmdAccTxCfgFreeChannelGet (aalServiceType, connIdPtr) != IX_SUCCESS)
            {
                returnStatus = IX_ATMDACC_BUSY;
            }
            else
            {
                /* get scheduler id for this VC, using the user scheduler callback */
                if(ixAtmdAccTxCfgSchVcIdGet (port,
                    vpi,
                    vci,
                    *connIdPtr,
                    &schedulerId) == IX_SUCCESS)
                {
                    /* configure the channel */
                    returnStatus = ixAtmdAccTxCfgChannelSet (*connIdPtr,
                        schedulerId,
                        port,
                        vpi,
                        vci,
                        aalServiceType,
                        userId,
                        txDoneCallback);
                    if(returnStatus != IX_SUCCESS)
                    {
                        /* roll back by clearing the requested scheduler demand */
                        ixAtmdAccTxCfgVcDemandCancel (*connIdPtr, port, schedulerId);
                    }
                }
            }
        } /* end of if(ixAtmdAccTxCfgVcConfigured) */
    } /* end of if(ixAtmdAccTxPortEnabledQuery) */

    return returnStatus;
}

/* ---------------------------------------------------
*   establish a connection on this port, vpi and vci
*/
PUBLIC IX_STATUS
ixAtmdAccTxVcConnect (IxAtmLogicalPort port,
                      unsigned int vpi,
                      unsigned int vci,
                      IxAtmdAccAalType aalServiceType,
                      IxAtmdAccUserId userId,
                      IxAtmdAccTxVcBufferReturnCallback txDoneCallback,
                      IxAtmConnId * connIdPtr)
{

    IX_STATUS returnStatus = IX_FAIL;

    /* we have not been initialised, or we
    have be passed a null poiter, so no point
    in continuing
    */
    if(ixAtmdAccTxCfgInitDone)
    {
        /* protect against re-entrancy */
        IX_ATMDACC_TX_LOCK_GET ();

        if(ixAtmdAccTxVcConnectParamsValidate (port,
            vpi,
            vci,
            aalServiceType,
            txDoneCallback,
            connIdPtr) == IX_SUCCESS)
        {
            returnStatus = ixAtmdAccTxVcConnectPerform (port,
                vpi,
                vci,
                aalServiceType,
                userId,
                txDoneCallback,
                connIdPtr);
        }

        if(returnStatus == IX_SUCCESS)
        {
            /* increment statistics */
            ixAtmdAccTxStats.connectCount++;
        }
        else
        {
            /* increment statistics */
            ixAtmdAccTxStats.connectDenied++;
        } /* end of if-else(ixAtmdAccTxCfgVcConfigured) */

        IX_ATMDACC_TX_LOCK_RELEASE ();
    }
    return returnStatus;
}

/* ---------------------------------------------------
*   remove a connection
*/
PUBLIC IX_STATUS
ixAtmdAccTxVcTryDisconnect (IxAtmConnId connId)
{
    unsigned int txId;
    IX_STATUS returnStatus = IX_FAIL;

    /* we have not been initialised no point
    in continuing
    */
    if(ixAtmdAccTxCfgInitDone)
    {
        IX_ATMDACC_TX_LOCK_GET ();

        /* check the connId and retrieve the channel id */
        if(ixAtmdAccTxCfgIndexGet (connId, &txId) == IX_SUCCESS)
        {
            /* invalidate the connection Id */
            ixAtmdAccTxCfgConnIdInvalidate (txId);

            /* remove entries from the tx queue if the port is down */
            if(ixAtmdAccTxCfgPortResourcesRelease (connId) == IX_SUCCESS)
            {
                /* check if resources are still allocated */
                if(!ixAtmdAccTxCfgFreeResourcesCheck (txId))
                {
                    returnStatus = IX_ATMDACC_RESOURCES_STILL_ALLOCATED;
                }
                else
                {
                    /* clear any scheduler demand
                    * this must be done before reset because reset
                    * destroys the schedulerId
                    */
                    ixAtmdAccTxCfgVcDemandClear (connId);

                    /* reset internal data */
                    returnStatus = ixAtmdAccTxCfgChannelReset (txId);
                } /* end of if-else(qEntry) */
            }
        }

        if(returnStatus == IX_SUCCESS)
        {
            ixAtmdAccTxStats.disconnectCount++;
        }
        else
        {
            ixAtmdAccTxStats.disconnectDenied++;
        } /* end of if-else(ixAtmdAccTxCfgVcConfigured) */

        IX_ATMDACC_TX_LOCK_RELEASE ();
    }
    return returnStatus;
}

/* ------------------------------------------------
*   set the tx queue nearly-empty threshold
*/
PUBLIC IX_STATUS
ixAtmdAccPortTxCallbackRegister (IxAtmLogicalPort port,
                                 unsigned int numberOfCells,
                                 IxAtmdAccPortTxLowCallback callback)
{
    IX_STATUS returnStatus = IX_FAIL;

    if (ixAtmdAccTxCfgInitDone &&
        (port >= IX_UTOPIA_PORT_0) &&
        (port < IX_UTOPIA_MAX_PORTS) &&
        (callback != NULL))
    {
        IX_ATMDACC_TX_LOCK_GET ();

        if(ixAtmdAccPortConfigured (port) &&
            !ixAtmdAccTxCfgPortVcsExist (port))
        {
            returnStatus = ixAtmdAccTxCfgTxCallbackRegister (port, numberOfCells, callback);
        }

        IX_ATMDACC_TX_LOCK_RELEASE ();
    } /* end of if(ixAtmdAccTxCfgInitDone) */

    return returnStatus;
}


/* ------------------------------------------------
*   set the tx queue nearly-empty threshold
*/
PUBLIC void
ixAtmdAccPortTxCallbackUnregister (IxAtmLogicalPort port)
{
    ixAtmdAccTxCfgTxCallbackUnregister(port);
}



/* ------------------------------------------------
*   set the transmit dome nearly-full threshold
*/
PUBLIC IX_STATUS
ixAtmdAccTxDoneDispatcherRegister (unsigned int numberOfMbufs,
                                   IxAtmdAccTxDoneDispatcher callback)
{
    IX_STATUS returnStatus = IX_FAIL;

    /* Check that initialisation has been done,
    that we have not been passed a null pointer,
    and that the port is idle, the threshold should
    not be set whilst there is traffic present
    */
    if(ixAtmdAccTxCfgInitDone &&
        (callback != NULL))
    {
        IX_ATMDACC_TX_LOCK_GET ();

        if(!ixAtmdAccTxCfgVcsExist ())
        {
            returnStatus = ixAtmdAccTxCfgTxDoneCallbackRegister (numberOfMbufs, callback);
        }

        IX_ATMDACC_TX_LOCK_RELEASE ();
    }

    return returnStatus;
}


/* --------------------------------------------
*   Unregister the transmit done queue dispatcher
*/
PUBLIC void
ixAtmdAccTxDoneDispatcherUnregister (void)
{
    ixAtmdAccTxCfgTxDoneCallbackUnregister ();
}


/* ----------------------------------------------------
*   check the input params for ixAtmdAccPortTxScheduledModeEnable
*/
PUBLIC IX_STATUS
ixAtmdAccPortTxScheduledModeEnablePararmsValidate (IxAtmLogicalPort port,
                                                   IxAtmdAccTxVcDemandUpdateCallback demandUpdate,
                                                   IxAtmdAccTxVcDemandClearCallback demandClear,
                                                   IxAtmdAccTxSchVcIdGetCallback vcIdGet)
{
    IX_STATUS returnStatus = IX_SUCCESS;

    /* check parameters */
    if ((port >= IX_UTOPIA_MAX_PORTS) ||
        (port < IX_UTOPIA_PORT_0)  ||
        (demandUpdate == NULL)     ||
        (demandClear == NULL)      ||
        (vcIdGet == NULL)          ||
        !ixAtmdAccPortConfigured (port))
    {
        returnStatus = IX_FAIL;
    } /* end of if(port) */

    return returnStatus;
}

/* ----------------------------------------------------
*        regsiter the scheduler
*/
PUBLIC IX_STATUS
ixAtmdAccPortTxScheduledModeEnable (IxAtmLogicalPort port,
                                    IxAtmdAccTxVcDemandUpdateCallback demandUpdate,
                                    IxAtmdAccTxVcDemandClearCallback demandClear,
                                    IxAtmdAccTxSchVcIdGetCallback vcIdGet)
{
    IX_STATUS returnStatus = IX_FAIL;

    /* we have not been initialised no point
    in continuing
    */
    if(ixAtmdAccTxCfgInitDone)
    {
        IX_ATMDACC_TX_LOCK_GET ();

        /* check input params */
        if(ixAtmdAccPortTxScheduledModeEnablePararmsValidate (port,
            demandUpdate,
            demandClear,
            vcIdGet) == IX_SUCCESS)
        {
            /* check no channel are already set on this port */
            if (!ixAtmdAccTxCfgPortVcsExist (port))
            {
                ixAtmdAccTxCfgSchCallbackRegister (port,
                    demandUpdate,
                    demandClear,
                    vcIdGet);
                returnStatus = IX_SUCCESS;
            } /* end of if(ixAtmdAccTxCfgPortVcsExist) */
        }
        IX_ATMDACC_TX_LOCK_RELEASE ();
    }

    return returnStatus;
}



/* ----------------------------------------------------
*       deregister the scheduler
*/
PUBLIC IX_STATUS
ixAtmdAccPortTxScheduledModeDisable (IxAtmLogicalPort port)
{
    IX_STATUS returnStatus = IX_SUCCESS;

     /* check parameters */
    if ((IX_UTOPIA_MAX_PORTS <= port) ||
        (IX_UTOPIA_PORT_0 > port) ||
        (!ixAtmdAccPortConfigured (port)))
    {
        returnStatus = IX_FAIL;
    }  /* end of if(port) */

    if (ixAtmdAccTxCfgInitDone)
    {
        IX_ATMDACC_TX_LOCK_GET ();

        /* check no channel is already set on this port */
            if (!ixAtmdAccTxCfgPortVcsExist (port))
            {
                ixAtmdAccTxCfgSchCallbackUnregister (port);
                returnStatus = IX_SUCCESS;
            } /* end of if(ixAtmdAccTxCfgPortVcsExist) */

        IX_ATMDACC_TX_LOCK_RELEASE ();
    }

    return returnStatus;
}



/* ----------------------------------------------------
*       get the tx done queue size
*/
PUBLIC IX_STATUS
ixAtmdAccTxDoneQueueSizeQuery (unsigned int *numberOfPdusPtr)
{
    IX_STATUS returnStatus = IX_FAIL;

    /* check parameters */
    if (ixAtmdAccTxCfgInitDone &&
        numberOfPdusPtr != NULL)
    {
        /* query the queue size */
        returnStatus =
            ixAtmdAccUtilQueueSizeQuery(IX_NPE_A_QMQ_ATM_TX_DONE,
            numberOfPdusPtr);
    } /* end of if(ixAtmdAccTxCfgInitDone) */
    return returnStatus;
}