ixhssaccpcm.c

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

/**
 * @file IxHssAccPCM.c
 *
 * @author Intel Corporation
 * @date 10 Jan 2002
 *
 * @brief This file contains the implementation of the private API for the 
 * Packetised Connection Manager.
 *
 * 
 * @par
 * IXP400 SW Release version 2.1
 * 
 * -- Copyright Notice --
 * 
 * @par
 * Copyright (c) 2001-2005, Intel Corporation.
 * All rights reserved.
 * 
 * @par
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the Intel Corporation nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 * 
 * 
 * @par
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * 
 * @par
 * -- End of Copyright Notice --
*/

#ifndef IXHSSACCPCM_P_H
#   define IXHSSACCPCM_C
#else
#   error "Error: IxHssAccPCM_p.h should not be included before this definition."
#endif

/**
 * Put the system defined include files required.
 */

/**
 * Put the user defined include files required.
 */
#include "IxOsal.h"
#include "IxHssAcc.h"
#include "IxHssAccPCM_p.h"
#include "IxHssAccError_p.h"
#include "IxHssAccCommon_p.h"
#include "IxHssAccNpeA_p.h"

/**
 * #defines and macros used in this file.
 */
#define IX_HSSACC_PKT_MAX_NUM_FRAME_FLAGS     3
#define IX_HSSACC_PKT_NUM_FRAME_FLAGS_OFFSET  3
#define IX_HSSACC_PKT_HDLC_CRC_TYPE_OFFSET    1
#define IX_HSSACC_PKT_HDLC_BIG_ENDIAN_OFFSET  2
#define IX_HSSACC_PKT_HSS_PORT_OFFSET         16
#define IX_HSSACC_PKT_HDLC_PORT_OFFSET        24
#define IX_HSSACC_PKT_NUM_NPE_REGADDRS        6
#define IX_HSSACC_PKT_NUM_MILLISECS_TO_WAIT   100

#define IX_HSSACC_PKT_HDLC_CRC_32_MASK             0x2
#define IX_HSSACC_PKT_HDLC_CRC_16_MASK             0x0
#define IX_HSSACC_PKT_HDLC_IDLE_ONES_ENABLED_MASK  0x1
#define IX_HSSACC_PKT_HDLC_IDLE_FLAGS_ENABLED_MASK 0x0
#define IX_HSSACC_PKT_HDLC_MSB_ENDIAN_MASK         0x4 
#define IX_HSSACC_PKT_HDLC_LSB_ENDIAN_MASK         0x0
#define IX_HSSACC_PKT_HDLC_56KMODE_CAS_POLARITY0   0
#define IX_HSSACC_PKT_HDLC_56KMODE_CAS_POLARITY1   1
#define IX_HSSACC_PKT_RXFREE_Q_WATERMARK           IX_QMGR_Q_WM_LEVEL4
#define IX_HSSACC_PKT_CRC_32_SIZE_IN_BYTES         4
#define IX_HSSACC_PKT_CRC_16_SIZE_IN_BYTES         2

/*
 * Typedefs global to this file
 */
typedef struct 
{
    BOOL hdlcFraming;                                 
    IxHssAccHdlcMode hdlcMode;
    BOOL hdlcBitInvert;
    unsigned blockSizeInWords;
    UINT32 rawIdleBlockPattern;
    IxHssAccPktHdlcFraming hdlcTxFraming;            
    IxHssAccPktHdlcFraming hdlcRxFraming;            
    IxHssAccPktHdlcIdleType hdlcIdleType; 
    unsigned frmFlagStart;
    IxHssAccPktRxCallback rxCallback;  
    IxHssAccPktRxCallback rxDisconnectingCallback;
    IxHssAccPktRxFreeLowCallback rxFreeLowCallback;  
    IxHssAccPktTxDoneCallback txDoneCallback;
    IxHssAccPktTxDoneCallback txDoneDisconnectingCallback;
    IxHssAccPktUserId rxUserId;
    IxHssAccPktUserId txDoneUserId;
    IxHssAccPktUserId disconnectingTxDoneUserId;
    IxHssAccPktUserId disconnectingRxUserId;
    IxHssAccPktUserId rxFreeLowUserId;
    BOOL thisIsConnected;
    BOOL thisIsEnabled;
} IxHssAccPCMInfo;


typedef struct 
{
    unsigned hdlc_rxcfg;
    unsigned hdlc_txcfg;
    unsigned idle_pattern;
    unsigned mode;
    unsigned rx_sizeb;
    unsigned rx_sizew;
} IxHssAccPktNpeRegAddrs;


typedef struct 
{
    unsigned connections;
    unsigned disconnections;
    unsigned rawConnections;
    unsigned hdlcConnections;
    unsigned hdlc64kConnections;
    unsigned hdlc56kConnections;
    unsigned enables;
    unsigned disables;
    unsigned connectionRollbacks;
    unsigned rxCallbackRuns;
    unsigned txDoneCallbackRuns;
    unsigned rxFreeCallbackRuns;
    unsigned rxDummyCallbackRuns;
    unsigned rxFreeDummyCallbackRuns;
    unsigned txDoneDummyCallbackRuns;
} IxHssAccPCMStats;

/**
 * Variable declarations global to this file only. 
 * Externs are followed by static variables.
 */

IxQMgrQId ixHssAccPCMRxFreeQId[IX_HSSACC_HSS_PORT_MAX]
[IX_HSSACC_HDLC_PORT_MAX] = 
{
   {IX_NPE_A_QMQ_HSS0_PKT_RX_FREE0,      
    IX_NPE_A_QMQ_HSS0_PKT_RX_FREE1,      
    IX_NPE_A_QMQ_HSS0_PKT_RX_FREE2,       
    IX_NPE_A_QMQ_HSS0_PKT_RX_FREE3}, 
   {IX_NPE_A_QMQ_HSS1_PKT_RX_FREE0,      
    IX_NPE_A_QMQ_HSS1_PKT_RX_FREE1,      
    IX_NPE_A_QMQ_HSS1_PKT_RX_FREE2,       
    IX_NPE_A_QMQ_HSS1_PKT_RX_FREE3}
};

IxQMgrQId ixHssAccPCMTxQId[IX_HSSACC_HSS_PORT_MAX]
[IX_HSSACC_HDLC_PORT_MAX] = 
{
    {IX_NPE_A_QMQ_HSS0_PKT_TX0,       
     IX_NPE_A_QMQ_HSS0_PKT_TX1,      
     IX_NPE_A_QMQ_HSS0_PKT_TX2,       
     IX_NPE_A_QMQ_HSS0_PKT_TX3}, 
    {IX_NPE_A_QMQ_HSS1_PKT_TX0,       
     IX_NPE_A_QMQ_HSS1_PKT_TX1,      
     IX_NPE_A_QMQ_HSS1_PKT_TX2,       
     IX_NPE_A_QMQ_HSS1_PKT_TX3}
};  

IxQMgrQId ixHssAccPCMRxQId[IX_HSSACC_HSS_PORT_MAX] = 
{    IX_NPE_A_QMQ_HSS0_PKT_RX,       
     IX_NPE_A_QMQ_HSS1_PKT_RX
};

IxQMgrQId ixHssAccPCMTxDoneQId[IX_HSSACC_HSS_PORT_MAX] = 
{    IX_NPE_A_QMQ_HSS0_PKT_TX_DONE,       
     IX_NPE_A_QMQ_HSS1_PKT_TX_DONE
};

static IxHssAccPCMInfo ixHssAccPCMClientInfo[IX_HSSACC_HSS_PORT_MAX]
[IX_HSSACC_HDLC_PORT_MAX];

static IxHssAccPCMStats ixHssAccPCMStats;

/*
 * Static function prototypes
 */
PRIVATE IX_STATUS 
ixHssAccPCMRxCfgCreate (IxHssAccPktHdlcFraming hdlcRxFraming, UINT8 *rxCfg);

PRIVATE IX_STATUS 
ixHssAccPCMTxCfgCreate (IxHssAccPktHdlcFraming hdlcTxFraming,
			unsigned frmFlagStart, UINT8 *cfg);

PRIVATE IX_STATUS
ixHssAccPCMComCfgCreate (IxHssAccPktHdlcFraming hdlcComFraming, UINT8 *cfg);

PRIVATE IX_STATUS
ixHssAccPCMPktPipeModeCreate (IxHssAccHdlcMode hdlcMode, 
			      BOOL hdlcBitInvert, UINT32 *mode,
			      UINT32 *invMask, UINT32 *orMask);

PRIVATE void
ixHssAccPCMClientInfoReset (IxHssAccHssPort hssPortId, IxHssAccHdlcPort hdlcPortId);

PRIVATE IX_STATUS
ixHssAccPCMQFlush (IxQMgrQId readQId, IxQMgrQId writeQId);

PRIVATE void
ixHssAccPCMRxFreeBufLowEmptyCallback (IxHssAccPktUserId rxFreeLowUserId);

PRIVATE void 
ixHssAccPktTxDoneDisconnectCallback (IX_OSAL_MBUF *buffer, 
				     unsigned numHssErrs, 
				     IxHssAccPktStatus pktStatus,
				     IxHssAccPktUserId 
				     txDoneUserId);

PRIVATE void 
ixHssAccPktRxDisconnectCallback (IX_OSAL_MBUF *buffer, 
				 unsigned numHssErrs, 
				 IxHssAccPktStatus pktStatus,
				 IxHssAccPktUserId 
				 rxUserId);

PRIVATE void
ixHssAccPCMTxDoneEmptyCallback (IX_OSAL_MBUF *buffer, 
				unsigned numHssErrs, 
				IxHssAccPktStatus pktStatus,
				IxHssAccPktUserId txDoneUserId);
PRIVATE void
ixHssAccPCMRxEmptyCallback (IX_OSAL_MBUF *buffer, 
			    unsigned numHssErrs, 
			    IxHssAccPktStatus pktStatus,
			    IxHssAccPktUserId rxUserId);


/*
 *Function :ixHssAccPCMConnect
 */
IX_STATUS 
ixHssAccPCMConnect (IxHssAccHssPort hssPortId, 
		    IxHssAccHdlcPort hdlcPortId, 
		    BOOL hdlcFraming,
		    IxHssAccHdlcMode hdlcMode,
		    BOOL hdlcBitInvert,
		    unsigned blockSizeInWords,
		    UINT32 rawIdleBlockPattern,
		    IxHssAccPktHdlcFraming hdlcTxFraming, 
		    IxHssAccPktHdlcFraming hdlcRxFraming, 
		    unsigned frmFlagStart,
		    IxHssAccPktRxCallback rxCallback,
		    IxHssAccPktUserId rxUserId,
		    IxHssAccPktRxFreeLowCallback rxFreeLowCallback,
		    IxHssAccPktUserId rxFreeLowUserId,
		    IxHssAccPktTxDoneCallback txDoneCallback,
		    IxHssAccPktUserId txDoneUserId)

{
    IX_STATUS status = IX_SUCCESS;
    UINT8 rxCfg  = 0;
    UINT8 txCfg  = 0;
    UINT32 data = 0;
    UINT32 mode = 0;
    UINT32 invMask = 0;
    UINT32 orMask = 0;
    unsigned crcSizeInBytes;    
    unsigned msgData;
    IxNpeMhMessage message;
    
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
		      "ixHssAccPCMConnect\n");
    

    /* Is this Hss/Hdlc port combination already in use? */
    if (ixHssAccPCMClientInfo[hssPortId][hdlcPortId].thisIsConnected)
    {
	IX_HSSACC_REPORT_ERROR ("ixHssAccPCMConnect:"
				"This HSS/HDLC port combination "
				"already in use\n");
	return IX_FAIL;
    }

    if (hdlcFraming)
    {
	/* if HDLC framing is needed for this HDLC port*/
	status = ixHssAccPCMRxCfgCreate (hdlcRxFraming, &rxCfg);
	if (status == IX_SUCCESS)
	{	
	    status = ixHssAccPCMTxCfgCreate (hdlcTxFraming, 
					     frmFlagStart, &txCfg);
	}

	if (status == IX_SUCCESS)
	{	
	    data = rxCfg << IX_HSSACC_NPE_PKT_RXCFG_OFFSET |
		txCfg << IX_HSSACC_NPE_PKT_TXCFG_OFFSET;

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

	    /* send the message */
	    status = ixHssAccComNpeCmdMsgSend (
		message, 
		FALSE, /* no resp expected */
		IX_NPE_A_MSSG_HSS_PKT_PIPE_HDLC_CFG_WRITE);

	}

	mode = IX_HSSACC_NPE_PKT_MODE_HDLC;
    }
    else
    {
	/* Write the idle pattern to the NPE memory address specified */
	ixHssAccComNpeCmdMsgCreate (
	    IX_NPE_A_MSSG_HSS_PKT_PIPE_IDLE_PATTERN_WRITE, 
		0, hssPortId, hdlcPortId, rawIdleBlockPattern, &message);

	    /* send the message */
	    status = ixHssAccComNpeCmdMsgSend (
		message, 
		FALSE, /* no resp expected */
		IX_NPE_A_MSSG_HSS_PKT_PIPE_IDLE_PATTERN_WRITE);

	mode = IX_HSSACC_NPE_PKT_MODE_RAW;
    }

    if (status == IX_SUCCESS)
    {
	/* create packetised pipe mode settings */
	status = ixHssAccPCMPktPipeModeCreate (hdlcMode, hdlcBitInvert,
					       &mode, &invMask, &orMask);
        if (status == IX_SUCCESS)
        {
	    /* create the NpeMh message - NPE_A message format */
	    msgData = mode    << IX_HSSACC_NPE_PKT_MODE_OFFSET    |
	              invMask << IX_HSSACC_NPE_PKT_INVMASK_OFFSET |
	              orMask  << IX_HSSACC_NPE_PKT_ORMASK_OFFSET;
	
	    ixHssAccComNpeCmdMsgCreate (
	        IX_NPE_A_MSSG_HSS_PKT_PIPE_MODE_WRITE, 
	        0, hssPortId, hdlcPortId, msgData, &message);
	
	    /* send the message */
	    status = ixHssAccComNpeCmdMsgSend (
	        message, 
	        FALSE, /* no resp expected */
	        IX_NPE_A_MSSG_HSS_PKT_PIPE_MODE_WRITE);
        }
    }

    if (status == IX_SUCCESS)
    {
	/* Configuring the client max tx/rx block size */
	/* rx_sizeb and rx_sizew are the size in bytes and the same size*/
	/* expressed in words*/
	if (hdlcFraming)
	{
	    /* In the case of HDLC framing the crcSizeInBytes needs to be */
	    /* added to the max packet size the NPE is expecting.         */
	    if (hdlcRxFraming.crcType == IX_HSSACC_PKT_32_BIT_CRC) 
	    {
		crcSizeInBytes = IX_HSSACC_PKT_CRC_32_SIZE_IN_BYTES;
	    }
	    else
	    {
		crcSizeInBytes = IX_HSSACC_PKT_CRC_16_SIZE_IN_BYTES;
	    }
	    data = 
		(((blockSizeInWords * IX_HSSACC_BYTES_PER_WORD) +
		  crcSizeInBytes) << IX_HSSACC_NPE_PKT_RXSIZEB_OFFSET);
	}
	else
	{
	    data = 
		((blockSizeInWords * IX_HSSACC_BYTES_PER_WORD) << 
		 IX_HSSACC_NPE_PKT_RXSIZEB_OFFSET);
	}
	    /* create the NpeMh message - NPE_A message format */
	ixHssAccComNpeCmdMsgCreate (
	    IX_NPE_A_MSSG_HSS_PKT_PIPE_RX_SIZE_WRITE, 
	    0, hssPortId, hdlcPortId, data, &message);
	
	/* send the message */
	status = ixHssAccComNpeCmdMsgSend (
	    message, 
	    FALSE, /* no resp expected */
	    IX_NPE_A_MSSG_HSS_PKT_PIPE_RX_SIZE_WRITE);
    }

    if (status == IX_SUCCESS)
    {
	/* Only setup interrupts and callbacks if an ixHssAccPktRxFreeLowCallback*/
	/* has been supplied */
	if (rxFreeLowCallback != NULL)
	{
	    /* Set the Watermark for the RxFree Q for this client */
	    status = ixQMgrWatermarkSet (
		ixHssAccPCMRxFreeQId[hssPortId][hdlcPortId],
		IX_HSSACC_PKT_RXFREE_Q_WATERMARK/*NE flag*/,
		0/*NF flag*/);

	    if (status != IX_SUCCESS)
	    {
		IX_HSSACC_REPORT_ERROR("ixHssAccPCMConnect:"
				       "ixQMgrWatermarkSet failed for this"
				       " client\n");
		ixHssAccPCMClientInfoReset (hssPortId, hdlcPortId);
		/* Increment the ConnectionRollBacks stat */	
		ixHssAccPCMStats.connectionRollbacks++;
		return IX_FAIL;
	    }
	
	    /* set the client callback before enabling notifications */
	    ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rxFreeLowCallback =
		rxFreeLowCallback; 

	    /* Enable notification for the RxFree Q for this client */
	    status = ixQMgrNotificationEnable (
		ixHssAccPCMRxFreeQId[hssPortId][hdlcPortId],
		IX_QMGR_Q_SOURCE_ID_NE);
	    if (status != IX_SUCCESS)
	    {
		IX_HSSACC_REPORT_ERROR("ixHssAccPCMConnect:"
				       "Call to ixQMgrNotificationEnable"
				       " failed\n");
		ixHssAccPCMClientInfoReset (hssPortId, hdlcPortId);
		ixHssAccPCMStats.connectionRollbacks++; 
		/* Increment the ConnectionRollBacks stat */
		return IX_FAIL;
	    } 
	}
    }    

    if (status == IX_SUCCESS)
    { 
	/* 
	 * Save the values supplied by the client into the 
	 * ixHssAccPCMClientInfo struct for later reference
	 */
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].hdlcFraming = hdlcFraming;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].hdlcMode = hdlcMode;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].hdlcBitInvert = hdlcBitInvert;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].blockSizeInWords = blockSizeInWords;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].rawIdleBlockPattern = rawIdleBlockPattern;
	ixHssAccPCMClientInfo[hssPortId][hdlcPortId].hdlcTxFraming = hdlcTxFraming;