ixhssaccpcm.c

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

	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].hdlcRxFraming = hdlcRxFraming;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].frmFlagStart = frmFlagStart;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxCallback =
	    rxCallback;    
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	    rxDisconnectingCallback = rxCallback;    
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneCallback =
	    txDoneCallback;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	    txDoneDisconnectingCallback = txDoneCallback;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled = FALSE;
	/* 
	 * rxUserId is a client specified value which gets passed back 
	 * to the client through the clients Rx Callback
	 */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxUserId = rxUserId;
	/* 
	 * disconnectingRxUserId is a copy of the clients specified rxUserId
	 * While disconnecting, rxUserId will be overwritten by the hssAcc to 
	 * pass other info to the rxDisconnectCallback. disconnectingRxUserId
	 * will be the passed back to the client in the rxDisconnectCallback.
	 */  
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].disconnectingRxUserId =
	    rxUserId;
	/* 
	 * txDoneUserId is a client specified value which gets passed back 
	 * to the client through the clients TxDone Callback
	 */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneUserId = txDoneUserId;
	/* 
	 * disconnectingTxDoneUserId is a copy of the clients specified txDoneUserId
	 * While disconnecting, txDoneUserId will be overwritten by the hssAcc to 
	 * pass other info to the txDoneDisconnectCallback. disconnectingTxDoneUserId
	 * will be the passed back to the client in the txDoneDisconnectCallback.
	 */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].disconnectingTxDoneUserId =
	    txDoneUserId;
        /* 
	 * rxFreeLowUserId is a client specified value which gets passed back 
	 * to the client through the clients rxFreeLow Callback
	 */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowUserId = rxFreeLowUserId;
	/* Set the IsConnected flag for this Hss/Hdlc Port combination*/
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected = TRUE;
	ixHssAccPCMStats.connections++;
	/* Initialise the PDM Stats for this client*/
	ixHssAccPDMStatsInit (hssPortId, hdlcPortId); 
	
	if (hdlcFraming)
	{
	    ixHssAccPCMStats.hdlcConnections++;
	}
	else
	{
	    ixHssAccPCMStats.rawConnections++;
	}
	
	if (!hdlcMode.hdlc56kMode)
	{
	    ixHssAccPCMStats.hdlc64kConnections++;
	}
	else
	{
	    ixHssAccPCMStats.hdlc56kConnections++;
	}
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting ixHssAccPCMConnect\n");
    return status;
}

/*
 * Function : ixHssAccPCMRxCfgCreate
 */
PRIVATE IX_STATUS 
ixHssAccPCMRxCfgCreate (IxHssAccPktHdlcFraming hdlcRxFraming, UINT8 *rxCfg)
{
    IX_STATUS status = IX_SUCCESS;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
		      "ixHssAccPCMRxCfgCreate\n");
    /* Call the ixHssAccPCMComCfgCreate to create the Rx config register */
    status = ixHssAccPCMComCfgCreate (hdlcRxFraming, rxCfg);
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMRxCfgCreate\n");
    return status;
}

/*
 *Function :ixHssAccPCMTxCfgCreate
 */
PRIVATE IX_STATUS 
ixHssAccPCMTxCfgCreate (IxHssAccPktHdlcFraming hdlcTxFraming,
			unsigned frmFlagStart, 
			UINT8 *txCfg)
{
    IX_STATUS status = IX_SUCCESS;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
		      "ixHssAccPCMTxCfgCreate\n");

    /* The Tx config register is the same as the Rx config register */
    /* except for the frmFlagStart parameter, */
    /* so this is set and then ixHssAccPCMComCfgCreate is called */   
    *txCfg |= frmFlagStart << IX_HSSACC_PKT_NUM_FRAME_FLAGS_OFFSET;
    status = ixHssAccPCMComCfgCreate (hdlcTxFraming, txCfg);

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMTxCfgCreate\n");
    return status;
}

/*
 *Function :ixHssAccPCMComCfgCreate
 */
PRIVATE IX_STATUS
ixHssAccPCMComCfgCreate (IxHssAccPktHdlcFraming hdlcComFraming, UINT8 *cfg)
{
    IX_STATUS status = IX_SUCCESS;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering"
		      " ixHssAccPCMComCfgCreate \n");

    /* Firstly, set the Hdlc Idle Type on the register*/
    if (hdlcComFraming.hdlcIdleType == IX_HSSACC_HDLC_IDLE_ONES)
    {
	*cfg |= IX_HSSACC_PKT_HDLC_IDLE_ONES_ENABLED_MASK;
    }
    else if (hdlcComFraming.hdlcIdleType == IX_HSSACC_HDLC_IDLE_FLAGS)
    {
	*cfg |= IX_HSSACC_PKT_HDLC_IDLE_FLAGS_ENABLED_MASK;
    }
    else
    {
	IX_HSSACC_REPORT_ERROR ("ixHssAccPCMComCfgCreate:"
				"hdlcComFraming.hdlcIdleType was invalid\n");
	return IX_HSSACC_PARAM_ERR;
    }

    /* Next, set the Hdlc CRC-Type on the register*/
    if (hdlcComFraming.crcType == IX_HSSACC_PKT_32_BIT_CRC)
    {
	*cfg |= IX_HSSACC_PKT_HDLC_CRC_32_MASK;
    }
    else if (hdlcComFraming.crcType == IX_HSSACC_PKT_16_BIT_CRC)
    {
	*cfg |= IX_HSSACC_PKT_HDLC_CRC_16_MASK;
    }
    else
    {
	IX_HSSACC_REPORT_ERROR("ixHssAccPCMComCfgCreate:"
			       "hdlcComFraming.crcType was invalid\n");
	return IX_HSSACC_PARAM_ERR;
    }
    
    /* Finally, set the Data Endianness on the register*/
    if (hdlcComFraming.dataEndian == IX_HSSACC_MSB_ENDIAN)
    {
	*cfg |= IX_HSSACC_PKT_HDLC_MSB_ENDIAN_MASK;
    }
    else if (hdlcComFraming.dataEndian == IX_HSSACC_LSB_ENDIAN)
    {
	*cfg |= IX_HSSACC_PKT_HDLC_LSB_ENDIAN_MASK;
    }
    else
    {
	IX_HSSACC_REPORT_ERROR("ixHssAccPCMComCfgCreate:"
			       "hdlcComFraming.dataEndian was invalid\n");
	return IX_HSSACC_PARAM_ERR;
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMComCfgCreate\n");
    return status;
}

/*
 *Function : ixHssAccPCMPktPipeModeCreate
 */
PRIVATE IX_STATUS
ixHssAccPCMPktPipeModeCreate (IxHssAccHdlcMode hdlcMode, 
			      BOOL hdlcBitInvert,
			      UINT32 *mode,
			      UINT32 *invMask,
			      UINT32 *orMask)
{
    IX_STATUS status = IX_SUCCESS;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering"
		      " ixHssAccPCMPktPipeModeCreate \n");

    /* if this HDLC port is going to run in 56k mode */
    if (hdlcMode.hdlc56kMode)
    {
	/* Error check the hdlcMode parameter */
        if (IX_HSSACC_ENUM_INVALID (hdlcMode.hdlc56kEndian, IX_HSSACC_56KE_MAX))
        {
      	    /* report the error */
	    IX_HSSACC_REPORT_ERROR ("ixHssAccPCMPktPipeModeCreate: invalid parameter\n");
	    /* return error */
	    status = IX_HSSACC_PARAM_ERR;
    	}
        else
        {
            *mode |= IX_HSSACC_NPE_PKT_MODE_56KMODE;
            
            if (hdlcMode.hdlc56kEndian == IX_HSSACC_56KE_BIT_7_UNUSED)
            {
            	/* if CAS bit is at MSB position */
            	*mode |= IX_HSSACC_NPE_PKT_MODE_56KENDIAN_MSB;

            	if (!hdlcMode.hdlc56kUnusedBitPolarity0)
            	{
            	    /* if the polarity of the unused bit (CAS bit) is 1 */
            	    *orMask = IX_HSSACC_NPE_PKT_ORMASK_MSB_POLARITY1;
		}
	    }
	    else if (hdlcMode.hdlc56kEndian == IX_HSSACC_56KE_BIT_0_UNUSED)
	    {
            	/* if CAS bit is at LSB position */
            	*mode |= IX_HSSACC_NPE_PKT_MODE_56KENDIAN_LSB;	    
            	
            	if (!hdlcMode.hdlc56kUnusedBitPolarity0)
            	{
            	    /* if the polarity of the unused bit (CAS bit) is 1 */
            	    *orMask = IX_HSSACC_NPE_PKT_ORMASK_LSB_POLARITY1;
		}
	    }
        }
    }	

    if (status == IX_SUCCESS)
    {
	/* if bit inversion is required between HDLC and HSS co-processors */
	if (hdlcBitInvert)
	{
	    *invMask = IX_HSSACC_NPE_PKT_INVMASK;
	}
    }
    	
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMPktPipeModeCreate\n");
    return status;
}

/*
 *Function :ixHssAccPCMPortEnable
 */
IX_STATUS 
ixHssAccPCMPortEnable (IxHssAccHssPort hssPortId, IxHssAccHdlcPort hdlcPortId)
{
    IX_STATUS status = IX_SUCCESS; 
    IxNpeMhMessage message;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering ixHssAccPCMPortEnable\n");
    
    /* Ensure that the Hdlc Port is connected but not started */
    if (ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected && 
	!(ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled))
    {
	/* create the message to enable the NPE flow */
	ixHssAccComNpeCmdMsgCreate (IX_NPE_A_MSSG_HSS_PKT_PIPE_FLOW_ENABLE,
				       0, hssPortId, hdlcPortId, 0, &message);
	/* send the message - don't block for a response */
	/* As the NPE does not send any*/
	status = ixHssAccComNpeCmdMsgSend (message, FALSE, 
					   IX_NPE_A_MSSG_HSS_PKT_PIPE_FLOW_ENABLE); 
	if (status != IX_SUCCESS) 
	{
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR ("ixHssAccPCMPortEnable: NpeMh failed "
				    "to send flow enable\n");
	    return IX_FAIL;
	}

	/* Mark the port enabled if it enabled successfully */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled = TRUE;
	ixHssAccPCMStats.enables++; /* Increment the num of Enables stat */
    }
    else
    {
	IX_HSSACC_REPORT_ERROR ("ixHssAccPCMEnable:"
				"Tried to start a hdlc Port that isnt "
				"connected or is already enabled\n");

	status = IX_FAIL; 
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting ixHssAccPCMPortEnable\n");

    return status;
}

/*
 *Function :ixHssAccPCMPortDisable
 */
IX_STATUS 
ixHssAccPCMPortDisable (IxHssAccHssPort hssPortId, IxHssAccHdlcPort hdlcPortId)
{
    IX_STATUS status = IX_SUCCESS; 
    IxNpeMhMessage message;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering ixHssAccPCMPortDisable\n");

    /* Ensure that the the Hdlc Port is connected and started */
    if (ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected &&
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled)
    {	
        /* create the message to disable the NPE flow */
	ixHssAccComNpeCmdMsgCreate (IX_NPE_A_MSSG_HSS_PKT_PIPE_FLOW_DISABLE,
				       0, hssPortId, hdlcPortId, 0, &message);
	/* send the message - don't block for a response as*/
        /* the NPE doesent send one */
	status = ixHssAccComNpeCmdMsgSend (message, FALSE,
					   IX_NPE_A_MSSG_HSS_PKT_PIPE_FLOW_DISABLE);
	if (status != IX_SUCCESS) 
	{
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR ("ixHssAccPCMDisable:"
				    "NpeMh failed to send flow disable\n");
	    return IX_FAIL;
	}
	/* Mark the port disabled if it disabled successfully */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled = FALSE;
	ixHssAccPCMStats.disables++; /* Increment the num of Disables stat */
    }
    else
    {
	IX_HSSACC_REPORT_ERROR("ixHssAccPCMDisable:"
			       "Tried to stop a hdlc Port that isnt"
			       " connected or isnt started\n");
	status = IX_FAIL;
    }
    
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting ixHssAccPCMPortDisable\n");
    return status;   
}

/*
 *Function :ixHssAccPCMDisconnect
 */
IX_STATUS 
ixHssAccPCMDisconnect (IxHssAccHssPort hssPortId, IxHssAccHdlcPort hdlcPortId)
{
    IX_STATUS status = IX_SUCCESS;
    IxHssAccPktRxFreeLowCallback tmpRxFreeLowCallback;
    UINT32 lockKey;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
		      "ixHssAccPCMDisconnect\n");

    /* Ensure the port is connected */
    if (!ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected)
    {
       IX_HSSACC_REPORT_ERROR("ixHssAccPCMDisconnect:Attempted to disconnect"
			      " a port that was not connected\n");
       return IX_FAIL;
    }
    
    tmpRxFreeLowCallback = ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	rxFreeLowCallback;
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowCallback =
	ixHssAccPCMRxFreeBufLowEmptyCallback;
   
    status = ixHssAccPCMQFlush (ixHssAccPCMRxFreeQId[hssPortId][hdlcPortId],
                                ixHssAccPCMRxQId[hssPortId]);
    if (status != IX_SUCCESS)
    {
	IX_HSSACC_REPORT_ERROR("ixHssAccPCMDisconnect:"
			       "flushing the RxFree Q failed for this "
			       "client\n");
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowCallback =
	    tmpRxFreeLowCallback;
	return IX_FAIL;
    }
    
    /* Disable Interrupts - if TxDone is called during these instructions */
    /* the txDoneUserId passed back to the client will be incorrect */
    lockKey = ixOsalIrqLock();
    /* setup the new txDoneUserId - combination of hss and hdlc port Ids. These */
    /* will be used in the ixHssAccPktTxDoneDisconnectCallback registered here */
    /* to enable an extra check. This will see if all descriptors have been returned */
    /* for this client. If so, the thisIsConnected state is updated */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneUserId = 
	(hssPortId << IX_HSSACC_PKT_CBID_HSS_OFFSET)
	| (unsigned)hdlcPortId;
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneCallback =
	ixHssAccPktTxDoneDisconnectCallback;

    /* modify rx path similar to the txdone while disconnecting */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxUserId = 
	(hssPortId << IX_HSSACC_PKT_CBID_HSS_OFFSET)
	| (unsigned)hdlcPortId;
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxCallback =
	ixHssAccPktRxDisconnectCallback;
    /* Enable Interrupts again */
    /* ixOsalIrqUnlock(lockKey);*/

    /* if started then stop */
    if (ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled)
    {
	status = ixHssAccPCMPortDisable (hssPortId, hdlcPortId);
	ixOsalIrqUnlock(lockKey);
	if (status != IX_SUCCESS) 
	{
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR ("ixHssAccPCMDisconnect:"
				    "Unable to disable this port on the NPE\n");

	    /* Disable Interrupts */
	    lockKey = ixOsalIrqLock();
	    /* rollback userIds */
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneUserId = 
		ixHssAccPCMClientInfo[hssPortId][hdlcPortId].disconnectingTxDoneUserId;
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxUserId = 
		ixHssAccPCMClientInfo[hssPortId][hdlcPortId].disconnectingRxUserId;
	    /* rollback the client callbacks */
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowCallback =
		tmpRxFreeLowCallback;
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneCallback =
		ixHssAccPCMClientInfo[hssPortId][hdlcPortId].txDoneDisconnectingCallback;
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxCallback =
		ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxDisconnectingCallback;
	    /* Enable Interrupts again */
	    ixOsalIrqUnlock(lockKey);
	    return IX_FAIL;
	}
    }
    else
    {
      ixOsalIrqUnlock(lockKey);
    }

    status = ixHssAccPCMQFlush (ixHssAccPCMTxQId[hssPortId][hdlcPortId],
                                ixHssAccPCMTxDoneQId[hssPortId]);
    if (status != IX_SUCCESS)
    {
	IX_HSSACC_REPORT_ERROR("ixHssAccPCMDisconnect:"
			       "flushing the Tx Q failed for this "
			       "client - packetised service in an unknown state.\n");
	return IX_FAIL;
    }
    /* Check if all descs have been returned, if so no more data is*/
    /* outstanding for Tx or Rx for the client*/
    if (ixHssAccPDMNumDescInUse (hssPortId, hdlcPortId) == 0)
    {
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected = FALSE;
	ixHssAccPCMClientInfoReset (hssPortId, hdlcPortId);
    }
    else
    {
	status = IX_HSSACC_PKT_DISCONNECTING;
    }
    
    ixHssAccPCMStats.disconnections++; 
    /* Increment the num of disconnections for stats */
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMDisconnect\n");
    
    return status; 
}

/*
 *Function :ixHssAccPCMIsDisconnectComplete
 */
BOOL 
ixHssAccPCMIsDisconnectComplete (IxHssAccHssPort hssPortId, 
				 IxHssAccHdlcPort hdlcPortId)
{
    return !(ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected);
}