ixhssacccommon.c

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

    if (lastErrorCallback != NULL)
    {
	ixHssAccComConfiguration[hssPortId].lastErrorCallback = lastErrorCallback;
    }
    else
    {
	/* ensure the empty callback is called during this configuration */
	ixHssAccComConfiguration[hssPortId].lastErrorCallback = 
	    ixHssAccComEmptyLastErrorCallback;
    }

    if (status == IX_SUCCESS)
    {
	ixHssAccComStats.validConfigs++;
    }
    else
    {
	ixHssAccComStats.invalidConfigs++;
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComPortInit - configuration failed\n");
    }

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


/**
 * Function definition: ixHssAccComPortUninit
 */
IX_STATUS
ixHssAccComPortUninit (IxHssAccHssPort hssPortId)
{
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering ixHssAccComPortUninit\n");

    /* ensure the empty callback is called during this configuration */
    ixHssAccComConfiguration[hssPortId].lastErrorCallback = ixHssAccComEmptyLastErrorCallback;


    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting ixHssAccComPortUninit\n");
    return IX_SUCCESS;
}



/**
 * Function definition: ixHssAccComPortConfigWrite
 */
PRIVATE IX_STATUS 
ixHssAccComPortConfigWrite (IxHssAccHssPort hssPortId, 
			    IxHssAccConfigParams *configParams, 
			    IxHssAccTdmSlotUsage *tdmMap,
			    unsigned *maxPktTrunkInTdmMap)
{
    IX_STATUS status = IX_SUCCESS;
    int i;
    unsigned hssPktChannelCount = configParams->hssPktChannelCount;
    unsigned offset = 0;
    unsigned *configWord = (unsigned *) &(ixHssAccComConfiguration[hssPortId]);
    IxNpeMhMessage npeMhMsg;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComPortConfigWrite\n");

    /* Create TxPCR */
    status = ixHssAccComPCRCreate (
	IX_HSSACC_TX_PCR, 
	&(configParams->txPortConfig), 
	&(ixHssAccComConfiguration[hssPortId].txPCR));
    if (status == IX_SUCCESS)
    {
	/* Create RxPCR */
	status = ixHssAccComPCRCreate (
	    IX_HSSACC_RX_PCR, 
	    &(configParams->rxPortConfig), 
	    &(ixHssAccComConfiguration[hssPortId].rxPCR));
    }

    if (status == IX_SUCCESS)
    {
	/* Create clkCR */
	status = ixHssAccComClkCRCreate (
	    configParams->clkSpeed, 
	    &(ixHssAccComConfiguration[hssPortId].clkCR));
    }

    if (status == IX_SUCCESS)
    {
	/* Create TxFCR */
	status = ixHssAccComFCRCreate (
	    configParams->txPortConfig.frmOffset, 
	    configParams->txPortConfig.maxFrmSize, 				       
	    &(ixHssAccComConfiguration[hssPortId].txFCR));
    }

    if (status == IX_SUCCESS)
    {
	/* Create RxFCR */
	status = ixHssAccComFCRCreate (
	    configParams->rxPortConfig.frmOffset, 
	    configParams->rxPortConfig.maxFrmSize, 				       
	    &(ixHssAccComConfiguration[hssPortId].rxFCR));
    }

    if (status == IX_SUCCESS)
    {
	/* Create HssTxLUT */
	status = ixHssAccComHssLUTCreate (
	    tdmMap, 
	    hssPktChannelCount, 	
	    configParams->numChannelised,
	    configParams->clkSpeed,
	    &(ixHssAccComConfiguration[hssPortId].hssTxLUT[0]),
	    maxPktTrunkInTdmMap);
    }

    if (status == IX_SUCCESS)
    {
	/* HssRxLUT will be the same as the HssTxLUT*/
	ixOsalMemCopy (&(ixHssAccComConfiguration[hssPortId].hssRxLUT[0]),
		       &(ixHssAccComConfiguration[hssPortId].hssTxLUT[0]),
		       sizeof (UINT32) * IX_HSSACC_LUT_WORDS_PER_LUT);
    }

    if (status == IX_SUCCESS)
    {
	/* Create CCR */
	status = ixHssAccComCCRCreate (
	    *maxPktTrunkInTdmMap, 
	    configParams->loopback, hssPortId, 
	    &(ixHssAccComConfiguration[hssPortId].cCR));
    }

    for (i = 0; 
	 (i < IX_HSSACC_NUM_PORT_CONFIG_WORDS) && (status == IX_SUCCESS); 
	 i++)
    {
	ixHssAccComNpeCmdMsgCreate (
	    IX_NPE_A_MSSG_HSS_PORT_CONFIG_WRITE,
	    0, hssPortId, offset, 
	    configWord[i], &npeMhMsg);
	status = ixHssAccComNpeCmdMsgSend (
	    npeMhMsg, 
	    FALSE, /* no response expected */
	    IX_NPE_A_MSSG_HSS_PORT_CONFIG_WRITE);
	offset += sizeof (UINT32);
    }

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

/**
 * Function definition: ixHssAccComPipeInfoWrite
 */
PRIVATE IX_STATUS 
ixHssAccComPipeInfoWrite (IxHssAccHssPort hssPortId, 
			  unsigned hfifoValue,
			  unsigned packetizedIdlePattern)
{
    IX_STATUS status = IX_SUCCESS;
    unsigned msgData;
    IxHssAccHdlcPort hdlcPortIndex;
    IxNpeMhMessage npeMhMsg;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComPipeInfoWrite\n");

    for (hdlcPortIndex = IX_HSSACC_HDLC_PORT_0;
	 (hdlcPortIndex < IX_HSSACC_HDLC_PORT_MAX) && (status == IX_SUCCESS);
	 hdlcPortIndex++)
    {
	msgData = ixHssAccComPipeFifoSizew[hfifoValue][hdlcPortIndex] <<
	    IX_HSSACC_NPE_PKT_FIFOSIZEW_OFFSET;
	ixHssAccComNpeCmdMsgCreate (
	    IX_NPE_A_MSSG_HSS_PKT_PIPE_FIFO_SIZEW_WRITE,
	    0, hssPortId, hdlcPortIndex, 
	    msgData, 
	    &npeMhMsg);
    
	status = ixHssAccComNpeCmdMsgSend (
	    npeMhMsg, 
	    FALSE, /* no response expected */
	    IX_NPE_A_MSSG_HSS_PKT_PIPE_FIFO_SIZEW_WRITE);
	if (status == IX_SUCCESS)
	{
	    ixHssAccComNpeCmdMsgCreate (
		IX_NPE_A_MSSG_HSS_PKT_PIPE_IDLE_PATTERN_WRITE,
		0, hssPortId, hdlcPortIndex, 
		packetizedIdlePattern, 
		&npeMhMsg);
    
	    status = ixHssAccComNpeCmdMsgSend (
		npeMhMsg, 
		FALSE, /* no response expected */
		IX_NPE_A_MSSG_HSS_PKT_PIPE_IDLE_PATTERN_WRITE);
	}
    }

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

/**
 * Function definition: ixHssAccComPCRCreateComParamsInvalid
 */
PRIVATE BOOL 
ixHssAccComPCRCreateComParamsInvalid (IxHssAccPortConfig *portConfig)
{
    BOOL invalid = FALSE;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComPCRCreateComParamsInvalid\n");

    if (IX_HSSACC_ENUM_INVALID (portConfig->frmSyncType, IX_HSSACC_FRM_SYNC_TYPE_MAX)  ||
	IX_HSSACC_ENUM_INVALID (portConfig->frmSyncIO, IX_HSSACC_FRM_SYNC_ENABLE_MAX)  ||
	portConfig->frmSyncIO == IX_HSSACC_FRM_SYNC_INVALID_VALUE                      ||
	IX_HSSACC_ENUM_INVALID (portConfig->frmSyncClkEdge, IX_HSSACC_CLK_EDGE_MAX)    ||
	IX_HSSACC_ENUM_INVALID (portConfig->dataClkEdge, IX_HSSACC_CLK_EDGE_MAX)       ||
	IX_HSSACC_ENUM_INVALID (portConfig->clkDirection, IX_HSSACC_SYNC_CLK_DIR_MAX)  ||
	IX_HSSACC_ENUM_INVALID (portConfig->frmPulseUsage, IX_HSSACC_FRM_PULSE_MAX)    ||
	IX_HSSACC_ENUM_INVALID (portConfig->dataRate, IX_HSSACC_DATA_RATE_MAX)         ||
	IX_HSSACC_ENUM_INVALID (portConfig->dataPolarity, IX_HSSACC_DATA_POLARITY_MAX) ||
	IX_HSSACC_ENUM_INVALID (portConfig->dataEndianness, IX_HSSACC_ENDIAN_MAX)      ||
	IX_HSSACC_ENUM_INVALID (portConfig->fBitUsage, IX_HSSACC_SOF_MAX)
	)
    {
	invalid = TRUE;
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccComPCRCreateComParamsInvalid\n");
    return invalid;
}

/**
 * Function definition: ixHssAccComPCRCreateTxParamsInvalid
 */
PRIVATE BOOL 
ixHssAccComPCRCreateTxParamsInvalid (IxHssAccPortConfig *portConfig)
{
    BOOL invalid = FALSE;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComPCRCreateTxParamsInvalid\n");

    if (IX_HSSACC_ENUM_INVALID (portConfig->drainMode, IX_HSSACC_TX_PINS_MAX)    ||
	IX_HSSACC_ENUM_INVALID (portConfig->dataEnable, IX_HSSACC_DE_MAX)        ||
	IX_HSSACC_ENUM_INVALID (portConfig->voice56kType, IX_HSSACC_TXSIG_MAX)   ||
	IX_HSSACC_ENUM_INVALID (portConfig->unassignedType, IX_HSSACC_TXSIG_MAX) ||
	IX_HSSACC_ENUM_INVALID (portConfig->fBitType, IX_HSSACC_FB_MAX)          ||
	IX_HSSACC_ENUM_INVALID (portConfig->voice56kEndian, IX_HSSACC_56KE_MAX)  ||
	IX_HSSACC_ENUM_INVALID (portConfig->voice56kSel, IX_HSSACC_56KS_MAX)
	)
    {
	invalid = TRUE;
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccComPCRCreateTxParamsInvalid\n");
    return invalid;
}

/**
 * Function definition: ixHssAccComPCRCreate
 */
PRIVATE IX_STATUS 
ixHssAccComPCRCreate (IxHssAccPcrType type, IxHssAccPortConfig *portConfig, unsigned *pcr)
{
    IX_STATUS status = IX_SUCCESS;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComPCRCreate\n");

    /* Error check the parameters */
    /* first those common to tx and rx */
    if (ixHssAccComPCRCreateComParamsInvalid (portConfig))
    {
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComPCRCreate - invalid parameter\n");
	/* return error */
	status = IX_HSSACC_PARAM_ERR;
    }
    else
    {
	/* create the common parts of the HSS co-p pcr register */
	*pcr = 
	    portConfig->frmSyncType    << IX_HSSACC_COM_HSSPCR_FTYPE_OFFSET   |
	    portConfig->frmSyncIO      << IX_HSSACC_COM_HSSPCR_FENABLE_OFFSET |
	    portConfig->frmSyncClkEdge << IX_HSSACC_COM_HSSPCR_FEDGE_OFFSET   |
	    portConfig->dataClkEdge    << IX_HSSACC_COM_HSSPCR_DEDGE_OFFSET   |
	    portConfig->clkDirection   << IX_HSSACC_COM_HSSPCR_CLKDIR_OFFSET  |
	    portConfig->frmPulseUsage  << IX_HSSACC_COM_HSSPCR_FRAME_OFFSET   |
	    portConfig->dataRate       << IX_HSSACC_COM_HSSPCR_HALF_OFFSET    |
	    portConfig->dataPolarity   << IX_HSSACC_COM_HSSPCR_DPOL_OFFSET    |
	    portConfig->dataEndianness << IX_HSSACC_COM_HSSPCR_BITEND_OFFSET  |
	    portConfig->fBitUsage      << IX_HSSACC_COM_HSSPCR_FBIT_OFFSET;
    }

    if (status == IX_SUCCESS)
    {
	/* check the tx specific parameters */
	if (type == IX_HSSACC_TX_PCR)
	{
	    if (ixHssAccComPCRCreateTxParamsInvalid (portConfig))
	    {
		/* report the error */
		IX_HSSACC_REPORT_ERROR ("ixHssAccComPCRCreate - invalid parameter\n");
		/* return error */
		status = IX_HSSACC_PARAM_ERR;
	    }
	    else
	    {
		/* create the tx specific parts of the HSS co-p pcr register */
		*pcr |= 
		    portConfig->drainMode      << IX_HSSACC_COM_HSSPCR_ODRAIN_OFFSET  |
		    portConfig->dataEnable     << IX_HSSACC_COM_HSSPCR_ENABLE_OFFSET  |
		    portConfig->voice56kType   << IX_HSSACC_COM_HSSPCR_56KTYPE_OFFSET |
		    portConfig->unassignedType << IX_HSSACC_COM_HSSPCR_UTYPE_OFFSET   |
		    portConfig->fBitType       << IX_HSSACC_COM_HSSPCR_FBTYPE_OFFSET  |
		    portConfig->voice56kEndian << IX_HSSACC_COM_HSSPCR_56KEND_OFFSET  |
		    portConfig->voice56kSel    << IX_HSSACC_COM_HSSPCR_56KSEL_OFFSET;
		
		IX_HSSACC_TRACE1 (IX_HSSACC_DEBUG, "txPCR = 0x%X\n", *pcr);
	    }
	}
	else
	{
	    IX_HSSACC_TRACE1 (IX_HSSACC_DEBUG, "rxPCR = 0x%X\n", *pcr);
	}
    }

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

/**
 * Function definition: ixHssAccComCCRCreate
 */
PRIVATE IX_STATUS 
ixHssAccComCCRCreate (unsigned hdlcPortCount, 
		      BOOL loopback, 
		      IxHssAccHssPort hssPortId,
		      unsigned *ccr)
{
    IX_STATUS status = IX_SUCCESS;
    unsigned hfifoValue;
    BOOL regValue;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComCCRCreate\n");

    hfifoValue = ixHssAccComHfifoValues[hdlcPortCount];
    /* ensure we only write TRUE or FALSE values to register */
    if (loopback) /* could be > 1 */
    {
	regValue = TRUE;
    }
    else
    {
	regValue = FALSE;
    }
    
    *ccr = 
	hfifoValue << IX_HSSACC_COM_HSSCCR_HFIFO_OFFSET |
	regValue   << IX_HSSACC_COM_HSSCCR_LBACK_OFFSET |
	hssPortId  << IX_HSSACC_COM_HSSCCR_COND_OFFSET;
    IX_HSSACC_TRACE1 (IX_HSSACC_DEBUG, "ccr = 0x%X\n", *ccr);

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

/**
 * Function definition: ixHssAccComClkCRCreate
 */
PRIVATE IX_STATUS 
ixHssAccComClkCRCreate (IxHssAccClkSpeed clkRate, unsigned *clkCR)
{
    IX_STATUS status = IX_SUCCESS;
    IxHssAccComSysClk clk;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComClkCRCreate\n");

    /* Error check the parameters */
    if (IX_HSSACC_ENUM_INVALID (clkRate, IX_HSSACC_CLK_SPEED_MAX))
    {
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComClkCRCreate - invalid parameter\n");
	/* return error */
	status = IX_HSSACC_PARAM_ERR;
    }
    else
    {
	clk = ixHssAccComSysClk133M[clkRate];
	*clkCR = 
	    clk.main  << IX_HSSACC_COM_HSSCLKCR_MAIN_OFFSET |
	    clk.num   << IX_HSSACC_COM_HSSCLKCR_NUM_OFFSET  |
	    clk.denom << IX_HSSACC_COM_HSSCLKCR_DENOM_OFFSET;
	IX_HSSACC_TRACE1 (IX_HSSACC_DEBUG, "clkCR = 0x%X\n", *clkCR);
    }

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