stv0g/embeddedsw
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

scuwdt_v2_1: Added new version for scuwdt driver.

Browse source 
This patch adds new version for scuwdt driver by changing mdd files.

Signed-off-by: P L Sai Krishna <lakshmis@xilinx.com>
This commit is contained in:
P L Sai Krishna 2015-01-06 16:35:18 +05:30 • committed by Suneel Garapati
parent f055d1560d
commit e7aecfb1d9
14 changed files with 2022 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
XilinxProcessorIPLib/drivers/scuwdt/data/scuwdt.mdd Normal file
View file

@ -0,0 +1,42 @@
###############################################################################
#
# Copyright (C) 2011 - 2014 Xilinx, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# Use of the Software is limited solely to applications:
# (a) running on a Xilinx device, or
# (b) that interact with a Xilinx device through a bus or interconnect.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
# OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Except as contained in this notice, the name of the Xilinx shall not be used
# in advertising or otherwise to promote the sale, use or other dealings in
# this Software without prior written authorization from Xilinx.
#
###############################################################################
OPTION psf_version = 2.1;
BEGIN driver scuwdt
OPTION supported_peripherals = (ps7_scuwdt);
OPTION driver_state = ACTIVE;
OPTION copyfiles = all;
OPTION VERSION = 2.1;
OPTION NAME = scuwdt;
END driver

51
XilinxProcessorIPLib/drivers/scuwdt/data/scuwdt.tcl Executable file
View file

@ -0,0 +1,51 @@
###############################################################################
#
# Copyright (C) 2011 - 2014 Xilinx, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# Use of the Software is limited solely to applications:
# (a) running on a Xilinx device, or
# (b) that interact with a Xilinx device through a bus or interconnect.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
# OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Except as contained in this notice, the name of the Xilinx shall not be used
# in advertising or otherwise to promote the sale, use or other dealings in
# this Software without prior written authorization from Xilinx.
#
###############################################################################
##############################################################################
#
# Modification History
#
# Ver Who Date Changes
# ----- ---- -------- -----------------------------------------------
# 1.00a sdm 11/22/11 Created
# 2.0 adk 12/10/13 Updated as per the New Tcl API's
##############################################################################
#uses "xillib.tcl"
proc generate {drv_handle} {
xdefine_zynq_include_file $drv_handle "xparameters.h" "XScuWdt" "NUM_INSTANCES" "DEVICE_ID" "C_S_AXI_BASEADDR" "C_S_AXI_HIGHADDR"
xdefine_zynq_config_file $drv_handle "xscuwdt_g.c" "XScuWdt" "DEVICE_ID" "C_S_AXI_BASEADDR"
xdefine_zynq_canonical_xpars $drv_handle "xparameters.h" "ScuWdt" "DEVICE_ID" "C_S_AXI_BASEADDR" "C_S_AXI_HIGHADDR"
}

43
XilinxProcessorIPLib/drivers/scuwdt/data/scuwdt_header.h Normal file
View file

@ -0,0 +1,43 @@
/******************************************************************************
*
* Copyright (C) 2011 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
#ifndef SCUWDT_HEADER_H /* prevent circular inclusions */
#define SCUWDT_HEADER_H /* by using protection macros */
#include "xil_types.h"
#include "xil_assert.h"
#include "xstatus.h"
int ScuWdtIntrExample(XScuGic *IntcInstancePtr, XScuWdt *WdtInstancePtr,
u16 WdtDeviceId, u16 WdtIntrId);
#endif

165
XilinxProcessorIPLib/drivers/scuwdt/data/scuwdt_tapp.tcl Executable file
View file

@ -0,0 +1,165 @@
###############################################################################
#
# Copyright (C) 2011 - 2014 Xilinx, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# Use of the Software is limited solely to applications:
# (a) running on a Xilinx device, or
# (b) that interact with a Xilinx device through a bus or interconnect.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
# OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Except as contained in this notice, the name of the Xilinx shall not be used
# in advertising or otherwise to promote the sale, use or other dealings in
# this Software without prior written authorization from Xilinx.
#
###############################################################################
###############################################################################
#
# MODIFICATION HISTORY:
# Ver Who Date Changes
# -------- ------ -------- ------------------------------------
# 2.0 adk 12/10/13 Updated as per the New Tcl API's
##############################################################################
# Uses $XILINX_EDK/bin/lib/xillib_sw.tcl
# -----------------------------------------------------------------
# Software Project Types (swproj):
# 0 : MemoryTest - Calls basic memorytest routines from common driver dir
# 1 : PeripheralTest - Calls any existing polled_example and/or selftest
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# TCL Procedures:
# -----------------------------------------------------------------
proc gen_include_files {swproj mhsinst} {
if {$swproj == 0} {
return ""
}
if {$swproj == 1} {
set inc_file_lines {xscuwdt.h scuwdt_header.h}
}
return $inc_file_lines
}
proc gen_src_files {swproj mhsinst} {
if {$swproj == 0} {
return ""
}
if {$swproj == 1} {
set inc_file_lines {examples/xscuwdt_intr_example.c data/scuwdt_header.h}
return $inc_file_lines
}
}
proc gen_testfunc_def {swproj mhsinst} {
return ""
}
proc gen_init_code {swproj mhsinst} {
if {$swproj == 0} {
return ""
}
if {$swproj == 1} {
set ipname [get_property NAME $mhsinst]
set decl " static XScuWdt ${ipname};"
set inc_file_lines $decl
return $inc_file_lines
}
}
proc gen_testfunc_call {swproj mhsinst} {
if {$swproj == 0} {
return ""
}
set ipname [get_property NAME $mhsinst]
set deviceid [::hsi::utils::get_ip_param_name $mhsinst "DEVICE_ID"]
set stdout [get_property CONFIG.STDOUT [get_os]]
if { $stdout == "" || $stdout == "none" } {
set hasStdout 0
} else {
set hasStdout 1
}
set isintr [::hsi::utils::is_ip_interrupting_current_proc $mhsinst]
set intcvar intc
set testfunc_call ""
if {${hasStdout} == 0} {
if {$isintr == 1} {
set intr_id "XPAR_${ipname}_INTR"
set intr_id [string toupper $intr_id]
append testfunc_call "
{
int Status;
Status = ScuWdtIntrExample(&${intcvar}, &${ipname}, \\
${deviceid}, \\
${intr_id});
}"
}
} else {
if {$isintr == 1} {
set intr_id "XPAR_${ipname}_INTR"
set intr_id [string toupper $intr_id]
append testfunc_call "
{
int Status;
print(\"\\r\\n Running Interrupt Test for ${ipname}...\\r\\n\");
Status = ScuWdtIntrExample(&${intcvar}, &${ipname}, \\
${deviceid}, \\
${intr_id});
if (Status == 0) {
print(\"ScuWdtIntrExample PASSED\\r\\n\");
}
else {
print(\"ScuWdtIntrExample FAILED\\r\\n\");
}
}"
}
}
return $testfunc_call
}

18
XilinxProcessorIPLib/drivers/scuwdt/examples/index.html Executable file
View file

@ -0,0 +1,18 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Driver example applications</title>
<link rel="stylesheet" type="text/css" href="../help.css">
</head>
<body bgcolor="#FFFFFF">
<h1> Example Applications for the driver scuwdt_v2_0 </h1>
<HR>
<ul>
<li>xscuwdt_intr_example.c <a href="xscuwdt_intr_example.c">(source)</a> </li>
<li>xscuwdt_polled_example.c <a href="xscuwdt_polled_example.c">(source)</a> </li>
</ul>
<p><font face="Times New Roman" color="#800000">Copyright <20> 1995-2014 Xilinx, Inc. All rights reserved.</font></p>
</body>
</html>

428
XilinxProcessorIPLib/drivers/scuwdt/examples/xscuwdt_intr_example.c Normal file
View file

@ -0,0 +1,428 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/*****************************************************************************/
/**
*
* @file xscuwdt_intr_example.c
*
* This file contains a design example using the Xilinx SCU Private Watchdog
* Timer driver (XScuWdt) and hardware in Timer mode using interrupts.
*
* @note None.
*
* <pre>
*
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- ---- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* </pre>
*
******************************************************************************/
/***************************** Include Files *********************************/
#include "xparameters.h"
#include "xscuwdt.h"
#include "xscugic.h"
#include "xil_exception.h"
#include "xil_printf.h"
/************************** Constant Definitions *****************************/
/*
* The following constants map to the XPAR parameters created in the
* xparameters.h file. They are only defined here such that a user can easily
* change all the needed parameters in one place.
*/
#define WDT_DEVICE_ID XPAR_SCUWDT_0_DEVICE_ID
#define INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
#define WDT_IRPT_INTR XPAR_SCUWDT_INTR
#define HANDLER_CALLED 0xFFFFFFFF
#define WDT_LOAD_VALUE 0xFF
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
int ScuWdtIntrExample(XScuGic *IntcInstancePtr, XScuWdt * WdtInstancePtr,
u16 WdtDeviceId, u16 WdtIntrId);
static void WdtIntrHandler(void *CallBackRef);
static int WdtSetupIntrSystem(XScuGic *IntcInstancePtr,
XScuWdt * WdtInstancePtr, u16 WdtIntrId);
static void WdtDisableIntrSystem(XScuGic *IntcInstancePtr, u16 WdtIntrId);
/************************** Variable Definitions *****************************/
XScuWdt WdtInstance; /* Cortex SCU Private WatchDog Timer Instance */
XScuGic IntcInstance; /* Interrupt Controller Instance */
volatile u32 HandlerCalled; /* flag is set when timeout interrupt occurs */
/*****************************************************************************/
/**
*
* Main function to call the Scu Private Wdt interrupt example.
*
* @param None.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
#ifndef TESTAPP_GEN
int main(void)
{
int Status;
xil_printf("SCU WDT Interrupt Example Test \r\n");
/*
* Call the interrupt example, specify the parameters generated in
* xparameters.h
*/
Status = ScuWdtIntrExample(&IntcInstance, &WdtInstance,
WDT_DEVICE_ID, WDT_IRPT_INTR);
if (Status != XST_SUCCESS) {
xil_printf("SCU WDT Interrupt Example Test Failed\r\n");
return XST_FAILURE;
}
xil_printf("Successfully ran SCU WDT Interrupt Example Test\r\n");
return XST_SUCCESS;
}
#endif
/*****************************************************************************/
/**
*
* This function tests the functioning of the Scu Private WDT driver and hardware
* in Timer mode using interrupts.
*
* After one expiration of the timeout interval, an interrupt is generated and
* the Event flag bit is set in the watchdog interrupt status register.
*
* @param IntcInstancePtr is a pointer to the instance of the XScuGic
* driver.
* @param WdtInstancePtr is a pointer to the instance of XScuWdt driver.
* @param WdtDeviceId is the Device ID of the XScuWdt device.
* @param WdtIntrId is the Interrupt Id of the XScuWdt device.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
int ScuWdtIntrExample(XScuGic *IntcInstancePtr, XScuWdt * WdtInstancePtr,
u16 WdtDeviceId, u16 WdtIntrId)
{
int Status;
u32 Timebase = 0;
u32 ExpiredTimeDelta = 0;
XScuWdt_Config *ConfigPtr;
/*
* Initialize the ScuWdt driver.
*/
ConfigPtr = XScuWdt_LookupConfig(WdtDeviceId);
/*
* This is where the virtual address would be used, this example
* uses physical address.
*/
Status = XScuWdt_CfgInitialize(WdtInstancePtr, ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XScuWdt_SelfTest(WdtInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Put the watchdog timer in timer mode.
*/
XScuWdt_SetTimerMode(WdtInstancePtr);
/*
* Load the watchdog counter register.
*/
XScuWdt_LoadWdt(WdtInstancePtr, WDT_LOAD_VALUE);
/*
* Start the ScuWdt device.
*/
XScuWdt_Start(WdtInstancePtr);
/*
* Determine how long it takes for the watchdog timer to expire,
* for later processing.
*/
while (1) {
if (!(XScuWdt_IsTimerExpired(WdtInstancePtr))) {
ExpiredTimeDelta++;
} else {
break;
}
}
/*
* Stop the timer to set up the device in interrupt mode.
*/
XScuWdt_Stop(WdtInstancePtr);
/*
* Connect the device to interrupt subsystem so that interrupts
* can occur.
*/
Status = WdtSetupIntrSystem(IntcInstancePtr, WdtInstancePtr, WdtIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Reload the watchdog counter register.
*/
XScuWdt_RestartWdt(WdtInstancePtr);
/*
* Start the ScuWdt device.
*/
HandlerCalled = 0;
XScuWdt_Start(WdtInstancePtr);
/*
* Verify that the watchdog timer does timeout when not restarted
* all the time, wait more than the amount of time it took for it
* to expire in the previous test.
*/
while (1) {
/*
* If the handler is called, the test passed
*/
if ((HandlerCalled != 0)) {
XScuWdt_WriteReg(WdtInstancePtr->Config.BaseAddr,
XSCUWDT_ISR_OFFSET,
XSCUWDT_ISR_EVENT_FLAG_MASK);
break;
}
}
/*
* Reload the watchdog counter to allow the next test to run normally.
*/
XScuWdt_RestartWdt(WdtInstancePtr);
HandlerCalled = 0;
/*
* Verify that the watchdog timer does not timeout when restarted
* all the time, wait more than the amount of time it took for it
* to expire in the previous test.
*/
while (1) {
/*
* Reload the ScuWdt each pass through the loop.
*/
XScuWdt_RestartWdt(WdtInstancePtr);
/*
* If more time has gone past than it took for it to expire
* when not restarted in the previous test, then stop as the
* restarting worked.
*/
Timebase++;
if (Timebase > ExpiredTimeDelta + ExpiredTimeDelta) {
break;
}
/*
* If the watchdog timer expired and/or handler called, then the
* test failed.
*/
if ((XScuWdt_IsTimerExpired(WdtInstancePtr)) ||
(HandlerCalled != 0)) {
/*
* Disable and disconnect the interrupt system.
*/
WdtDisableIntrSystem(IntcInstancePtr, WdtIntrId);
return XST_FAILURE;
}
}
/*
* Disable and disconnect the interrupt system.
*/
WdtDisableIntrSystem(IntcInstancePtr, WdtIntrId);
return XST_SUCCESS;
}
/*****************************************************************************/
/**
*
* This function sets up the interrupt system such that interrupts can occur
* for the device.
*
* @param IntcInstancePtr is a pointer to the instance of the XScuGic
* driver.
* @param WdtInstancePtr is a pointer to the instance of XScuWdt driver.
* @param WdtIntrId is the Interrupt Id of the XScuWdt device.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
static int WdtSetupIntrSystem(XScuGic *IntcInstancePtr,
XScuWdt *WdtInstancePtr, u16 WdtIntrId)
{
int Status;
u32 Reg;
#ifndef TESTAPP_GEN
XScuGic_Config *IntcConfig;
/*
* Initialize the interrupt controller driver so that it is ready to
* use.
*/
IntcConfig = XScuGic_LookupConfig(INTC_DEVICE_ID);
if (NULL == IntcConfig) {
return XST_FAILURE;
}
Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
IntcConfig->CpuBaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Xil_ExceptionInit();
/*
* Connect the interrupt controller interrupt handler to the hardware
* interrupt handling logic in the processor.
*/
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
(Xil_ExceptionHandler)
XScuGic_InterruptHandler,
IntcInstancePtr);
#endif
/*
* Connect the device driver handler that will be called when an
* interrupt for the device occurs, the handler defined above performs
* the specific interrupt processing for the device.
*/
Status = XScuGic_Connect(IntcInstancePtr, WdtIntrId,
(Xil_ExceptionHandler)WdtIntrHandler,
(void *)WdtInstancePtr);
if (Status != XST_SUCCESS) {
return Status;
}
/*
* Enable the watchdog interrupts for timer mode.
*/
Reg = XScuWdt_GetControlReg(WdtInstancePtr);
XScuWdt_SetControlReg(WdtInstancePtr,
Reg | XSCUWDT_CONTROL_IT_ENABLE_MASK);
/*
* Enable the interrupt for the device.
*/
XScuGic_Enable(IntcInstancePtr, WdtIntrId);
#ifndef TESTAPP_GEN
/*
* Enable interrupts in the Processor.
*/
Xil_ExceptionEnable();
#endif
return XST_SUCCESS;
}
/*****************************************************************************/
/**
*
* This function is the Interrupt handler for the WDT Interrupt of the
* Wdt device. It is called on the expiration of the timer counter in
* interrupt context.
*
* @param CallBackRef is a pointer to the callback function.
*
* @return None.
*
* @note None.
*
******************************************************************************/
static void WdtIntrHandler(void *CallBackRef)
{
/*
* WDT timed out and interrupt occurred, let main test loop know.
*/
HandlerCalled = HANDLER_CALLED;
}
/*****************************************************************************/
/**
*
* This function disables the interrupts that occur for the device.
*
* @param IntcInstancePtr is the pointer to the instance of XScuGic
* driver.
* @param WdtIntrId is the Interrupt Id for the device.
*
* @return None.
*
* @note None.
*
******************************************************************************/
static void WdtDisableIntrSystem(XScuGic *IntcInstancePtr, u16 WdtIntrId)
{
/*
* Disconnect and disable the interrupt for the Wdt.
*/
XScuGic_Disconnect(IntcInstancePtr, WdtIntrId);
}

179
XilinxProcessorIPLib/drivers/scuwdt/examples/xscuwdt_polled_example.c Normal file
View file

@ -0,0 +1,179 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/*****************************************************************************/
/**
* @file xscuwdt_polled_example.c
*
* This file contains a design example using the Xilinx SCU Private Watchdog
* Timer driver (XScuWdt) and hardware device in watchdog mode. This test
* illustrates how to initialize the watchdog device and restart it periodially
* to avoid the assertion of the WDRESETREQ pin.
*
* @note None.
*
* MODIFICATION HISTORY:
*
*<pre>
* Ver Who Date Changes
* ----- ---- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
*</pre>
******************************************************************************/
/***************************** Include Files *********************************/
#include "xparameters.h"
#include "xscuwdt.h"
#include "xil_printf.h"
#include <sleep.h>
/************************** Constant Definitions *****************************/
/*
* The following constants map to the XPAR parameters created in the
* xparameters.h file. They are only defined here such that a user can easily
* change all the needed parameters in one place.
*/
#define WDT_DEVICE_ID XPAR_SCUWDT_0_DEVICE_ID
#define WDT_LOAD_VALUE 0xFFFF0000
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
int ScuWdtPolledExample(XScuWdt * WdtInstancePtr, u16 DeviceId);
/************************** Variable Definitions *****************************/
XScuWdt Watchdog; /* Cortex SCU Private WatchDog Timer Instance */
/*****************************************************************************/
/**
*
* Main function to call the Scu Priver Wdt polled mode example.
*
* @param None.
*
* @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful.
*
* @note None.
*
******************************************************************************/
int main(void)
{
int Status;
xil_printf("SCU WDT Polled Mode Example Test \r\n");
/*
* Call the example , specify the device ID that is generated in
* xparameters.h.
*/
Status = ScuWdtPolledExample(&Watchdog, WDT_DEVICE_ID);
if (Status != XST_SUCCESS) {
xil_printf("SCU WDT Polled Mode Example Test Failed\r\n");
return XST_FAILURE;
}
xil_printf("Successfully ran SCU WDT Polled Mode Example Test\r\n");
return XST_SUCCESS;
}
/*****************************************************************************/
/**
* This function does a minimal test on the watchdog timer device and driver.
* The purpose of this function is to illustrate how to use the XScuWdt driver.
*
* @param WdtInstancePtr is a pointer to the instance of XScuWdt driver.
* @param DeviceId is the unique device id of the device.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
****************************************************************************/
int ScuWdtPolledExample(XScuWdt * WdtInstancePtr, u16 DeviceId)
{
int Status;
XScuWdt_Config *ConfigPtr;
int Count = 0;
/*
* Initialize the SCU Private Wdt driver so that it is ready to use.
*/
ConfigPtr = XScuWdt_LookupConfig(DeviceId);
/*
* This is where the virtual address would be used, this example
* uses physical address.
*/
Status = XScuWdt_CfgInitialize(WdtInstancePtr, ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Put the watchdog timer in watchdog mode.
*/
XScuWdt_SetWdMode(WdtInstancePtr);
/*
* Load the watchdog counter register.
*/
XScuWdt_LoadWdt(WdtInstancePtr, WDT_LOAD_VALUE);
/*
* Start the ScuWdt device.
*/
XScuWdt_Start(WdtInstancePtr);
while (Count < 20) {
/*
* We have nothing to do here. Sleep for some time and then
* restart the watchdog such that the WDRESETREQ pin is not
* asserted. If the WDRESETREQ pin is asserted and the system
* is reset, then the watchdog device/driver is not working as
* expected.
* The user application needs to call the XScuWdt_RestartWdt
* periodially to avoid the watchdog from being timed-out.
*/
sleep(1);
Count++;
XScuWdt_RestartWdt(WdtInstancePtr);
}
return XST_SUCCESS;
}

40
XilinxProcessorIPLib/drivers/scuwdt/src/Makefile Normal file
View file

@ -0,0 +1,40 @@
COMPILER=
ARCHIVER=
CP=cp
COMPILER_FLAGS=
EXTRA_COMPILER_FLAGS=
LIB=libxil.a
CC_FLAGS = $(COMPILER_FLAGS)
ECC_FLAGS = $(EXTRA_COMPILER_FLAGS)
RELEASEDIR=../../../lib
INCLUDEDIR=../../../include
INCLUDES=-I./. -I${INCLUDEDIR}
OUTS = *.o
LIBSOURCES:=*.c
INCLUDEFILES:=*.h
OBJECTS = $(addsuffix .o, $(basename $(wildcard *.c)))
libs: banner scuwdt_libs clean
%.o: %.c
${COMPILER} $(CC_FLAGS) $(ECC_FLAGS) $(INCLUDES) -o $@ $<
banner:
echo "Compiling scuwdt"
scuwdt_libs: ${OBJECTS}
$(ARCHIVER) -r ${RELEASEDIR}/${LIB} ${OBJECTS}
.PHONY: include
include: scuwdt_includes
scuwdt_includes:
${CP} ${INCLUDEFILES} ${INCLUDEDIR}
clean:
rm -rf ${OBJECTS}

210
XilinxProcessorIPLib/drivers/scuwdt/src/xscuwdt.c Normal file
View file

@ -0,0 +1,210 @@
/* $Id: xscuwdt.c,v 1.1.2.1 2011/01/20 04:04:40 sadanan Exp $ */
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/****************************************************************************/
/**
*
* @file xscuwdt.c
*
* Contains the implementation of interface functions of the XScuWdt driver.
* See xscuwdt.h for a description of the driver.
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- --- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* </pre>
*
******************************************************************************/
/***************************** Include Files *********************************/
#include "xscuwdt.h"
/************************** Constant Definitions *****************************/
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
/************************** Variable Definitions *****************************/
/****************************************************************************/
/**
*
* Initialize a specific watchdog timer instance/driver. This function
* must be called before other functions of the driver are called.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
* @param ConfigPtr is the config structure.
* @param EffectiveAddress is the base address for the device. It could be
* a virtual address if address translation is supported in the
* system, otherwise it is the physical address.
*
* @return
* - XST_SUCCESS if initialization was successful.
* - XST_DEVICE_IS_STARTED if the device has already been started.
*
* @note This function enables the watchdog mode.
*
******************************************************************************/
int XScuWdt_CfgInitialize(XScuWdt *InstancePtr,
XScuWdt_Config *ConfigPtr, u32 EffectiveAddress)
{
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(ConfigPtr != NULL);
/*
* If the device is started, disallow the initialize and return a
* status indicating it is started. This allows the user to stop the
* device and reinitialize, but prevents a user from inadvertently
* initializing.
*/
if (InstancePtr->IsStarted == XIL_COMPONENT_IS_STARTED) {
return XST_DEVICE_IS_STARTED;
}
/*
* Copy configuration into instance.
*/
InstancePtr->Config.DeviceId = ConfigPtr->DeviceId;
/*
* Save the base address pointer such that the registers of the block
* can be accessed and indicate it has not been started yet.
*/
InstancePtr->Config.BaseAddr = EffectiveAddress;
InstancePtr->IsStarted = 0;
/*
* Put the watchdog timer in Watchdog mode.
*/
XScuWdt_SetWdMode(InstancePtr);
/*
* Indicate the instance is ready to use, successfully initialized.
*/
InstancePtr->IsReady = XIL_COMPONENT_IS_READY;
return XST_SUCCESS;
}
/****************************************************************************/
/**
*
* Start the watchdog counter of the device.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return None.
*
* @note User needs to select the appropriate mode (watchdog/timer)
* before using this API.
* See XScuWdt_SetWdMode/XScuWdt_SetTimerMode macros in
* xscuwdt.h.
*
******************************************************************************/
void XScuWdt_Start(XScuWdt *InstancePtr)
{
u32 Register;
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
/*
* Read the contents of the Control register.
*/
Register = XScuWdt_ReadReg(InstancePtr->Config.BaseAddr,
XSCUWDT_CONTROL_OFFSET);
/*
* Set the 'watchdog enable' bit in the register.
*/
Register |= XSCUWDT_CONTROL_WD_ENABLE_MASK;
/*
* Update the Control register with the new value.
*/
XScuWdt_WriteReg(InstancePtr->Config.BaseAddr,
XSCUWDT_CONTROL_OFFSET, Register);
/*
* Indicate that the device is started.
*/
InstancePtr->IsStarted = XIL_COMPONENT_IS_STARTED;
}
/****************************************************************************/
/**
*
* Stop the watchdog timer.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return None.
*
* @note None.
*
******************************************************************************/
void XScuWdt_Stop(XScuWdt *InstancePtr)
{
u32 Register;
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
/*
* Read the contents of the Control register.
*/
Register = XScuWdt_ReadReg(InstancePtr->Config.BaseAddr,
XSCUWDT_CONTROL_OFFSET);
/*
* Clear the 'watchdog enable' bit in the register.
*/
Register &= ~XSCUWDT_CONTROL_WD_ENABLE_MASK;
/*
* Update the Control register with the new value.
*/
XScuWdt_WriteReg(InstancePtr->Config.BaseAddr,
XSCUWDT_CONTROL_OFFSET, Register);
/*
* Indicate that the device is stopped.
*/
InstancePtr->IsStarted = 0;
}

380
XilinxProcessorIPLib/drivers/scuwdt/src/xscuwdt.h Normal file
View file

@ -0,0 +1,380 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/****************************************************************************/
/**
*
* @file xscuwdt.h
*
* The Xilinx SCU watchdog timer driver (XScuWdt) supports the Xilinx SCU private
* watchdog timer hardware.
*
* The XScuWdt driver supports the following features:
* - Watchdog mode
* - Timer mode
* - Auto reload (timer mode only)
*
* The watchdog counter register is a down counter and starts decrementing when
* the watchdog is started.
* In watchdog mode, when the counter reaches 0, the Reset flag is set in the
* Reset status register and the WDRESETREQ pin is asserted, causing a system
* reset. The Reset flag is not reset by normal processor reset and is cleared
* when written with a value of 1. This enables the user to differentiate a
* normal reset and a reset caused by watchdog time-out. The user needs to call
* XScuWdt_RestartWdt() periodically, to avoid the watchdog from being timed-out.
*
* The IsWdtExpired function can be used to check if the watchdog was the cause
* of the last reset. In this situation, call Initialize then call IsWdtExpired.
* If the result is true, watchdog timeout caused the last system reset. The
* application then needs to clear the Reset flag.
*
* In timer mode, when the counter reaches 0, the Event flag is set in the
* Interrupt status register and if interrupts are enabled, interrupt ID 30 is
* set as pending in the interrupt distributor. The IsTimerExpired function
* is used to check if the watchdog counter has decremented to 0 in timer mode.
* If auto-reload mode is enabled, the Counter register is automatically reloaded
* from the Load register.
*
* <b> Initialization and Configuration </b>
*
* The device driver enables higher layer software (e.g., an application) to
* communicate with the Watchdog Timer.
*
* XScuWdt_CfgInitialize() API is used to initialize the Watchdog Timer. The
* user needs to first call the XScuWdt_LookupConfig() API which returns
* the Configuration structure pointer which is passed as a parameter to
* the XScuWdt_CfgInitialize() API.
*
* <b>Interrupts</b>
*
* The SCU Watchdog Timer supports interrupts in Timer mode.
*
* This driver does not provide a Interrupt Service Routine (ISR) for the device.
* It is the responsibility of the application to provide one if needed. Refer to
* the interrupt example provided with this driver for details on using the
* Timer in interrupt mode.
*
* <b> Virtual Memory </b>
*
* This driver supports Virtual Memory. The RTOS is responsible for calculating
* the correct device base address in Virtual Memory space.
*
* <b> Threads </b>
*
* This driver is not thread safe. Any needs for threads or thread mutual
* exclusion must be satisfied by the layer above this driver.
*
* <b> Asserts </b>
*
* Asserts are used within all Xilinx drivers to enforce constraints on argument
* values. Asserts can be turned off on a system-wide basis by defining, at
* compile time, the NDEBUG identifier. By default, asserts are turned on and it
* is recommended that users leave asserts on during development.
*
* <b> Building the driver </b>
*
* The XScuWdt driver is composed of several source files. This allows the user
* to build and link only those parts of the driver that are necessary.
*
* <br><br>
*
* NOTE:
* The watchdog timer is not a part of the snoop control unit as indicated
* by the prefix "scu" in the name of the driver.
* It is an independent module in APU.
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- --- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* 1.02a sg 07/17/12 Included xil_assert.h for CR 667947. This is an issue
* when the xstatus.h in the common driver overwrites
* the xstatus.h of the standalone BSP during the
* libgen.
* </pre>
*
******************************************************************************/
#ifndef XSCUWDT_H /* prevent circular inclusions */
#define XSCUWDT_H /* by using protection macros */
/***************************** Include Files *********************************/
#include "xstatus.h"
#include "xscuwdt_hw.h"
#ifdef __cplusplus
extern "C" {
#endif
/************************** Constant Definitions *****************************/
/**************************** Type Definitions *******************************/
/**
* This typedef contains configuration information for the device.
*/
typedef struct {
u16 DeviceId; /**< Unique ID of device */
u32 BaseAddr; /**< Base address of the device */
} XScuWdt_Config;
/**
* The XScuWdt driver instance data. The user is required to allocate a
* variable of this type for every watchdog/timer device in the system.
* A pointer to a variable of this type is then passed to the driver API
* functions.
*/
typedef struct {
XScuWdt_Config Config;/**< Hardware Configuration */
u32 IsReady; /**< Device is initialized and ready */
u32 IsStarted; /**< Device watchdog timer is running */
} XScuWdt;
/***************** Macros (Inline Functions) Definitions *********************/
/****************************************************************************/
/**
*
* This function is used to check if the watchdog has timed-out and the last
* reset was caused by the watchdog reset.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return
* - TRUE if the watchdog has expired.
* - FALSE if the watchdog has not expired.
*
* @note C-style signature:
* int XScuWdt_IsWdtExpired(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_IsWdtExpired(InstancePtr) \
((XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_RST_STS_OFFSET) & \
XSCUWDT_RST_STS_RESET_FLAG_MASK) == XSCUWDT_RST_STS_RESET_FLAG_MASK)
/****************************************************************************/
/**
*
* This function is used to check if the watchdog counter has reached 0 in timer
* mode.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return
* - TRUE if the watchdog has expired.
* - FALSE if the watchdog has not expired.
*
* @note C-style signature:
* int XScuWdt_IsTimerExpired(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_IsTimerExpired(InstancePtr) \
((XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_ISR_OFFSET) & \
XSCUWDT_ISR_EVENT_FLAG_MASK) == XSCUWDT_ISR_EVENT_FLAG_MASK)
/****************************************************************************/
/**
*
* Re-start the watchdog timer. This macro will read the watchdog load register
* and write the same value to load register to update the counter register.
* An application needs to call this function periodically to keep the watchdog
* from asserting the WDRESETREQ reset request output pin.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return None.
*
* @note C-style signature:
* void XScuWdt_RestartWdt(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_RestartWdt(InstancePtr) \
XScuWdt_LoadWdt(InstancePtr, \
(XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_LOAD_OFFSET)))
/****************************************************************************/
/**
*
* Write to the watchdog timer load register. This will also update the
* watchdog counter register with the new value. This macro can be used to
* change the time-out value.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
* @param Value is the value to be written to the Watchdog Load register.
*
* @return None.
*
* @note C-style signature:
* void XScuWdt_LoadWdt(XScuWdt *InstancePtr, u32 Value)
*
******************************************************************************/
#define XScuWdt_LoadWdt(InstancePtr, Value) \
XScuWdt_WriteReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_LOAD_OFFSET, Value)
/****************************************************************************/
/**
*
* Put the watchdog timer in Watchdog mode by setting the WD mode bit of the
* Watchdog control register.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return None.
*
* @note C-style signature:
* void XScuWdt_SetWdMode(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_SetWdMode(InstancePtr) \
XScuWdt_WriteReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_CONTROL_OFFSET, \
(XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_CONTROL_OFFSET) | \
XSCUWDT_CONTROL_WD_MODE_MASK))
/****************************************************************************/
/**
*
* Put the watchdog timer in Timer mode by writing 0x12345678 and 0x87654321
* successively to the Watchdog Disable Register.
* The software must write 0x12345678 and 0x87654321 successively to the
* Watchdog Disable Register so that the watchdog mode bit in the Watchdog
* Control Register is set to zero.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return None.
*
* @note C-style signature:
* void XScuWdt_SetTimerMode(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_SetTimerMode(InstancePtr) \
{ \
XScuWdt_WriteReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_DISABLE_OFFSET, \
XSCUWDT_DISABLE_VALUE1); \
XScuWdt_WriteReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_DISABLE_OFFSET, \
XSCUWDT_DISABLE_VALUE2); \
}
/****************************************************************************/
/**
*
* Get the contents of the watchdog control register.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return Contents of the watchdog control register.
*
* @note C-style signature:
u32 XScuWdt_GetControlReg(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_GetControlReg(InstancePtr) \
XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_CONTROL_OFFSET)
/****************************************************************************/
/**
*
* Write to the watchdog control register.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
* @param ControlReg is the value to be written to the watchdog control
* register.
*
* @return None.
*
* @note C-style signature:
void XScuWdt_SetControlReg(XScuWdt *InstancePtr, u32 ControlReg)
*
******************************************************************************/
#define XScuWdt_SetControlReg(InstancePtr, ControlReg) \
XScuWdt_WriteReg((InstancePtr)->Config.BaseAddr, \
XSCUWDT_CONTROL_OFFSET, ControlReg)
/****************************************************************************/
/**
*
* Enable auto-reload mode.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return None.
*
* @note C-style signature:
* void XScuWdt_EnableAutoReload(XScuWdt *InstancePtr)
*
******************************************************************************/
#define XScuWdt_EnableAutoReload(InstancePtr) \
XScuWdt_SetControlReg((InstancePtr), \
(XScuWdt_GetControlReg(InstancePtr) | \
XSCUWDT_CONTROL_AUTO_RELOAD_MASK))
/************************** Function Prototypes ******************************/
/*
* Lookup configuration in xscuwdt_sinit.c.
*/
XScuWdt_Config *XScuWdt_LookupConfig(u16 DeviceId);
/*
* Selftest function in xscuwdt_selftest.c
*/
int XScuWdt_SelfTest(XScuWdt *InstancePtr);
/*
* Interface functions in xscuwdt.c
*/
int XScuWdt_CfgInitialize(XScuWdt *InstancePtr,
XScuWdt_Config *ConfigPtr, u32 EffectiveAddress);
void XScuWdt_Start(XScuWdt *InstancePtr);
void XScuWdt_Stop(XScuWdt *InstancePtr);
/*
* Self-test function in xwdttb_selftest.c.
*/
int XScuWdt_SelfTest(XScuWdt *InstancePtr);
#ifdef __cplusplus
}
#endif
#endif /* end of protection macro */

75
XilinxProcessorIPLib/drivers/scuwdt/src/xscuwdt_g.c Normal file
View file

@ -0,0 +1,75 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/****************************************************************************/
/**
*
* @file xscuwdt_g.c
*
* This file contains a table that specifies the configuration of the SCU
* watchdog timer devices in the system. Each device should have an entry
* in the table.
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- --- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* </pre>
*
******************************************************************************/
/***************************** Include Files *********************************/
#include "xscuwdt.h"
#include "xparameters.h"
/************************** Constant Definitions *****************************/
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
/************************** Variable Prototypes ******************************/
/**
* This table contains configuration information for each watchdog timer
* device in the system.
*/
XScuWdt_Config XScuWdt_ConfigTable[XPAR_XSCUWDT_NUM_INSTANCES] = {
{
XPAR_SCUWDT_0_DEVICE_ID,
XPAR_SCUWDT_0_BASEADDR
}
};

178
XilinxProcessorIPLib/drivers/scuwdt/src/xscuwdt_hw.h Normal file
View file

@ -0,0 +1,178 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/****************************************************************************/
/**
*
* @file xscuwdt_hw.h
*
* This file contains the hardware interface to the Xilinx SCU private Watch Dog
* Timer (XSCUWDT).
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- --- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* 1.01a bss 02/27/12 Updated the register offsets to start at 0x0 instead
* of 0x20 as the base address obtained from the tools
* starts at 0x20.
* 1.02a sg 07/17/12 Included xil_assert.h for CR 667947. This is an issue
* when the xstatus.h in the common driver overwrites
* the xstatus.h of the standalone BSP during the
* libgen.
* </pre>
*
******************************************************************************/
#ifndef XSCUWDT_HW_H /* prevent circular inclusions */
#define XSCUWDT_HW_H /* by using protection macros */
#ifdef __cplusplus
extern "C" {
#endif
/***************************** Include Files *********************************/
#include "xil_types.h"
#include "xil_io.h"
#include "xil_assert.h"
/************************** Constant Definitions *****************************/
/** @name Register Map
* Offsets of registers from the start of the device. The WDT registers start at
* an offset 0x20
* @{
*/
#define XSCUWDT_LOAD_OFFSET 0x00 /**< Watchdog Load Register */
#define XSCUWDT_COUNTER_OFFSET 0x04 /**< Watchdog Counter Register */
#define XSCUWDT_CONTROL_OFFSET 0x08 /**< Watchdog Control Register */
#define XSCUWDT_ISR_OFFSET 0x0C /**< Watchdog Interrupt Status Register */
#define XSCUWDT_RST_STS_OFFSET 0x10 /**< Watchdog Reset Status Register */
#define XSCUWDT_DISABLE_OFFSET 0x14 /**< Watchdog Disable Register */
/* @} */
/** @name Watchdog Control register
* This register bits control the prescaler, WD/Timer mode, Intr enable,
* auto-reload, watchdog enable.
* @{
*/
#define XSCUWDT_CONTROL_PRESCALER_MASK 0x0000FF00 /**< Prescaler */
#define XSCUWDT_CONTROL_PRESCALER_SHIFT 8
#define XSCUWDT_CONTROL_WD_MODE_MASK 0x00000008 /**< Watchdog/Timer mode */
#define XSCUWDT_CONTROL_IT_ENABLE_MASK 0x00000004 /**< Intr enable (in
timer mode) */
#define XSCUWDT_CONTROL_AUTO_RELOAD_MASK 0x00000002 /**< Auto-reload (in
timer mode) */
#define XSCUWDT_CONTROL_WD_ENABLE_MASK 0x00000001 /**< Watchdog enable */
/* @} */
/** @name Interrupt Status register
* This register indicates the Counter register has reached zero in Counter
* mode.
* @{
*/
#define XSCUWDT_ISR_EVENT_FLAG_MASK 0x00000001 /**< Event flag */
/*@}*/
/** @name Reset Status register
* This register indicates the Counter register has reached zero in Watchdog
* mode and a reset request is sent.
* @{
*/
#define XSCUWDT_RST_STS_RESET_FLAG_MASK 0x00000001 /**< Time out occured */
/*@}*/
/** @name Disable register
* This register is used to switch from watchdog mode to timer mode.
* The software must write 0x12345678 and 0x87654321 successively to the
* Watchdog Disable Register so that the watchdog mode bit in the Watchdog
* Control Register is set to zero.
* @{
*/
#define XSCUWDT_DISABLE_VALUE1 0x12345678 /**< Watchdog mode disable
value 1 */
#define XSCUWDT_DISABLE_VALUE2 0x87654321 /**< Watchdog mode disable
value 2 */
/*@}*/
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/****************************************************************************/
/**
*
* Read the given register.
*
* @param BaseAddr is the base address of the device
* @param RegOffset is the register offset to be read
*
* @return The 32-bit value of the register
*
* @note C-style signature:
* u32 XScuWdt_ReadReg(u32 BaseAddr, u32 RegOffset)
*
*****************************************************************************/
#define XScuWdt_ReadReg(BaseAddr, RegOffset) \
Xil_In32((BaseAddr) + (RegOffset))
/****************************************************************************/
/**
*
* Write the given register.
*
* @param BaseAddr is the base address of the device
* @param RegOffset is the register offset to be written
* @param Data is the 32-bit value to write to the register
*
* @return None.
*
* @note C-style signature:
* void XScuWdt_WriteReg(u32 BaseAddr, u32 RegOffset, u32 Data)
*
*****************************************************************************/
#define XScuWdt_WriteReg(BaseAddr, RegOffset, Data) \
Xil_Out32((BaseAddr) + (RegOffset), (Data))
/************************** Function Prototypes ******************************/
/************************** Variable Definitions *****************************/
#ifdef __cplusplus
}
#endif
#endif /* end of protection macro */

123
XilinxProcessorIPLib/drivers/scuwdt/src/xscuwdt_selftest.c Normal file
View file

@ -0,0 +1,123 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/****************************************************************************/
/**
*
* @file xscuwdt_selftest.c
*
* Contains diagnostic self-test functions for the XScuWdt driver.
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- --- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* </pre>
*
******************************************************************************/
/***************************** Include Files *********************************/
#include "xscuwdt.h"
/************************** Constant Definitions *****************************/
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
/************************** Variable Definitions *****************************/
/****************************************************************************/
/**
*
* Run a self-test on the WDT. This test stops the watchdog, writes a value to
* the watchdog load register, starts the watchdog and verifies that the value
* read from the counter register is less that the value written to the load
* register. It then restores the control register and the watchdog load
* register.
*
* @param InstancePtr is a pointer to the XScuWdt instance.
*
* @return
* - XST_SUCCESS if self-test was successful.
* - XST_FAILURE if the WDT is not decrementing.
*
* @note None.
*
******************************************************************************/
int XScuWdt_SelfTest(XScuWdt *InstancePtr)
{
u32 Register;
u32 CtrlOrig;
u32 LoadOrig;
/*
* Assert to ensure the inputs are valid and the instance has been
* initialized.
*/
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
/*
* Stop the watchdog timer.
*/
CtrlOrig = XScuWdt_GetControlReg(InstancePtr);
XScuWdt_SetControlReg(InstancePtr,
CtrlOrig & ~XSCUWDT_CONTROL_WD_ENABLE_MASK);
LoadOrig = XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr,
XSCUWDT_LOAD_OFFSET);
XScuWdt_LoadWdt(InstancePtr, 0xFFFFFFFF);
/*
* Start the watchdog timer and check if the watchdog counter is
* decrementing.
*/
XScuWdt_SetControlReg(InstancePtr,
CtrlOrig | XSCUWDT_CONTROL_WD_ENABLE_MASK);
Register = XScuWdt_ReadReg((InstancePtr)->Config.BaseAddr,
XSCUWDT_COUNTER_OFFSET);
XScuWdt_LoadWdt(InstancePtr, LoadOrig);
XScuWdt_SetControlReg(InstancePtr, CtrlOrig);
if (Register == 0xFFFFFFFF) {
return XST_FAILURE;
}
return XST_SUCCESS;
}

90
XilinxProcessorIPLib/drivers/scuwdt/src/xscuwdt_sinit.c Normal file
View file

@ -0,0 +1,90 @@
/******************************************************************************
*
* Copyright (C) 2010 - 2014 Xilinx, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/
/*****************************************************************************/
/**
*
* @file xscuwdt_sinit.c
*
* This file contains method for static initialization (compile-time) of the
* driver.
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- --- -------- ---------------------------------------------
* 1.00a sdm 01/15/10 First release
* </pre>
*
******************************************************************************/
/***************************** Include Files *********************************/
#include "xscuwdt.h"
#include "xparameters.h"
/************************** Constant Definitions *****************************/
/**************************** Type Definitions *******************************/
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
/*****************************************************************************/
/**
* Lookup the device configuration based on the unique device ID. The table
* contains the configuration info for each device in the system.
*
* @param DeviceId is the unique device ID of the device being looked up.
*
* @return A pointer to the configuration table entry corresponding to the
* given device ID, or NULL if no match is found.
*
* @note None.
*
******************************************************************************/
XScuWdt_Config *XScuWdt_LookupConfig(u16 DeviceId)
{
extern XScuWdt_Config XScuWdt_ConfigTable[];
XScuWdt_Config *CfgPtr = NULL;
int Index;
for (Index = 0; Index < XPAR_XSCUWDT_NUM_INSTANCES; Index++) {
if (XScuWdt_ConfigTable[Index].DeviceId == DeviceId) {
CfgPtr = &XScuWdt_ConfigTable[Index];
break;
}
}
return (CfgPtr);
}