wdogav.c

Curtiss-Wright Controls Embedded Computing公司的cw183板bsp源代码

                if(OK == semTake(wDogSemId, WAIT_FOREVER))
                {
                }
                else
                {
                    return ERROR;
                }
            }

            pMaxValAdrs =  pAddress + IOFPGA_WD_MAX_TIMEOUT_7_0;
            localMaximumValue = (UINT8)*pMaxValAdrs;
            pMaxValAdrs = pAddress + IOFPGA_WD_MAX_TIMEOUT_15_8;
            localMaximumValue |= (UINT8)(*pMaxValAdrs)<<8;
            pMaxValAdrs = pAddress + IOFPGA_WD_MAX_TIMEOUT_23_16;
            localMaximumValue |= (UINT8)(*pMaxValAdrs)<<16;

    	    IO_SYNC;

            if(NULL != wDogSemId)
            {
                semGive(wDogSemId);
            }

         if(wDogDebug)
            printf("Minimum Value: 0x%.6x \n",localMaximumValue);

        return localMaximumValue;
        }
    else
        {

        if(wDogDebug)
            {
            printf("Watchdog has not been initialized.\n");
            }

        return ERROR;
        }
}


/***********************************************************
* Function Name : wDogAvShow
*
* Description   :
*      - Displays the addresses of the watchdog registers
*      - Displays the contents of the minimum and maximum
*        timeout registers
*      - Shows the status of wDogInitialized, wDogLocked,
*        wDogJmprInstalled, wDogIntEnabled, wDogIntConnected,
*        wDogMode
*
*  Arguments    :
*      void
*
*  Return Value :
*      void
*
*  Comments:
*      N/A
*/  

void wDogAvShow
(
void
)
{
    UINT8 *pWDogAdrs = wDogAdrs;
    UINT8 *pMaxValAdrs_23_16,*pMaxValAdrs_15_8,*pMaxValAdrs_7_0;
    UINT8 *pMinValAdrs_23_16,*pMinValAdrs_15_8,*pMinValAdrs_7_0;    
    UINT32 minVal_7_0,minVal_15_8,minVal_23_16, minVal;
    
    pMinValAdrs_7_0 =  pWDogAdrs + IOFPGA_WD_MIN_TIMEOUT_7_0;
    pMinValAdrs_15_8 = pWDogAdrs + IOFPGA_WD_MIN_TIMEOUT_15_8;
    pMinValAdrs_23_16 = pWDogAdrs + IOFPGA_WD_MIN_TIMEOUT_23_16;   
    
   /* added for PT 2156 in order to obtain true value from the
    * minimum timeout register 
    */ 
    minVal_7_0 = *pMinValAdrs_7_0;
    minVal_15_8 = *pMinValAdrs_15_8<<8;
    minVal_23_16 = *pMinValAdrs_23_16<<16;   
    
    minVal = minVal_23_16 | minVal_15_8 | minVal_7_0;

 
    pMaxValAdrs_7_0 =  pWDogAdrs + IOFPGA_WD_MAX_TIMEOUT_7_0;
    pMaxValAdrs_15_8 = pWDogAdrs + IOFPGA_WD_MAX_TIMEOUT_15_8;
    pMaxValAdrs_23_16 = pWDogAdrs + IOFPGA_WD_MAX_TIMEOUT_23_16;   

    printf("--------------------------------------\n");   
    
    /* Addresses of the watchdog registers */    
    printf("Watchdog Register Address: 0x%x \n",(int)wDogAdrs);
    printf("Watchdog Kick Address: 0x%x \n\n",(int)wDogAdrs + IOFPGA_WD_KICK);
  
    printf("Minimum Timeout Register Addresses: \n0x%x\n0x%x\n0x%x\n\n",
           (int)pMinValAdrs_7_0,(int)pMinValAdrs_15_8,(int)pMinValAdrs_23_16);
    printf("Maximum Timeout Register Addresses: \n0x%x\n0x%x\n0x%x\n\n",
           (int)pMaxValAdrs_7_0,(int)pMaxValAdrs_15_8,(int)pMaxValAdrs_23_16);
           
    /* Minimum and Maximum timeout values */
    printf("Minimum Timeout Value: 0x%.6x\n",minVal);
    printf("Maximum Timeout Value: 0x%.2x%.2x%.2x\n\n",*pMaxValAdrs_23_16,
           *pMaxValAdrs_15_8,*pMaxValAdrs_7_0);
    
    /* Watchdog Interrupt/Reset mode status */       
    if(WDOG_MODE_INTERRUPT == wDogMode)
        {
        printf("Watchdog Mode:\t\t\tInterrupt \n");
        }
    else if(WDOG_MODE_RESET == wDogMode)
        {
        printf("Watchdog Mode:\t\t\tReset \n"); 
        } 
    else
        {
        printf("Watchdog Mode:\t\t\tunknown \n");  
        }
         
    /* Watchdog Initialized status */          
    if(wDogInitialized)
        {
        printf("Watchdog initialized:\t\tTRUE \n");
        }
    else
        {
        printf("Watchdog initialized:\t\tFALSE \n"); 
        }  

    /* Watchdog Locked status */                 
    if(wDogLocked)
        {
        printf("Watchdog locked:\t\tTRUE \n");
        }
    else
        {
        printf("Watchdog locked:\t\tFALSE \n"); 
        }

#if (defined(CCA_145)|| defined(CCA_146) || defined(CCA_149)|| defined(VME_183))
    /* Watchdog Locked status */                 
    if(wDogEnabled)
        {
        printf("Watchdog enabled:\t\tTRUE \n");
        }
    else
        {
        printf("Watchdog enabled:\t\tFALSE \n"); 
        }
    
    /* Watchdog int mask status */                 
    if(wDogCPU0IntMasked)
        {
#ifdef CCA_149        
        printf("Watchdog Int Masked:\t\tTRUE \n");
#else
        printf("Watchdog CPU0 Int Masked:\tTRUE \n");
#endif                
        }
    else
        {
#ifdef CCA_149        
        printf("Watchdog Int Masked:\t\tFALSE \n"); 
#else
        printf("Watchdog CPU0 Int Masked:\tFALSE \n"); 
#endif                
        }
#if (defined(CCA_145)|| defined(CCA_146) || defined(VME_183))        
        /* Watchdog int mask status */                 
    if(wDogCPU1IntMasked)
        {
        printf("Watchdog CPU1 Int Masked:\tTRUE \n");
        }
    else
        {
        printf("Watchdog CPU1 Int Masked:\tFALSE \n"); 
        }  
#endif /*#if (defined(CCA_145)|| defined(CCA_146) || defined(VME_183))*/        
#endif

#if !(defined(CCA_145)|| defined(CCA_146) || defined(CCA_149)|| defined(VME_183))
    /* Watchdog Jumper Installed status */        
    if(wDogJmprInstalled)
        {
        printf("Watchdog jumper installed:\tTRUE \n");
        }
    else
        {
        printf("Watchdog jumper installed:\tFALSE \n"); 
        }  
#endif
    
    /* Watchdog Interrupt Enabled status */
    if(OK == wDogIntEnabled)
        {
        printf("Watchdog Interrupt Enabled:\tTRUE \n");
        }
    else
        {
        printf("Watchdog Interrupt Enabled:\tFALSE \n"); 
        }
        
    /* Watchdog Interrupt Connected status */     
    if(OK == wDogIntConnected)
        {
        printf("Watchdog Interrupt Connected:\tTRUE \n");
        }
    else
        {
        printf("Watchdog Interrupt Connected:\tFALSE \n"); 
        }  
         
    printf("--------------------------------------\n");   
    
}

/***********************************************************
* Function Name : wDogAvKick
*
* Description   :
*           Resets the watchdog timer  
*           - writes to the specific location
*
*  Arguments    :
*      void
*
*  Return Value :
*      STATUS OK    - if the watchdog has been kicked
*             ERROR - if the watchdog has not been initialized
*
*  Comments:
*      N/A
*/ 
STATUS wDogAvKick
(
void
)
{
    UINT8 *pKickAdrs; 
    
    if(wDogInitialized)
        {
        pKickAdrs = wDogAdrs + IOFPGA_WD_KICK;    
        *pKickAdrs = WDOG_KICK_VALUE;
        IO_SYNC;
	
        if(wDogDebug)
            {
            logMsg("kick Address: %x\n",
                    (int)pKickAdrs,0,0,0,0,0);
            } 
            
        return OK;  
        }
    else
        {
            
        if(wDogDebug)
            {
            logMsg("Cannot Kick. The watchdog has not" 
                    "been initialized.\n",0,0,0,0,0,0);
            }
             
        return ERROR;
        }              
}

#if (defined(CCA_145)|| defined(CCA_146) || defined(CCA_149)|| defined(VME_183))

/***********************************************************
* Function Name : wDogEnable
* Description   :
*     Enables operation of the watchdog
*
*
*  Arguments    :
*      void
*
*  Return Value :
*      STATUS - OK if watchdog has been enabled.
*             - ERROR if watchdog has not been initialized
*
*  Comments:
*      Once enabled, the watchdog must be serviced by software
*      within the limits defined by the WDOG_MIN and WDOG_MAX
*      interval registers
*
*/
STATUS wDogEnable
(
void
)
{
    UINT8 *pAddress = wDogAdrs;  
    UINT8 *pCtrlAdrs;
    
    if (!wDogLocked)
        {
	 pCtrlAdrs = pAddress + IOFPGA_WD_CONTROL;
        *pCtrlAdrs |= WDOG_ENBL_VALUE;
	IO_SYNC;
        wDogEnabled = TRUE;
        
        if(wDogDebug)
            {
            logMsg("Watchdog has been enabled.\n"
                    ,0,0,0,0,0,0);
            }
            
        return OK;
        }
    else
        {
            
        if(wDogDebug)
            {
            logMsg("Watchdog has not been enabled.\n"
                        ,0,0,0,0,0,0);
            } 
            
        return ERROR;
        }
}

/***********************************************************
* Function Name : wDogDisable
* Description   :
*     Disables operation of the watchdog
*
*
*  Arguments    :
*      void
*
*  Return Value :
*      STATUS - OK if watchdog has been enabled.
*             - ERROR if watchdog has not been initialized
*
*  Comments:
*      Once enabled, the watchdog must be serviced by software
*      within the limits defined by the WDOG_MIN and WDOG_MAX
*      interval registers
*
*/
STATUS wDogDisable
(
void
)
{
    UINT8 *pAddress = wDogAdrs;  
    UINT8 *pCtrlAdrs;
    
    if (!wDogLocked)
        {
	 pCtrlAdrs = pAddress + IOFPGA_WD_CONTROL;
        *pCtrlAdrs &= ~WDOG_ENBL_VALUE;
	IO_SYNC;
        wDogEnabled = FALSE;
        
        if(wDogDebug)
            {
            logMsg("Watchdog has been disabled.\n"
                    ,0,0,0,0,0,0);
            }
            
        return OK;
        }
    else
        {
            
        if(wDogDebug)
            {
            logMsg("Watchdog has not been disabled.\n"
                        ,0,0,0,0,0,0);
            } 
            
        return ERROR;
        }
}

/***********************************************************
* Function Name : wDogResetEnable
* Description   :
*     Enables reset on the watchdog interrupt
*
*
*  Arguments    :
*      void
*
*  Return Value :
*      STATUS - OK if watchdog reset has been enabled.
*             - ERROR if watchdog reset has not been initialized
*
*  Comments:
*
*/
STATUS wDogResetEnable
(
void
)
{
    UINT8 *pAddress = wDogAdrs;  
    UINT8 *pCtrlAdrs;
    
    if (!wDogLocked)
        {
	 pCtrlAdrs = pAddress + IOFPGA_WD_CONTROL;
        *pCtrlAdrs |= WDOG_RESET_ENBL_VALUE;
	IO_SYNC;
        wDogEnabled = TRUE;
        
        if(wDogDebug)
            {
            logMsg("Watchdog reset has been enabled.\n"
                    ,0,0,0,0,0,0);
            }
            
        return OK;
        }
    else
        {
            
        if(wDogDebug)
            {
            logMsg("Watchdog reset has not been enabled.\n"
                        ,0,0,0,0,0,0);
            } 
            
        return ERROR;
        }
}

/***********************************************************
* Function Name : wDogResetDisable
* Description   :
*     Disables reset on the watchdog interrupt
*
*
*  Arguments    :
*      void
*
*  Return Value :
*      STATUS - OK if watchdog reset has been enabled.
*             - ERROR if watchdog reset has not been initialized
*
*  Comments:
*
*/
STATUS wDogResetDisable
(
void
)
{
    UINT8 *pAddress = wDogAdrs;  
    UINT8 *pCtrlAdrs;
    
    if (!wDogLocked)
        {
	 pCtrlAdrs = pAddress + IOFPGA_WD_CONTROL;
        *pCtrlAdrs &= ~WDOG_RESET_ENBL_VALUE;
	IO_SYNC;
        wDogEnabled = TRUE;
        
        if(wDogDebug)
            {
            logMsg("Watchdog reset has been disabled.\n"
                    ,0,0,0,0,0,0);
            }
            
        return OK;
        }
    else
        {
            
        if(wDogDebug)
            {
            logMsg("Watchdog reset has not been disabled.\n"
                        ,0,0,0,0,0,0);
            } 
            
        return ERROR;
        }
}

/***********************************************************
* Function Name : wDogIntClear
*
* Description   :
*           Clears the four possible Watchdog error conditions  
*
*  Arguments    :
*      void
*
*  Return Value :
*      STATUS OK    - if the watchdog has been kicked
*             ERROR - if the watchdog has not been initialized
*
*  Comments:
*      Note that when this bit is cleared, all potential Watchdog
*      interrupt sources are cleared.
*/