ixatmm.c

来自「有关ARM开发板上的IXP400网络驱动程序的源码以。」· C语言 代码 · 共 964 行 · 第 1/2 页

    if ((txPortRate == NULL) || (rxPortRate == NULL))
    {
        return IX_ATMM_RET_INVALID_PARAM_PTR;
    }

    if (!portValidate (port))
    {
	return IX_ATMM_RET_INVALID_PORT;
    }

    *txPortRate = ixAtmmPortInfo[port].txPortRate;
    *rxPortRate = ixAtmmPortInfo[port].rxPortRate;

    return IX_SUCCESS;
}

PUBLIC IX_STATUS
ixAtmmPortModify (IxAtmLogicalPort port, 
		  unsigned txPortRate, 
		  unsigned rxPortRate)
{
    IX_STATUS retval;
    unsigned portRateCells;

    if (!portValidate (port))
    {
	return IX_ATMM_RET_INVALID_PORT;
    }

    if ((txPortRate == 0) || (rxPortRate == 0))
    {
	return IX_FAIL;
    }
    
    /* Notify AtmSch of the new transmit port rate (cells per second) */
    portRateCells = (unsigned) txPortRate / IX_ATMM_BITS_PER_ATM_CELL;

    IX_ATMM_LOCK();

    retval = ixAtmSchPortRateModify (port, portRateCells);

    if (retval != IX_SUCCESS) 
    {
	IX_ATMM_UNLOCK();
	return IX_FAIL;
    }

    /* Store port rates */
    ixAtmmPortInfo[port].txPortRate = txPortRate;
    ixAtmmPortInfo[port].rxPortRate =  rxPortRate;

    IX_ATMM_UNLOCK();

    return IX_SUCCESS;
}

/************************************************************************
 * Function Name: checkVcNotAlreadyRegistered
 * Parameters   : In: port - Port to register this VC
 *                In: vcDesc - VC descriptor for VC to be verified
 *                Out: vcId - Set to vcId of existing VC if the VC has 
 *                            been previously registered.  
 *                            Set to -1 otherwise.
 * Description  : Validates whether a given VC descriptor has
 *                already been registered in the system
 * Return Value : IX_SUCCESS, IX_ATMM_RET_ALREADY_ACTIVATED
 ************************************************************************/
PRIVATE IX_STATUS
checkVcNotAlreadyRegistered (IxAtmLogicalPort port, IxAtmmVc *vcDesc, IxAtmSchedulerVcId *vcId)
{
    int i;

    *vcId = -1;
    for (i=0; i<IX_ATMM_MAX_RX_TX_VCS; i++)
    {
	if (port == ixAtmmVcInfo[i].port)
	{
	    if ( (ixAtmmVcInfo[i].inUse) &&
		 (ixAtmmVcInfo[i].vcData.vpi == vcDesc->vpi) &&
		 (ixAtmmVcInfo[i].vcData.vci == vcDesc->vci) &&
		 (ixAtmmVcInfo[i].vcData.direction == vcDesc->direction) )
	    {
		*vcId = i;
		return IX_ATMM_RET_VC_CONFLICT;
	    }
	}
    }
    return IX_SUCCESS;
}


/************************************************************************
 * Function Name: validateVC
 * Parameters   : In: vcDesc - VC descriptor for VC to be validated
 * Description  : Verifies whether a given VC descriptor is a valid
 *                one in the system
 * Return Value : IX_SUCCESS, IX_ATMM_INVALID_VC_DESCRIPTOR, 
 *                IX_ATMM_VC_CONFLICT
 ************************************************************************/
PRIVATE IX_STATUS
validateVC(IxAtmmVc *vcDesc)
{
    if (vcDesc == NULL)
    {
	return IX_ATMM_RET_INVALID_VC_DESCRIPTOR;
    }

    if ( (vcDesc->vpi > 0xff) ||   /* VPI is an 8 bit number at UNI */
	 (vcDesc->vci > 0xffff) )  /* VCI is a 16 bit number */
    {
	return IX_ATMM_RET_INVALID_VC_DESCRIPTOR;
    }
    
    if ( (vcDesc->direction != IX_ATMM_VC_DIRECTION_TX) &&
	 (vcDesc->direction != IX_ATMM_VC_DIRECTION_RX) )
    {
	return IX_ATMM_RET_INVALID_VC_DESCRIPTOR;
    }
    
    switch (vcDesc->trafficDesc.atmService)
    {
	case IX_ATM_CBR:
	case IX_ATM_RTVBR:
	case IX_ATM_VBR:
	case IX_ATM_UBR:
	case IX_ATM_ABR:
	    break;
	default:
	    return IX_ATMM_RET_INVALID_VC_DESCRIPTOR;
    }

    return IX_SUCCESS;
}

/************************************************************************
 * Function Name: setupTxVc
 * Parameters   : In: port - port to add VC on
 *                In: vcDesc - VC descriptor for VC to be added
 *                Out: newVcId - ptr to vcId allocated to new VC
 * Description  : Adds a new Tx VC to the system (via the ixAtmSch 
 *                component) and returns it's vcId.
 * Return Value : IX_SUCCESS, IX_ATMM_PORT_CAPACITY_IS_FULL,
 *                IX_ATMM_INVALID_VC_DESCRIPTOR
 ************************************************************************/
PRIVATE IX_STATUS
setupTxVc (IxAtmLogicalPort port, IxAtmmVc *vcDesc, IxAtmSchedulerVcId *newVcId)
{
    IX_STATUS retval;

    /* Transmit VCs must be registered with the scheduler,
     * N.B. ATMSCH generates the vcId
     */
    retval = ixAtmSchVcModelSetup (port, &vcDesc->trafficDesc, newVcId);

    if (retval == IX_ATMSCH_RET_NOT_ADMITTED) 
    {
	return IX_ATMM_RET_PORT_CAPACITY_IS_FULL;
    }
    if (retval == IX_FAIL) 
    {
	return IX_ATMM_RET_INVALID_VC_DESCRIPTOR;
    }

    /* Check ATMSCH generated a VcId in the correct range */
    IX_OSAL_ASSERT((*newVcId >= 0) && (*newVcId < IX_ATM_MAX_NUM_AAL_OAM_TX_VCS ));

    /* If the VC is already in use then ATMM & ATMSCH are inconsistent */
    IX_OSAL_ASSERT(ixAtmmVcInfo[*newVcId].inUse == FALSE);
    
    return IX_SUCCESS;
}

/************************************************************************
 * Function Name: getRxVcId
 * Parameters   : Out: newVcId - ptr to vcId allocated to new VC
 * Description  : Finds the next available Rx vcId and returns it
 * Return Value : IX_SUCCESS, IX_ATMM_PORT_CAPACITY_IS_FULL
 ************************************************************************/
PRIVATE IX_STATUS
getRxVcId (IxAtmSchedulerVcId *newVcId)
{
    int i;

    *newVcId = -1;
	    
    for (i=IX_ATM_MAX_NUM_AAL_OAM_TX_VCS ; i<IX_ATMM_MAX_RX_TX_VCS; i++)
    {
	if (ixAtmmVcInfo[i].inUse == FALSE)
	{
	    *newVcId = i;
	    return IX_SUCCESS;
	}
    }
    return IX_ATMM_RET_PORT_CAPACITY_IS_FULL;
}

/************************************************************************
 * Function Name: callCallbacks
 * Parameters   : In: eventType - Indicates whether VC has been added 
 *                                or removed
 *                In: port to callback on
 *                In: vcDesc - VC Descriptor of modified VC
 * Description  : Invokes all registered callbacks with indication of the
 *                change to the system profile.
 * Return Value : void
 ************************************************************************/
PRIVATE void
callCallbacks (IxAtmmVcChangeEvent eventType, 
	       IxAtmLogicalPort port, 
	       IxAtmmVc *vcDesc)
{
    int i;
    IxAtmmVcChangeCallback callback = NULL;  

    for (i=0; i<IX_ATMM_MAX_NUM_VC_CHANGE_CBS; i++)
    {
	callback = vcChangeCbTable[i];
	if (callback != NULL)
	{
	    /* 
	     * Call the client supplied callback to inform 
	     * of the newly changed VC.  We return the original
	     * VC description supplied by the client.  It is the 
	     * responsibility of the client supplied callback that 
	     * this not be modified.
	     */
	    callback (eventType, port, vcDesc);
	}
    }
}

PUBLIC IX_STATUS
ixAtmmVcRegister (IxAtmLogicalPort port, 
		  IxAtmmVc *vcDesc, 
		  IxAtmSchedulerVcId *vcId)
{    
    IxAtmSchedulerVcId newVcId;
    IX_STATUS retval = IX_SUCCESS;

    if (!portValidate (port))
    {
	return IX_ATMM_RET_INVALID_PORT;
    }

    retval = validateVC(vcDesc);
    if (retval != IX_SUCCESS) 
    {
	return retval;
    }

    if (vcId == NULL)
    {
        return IX_ATMM_RET_INVALID_PARAM_PTR;
    }

    IX_ATMM_LOCK();

    /* Check that the VC hasn't been registered already. */
    retval = checkVcNotAlreadyRegistered (port, vcDesc, vcId);

    if (retval == IX_SUCCESS)
    {
	if (vcDesc->direction == IX_ATMM_VC_DIRECTION_TX) 
	{ 
	    retval = setupTxVc (port, vcDesc, &newVcId);
	}
	else
	{
	    retval = getRxVcId (&newVcId);
	}
    }

    if (retval == IX_SUCCESS) 
    {
	/* Store the VC Details */
        ixAtmmVcInfo[newVcId].port = port;
	ixAtmmVcInfo[newVcId].vcData = *vcDesc;
	*vcId = newVcId;
	ixAtmmVcInfo[newVcId].inUse = TRUE;
    }

    IX_ATMM_UNLOCK();

    if (retval == IX_SUCCESS)
    {
	callCallbacks (IX_ATMM_VC_CHANGE_EVENT_REGISTER, port, vcDesc);
    }
    return retval;
}

PUBLIC IX_STATUS
ixAtmmVcDeregister (IxAtmLogicalPort port, IxAtmSchedulerVcId vcId)
{
    IX_STATUS retval = IX_SUCCESS;
    IxAtmmVc *vcRemoved = NULL;

    if (!portValidate (port))
    {
	return IX_ATMM_RET_INVALID_PORT;
    }

    IX_ATMM_LOCK();
    
    if ( (vcId < 0) || 
	 (vcId > (IX_ATMM_MAX_RX_TX_VCS - 1) ) ||
	 !ixAtmmVcInfo[vcId].inUse || 
	 (ixAtmmVcInfo[vcId].port != port))
    {
	retval = IX_FAIL;
    }
    else
    {
	if (ixAtmmVcInfo[vcId].vcData.direction == IX_ATMM_VC_DIRECTION_TX)
	{
	    retval = ixAtmSchVcModelRemove (port, vcId);
	    
	    /* Should always succeed */
	    IX_OSAL_ASSERT(retval == IX_SUCCESS);
	}
	vcRemoved = &ixAtmmVcInfo[vcId].vcData;
	ixAtmmVcInfo[vcId].inUse = FALSE;
    }

    IX_ATMM_UNLOCK();

    if (retval == IX_SUCCESS)
    {
	callCallbacks (IX_ATMM_VC_CHANGE_EVENT_DEREGISTER, port, vcRemoved);
    }
    return retval;
}

PUBLIC IX_STATUS
ixAtmmVcQuery (IxAtmLogicalPort port, 
	       unsigned vpi, 
	       unsigned vci, 
	       IxAtmmVcDirection direction, 
	       IxAtmSchedulerVcId *vcId, 
	       IxAtmmVc *vcDesc)
{
    int i;
    IxAtmSchedulerVcId vcIdFound = -1;
    IX_STATUS retval;

    if (!portValidate (port))
    {
	return IX_ATMM_RET_INVALID_PORT;
    }

    if ((vcDesc == NULL) || (vcId == NULL))
    {
        return IX_ATMM_RET_INVALID_PARAM_PTR;
    }

    IX_ATMM_LOCK();
    
    for (i=0; i<IX_ATMM_MAX_RX_TX_VCS; i++)
    {
	if ( (ixAtmmVcInfo[i].inUse) && 
	     (ixAtmmVcInfo[i].port == port) &&
	     (ixAtmmVcInfo[i].vcData.direction == direction) &&
	     (ixAtmmVcInfo[i].vcData.vci == vci) &&
	     (ixAtmmVcInfo[i].vcData.vpi == vpi))
	{
	    vcIdFound = i;
	    break;
	}
    }

    if (vcIdFound == -1)
    {
	retval = IX_ATMM_RET_NO_SUCH_VC;
    }
    else
    {
	*vcId = vcIdFound;
	*vcDesc = ixAtmmVcInfo[vcIdFound].vcData;
	retval = IX_SUCCESS;
    }

    IX_ATMM_UNLOCK();

    return retval;
}

PUBLIC IX_STATUS
ixAtmmVcIdQuery (IxAtmLogicalPort port, IxAtmSchedulerVcId vcId, IxAtmmVc *vcDesc)
{
    IX_STATUS retval = IX_SUCCESS;

    if (!portValidate (port))
    {
	return IX_ATMM_RET_INVALID_PORT;
    }

    if (vcDesc == NULL)
    {
        return IX_ATMM_RET_INVALID_PARAM_PTR;
    }

    IX_ATMM_LOCK();
    
    if ( (vcId < 0) || (vcId > (IX_ATMM_MAX_RX_TX_VCS - 1) ) )
    {
	retval = IX_ATMM_RET_INVALID_VC_ID;
    }
    if ( (retval == IX_SUCCESS) &&
	 (!ixAtmmVcInfo[vcId].inUse || 
	  (ixAtmmVcInfo[vcId].port != port) ))
    {
	retval = IX_ATMM_RET_NO_SUCH_VC;
    }
    if (retval == IX_SUCCESS)
    {
	*vcDesc = ixAtmmVcInfo[vcId].vcData;
	retval = IX_SUCCESS;
    }
    IX_ATMM_UNLOCK();

    return retval;
}

PUBLIC IX_STATUS
ixAtmmVcChangeCallbackRegister (IxAtmmVcChangeCallback callback)
{
    int i;
    
    /* Check if at least one port initialized */
    if (!ixAtmmPortInfo[IX_UTOPIA_PORT_0].initialized)
    {
	return IX_FAIL;
    }
    
    IX_ATMM_LOCK();
    for (i=0; i<IX_ATMM_MAX_NUM_VC_CHANGE_CBS; i++)
    {
	if (vcChangeCbTable[i] == NULL)
	{
	    vcChangeCbTable[i] = callback;
	    break;
	}
    }
    IX_ATMM_UNLOCK();

    if (i == IX_ATMM_MAX_NUM_VC_CHANGE_CBS)
    {
	return IX_FAIL;
    }

    return IX_SUCCESS;
}

PUBLIC IX_STATUS
ixAtmmVcChangeCallbackDeregister (IxAtmmVcChangeCallback callback)
{
    int i;

    /* Check if at least one port initialized */
    if (!ixAtmmPortInfo[IX_UTOPIA_PORT_0].initialized)
    {
	return IX_FAIL;
    }

    IX_ATMM_LOCK();
    for (i=0; i<IX_ATMM_MAX_NUM_VC_CHANGE_CBS; i++)
    {
	if (vcChangeCbTable[i] == callback)
	{
	    vcChangeCbTable[i] = NULL;
	    break;
	}
    }
    IX_ATMM_UNLOCK();

    /* specified callback is not registered */
    if (i == IX_ATMM_MAX_NUM_VC_CHANGE_CBS)
    {
	return IX_FAIL;
    }
    return IX_SUCCESS;
}