dpx.c

交换机中常用芯片链路复用7350的驱动源代码(vxworks中实现)

*******************************************************************************/

VOID pDpxEventNotify(sDPX_DDB *psDpxDdb, eDPX_EVENT_ID eEventId, 
                        UINT1 u1IndRegValue, INT4 len, UINT1 *pSupplement)
{
    sDPX_EVENT_NOTIFY_IND *psDpxEventInd;
    sDPX_IND_BUF *psIndCtxt;

    if(len > (DPX_MAX_IND_BUFSZ-4))
         return;
    
    /* call indication callback routine */
    if(psDpxDdb->indNotify != DPX_NULL)
    {
        /*  gets an indication buffer */
        psIndCtxt = duplexGetIndBuf();
        if(psIndCtxt == DPX_NULL)
            return;
        
        psIndCtxt->u4Len = sizeof(eDPX_EVENT_ID) + 1 + len ;
        psDpxEventInd = (sDPX_EVENT_NOTIFY_IND *) (psIndCtxt->u1Data);
    
        /* fill in the event information */
        psDpxEventInd->eEventId = eEventId;
        psDpxEventInd->u1IndRegValue = u1IndRegValue;
        
        if((len != 0) && (pSupplement != DPX_NULL))
            sysDuplexMemCopy(psDpxEventInd->supplement, pSupplement, len);
              
        psDpxDdb->indNotify(psDpxDdb->usrCtxt, psIndCtxt);
    } 
    return;
}
      

/*******************************************************************************
**
**  pDpxProcessRxBOC
**  ___________________________________________________________________________ 
**
**  DESCRIPTION: This routine is called by the duplexDPR when the device 
**               received BOC code on RXD1 or RXD2 link.
**               
**
**  VALID STATES:  Not applicable
**
**  SIDE EFFECTS: 
**
**  INPUTS:	     psDpxDdb - pointer to the device DDB
**               u1HssLnkId - serial link on which the BOC was received
**               u1RxBocStatus	- status bits read from RX BOC Status register
**
**  OUTPUTS:	 None
**
**  RETURN CODES: None
**
*******************************************************************************/
VOID pDpxProcessRxBOC(sDPX_DDB *psDpxDdb, UINT1 u1HssLnkId, UINT1 u1RxBocStatus)
{
    UINT1 u1BOC = 0;
    sDPX_RX_BOC_IND *psDpxBocInd;
    sDPX_IND_BUF *psIndCtxt;

    /* gets BOC[5:0] */
    u1BOC = (u1RxBocStatus & DPX_MASK_BOC_RCV_STATUS_BOC);
                    
    /*  gets an indication buffer */
    psIndCtxt = duplexGetIndBuf();
    if(psIndCtxt != DPX_NULL)
    {  
        psIndCtxt->u4Len = sizeof(sDPX_RX_BOC_IND);
        psDpxBocInd = (sDPX_RX_BOC_IND *) (psIndCtxt->u1Data);
        psDpxBocInd->u1HssLnkId = u1HssLnkId;
        psDpxBocInd->u1BOC = u1BOC;
         psDpxBocInd->u1IndRegValue = u1RxBocStatus;
                    
        /* call indication callback routine */
        if(psDpxDdb->indRxBOC != DPX_NULL)
                psDpxDdb->indRxBOC(psDpxDdb->usrCtxt, psIndCtxt);
    } 
 
}

/*******************************************************************************
**
**  pDpxProcessRxHssInt
**  ___________________________________________________________________________ 
**
**  DESCRIPTION: This routine is called by the duplexDPR when the device 
**               gets HSS interrupt on RXD1 or RXD2 link.
**               
**
**  VALID STATES:  Not applicable
**
**  SIDE EFFECTS: 
**
**  INPUTS:	  u1HSSIntStatu	- value read from HSS Interrupt Status register
**            u1HSSCellStatus - read from HSS Cell Filtering Config/Status
**                                  register.
**
**  OUTPUTS:	 None
**
**  RETURN CODES: None
**
*******************************************************************************/
VOID   pDpxProcessRxHssInt(sDPX_DDB *psDpxDdb, UINT1 u1HssLnkId,
                           UINT1 u1HSSIntStatus, UINT1 u1HSSCellStatus)
{
    INT4 lnkId;
    
    if(u1HssLnkId == DPX_RXD1)
        lnkId = 0;
    else
        lnkId = 1;
        
    if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_LOSI)
    {
        /* Loss of Signal (LOSV) state changed */
        if(u1HSSCellStatus & DPX_MASK_HSS_CELL_FLT_LOSV)
        {
            /* Loss of Signal occured */
            (psDpxDdb->sStatCounts.Count_RxHss_Loss_Of_Signal[lnkId])++;
            pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_LOSS_OF_SIGNAL,
                             u1HSSIntStatus, 1, &u1HssLnkId);
        }
        else
        {
             /*   Signal transition detected */
             (psDpxDdb->sStatCounts.Count_RxHss_Signal_Detected[lnkId])++;

             pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_SIGNAL_DETECTED, 
                             u1HSSIntStatus,1, &u1HssLnkId);
             
         }
    }

    if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_LCDI)
    {
         /* LOSS of CELL Delineation (LCDV) state changed */
         if(u1HSSCellStatus & DPX_MASK_HSS_CELL_FLT_LCDV)
         {
             /* Loss ofCELL Delineation occured for 1318 cells */
             (psDpxDdb->sStatCounts.Count_RxHss_Out_Of_Delin[lnkId])++;
             pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_OUT_OF_DELIN, 
                              u1HSSIntStatus, 1, &u1HssLnkId);
             
         }
         else
         {
             /*  cell delineation state maintained for 1318 cells */
             (psDpxDdb->sStatCounts.Count_RxHss_In_Delin[lnkId])++;
             pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_IN_DELIN, 
                              u1HSSIntStatus, 1, &u1HssLnkId);
             
         }
     }

     if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_ACTI)
     {
         /* ACTIVE bit in the cell prepend state changed */
         if(u1HSSCellStatus & DPX_MASK_HSS_CELL_FLT_ACTV)
         {
             /* ACTIVE bit detected for three consecutive valid cells */
             (psDpxDdb->sStatCounts.Count_RxHss_Active_Bit[lnkId])++;
             pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_ACTIVE_BIT, 
                              u1HSSIntStatus, 1, &u1HssLnkId);
             
         }
         else
         {
             /*   Active bit lost */
             (psDpxDdb->sStatCounts.Count_RxHss_No_Active_Bit[lnkId])++;
             pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_NO_ACTIVE_BIT, 
                              u1HSSIntStatus, 1, &u1HssLnkId);
             
         }
      }

      if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_OCDI)
      {
           /* Cell Delineation state machine enters/exits the SYNC state */
           if(u1HSSCellStatus & DPX_MASK_HSS_CELL_FLT_OCDV)
           {
               /* cell delineation state machine is in the "HUNT" or 
                  "PRESYNC" state */
               (psDpxDdb->sStatCounts.Count_RxHss_Out_Of_Sync[lnkId])++;
               pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_OUT_OF_SYNC, 
                                u1HSSIntStatus, 1, &u1HssLnkId);
               
           }
           else
           {
               /*   Signal transition detected */
               (psDpxDdb->sStatCounts.Count_RxHss_In_Sync[lnkId])++;
               pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_IN_SYNC, 
                                u1HSSIntStatus, 1, &u1HssLnkId);
               
           }
       }

       if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_CELLERRI)
       {
           /* non-zero remained occurs for the CRC-8 protecting the entire 
              cell */
           (psDpxDdb->sStatCounts.Count_RxHss_CRC8_Error[lnkId])++;
           pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_CRC8_ERROR, 
                            u1HSSIntStatus, 1, &u1HssLnkId);
           
       }

       if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_HCSI)
       {
           /* HCS error detected */
           (psDpxDdb->sStatCounts.Count_RxHss_HCS_Error[lnkId])++;
           pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_HCS_ERROR, 
                            u1HSSIntStatus, 1, &u1HssLnkId);
           
       }

      if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_XFERI)
      {
           /* Counter registers has been updated */
           (psDpxDdb->sStatCounts.Count_RxHss_Count_Updated[lnkId])++;
           pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_COUNT_UPDATED, 
                            u1HSSIntStatus, 1, &u1HssLnkId);
           

           /* it's time to read in the Counter register */
      }

      if(u1HSSIntStatus & DPX_MASK_HSS_INT_STATUS_OVR)
      {
           /* Counter registers has been overwritten */
           (psDpxDdb->sStatCounts.Count_RxHss_Count_Overflow[lnkId])++;
           pDpxEventNotify(psDpxDdb,DPX_EVENT_RX_HSS_COUNT_OVERFLOW, 
                            u1HSSIntStatus, 1, &u1HssLnkId);
           
      }
}


   
/*******************************************************************************
**
**  duplexFindDev
**  ___________________________________________________________________________ 
**
**  DESCRIPTION:  utility function for finding a DDB within GDD structure based 
**                on its pointer. It can be used to validate the device handler.
**
**  VALID STATES:  Not applicable
**
**  SIDE EFFECTS:  None.
**
**  INPUTS:		   psDpxDdb - pointer to the device DDB or device Handler.
**
**  OUTPUTS:	   pu1DdbId - index to the DDB within the GDD
**
**  RETURN CODES:  
**                 DPX_SUCCESS (if find a match one in the GDD) 
**                 DPX_ERR_INVALID_DEVICE  (invalid device handle)
**                 DPX_ERR_MOD_UNINIT (Module has not been initialized) 
**
*******************************************************************************/
INT4 duplexFindDev(sDPX_DDB  *psDpxDdb, UINT1 *pu1DdbIdx)
{
    UINT1   u1NextDev;
    INT4   ErrorCode = DPX_ERR_INVALID_DEVICE; 
                       /* assume device not valid, unless proven otherwise!! */
  
    if(	psDpxGdd == DPX_NULL)
    { 
        ErrorCode = DPX_ERR_MOD_NOT_INIT;
 	    return (ErrorCode);
    } 
  
    if(psDpxDdb != DPX_NULL)
    {
        for(u1NextDev=0; u1NextDev < DPX_MAX_NUM_DEVS; ++u1NextDev)
        {        
            if( psDpxDdb == psDpxGdd->pDdb[u1NextDev]) 
            {
                *pu1DdbIdx  = u1NextDev;
                ErrorCode = DPX_SUCCESS;
                break;
            }
        }          
    }
    return(ErrorCode);
}

/*******************************************************************************
**
**  duplexFindDevFromBaseAddr
**  ___________________________________________________________________________ 
**
**  DESCRIPTION:  utility function for finding a DDB within GDD structure based 
**                on its device base address.
**
**  VALID STATES:  Not applicable
**
**  SIDE EFFECTS:  None.
**
**  INPUTS:		   u4BaseAddr - Device Base address.
**
**  OUTPUTS:	   psDpxDdb - pointer to the device DDB or device Handler.
**                 pu1DdbId - index to the DDB within the GDD
**
**  RETURN CODES:  
**                 DPX_SUCCESS (if find a match one in the GDD) 
**                 DPX_ERR_INVALID_DEVICE  (invalid device handle)
**                 DPX_ERR_MOD_UNINIT (Module has not been initialized) 
**
*******************************************************************************/
INT4 duplexFindDevFromBaseAddr(UINT4 u4BaseAddr, DUPLEX  *psDpxDdb, 
                                                               UINT1 *pu1DdbIdx)
{
    UINT1   u1NextDev;
    INT4   ErrorCode = DPX_ERR_INVALID_DEVICE; 
                      /* assume device not valid, unless proven otherwise!! */
  
    if(	psDpxGdd == DPX_NULL)
    { 
        ErrorCode = DPX_ERR_MOD_NOT_INIT;
 	    return (ErrorCode);
    } 
  

    for(u1NextDev=0; u1NextDev < DPX_MAX_NUM_DEVS; ++u1NextDev)
    { 
	if(psDpxGdd->pDdb[u1NextDev] != DPX_NULL)
        {       
            if(u4BaseAddr == psDpxGdd->pDdb[u1NextDev]->u4BaseAddr) 
            {
		        *psDpxDdb = psDpxGdd->pDdb[u1NextDev];
                *pu1DdbIdx  = u1NextDev;
                ErrorCode = DPX_SUCCESS;
                break;
            }
        }          
    }
    return(ErrorCode);
} 

/*******************************************************************************
**
**  duplexHWReset
**  ___________________________________________________________________________ 
**
**  DESCRIPTION:   Resets the DUPLEX device.  For driver internal use only
**