ixhssacccommon.c

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

	    }
	    break;

        default:
		ixHssAccComStats.npeReadInvResps++;
	    break;

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

/**
 * Function definition: ixHssAccComNpeCmdMsgCreate
 */
void 
ixHssAccComNpeCmdMsgCreate (unsigned byte0, unsigned byte1, 
			    unsigned byte2, unsigned byte3,
			    unsigned data,
			    IxNpeMhMessage *pMessage)
{
    /* create the NpeMh message - NPE_A message format */
    pMessage->data[0] = 
	byte3 << IX_HSSACC_COM_BYTE3_OFFSET |
	byte2 << IX_HSSACC_COM_BYTE2_OFFSET |
	byte1 << IX_HSSACC_COM_BYTE1_OFFSET |
	byte0 << IX_HSSACC_COM_BYTE0_OFFSET;
    pMessage->data[1] = data; 
    IX_HSSACC_TRACE2 (IX_HSSACC_DEBUG, 
		      "ixHssAccComNpeCmdMsgCreate: 0x%08X, 0x%08X\n",
		      pMessage->data[0], pMessage->data[1]);
}

/**
 * Function definition: ixHssAccComNpeCmdMsgSend
 */
IX_STATUS 
ixHssAccComNpeCmdMsgSend (IxNpeMhMessage message, 
			  BOOL reqResp, 
			  unsigned npeMsgId)
{
    IX_STATUS status = IX_SUCCESS;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccComNpeCmdMsgSend\n");
    
    ixHssAccComStats.npeCmdSends++;

    /* check if a response is required */
    if (reqResp)
    {
	IX_HSSACC_TRACE0 (IX_HSSACC_DEBUG, 
			  "Calling ixNpeMhMessageWithResponseSend\n");
	/* send the message to the NpeMh */
	status = ixNpeMhMessageWithResponseSend (IX_NPEMH_NPEID_NPEA,
						 message, npeMsgId,
						 ixHssAccComNpeCmdRespCallback,
						 IX_HSSACC_NPEMH_SEND_RETRIES);
    }
    else
    {
	IX_HSSACC_TRACE0 (IX_HSSACC_DEBUG, "Calling ixNpeMhMessageSend\n");
	/* send the message to the NpeMh */
	status = ixNpeMhMessageSend (IX_NPEMH_NPEID_NPEA, message,
				     IX_HSSACC_NPEMH_SEND_RETRIES);       
    }

    /* check the return from the NpeMh and block for response if requested */
    if (status != IX_SUCCESS)
    {
	/* report the error */
	IX_HSSACC_REPORT_ERROR ("ixHssAccComNpeCmdMsgSend - NpeMh failed to send\n");
	/* return error */
	status = IX_FAIL;		    
    }
    else
    {
	/* wait for a NPE_A response if one is expected */
	if (reqResp)
	{
	    IX_HSSACC_TRACE0 (IX_HSSACC_DEBUG, "SEM PEND\n");
	    /* pend on a semaphore - the callback will set this */
	    IX_HSSACC_COM_MUT_LOCK ();
	}
    }

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

/**
 * Function definition: ixHssAccComTdmToNpeVoiceChanTranslate
 */
UINT32 
ixHssAccComTdmToNpeVoiceChanTranslate (IxHssAccHssPort hssPortId,
				       UINT32 tdmSlotId)
{
    /*
     * Note (Please read before using this API):
     * This API performs no error checking on the tdmSlotId passed in by 
     * client. Hence, before this API is called, client should ensure 
     * that the tdmSlotId passed in has been configured as a channelised 
     * timeslot on the specified HSS port.
    */
    
    IxHssAccTdmSlotUsage tslotUsage;
    UINT32 index1;
    UINT32 npeVoiceChanId = 0;

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

    /* Search for each TDM timeslot configured as channelised timeslot starting
     * from TS0 till tdmSlotId (not inclusive). If channelised timeslot found, 
     * increment npeVoiceChanId
     */
    for (index1 = 0; index1 < tdmSlotId; index1++)
    {
    	/* Extract the timeslot usage for TDM timeslot pointed by index1 from
    	 * HSS LUT word. Please refer to the description of this macro (located
    	 * in this source file) for more details.
    	 */
     	IX_HSSACC_TSLOTUSAGE_GET(hssPortId, index1, tslotUsage)

        /* if index1 is a channelised timeslot, then increment npeVoiceChanId */
	if ((tslotUsage == IX_HSSACC_TDMMAP_VOICE56K) || 
	    (tslotUsage == IX_HSSACC_TDMMAP_VOICE64K))
    	{
	    npeVoiceChanId++;		    
    	}
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccComTdmToNpeVoiceChanTranslate\n");
    
    /* return NPE voice channel Id */
    return npeVoiceChanId;
}

/**
 * Function definition: ixHssAccComPortConfigLoad
 */
PRIVATE IX_STATUS 
ixHssAccComPortConfigLoad (IxHssAccHssPort hssPortId)
{
    IX_STATUS status = IX_SUCCESS;
    IxNpeMhMessage message;

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

    /* create the NpeMh message - NPE_A message format */
    ixHssAccComNpeCmdMsgCreate (IX_NPE_A_MSSG_HSS_PORT_CONFIG_LOAD, 0, 
				   hssPortId, 0, 0, &message);
    /* send the message */
    status = ixHssAccComNpeCmdMsgSend (message, 
				       TRUE, /* block for response */
				       IX_NPE_A_MSSG_HSS_PORT_CONFIG_LOAD);

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

/**
 * Function definition: ixHssAccComEmptyLastErrorCallback
 */
PRIVATE void
ixHssAccComEmptyLastErrorCallback (unsigned lastHssError, 
				   unsigned servicePort)
{
    ixHssAccComStats.emptyLastErrCbs++;
}

/**
 * Function definition: ixHssAccComIsChanTimeslot
 */
BOOL 
ixHssAccComIsChanTimeslot (IxHssAccHssPort hssPortId,
			   UINT32 tdmSlotId)
{
    IxHssAccTdmSlotUsage tslotUsage;
    BOOL isChanTimeslot = TRUE;

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

    /* Extract the timeslot usage for TDM timeslot pointed by tdmSlotId from
     * HSS LUT words. Please refer to the description of this macro (located
     * in this source file) for more details. 
     */
    IX_HSSACC_TSLOTUSAGE_GET(hssPortId, tdmSlotId, tslotUsage)

    /* check whether tdmSlotId is a channelised timeslot */
    if ((tslotUsage != IX_HSSACC_TDMMAP_VOICE56K) && 
        (tslotUsage != IX_HSSACC_TDMMAP_VOICE64K))
    {
	isChanTimeslot = FALSE;		    
    }
        
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccComIsChanTimeslot\n");
    
    return isChanTimeslot;
}

/**
 * Function definition: ixHssAccComNumChanTimeslotGet
 */
UINT32 
ixHssAccComNumChanTimeslotGet (IxHssAccHssPort hssPortId)
{
    return ixHssAccComConfiguration[hssPortId].numChannelised;
}

/**
 * Function definition: ixHssAccComShow
 */
void 
ixHssAccComShow (void)
{
    IxHssAccHssPort hssPortIndex;

    printf ("\nixHssAccComShow:\n");
    printf ("\t   validConfigs: %d \t  invalidConfigs: %d\n", 
	    ixHssAccComStats.validConfigs, 
	    ixHssAccComStats.invalidConfigs);
    printf ("\t    npeCmdSends: %d \t emptyLastErrCbs: %d\n", 
	    ixHssAccComStats.npeCmdSends, 
	    ixHssAccComStats.emptyLastErrCbs);
    printf ("\t    npeCmdResps: %d \t    npeReadResps: %d\n", 
	    ixHssAccComStats.npeCmdResps, 
	    ixHssAccComStats.npeReadResps);
    printf ("\t npeCmdInvResps: %d \t npeReadInvResps: %d\n", 
	    ixHssAccComStats.npeCmdInvResps, 
	    ixHssAccComStats.npeReadInvResps);
    
    for (hssPortIndex = IX_HSSACC_HSS_PORT_0;
	 hssPortIndex < hssPortMax;
	 hssPortIndex++)
    {
    	printf ("\t CurrentConfig Port %d -  txPCR: 0x%X\n", 
		hssPortIndex, 
		ixHssAccComConfiguration[hssPortIndex].txPCR);
    	printf ("\t                       -  rxPCR: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].rxPCR);
    	printf ("\t                       -    cCR: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].cCR);
        printf ("\t                       -  clkCR: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].clkCR);
    	printf ("\t                       -  txFCR: 0x%X\n", 
	    ixHssAccComConfiguration[hssPortIndex].txFCR);
    	printf ("\t                       -  rxFCR: 0x%X\n", 
	    ixHssAccComConfiguration[hssPortIndex].rxFCR);
    	printf ("\t                       - LUT[0]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[0]);
    	printf ("\t                       - LUT[1]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[1]);
    	printf ("\t                       - LUT[2]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[2]);
    	printf ("\t                       - LUT[3]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[3]);
    	printf ("\t                       - LUT[4]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[4]);
    	printf ("\t                       - LUT[5]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[5]);
    	printf ("\t                       - LUT[6]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[6]);
    	printf ("\t                       - LUT[7]: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].hssTxLUT[7]);
    	printf ("\t                       -  #chan: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].numChannelised);
    	printf ("\t                       -  #pktd: 0x%X\n", 
		ixHssAccComConfiguration[hssPortIndex].numPacketised);
    #if (CPU!=SIMSPARCSOLARIS)
    	printf ("\t                       - lastErr: %p\n", 
		ixHssAccComConfiguration[hssPortIndex].lastErrorCallback);
    #endif
    }
}

/**
 * Function definition: ixHssAccComStatsInit
 */
void 
ixHssAccComStatsInit (void)
{
    ixHssAccComStats.validConfigs = 0;
    ixHssAccComStats.invalidConfigs = 0;
    ixHssAccComStats.emptyLastErrCbs = 0;
    ixHssAccComStats.npeCmdSends = 0;
    ixHssAccComStats.npeCmdResps = 0;
    ixHssAccComStats.npeReadResps = 0;
    ixHssAccComStats.npeCmdInvResps = 0;
}

/**
 * Function definition: ixHssAccComInit
 */
IX_STATUS 
ixHssAccComInit (void)
{
    IxHssAccHssPort hssPortIndex;
    IX_STATUS status = IX_SUCCESS;
    static BOOL mutexInitialised = FALSE;


    mutexInitialised = ixHssAccMutexInitialised;


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

    /* initialise stats */
    ixHssAccComStatsInit ();

    /* initialise the hssAccess mutex once */
    if (!mutexInitialised)
    {
	status = ixOsalMutexInit (&ixHssAccComMutex);
	if (status == IX_SUCCESS)
	{
	    mutexInitialised = TRUE;

        ixHssAccMutexInitialised = mutexInitialised;

	    IX_HSSACC_COM_MUT_LOCK(); /* lock the mutex initially */
	}
	else
	{
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR ("ixHssAccComInit - mutex initialisation failed\n");
	    status = IX_FAIL;
	}
    }

    /* setup the default lastErrCallback function */
    for (hssPortIndex = IX_HSSACC_HSS_PORT_0;
	 hssPortIndex < IX_HSSACC_HSS_PORT_MAX;
	 hssPortIndex++)
    {
	ixHssAccComConfiguration[hssPortIndex].lastErrorCallback =
	    ixHssAccComEmptyLastErrorCallback;
    }

    if (status == IX_SUCCESS)
    {
	/* register read-response handler to IxNpeMh */
	status = ixNpeMhUnsolicitedCallbackRegister (IX_NPEMH_NPEID_NPEA,
						     IX_NPE_A_MSSG_HSS_PORT_ERROR_READ,
						     ixHssAccComNpeReadRespCallback);
	if (status != IX_SUCCESS)
	{
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR ("ixHssAccComInit - failed to register ReadRespCallback\n");
	    status = IX_FAIL;
	}
    }

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

/*
 * Function definition: ixHssAccComUninit
 */
IX_STATUS
ixHssAccComUninit (void)
{
    IX_STATUS status;

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

    /*  unregister read-response handler to IxNpeMh */
    status = ixNpeMhUnsolicitedCallbackRegister (IX_NPEMH_NPEID_NPEA,
                                                 IX_NPE_A_MSSG_HSS_PORT_ERROR_READ,
                                                 NULL);
    if (IX_SUCCESS != status)
    {
        /* report the error */
        IX_HSSACC_REPORT_ERROR ("ixHssAccComUninit - failed to unregister ReadRespCallback\n");
        status = IX_FAIL;
    }

     /* uninitialise the hssAccess mutex */
    if (ixHssAccMutexInitialised)
    {
        status = ixOsalMutexDestroy (&ixHssAccComMutex);
        if (IX_SUCCESS == status)
        {
            ixHssAccMutexInitialised = FALSE;
        }
        else
        {
            /* report the error */
            IX_HSSACC_REPORT_ERROR ("ixHssAccComUninit - mutex uninitialisation failed\n");
            status = IX_FAIL;
        }
    }
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT,"Exiting ixHssAccComUninit\n");
    return status;
}