ixhssaccpcm.c

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

/*
 *Function :ixHssAccPCMClientInfoReset
 */
void 
ixHssAccPCMClientInfoReset (IxHssAccHssPort hssPortId, 
			     IxHssAccHdlcPort hdlcPortId)
{
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccPCMClientInfoReset\n");
    /* ixOsalMemSet the entire ixHssAccPCMClientInfo entry for this client to 0*/
    ixOsalMemSet (&(ixHssAccPCMClientInfo[hssPortId][hdlcPortId]), 
		  0, /*value to fill the struct with*/
		  sizeof (IxHssAccPCMInfo));
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	rxCallback = ixHssAccPCMRxEmptyCallback;
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	txDoneCallback = ixHssAccPCMTxDoneEmptyCallback;
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
      rxFreeLowCallback = ixHssAccPCMRxFreeBufLowEmptyCallback;
	    
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting"
		      " ixHssAccPCMClientInfoReset \n");  
}

/*
 *Function :ixHssAccPCMRxCallbackRun
 */
void 
ixHssAccPCMRxCallbackRun (IxHssAccHssPort hssPortId, 
			  IxHssAccHdlcPort hdlcPortId,
			  IX_OSAL_MBUF *buffer, 
			  unsigned numHssErrs,
			  IxHssAccPktStatus pktStatus,
			  UINT32 packetLength)
{
    /* This function is called from within an ISR */
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
					   "ixHssAccPCMRxCallbackRun \n"));
    
    IX_OSAL_MBUF_PKT_LEN(buffer) = packetLength;
    /* Increment the rxCallbackRuns stat */
    ixHssAccPCMStats.rxCallbackRuns++; 
    /* Execute the clients Rx Callback function from the */
    /*ixHssAccPCMClientInfo struct */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	rxCallback (buffer, numHssErrs, pktStatus,
			   ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
			   rxUserId);

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


/*
 *Function :ixHssAccPCMTxDoneCallbackRun
 */
void 
ixHssAccPCMTxDoneCallbackRun (IxHssAccHssPort hssPortId,
			      IxHssAccHdlcPort hdlcPortId, 
			      IX_OSAL_MBUF *buffer, unsigned numHssErrs, 
			      IxHssAccPktStatus pktStatus)
{
    /* This function is called from within an ISR */
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering"
					   " ixHssAccPCMTxDoneCallbackRun \n"));
    
    /* Execute the clients TxDone Callback function from the*/
    /* ixHssAccPCMClientInfo struct */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	txDoneCallback (buffer, numHssErrs, pktStatus, 
			ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
			txDoneUserId);
    /* Increment the txDoneCallbackRuns stat */
    ixHssAccPCMStats.txDoneCallbackRuns++; 
    
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
					   "ixHssAccPCMTxDoneCallbackRun\n"));
}


/*
 *Function :ixHssAccPCMRxFreeLowCallbackRun
 */
void 
ixHssAccPCMRxFreeLowCallbackRun (IxHssAccHssPort hssPortId, 
				 IxHssAccHdlcPort hdlcPortId)
{
    /* This function is called from within an ISR */
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
					   "ixHssAccPCMFreeLowCallbackRun \n"));
    /* Increment the FreeLowCallbackRuns stat */
    ixHssAccPCMStats.rxFreeCallbackRuns++;  
 
    /* Execute the clients FreeLow Callback function from*/
    /* the ixHssAccPCMClientInfo struct */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowCallback (
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowUserId);
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
					   "ixHssAccPCMRxFreeLowCallbackRun \n"));
}

/*
 * Function :ixHssAccPCMInit
 */
IX_STATUS ixHssAccPCMInit ()
{
    IX_STATUS status = IX_SUCCESS;
    IxHssAccHdlcPort hdlcPortIndex;
    IxHssAccHssPort hssPortIndex;
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
		      "ixHssAccPCMInit \n");

    /* Initialise the stats */ 
    ixHssAccPCMStatsInit ();  
   
    /* Set up the common Qs, ie Rx and TxDone... */
    for (hssPortIndex = IX_HSSACC_HSS_PORT_0; 
	 hssPortIndex < IX_HSSACC_HSS_PORT_MAX; 
	 hssPortIndex++)
    {
	for (hdlcPortIndex = IX_HSSACC_HDLC_PORT_0; 
	     hdlcPortIndex < IX_HSSACC_HDLC_PORT_MAX; 
	     hdlcPortIndex++)
	{
	    /*Set the thisIsConnected flag of every Hss/Hdlc port */
            /*combination to be FALSE*/
	    ixHssAccPCMClientInfo[hssPortIndex][hdlcPortIndex].
		thisIsConnected = FALSE;
	    ixHssAccPCMClientInfo[hssPortIndex][hdlcPortIndex].
		thisIsEnabled = FALSE;
	    ixHssAccPCMClientInfo[hssPortIndex][hdlcPortIndex].
		rxCallback = ixHssAccPCMRxEmptyCallback;
	    ixHssAccPCMClientInfo[hssPortIndex][hdlcPortIndex].
		txDoneCallback = ixHssAccPCMTxDoneEmptyCallback;
	    ixHssAccPCMClientInfo[hssPortIndex][hdlcPortIndex].
		rxFreeLowCallback = ixHssAccPCMRxFreeBufLowEmptyCallback;
	}
    }
        
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMInit\n");
    return status;
}


/*
 * Function :ixHssAccPCMCheckTxOk
 */
BOOL
ixHssAccPCMCheckTxOk (IxHssAccHssPort hssPortId, IxHssAccHdlcPort hdlcPortId)
{
    /* This function is called from within an ISR */
    BOOL status = FALSE;
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
					   "ixHssAccPCMCheckTxOk\n"));
    /* Is this port connected and started, if yes, then ok to Tx so return*/
    /* success */
    if (ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected && 
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsEnabled)
    {
       status = TRUE;
    }
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPCMCheckTxOk\n");
    return status;
}


/*
 * Function :ixHssAccPCMCheckReplenishOk
 */
BOOL
ixHssAccPCMCheckReplenishOk (IxHssAccHssPort hssPortId, 
			     IxHssAccHdlcPort hdlcPortId)
{
    /* This function may be called from within an ISR */
    BOOL status = FALSE;
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
					   "ixHssAccPCMCheckReplenishOk\n"));
    /* Is this port connected, if yes, then ok to replenish so return*/
    /* success */
    if (ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected)
    {
       status = TRUE;
    }
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
					   "ixHssAccPCMCheckReplenishOk\n"));
    return status;
}


/*
 * Function :ixHssAccPCMShow
 */
void ixHssAccPCMShow (void)
{  
    IxHssAccHssPort hssPortIndex;
    IxHssAccHdlcPort hdlcPortIndex;
    IxHssAccPCMInfo *pcmInfo;
    BOOL hdlc56kCasMsb = TRUE;

    printf ("\nixHssAccPCMShow:\n");
    printf ("\t   connects: %d ([H]%d,[R]%d)    \t enables: %d\n"
	    "       HDLC64K conn: %d  HDLC56K conn: %d\n",
	    ixHssAccPCMStats.connections,
	    ixHssAccPCMStats.hdlcConnections,
	    ixHssAccPCMStats.rawConnections, 
	    ixHssAccPCMStats.enables,
	    ixHssAccPCMStats.hdlc64kConnections,
	    ixHssAccPCMStats.hdlc56kConnections);
    printf ("\tdisconnects: %d connRollBacks: %d\tdisables: %d\n\n", 
	    ixHssAccPCMStats.disconnections,
	    ixHssAccPCMStats.connectionRollbacks,
	    ixHssAccPCMStats.disables);
    printf ("\t    rxCallbackRuns: %d    rxDummyCallbackRuns : %d\n",
	    ixHssAccPCMStats.rxCallbackRuns,
	    ixHssAccPCMStats.rxDummyCallbackRuns);
    printf ("\ttxDoneCallbackRuns: %d txDoneDummyCallbackRuns: %d\n",
	    ixHssAccPCMStats.txDoneCallbackRuns,
	    ixHssAccPCMStats.txDoneDummyCallbackRuns);
    printf ("\trxFreeCallbackRuns: %d rxFreeDummyCallbackRuns: %d\n\n",
	    ixHssAccPCMStats.rxFreeCallbackRuns,
	    ixHssAccPCMStats.rxFreeDummyCallbackRuns);

    for (hssPortIndex = IX_HSSACC_HSS_PORT_0;
	 hssPortIndex < hssPortMax;
	 hssPortIndex++)
    {
	for (hdlcPortIndex = IX_HSSACC_HDLC_PORT_0;
	     hdlcPortIndex < IX_HSSACC_HDLC_PORT_MAX;
	     hdlcPortIndex++)
	{
	    pcmInfo = &ixHssAccPCMClientInfo[hssPortIndex][hdlcPortIndex];
	    printf ("\tHSS[%d] HDLC[%d]: %s, %s\n"
		    "\t\t\tHDLC%s Mode  - Selected\n",
		    hssPortIndex,
		    hdlcPortIndex,
		    (pcmInfo->thisIsConnected ? "Connected" : "Disconnected"),
		    (pcmInfo->thisIsEnabled ? "Enabled" : "Disabled"),
		    (pcmInfo->hdlcMode.hdlc56kMode ? "56K" : "64K"));
		    
	    if (pcmInfo->hdlcMode.hdlc56kMode)
	    {
	        if (pcmInfo->hdlcMode.hdlc56kEndian == 
	            IX_HSSACC_56KE_BIT_7_UNUSED)
	        {    
	            hdlc56kCasMsb = TRUE;
	        }
	        else if (pcmInfo->hdlcMode.hdlc56kEndian == 
	                 IX_HSSACC_56KE_BIT_0_UNUSED)
	        {
	            hdlc56kCasMsb = FALSE;
	        }
	        printf ("\t\t\t\t      - CAS at %s\n"
			"\t\t\t\t      - CAS Polarity %d\n",
			hdlc56kCasMsb ? "MSB" : "LSB",
			pcmInfo->hdlcMode.hdlc56kUnusedBitPolarity0 ? 
			IX_HSSACC_PKT_HDLC_56KMODE_CAS_POLARITY0 : 
			IX_HSSACC_PKT_HDLC_56KMODE_CAS_POLARITY1);
	    }
            
            printf ("\t\t\tBit Inversion - %s\n",
		    (pcmInfo->hdlcBitInvert ? "Enabled" : "Disabled"));
	}
    }
}

/*
 * Function :ixHssAccPCMStatsInit
 */
void ixHssAccPCMStatsInit (void)
{
    ixHssAccPCMStats.connections          = 0;
    ixHssAccPCMStats.disconnections       = 0;
    ixHssAccPCMStats.rawConnections       = 0;
    ixHssAccPCMStats.hdlcConnections      = 0;
    ixHssAccPCMStats.enables              = 0;
    ixHssAccPCMStats.disables             = 0;
    ixHssAccPCMStats.connectionRollbacks  = 0;
    ixHssAccPCMStats.rxCallbackRuns       = 0;
    ixHssAccPCMStats.txDoneCallbackRuns   = 0;
    ixHssAccPCMStats.rxFreeCallbackRuns   = 0;
    ixHssAccPCMStats.rxDummyCallbackRuns  = 0;
    ixHssAccPCMStats.rxFreeDummyCallbackRuns = 0;
    ixHssAccPCMStats.txDoneDummyCallbackRuns = 0;
}


/*
 * Function :ixHssAccPktRxDisconnectCallback
 * 
 * The following callback replaces the client callback during a packetised
 * disconnect.  Having passed the received data to the client, this
 * function will check to see if all resources have been returned to
 * hssAccPkt before declaring the connection disconnected
 * 
 */
PRIVATE void 
ixHssAccPktRxDisconnectCallback (IX_OSAL_MBUF *buffer, 
				 unsigned numHssErrs, 
				 IxHssAccPktStatus pktStatus,
				 IxHssAccPktUserId 
				 rxUserId)
{
    /* This function is called from within an ISR */
    IxHssAccHdlcPort hdlcPortId = IX_HSSACC_PKT_CBID_HDLC_MASK & 
	(unsigned)rxUserId;
    IxHssAccHssPort hssPortId = (rxUserId >> IX_HSSACC_PKT_CBID_HSS_OFFSET);
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
					   "ixHssAccPktRxDisconnectCallback\n"));
    /* execute client registered callback */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	rxDisconnectingCallback (
	    buffer, 
	    numHssErrs, 
	    pktStatus,
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	    disconnectingRxUserId);

    /* Check if this is the last desc to be returned, if so no more data is */
    /* outstanding for Tx or Rx for the client */
    if (ixHssAccPDMNumDescInUse (hssPortId, hdlcPortId) == 1)
    {
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected = FALSE;
	ixHssAccPCMClientInfoReset (hssPortId, hdlcPortId);
    }
    
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
					   "ixHssAccPktRxDisconnectCallback\n"));
}


PRIVATE void 
ixHssAccPktTxDoneDisconnectCallback (IX_OSAL_MBUF *buffer, 
				     unsigned numHssErrs, 
				     IxHssAccPktStatus pktStatus,
				     IxHssAccPktUserId 
				     txDoneUserId)
{
    /* This function is called from within an ISR */
    IxHssAccHdlcPort hdlcPortId = IX_HSSACC_PKT_CBID_HDLC_MASK &
	(unsigned)txDoneUserId;
    IxHssAccHssPort hssPortId = (txDoneUserId >> IX_HSSACC_PKT_CBID_HSS_OFFSET);
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
					   "ixHssAccPktTxDoneDisconnectCallback\n"));

    /* execute client registered callback */
    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].
	txDoneDisconnectingCallback (buffer, 
				     numHssErrs, 
				     pktStatus, 
				     ixHssAccPCMClientInfo
				     [hssPortId][hdlcPortId].
				     disconnectingTxDoneUserId);
    
    /* Check if this desc is the last to be returned, if so no more data is*/
    /* outstanding for Tx or Rx for the client*/
    if (ixHssAccPDMNumDescInUse (hssPortId, hdlcPortId) == 1)
    {
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected = FALSE;
	ixHssAccPCMClientInfoReset (hssPortId, hdlcPortId);
    }
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
					   "ixHssAccPktTxDoneDisconnectCallback\n"));
}

PRIVATE void
ixHssAccPCMRxEmptyCallback (IX_OSAL_MBUF *buffer, 
			    unsigned numHssErrs, 
			    IxHssAccPktStatus pktStatus,
			    IxHssAccPktUserId rxUserId)
{
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "In "
					   "ixHssAccPCMRxEmptyCallback\n"));
    ixHssAccPCMStats.rxDummyCallbackRuns++;
}


PRIVATE void
ixHssAccPCMTxDoneEmptyCallback (IX_OSAL_MBUF *buffer, 
				unsigned numHssErrs, 
				IxHssAccPktStatus pktStatus,
				IxHssAccPktUserId txDoneUserId)
{
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "In "
					   "ixHssAccPCMTxDoneEmptyCallback\n"));    
    ixHssAccPCMStats.txDoneDummyCallbackRuns++;
}

PRIVATE void
ixHssAccPCMRxFreeBufLowEmptyCallback (IxHssAccPktUserId rxFreeLowPktUserId)
{
    IX_HSSACC_DEBUG_OFF (IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "In "
					   "ixHssAccPCMRxFreeBufLowEmptyCallback\n")); 
    ixHssAccPCMStats.rxFreeDummyCallbackRuns++;
    /*Dummy function for Rx Free Low Callback*/  
}

PRIVATE IX_STATUS
ixHssAccPCMQFlush (IxQMgrQId readQId, IxQMgrQId writeQId)
{
    IX_STATUS status;
    IX_STATUS writeStatus = IX_SUCCESS;
    IxHssAccPDMDescriptor *desc, *physDesc;
    UINT32 pDesc = 0;
    BOOL flushQIdIsReadQ;

    if ((writeQId == IX_NPE_A_QMQ_HSS0_PKT_RX) || (writeQId == IX_NPE_A_QMQ_HSS1_PKT_RX))
    {
       flushQIdIsReadQ = TRUE;
    }
    else 
    {
       flushQIdIsReadQ = FALSE;
    }
    
    IX_HSSACC_TRACE1 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccPCMQFlush for %s\n",
		      flushQIdIsReadQ ? (int) "RxFreeQ flush" : (int) "TxQ flush");
    do
    {
	status = ixQMgrQRead (readQId, &pDesc);
	desc = (IxHssAccPDMDescriptor *) pDesc;
	if ((status == IX_SUCCESS) && (desc != NULL))
	{
	    physDesc = (IxHssAccPDMDescriptor *) IX_HSSACC_PKT_MMU_PHY_TO_VIRT(desc);
	    IX_HSSACC_PKT_DATA_CACHE_INVALIDATE(physDesc, sizeof(*physDesc));
	    physDesc->npeDesc.status = IX_HSSACC_DISCONNECT_IN_PROGRESS;
	    IX_HSSACC_PKT_DATA_CACHE_FLUSH(physDesc, sizeof(*physDesc));
            pDesc = (UINT32) desc;
	    writeStatus = ixQMgrQWrite (writeQId, &pDesc);
	    if (writeStatus != IX_SUCCESS)
	    {
		IX_HSSACC_REPORT_ERROR ("ixHssAccPCMQFlush:"
					"Writing descriptors to the write "
					"Q failed - descriptor pool in a "
					"depleted state; client mbufs lost also\n");
		/* don't return here - still want to completely flush the readQ */
		/* queue if possible */
		writeStatus = IX_FAIL;
	    }
	}
	else if (status == IX_FAIL)
	{
	    IX_HSSACC_REPORT_ERROR ("ixHssAccPCMQFlush:"
				    "Reading a descriptor from the read "
				    "Q failed while trying to flush it\n");
	    
	    return status;
	}
    } while (status != IX_QMGR_Q_UNDERFLOW);
    IX_HSSACC_TRACE1 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccPCMQFlush for %s\n",
		      (flushQIdIsReadQ == TRUE ? 
		       (int) "RxFreeQ flush" : (int) "TxQ flush"));


    return writeStatus;
}