ixhssacccommon.c

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

}

/**
 * Function definition: ixHssAccComFCRCreate
 */
PRIVATE IX_STATUS 
ixHssAccComFCRCreate (unsigned offset, unsigned size, unsigned *fcr)
{
    IX_STATUS status = IX_SUCCESS;

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

    /* Error check the parameters */
    if (offset > IX_HSSACC_COM_HSSFCR_OFFSET_MAX ||
	(size - 1) > IX_HSSACC_COM_HSSFCR_SIZE_MAX) /* frmsize is 1-1024 for client, 0-1023 for hss */
    {
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComFCRCreate - invalid parameter\n");
	/* return error */
	status = IX_HSSACC_PARAM_ERR;
    }
    else
    {
	/* create the HSS co-p 32bit register format */
	*fcr = 
	    offset << IX_HSSACC_COM_HSSFCR_OFFSET_OFFSET |
	    (size - 1) << IX_HSSACC_COM_HSSFCR_SIZE_OFFSET;

	IX_HSSACC_TRACE1 (IX_HSSACC_DEBUG, "fcr = 0x%X\n", *fcr);
    }

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

/**
 * Function definition: ixHssAccComClkSpeedToNumTrunks
 */
PRIVATE void
ixHssAccComClkSpeedToNumTrunks (IxHssAccClkSpeed clkSpeed, unsigned *numTrunks)
{
    switch (clkSpeed)
    {
	/* the following cases are intentional fall-through */
        case IX_HSSACC_CLK_SPEED_512KHZ:
        case IX_HSSACC_CLK_SPEED_1536KHZ:
        case IX_HSSACC_CLK_SPEED_1544KHZ:
        case IX_HSSACC_CLK_SPEED_2048KHZ:
	    *numTrunks = 1;
	    break;

        case IX_HSSACC_CLK_SPEED_4096KHZ:
	    *numTrunks = 2;
	    break;

        case IX_HSSACC_CLK_SPEED_8192KHZ:
	    *numTrunks = 4;
	    break;

        case IX_HSSACC_CLK_SPEED_MAX:
	    break;
    }
}

/**
 * Function definition: ixHssAccComHssLUTCreate
 */
PRIVATE IX_STATUS 
ixHssAccComHssLUTCreate (IxHssAccTdmSlotUsage *tdmMap,
			 unsigned numHdlcClients, 
			 unsigned numChans,
			 IxHssAccClkSpeed clkSpeed,
			 unsigned *pHssLUT,
			 unsigned *maxPktTrunkInTdmMap)
{
    IX_STATUS status = IX_SUCCESS;
    unsigned trunksWithHldc = 0;
    unsigned numChannelised = 0;
    unsigned tdmMapIndex = 0;
    unsigned numTrunks = 0;
    unsigned trunkIndex;
    IxHssAccTdmSlotUsage mapEntry;
    BOOL hdlcFoundInTrunk[IX_HSSACC_HDLC_PORT_MAX];
    IxHssAccHdlcPort hdlcPortIndex;
    int i;
    int j;

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

    /*
     * The following algorithm creates the LUT format required for loading to the
     * HSS CoProcessor. The tdmMap contains 128 words - each word represents its
     * associated timeslot type. The HSS CoP expects each timeslot to be represented
     * by just 2 bits (4 timeslot types).
     *
     *     words   0      1               15                          127
     *           +------+------+--------+------+---------------------+------+
     *  tdmMap   |      |      |  ...   |      |      ..........     |      |
     *           +------+------+--------+------+---------------------+------+
     *           |                             /
     *           |                           /
     *           |                        /
     *           |                    /
     *           |               /
     *           |           /
     *                   /
     *           +------+------+--------+------+
     *  pHssLUT  |||||||||||||||  ...   ||||||||
     *           +------+------+--------+------+
     *     words   0      1               7
     *
     *
     * Algo:
     *       for each word expected by the hss co-p (pHssLUT)
     *           for every tdmMap entry to be associated with that word (tdmMap)
     *               create the hss co-p word format from each individual entry
     */
    for (hdlcPortIndex = IX_HSSACC_HDLC_PORT_0;
	 hdlcPortIndex < IX_HSSACC_HDLC_PORT_MAX;
	 hdlcPortIndex++)
    {
	/*
	 * a single hdlc client may only occupy timeslots in one
	 * trunk. Need to check how many trunks the client has requested
	 * hdlc for and verify that this is not greater than the number of
	 * hdlc clients - the trunk timeslots are interleaved, as the NPE
	 * only supported byte interleaved mode on the HSS line.
	 */
	hdlcFoundInTrunk[hdlcPortIndex] = FALSE;
    }
    /* 
     * determine the number of trunks - 1=>frame interleave style, >1=> byte
     * interleave style
     */
    ixHssAccComClkSpeedToNumTrunks (clkSpeed, &numTrunks);

    /* initialise the memory to be written to */
    ixOsalMemSet (pHssLUT, 0, IX_HSSACC_LUT_WORDS_PER_LUT * IX_HSSACC_BYTES_PER_WORD);
    *maxPktTrunkInTdmMap = 0;
    for (i = 0; i < IX_HSSACC_LUT_WORDS_PER_LUT; i++)
    {
	for (j = 0; j < IX_HSSACC_LUT_TS_PER_WORD; j++)
	{
	    tdmMapIndex = (i * IX_HSSACC_LUT_TS_PER_WORD) + j;
	    mapEntry = tdmMap[tdmMapIndex];
	    *(pHssLUT + i) |= mapEntry << (j * IX_HSSACC_LUT_BITS_PER_TS);

	    /* check hdlc clients */
	    if (mapEntry == IX_HSSACC_TDMMAP_HDLC)
	    {
		trunkIndex = tdmMapIndex % numTrunks;
		/* take note of hdlc trunk occupancy for error check later */
		if (!hdlcFoundInTrunk[trunkIndex])
		{
		    trunksWithHldc++;
		    /* record the highest trunk used */
		    if (trunkIndex > *maxPktTrunkInTdmMap)
		    {
			*maxPktTrunkInTdmMap = trunkIndex;
		    }
		    hdlcFoundInTrunk[trunkIndex] = TRUE;
		}
	    }

	    /* check voice clients */
	    if ((mapEntry == IX_HSSACC_TDMMAP_VOICE56K) ||
		(mapEntry == IX_HSSACC_TDMMAP_VOICE64K))
	    {
		numChannelised++;
	    }

	} /* for (j) */
	IX_HSSACC_TRACE2 (IX_HSSACC_DEBUG, "LUT[%d] = %X\n", i, *(pHssLUT + i));
    } /* for (i) */

    /* check packetised service */
    if (trunksWithHldc != numHdlcClients)
    {
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComHssLUTCreate - invalid pkt configuration\n");
	/* return error */
	status = IX_HSSACC_PARAM_ERR;
    }
	
    /* check channelised service */
    if ((numChannelised > IX_HSSACC_MAX_CHAN_TIMESLOTS) ||
	numChannelised != numChans)
    {
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComHssLUTCreate - invalid chan configuration\n");
	/* return error */
	status = IX_HSSACC_PARAM_ERR;
    }
	
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccComHssLUTCreate\n");

    return status;
}

/**
 * Function definition: ixHssAccComLastHssErrGet
 */
IX_STATUS 
ixHssAccComLastHssErrGet (IxHssAccHssPort hssPortId)
{
    IX_STATUS status;
    IxNpeMhMessage message;

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

    /* create the NpeMh message - NPE_A message format */
    ixHssAccComNpeCmdMsgCreate (IX_NPE_A_MSSG_HSS_PORT_ERROR_READ, 
				   0, hssPortId, 0, 0, &message);

    /* send the message */
    status = ixHssAccComNpeCmdMsgSend (message, FALSE, /* response asychronous */
				       IX_NPE_A_MSSG_HSS_PORT_ERROR_READ);

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

/**
 * Function definition: ixHssAccComNpeErrorTranslate
 */
PRIVATE void
ixHssAccComNpeErrorTranslate (unsigned lastNpeError, unsigned *lastError, 
			      unsigned *servicePort)
{
    unsigned hssTxError = 0;
    unsigned swTxError = 0;
    unsigned hssRxError = 0;
    unsigned swRxError = 0;

    /* initialise output params */
    *lastError = IX_HSSACC_NO_ERROR;
    *servicePort = 0;

    /* report first error detected in the lastNpeError register */

    /* check for HSS TX h/w error */
    hssTxError = (lastNpeError & IX_HSSACC_NPE_ERR_HSSTXERR_MASK) >> 
	IX_HSSACC_NPE_ERR_HSSTXERR_OFFSET;
    switch (hssTxError)
    {
        case IX_HSSACC_NPE_HSSTX_NO_ERR1:
        case IX_HSSACC_NPE_HSSTX_NO_ERR2:
	    break;

        case IX_HSSACC_NPE_HSSTX_FRMSYNC_ERR:
	    *lastError = IX_HSSACC_TX_FRM_SYNC_ERR;
	    return;

        case IX_HSSACC_NPE_HSSTX_OVERRUN_ERR:
	    *lastError = IX_HSSACC_TX_OVER_RUN_ERR;
	    *servicePort = (lastNpeError & IX_HSSACC_NPE_ERR_TXBUF_MASK) >>
		IX_HSSACC_NPE_ERR_TXBUF_OFFSET;
	    return;
    }

    /* if no error yet, check for NPE-A TX s/w error */
    swTxError = (lastNpeError & IX_HSSACC_NPE_ERR_SWTXERR_MASK) >> 
	IX_HSSACC_NPE_ERR_SWTXERR_OFFSET;
    switch (swTxError)
    {
        case IX_HSSACC_NPE_SWTX_NO_ERR:
	    break;

        case IX_HSSACC_NPE_SWTX_CHAN_ERR:
	    *lastError = IX_HSSACC_CHANNELISED_SW_TX_ERR;
	    return;

        case IX_HSSACC_NPE_SWTX_PKT_ERR:
	    *lastError = IX_HSSACC_PACKETISED_SW_TX_ERR;
	    *servicePort = (lastNpeError & IX_HSSACC_NPE_ERR_TXBUF_MASK) >>
		IX_HSSACC_NPE_ERR_TXBUF_OFFSET;
	    return;
    }

    /* if no error yet, check for HSS RX h/w error */
    hssRxError = (lastNpeError & IX_HSSACC_NPE_ERR_HSSRXERR_MASK) >> 
	IX_HSSACC_NPE_ERR_HSSRXERR_OFFSET;
    switch (hssRxError)
    {
        case IX_HSSACC_NPE_HSSRX_NO_ERR1:
        case IX_HSSACC_NPE_HSSRX_NO_ERR2:
	    break;

        case IX_HSSACC_NPE_HSSRX_FRMSYNC_ERR:
	    *lastError = IX_HSSACC_RX_FRM_SYNC_ERR;
	    return;

        case IX_HSSACC_NPE_HSSRX_OVERRUN_ERR:
	    *lastError = IX_HSSACC_RX_OVER_RUN_ERR;
	    *servicePort = (lastNpeError & IX_HSSACC_NPE_ERR_RXBUF_MASK) >>
		IX_HSSACC_NPE_ERR_RXBUF_OFFSET;
	    return;
    }

    /* if no error yet, check for NPE-A RX s/w error */
    swRxError = (lastNpeError & IX_HSSACC_NPE_ERR_SWRXERR_MASK) >> 
	IX_HSSACC_NPE_ERR_SWRXERR_OFFSET;
    switch (swRxError)
    {
        case IX_HSSACC_NPE_SWRX_NO_ERR:
	    break;

        case IX_HSSACC_NPE_SWRX_CHAN_ERR:
	    *lastError = IX_HSSACC_CHANNELISED_SW_RX_ERR;
	    return;

        case IX_HSSACC_NPE_SWRX_PKT_ERR:
	    *lastError = IX_HSSACC_PACKETISED_SW_RX_ERR;
	    *servicePort = (lastNpeError & IX_HSSACC_NPE_ERR_RXBUF_MASK) >>
		IX_HSSACC_NPE_ERR_RXBUF_OFFSET;
	    return;
    }
}

/**
 * Function definition: ixHssAccComNpeCmdRespCallback
 */
void 
ixHssAccComNpeCmdRespCallback (IxNpeMhNpeId npeId, IxNpeMhMessage msg)
{
    unsigned cmdType;

    /* this callback services all responses from the IxNpeMh for HssAccess */

    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
					   "Entering ixHssAccComNpeCmdRespCallback\n"));
    cmdType = (msg.data[0] & IX_HSSACC_NPE_CMD_ID_MASK) >>
	IX_HSSACC_NPE_CMD_ID_OFFSET;

    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE2 (
	IX_HSSACC_DEBUG, 
	"ixHssAccComNpeCmdRespCallback: [0] = 0x%X, [1] = 0x%X\n",
	msg.data[0], msg.data[1]));
    ixHssAccComStats.npeCmdResps++;
    switch (cmdType)
    {
        case IX_NPE_A_MSSG_HSS_PORT_CONFIG_LOAD_RESP:
        case IX_NPE_A_MSSG_HSS_CHAN_TSLOTSWITCH_ENABLE_RESP:
        case IX_NPE_A_MSSG_HSS_CHAN_TSLOTSWITCH_DISABLE_RESP:
        case IX_NPE_A_MSSG_HSS_CHAN_TSLOTSWITCH_GCT_DOWNLOAD_RESP:
	    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_DEBUG, "SEM POST\n"));
	    /* post the semphore to release the pending code */
	    IX_HSSACC_COM_MUT_UNLOCK ();
	    break;

        default:
		ixHssAccComStats.npeCmdInvResps++;
	    break;

    }
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
					   "Exiting ixHssAccComNpeCmdRespCallback\n"));
}

/**
 * Function definition: ixHssAccComNpeReadRespCallback
 */
void 
ixHssAccComNpeReadRespCallback (IxNpeMhNpeId npeId, IxNpeMhMessage msg)
{
    unsigned cmdType;
    unsigned lastNpeError;
    unsigned errorCount;
    unsigned lastError;
    unsigned servicePort;
    IxHssAccHssPort hssPortId;

    /* this callback services all read responses from the IxNpeMh */

    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
					   "Entering ixHssAccComNpeReadRespCallback\n"));
    cmdType = (msg.data[0] & IX_HSSACC_NPE_CMD_ID_MASK) >>
	IX_HSSACC_NPE_CMD_ID_OFFSET;

    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE2 (
	IX_HSSACC_DEBUG, 
	"ixHssAccComNpeReadRespCallback: [0] = 0x%X, [1] = 0x%X\n",
	msg.data[0], msg.data[1]));
    ixHssAccComStats.npeReadResps++;
    switch (cmdType)
    {
        case IX_NPE_A_MSSG_HSS_PORT_ERROR_READ_RESP:
	    /* process the data read - last hss error */
	    lastNpeError = (msg.data[1] & IX_HSSACC_NPE_LASTERR_MASK) >>
		IX_HSSACC_NPE_LASTERR_OFFSET;
	    errorCount = (msg.data[1] & IX_HSSACC_NPE_ERRCOUNT_MASK) >>
		IX_HSSACC_NPE_ERRCOUNT_OFFSET;
	    /* translate error to def'd value */
	    ixHssAccComNpeErrorTranslate (lastNpeError, &lastError, 
					  &servicePort);
	    hssPortId = (msg.data[0] & IX_HSSACC_NPE_CMD_HSSPORTID_MASK) >> 
		IX_HSSACC_NPE_CMD_HSSPORTID_OFFSET;
	    if (!IX_HSSACC_ENUM_INVALID (hssPortId, hssPortMax))
	    {
		ixHssAccComConfiguration[hssPortId].lastErrorCallback (lastError, servicePort);
	    }
	    else
	    {
		ixHssAccComStats.npeReadInvResps++;