diff --git a/XilinxProcessorIPLib/drivers/scaler/intgtest/ct.h b/XilinxProcessorIPLib/drivers/scaler/intgtest/ct.h
new file mode 100755
index 00000000..77dc1b69
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/scaler/intgtest/ct.h
@@ -0,0 +1,275 @@
+/******************************************************************************
+*
+* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
+* AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
+* SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE,
+* OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
+* APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
+* THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
+* AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
+* FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY
+* WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
+* IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
+* REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
+* INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE.
+*
+* (c) Copyright 2008 Xilinx Inc.
+* All rights reserved.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file ct.h
+*
+* Code test (CT) utility driver.
+*
+* This package is intented to help designers test their Xilinx device drivers
+* in unit and integration testing environments. The macros and functions
+* provide the following services:
+*
+* - Automated data comparison
+* - Xilinx driver assert testing
+* - Interrupt utilities
+* - Error & message logging
+* - Test sequencing utilities
+* - Timing utilities
+*
+* The main benefit of this package is to simplify test code and make it easier
+* for the tester to get more coverage in their integration and unit testing
+* without having to replicate common testing constructs.
+*
+* Integrating CT Source code
+*
+* This package consists of this header file and an implementation file. The
+* implementation can be operating system specific. When including this package
+* in your test, use this file and one of the CT implementation files such as
+* ct_vxworks.c.
+*
+* There are GNU specific "C" extensions used in this package and as a result
+* make it non-ANSI compliant. The tester must compile this package and their
+* other test code with the GNU compiler suite.
+*
+* The CT package requires that there be available standard header files
+* stdio.h, string.h, and stdarg.h.
+*
+*
+* Setup and Test Sequencing
+*
+* Before calling any comparison or utility function in this package, the tester
+* should call CT_Init() to initialize the library. This function only needs to
+* be called once.
+*
+* During tests, your code may be segmented into subtests where you would want
+* separate out the results. At the end of all subtests, you may want to
+* summarize all the tests run. The following pseudo code shows how this is done
+* with CT sequencing function calls:
+*
+*
+*
+* CT_Init();
+*
+* // Subtest #1
+* CT_TestReset("This is my Subtest #1");
+* ...
+* // Subtest code
+* ...
+* Failures = CT_GetTestFailures();
+* CT_Message("Subtest #1 had %d failures\n", Failures);
+*
+* // Subtest #2
+* CT_TestReset("This is my Subtest #2");
+* ...
+* // Subtest code
+* ...
+* Failures = CT_GetTestFailures();
+* CT_Message("Subtest #2 had %d failures\n", Failures);
+*
+* Failures = CT_GetTotalFailures();
+* CT_Message("Total test failures = %d\n", Failures);
+*
+*
+*
+* General Usage
+*
+* The heart of this package utilizes macros to compare variables or memory
+* areas. For example,
+*
+*
+*
+* CT_CMP_NUM(int, ActualValue, ExpectedValue);
+*
+*
+*
+* compares two values of type int. If they are not equal, then an error message
+* is logged and an internal counter is incremented. If they are equal, then the
+* test proceeds as if nothing had occurred. Other examples:
+*
+*
+*
+* CT_CMP_NUM(int, *ActualPtr, 5);
+* CT_CMP_NUM(int*, ActualPtr, 0x20002100);
+*
+*
+*
+* With each failure, a descriptive message is printed along with the line
+* number of the invoking code.
+*
+* If the tester needs to make a comparison manually, then they can use the
+* CT_LOG_FAILURE() macro to note the error in case the comparison is negative.
+* If the tester needs to emit an informational message, then they can use the
+* CT_Mesage() function. Calling this function does not increment error
+* counters.
+*
+*
+* Message Logging
+*
+* This package uses the printf() library for message logging.
+*
+* Ideally, the tester's environment should include some sort of UART. By
+* default CT utilizes a pre configured console UART.
+*
+* If your system does not contain a UART, then another method of providing
+* results includes printf'ing messages to memory. To enable this method,
+* enable the definition of IO_USE_BUFFER in this file. To further tailor this
+* method of logging, change IO_BUF_SIZE and IO_BUF_CUSHION. All output will
+* be written to the TextBuf array. Use your debugger or your own test
+* utilities to examine this buffer for generated output.
+*
+*
+* Limitations
+*
+* - This package must be compiled under the GNU compiler suite.
+* - CT_CMP macros can compare only ordinal data types. Structure type
+* comparisons require the tester to implement their own function.
+* - Some sort of BSP is required to support implementation of string.h,
+* stdio.h, and stdarg.h at a minimum.
+* - Advanced BSP support of signal.h is required to use CT_SetAlarm().
+* If support is not available, then this function will return an error.
+* - Testing asserts requires that NDEBUG not be defined in your driver under
+* test code.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* --- ---- -------- -----------------------------------------------
+* 1 rmm 12/23/03 First release for VxWorks
+*
+*
+******************************************************************************/
+
+#ifndef CT_H
+#define CT_H
+
+/***************************** Include Files *********************************/
+
+#include "xil_types.h" /* Needed for assert testing */
+#include "xil_assert.h"
+#include
+#include
+#include
+
+/************************** Constant Definitions *****************************/
+/*
+ * This is what the CT_Log* lines will be prepended with. The numerical arg
+ * should be the line number within the source file containing the call to
+ * the CT library function or macro.
+ */
+#define CT_ERR_FMT "FAIL: %04d: "
+
+/**************************** Type Definitions *******************************/
+
+
+/***************** Macros (Inline Functions) Definitions *********************/
+
+/*****************************************************************************/
+/**
+ *
+ * Log a failure with a supplied message. This provides a useful wrapper
+ * around the CT_LogFailure function that prints messages of the same format
+ * as other CT macros:
+ *
+ *
+ * 1 int i;
+ * 2
+ * 3 i = 10;
+ * 4 if (i != 5)
+ * 5 {
+ * 6 CT_LOG_FAILURE("GetDataFromDevice() returned %d instead of 5", i);
+ * 7 CT_LOG_FAILURE("D'oh");
+ * 8 }
+ *
+ * yields the output:
+ *
+ * FAIL: 0006: GetDataFromDevice() returned 10 instead of 5
+ * FAIL: 0007: D'oh
+ *
+ *
+ * @param fmt is a printf style format string
+ * @param args is a variable argument list that matches fields in the
+ * fmt string.
+ * @note
+ * Usage: CT_LOG_FAILURE(char* fmt, ...)
+ *
+ *****************************************************************************/
+#define CT_LOG_FAILURE(fmt, args...) \
+ CT_LogFailure(CT_ERR_FMT fmt "\n", __LINE__ , ## args)
+
+/*****************************************************************************/
+/**
+ *
+ * Compare numbers. If not equal, then output message and increment fail
+ * counter. The message contains the line number of the failure, the
+ * name of the variable, and its actual and expected values in hex and
+ * decimal. An example:
+ *
+ *
+ * 1 UINT32 result = 5;
+ * 2 UINT32 expected = 17;
+ * 3
+ * 4 CT_CMP_NUM(UINT32, result, expected)
+ *
+ * yields the output:
+ *
+ * FAIL: 0004: result=5(5h), expected 17(11h)
+ *
+ *
+ *
+ * @param type is data type to compare (must be an ordinal type such as
+ * int)
+ * @param actual is the actual data retrieved from test
+ * @param expected is the expected value
+ *
+ * @note Usage: CT_CMP_NUM(, actual, expected)
+ *
+ ****************************************************************************/
+#define CT_CMP_NUM(type, actual, expected) \
+ if ((type)(actual) != (type)(expected)) \
+ { \
+ CT_LogFailure(CT_ERR_FMT "%s=%d(%Xh), expected %d(%Xh)\n", \
+ __LINE__, #actual, (int)actual, (int)actual, \
+ (int)expected, (int)expected); \
+ }
+
+/************************** Function Prototypes ******************************/
+
+void CT_Init(void);
+void CT_TestReset(char *fmt, ...);
+void CT_NotifyNextPass(void);
+void CT_LogFailure(char* fmt, ...);
+unsigned CT_GetTestFailures(void);
+unsigned CT_GetTotalFailures(void);
+void CT_Message(char *fmt, ...);
+void CT_MemSet(void *Address, char Value, unsigned Bytes);
+int CT_IsAssertDisabled(void);
+
+void CT_VerboseOn(void);
+void CT_VerboseOff(void);
+
+int CT_GetUserInput(char* Prompt, char* Response, int MaxChars);
+extern char inbyte(void); /* Implemented by standalone BSP */
+extern void outbyte(char); /* Implemented by standalone BSP */
+
+#endif /* CT_H */
diff --git a/XilinxProcessorIPLib/drivers/scaler/intgtest/ct_standalone.c b/XilinxProcessorIPLib/drivers/scaler/intgtest/ct_standalone.c
new file mode 100755
index 00000000..6a75105b
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/scaler/intgtest/ct_standalone.c
@@ -0,0 +1,366 @@
+/******************************************************************************
+*
+* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
+* AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
+* SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE,
+* OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
+* APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
+* THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
+* AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
+* FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY
+* WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
+* IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
+* REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
+* INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE.
+*
+* (c) Copyright 2014 Xilinx Inc.
+* All rights reserved.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file ct_standalone.c
+*
+* Implements Code test (CT) utility driver. Test.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- -----------------------------------------------
+* 7.0 adk 01/09/14 First release.
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include
+#include
+#include
+#include
+#include "ct.h"
+
+/************************** Constant Definitions *****************************/
+
+
+/**************************** Type Definitions *******************************/
+
+
+/***************** Macros (Inline Functions) Definitions *********************/
+
+
+/************************** Function Prototypes ******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+unsigned CT_TotalFailures;
+unsigned CT_TestFailures;
+unsigned CT_TestPass;
+static int Verbose = 0; /* Verbosity flag */
+
+/*****************************************************************************/
+/**
+*
+* Initialize the CT subsystem.
+*
+* @return None
+*
+******************************************************************************/
+void CT_Init(void)
+{
+ CT_TestFailures = 0;
+ CT_TotalFailures = 0;
+ CT_TestPass = 0;
+}
+
+/*****************************************************************************/
+/**
+*
+* Reset for a new test and display a test specific message. This involves:
+*
+* - Zero out test failure counter.
+* - Print a message specified by the fmt parameter and its associated
+* arguments.
+*
+* @param Fmt is a "printf" style format string.
+* @param ... is a variable number of arguments that match "Fmt"
+*
+* @return None
+*
+******************************************************************************/
+void CT_TestReset(char *Fmt, ...)
+{
+ va_list Args;
+
+ CT_TestFailures = 0;
+ CT_TestPass = 1;
+
+ /*
+ * Print out the format and its associated argument list
+ */
+ va_start(Args, Fmt);
+ vprintf(Fmt, Args);
+ CT_Message("\n========================================================");
+ va_end(Args);
+ CT_Message("\n");
+}
+
+/*****************************************************************************/
+/**
+* Display current test pass number to user
+*
+* @return None
+*
+******************************************************************************/
+void CT_NotifyNextPass(void)
+{
+ CT_Message("\n=====>Pass %d\n", CT_TestPass++);
+}
+
+/*****************************************************************************/
+/**
+*
+* Log a test failure. This involves incrementing test failure and total test
+* failure counters, and displaying test specific message.
+*
+* @param Fmt is a "printf" style format string.
+* @param ... is a variable number of arguments that match "fmt"
+*
+* @return None
+*
+******************************************************************************/
+void CT_LogFailure(char* Fmt, ...)
+{
+ va_list Args;
+
+ /*
+ * Increment failure counters
+ */
+ CT_TestFailures++;
+ CT_TotalFailures++;
+
+ /*
+ * Print out the format and its associated argument list.
+ */
+ va_start(Args, Fmt);
+
+ vprintf(Fmt, Args);
+ va_end(Args);
+}
+
+/*****************************************************************************/
+/**
+*
+* Return the number of test failures since CT_TestReset() was called.
+*
+* @return Number of failures logged.
+*
+******************************************************************************/
+unsigned CT_GetTestFailures(void)
+{
+ return(CT_TestFailures);
+}
+
+/*****************************************************************************/
+/**
+*
+* Return the number of test failures since CT_Init() was called.
+*
+* @return Total number of failures logged.
+*
+******************************************************************************/
+unsigned CT_GetTotalFailures(void)
+{
+ return(CT_TotalFailures);
+}
+
+/*****************************************************************************/
+/**
+* Return status of the Xilinx driver assert mechanism.
+*
+* @return 1 if asserts are disabled, 0 otherwise
+*
+*****************************************************************************/
+int CT_IsAssertDisabled(void)
+{
+#ifdef NDEBUG
+ return(1);
+#else
+ return(0);
+#endif
+}
+
+/*****************************************************************************/
+/**
+*
+* Print a message based on the given format string and parameters.
+*
+* @param Fmt is a "printf" style format string.
+* @param ... is a variable number of arguments that match "fmt"
+*
+* @return None
+*
+******************************************************************************/
+void CT_Message(char *Fmt, ...)
+{
+ va_list Args;
+
+ va_start(Args, Fmt);
+
+ vprintf(Fmt, Args);
+
+ va_end(Args);
+}
+
+/*****************************************************************************/
+/**
+*
+* Set a series of bytes in memory to a specific value
+*
+* @param AddressPtr is the start address in memory to write
+* @param Value is the value to set memory to
+* @param Bytes is the number of bytes to set
+*
+* @return None
+*
+******************************************************************************/
+void CT_MemSet(void *AddressPtr, char Value, unsigned Bytes)
+{
+ char* AdrPtr = AddressPtr;
+
+ while(Bytes--)
+ {
+ *AdrPtr++ = Value;
+ }
+}
+
+/*****************************************************************************/
+/**
+*
+* Retrieve a line of input from the user. A line is defined as all characters
+* up to a new line.
+*
+* @param PromptPtr Printed before string is accepted to que the user to
+* enter something.
+*
+* @param ResponsePtr Null terminated string with new line stripped
+*
+* @param MaxChars Maximum number of characters to read (excluding null)
+*
+* @return Number of characters read (excluding new line)
+*
+* @note None
+*
+******************************************************************************/
+int CT_GetUserInput(char* PromptPtr, char* ResponsePtr, int MaxChars)
+{
+ u32 Index;
+ u8 Finished;
+
+ /*
+ * Display prompt
+ */
+ if (PromptPtr) printf(PromptPtr);
+
+ /*
+ * This basically implements a fgets function. The standalone EDK stdin
+ * is apparently buggy because it behaves differently when new line is
+ * entered by itself vs. when it is entered after a number of regular chars
+ * have been entered.Characters entered are echoed back.
+ */
+ Finished = 0;
+ Index = 0;
+
+ while(!Finished)
+ {
+ /*
+ * Flush out any output pending in stdout
+ */
+ fflush(stdout);
+
+ /*
+ * Wait for a character to arrive
+ */
+ ResponsePtr[Index] = inbyte();
+
+ /*
+ * Normal chars, add them to the string and keep going
+ */
+ if ((ResponsePtr[Index] >= 0x20) && (ResponsePtr[Index] <=0x7E))
+ {
+ printf("%c", ResponsePtr[Index++]);
+ continue;
+ }
+
+ /*
+ * Control chars
+ */
+ switch(ResponsePtr[Index])
+ {
+ /*
+ * Carriage return
+ */
+ case '\r':
+ case '\n':
+ ResponsePtr[Index] = 0;
+ Finished = 1;
+ printf("\n");
+ break;
+
+ /*
+ * Backspace
+ */
+ case 0x08:
+ if (Index != 0)
+ {
+ /*
+ * Erase previous character and move cursor back one space
+ */
+ printf("\b \b");
+ ResponsePtr[--Index] = 0;
+ }
+ break;
+
+ /*
+ * Ignore all other control chars
+ */
+ default:
+ continue;
+ }
+ }
+
+ return(Index);
+}
+
+/*****************************************************************************/
+/**
+*
+* Enable output of CT_MessageV().
+*
+* @return None
+*
+* @note None
+*
+******************************************************************************/
+void CT_VerboseOn(void)
+{
+ Verbose = 1;
+}
+
+/*****************************************************************************/
+/**
+* Disable output of CT_MessageV().
+*
+* @return None
+*
+* @note None
+*
+******************************************************************************/
+void CT_VerboseOff(void)
+{
+ Verbose = 0;
+}
diff --git a/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_basic.c b/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_basic.c
new file mode 100755
index 00000000..1bd5c61b
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_basic.c
@@ -0,0 +1,671 @@
+/******************************************************************************
+*
+* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
+* AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
+* SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE,
+* OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
+* APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
+* THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
+* AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
+* FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY
+* WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
+* IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
+* REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
+* INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE.
+*
+* (c) Copyright 2014 Xilinx Inc.
+* All rights reserved.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file scaler_intg_basic.c
+*
+* @note
+*
+* This test works with Zynq702 system.
+*
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ---------------------------------------------
+* 7.0 adk 22/08/14 First release.
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+#include "xscaler.h"
+#include "xscaler_hw.h"
+#include "xparameters.h"
+#include "scaler_intgtest.h"
+
+/************************** Constant Definitions *****************************/
+
+
+/***************** Macros (Inline Functions) Definitions *********************/
+
+
+/*****************************************************************************/
+/**
+ *
+ * Compare numbers. If not equal, then output message and increment fail
+ * counter. The message contains the line number of the failure, the
+ * name of the variable, and its actual and expected values in hex and
+ * decimal. If equal, display current test pass number to user.
+ * An example:
+ *
+ *
+ * 1 UINT32 result = 5;
+ * 2 UINT32 expected = 17;
+ * 3
+ * 4 CT_CMP_NUM(UINT32, result, expected)
+ *
+ * yields the output:
+ *
+ * FAIL: 0004: result=5(5h), expected 17(11h)
+ *
+ *
+ * @param Type is data type to compare (must be an ordinal type such
+ * as int)
+ * @param Val_16 is the actual data retrieved from test
+ * @param Val_32 is the expected value
+ *
+ * @note Usage: CT_CMP_NUM(, actual, expected)
+ *
+ *****************************************************************************/
+#define check_status_update(Type, Val_16, Val_32) \
+ if((Type)(Val_16) != (Type)(Val_32)){ \
+ CT_CMP_NUM(Type, XST_FAILURE, XST_SUCCESS); \
+ } \
+ else{ \
+ CT_NotifyNextPass(); \
+ } \
+
+/**************************** Type Definitions *******************************/
+#define round(x) ((x) >= 0 ? (s32)((x) + 0.5) : (s32)((x) - 0.5))
+
+/************************** Function Prototypes ******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+
+/************************** Function Definitions *****************************/
+
+/*****************************************************************************/
+/**
+*
+* This function executes the XScaler Self test.
+*
+* @param TestLoops is the number of times to execute test.
+*
+* @return Returns the total number of test failures.
+*
+* @note None.
+*
+******************************************************************************/
+int Scaler_Intg_SelfTest(int TestLoops)
+{
+ u32 Status = (u32)XST_SUCCESS;
+
+ double HoriScaleFactor;
+ double VertScaleFactor;
+
+
+ u32 OldScalerReg;
+ u32 NewScalerReg;
+ u32 LumaLeftH;
+ u32 LumaTopV;
+ u32 ChromaLeftH;
+ u32 ChromaTopV;
+
+ u32 OutSize;
+ u32 InLine;
+ u32 InPixel;
+ u32 SrcSize;
+ u32 QuantizedHoriSize;
+ u32 QuantizedVertSize;
+ u32 QuantizedInLastPixel;
+ u32 QuantizedInLastLine;
+
+ u32 PhaseRegValue;
+ u16 VertPhaseNum;
+ u16 HoriPhaseNum;
+
+ u8 ChromaFormat;
+ u8 ChromaLumaShareCoeff;
+ u8 HoriVertShareCoeff;
+ u8 VertSetIndex;
+ u8 HoriSetIndex;
+
+ u32 InLine_1;
+ u32 InPixel_1;
+ u32 OutSize_1 ;
+ u32 SrcSize_1 ;
+ double HoriScaleFactor_1;
+ double VertScaleFactor_1;
+
+ XScaler ScalerInst;
+
+ XScalerStartFraction StartFractionInst;
+
+ XScalerCoeffBank CoeffBankPtr;
+
+ XScalerAperture AperturePtr;
+ XScalerAperture AperturePtr_1;
+
+ XScaler_Config *Config;
+
+ CT_TestReset("Scaler Self Test .. ..");
+ while (TestLoops--) {
+ CT_NotifyNextPass();
+
+ /* Initialize the XScaler instance. */
+ Status = Scaler_Initialize(&ScalerInst, (u16)SCALER_0_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return Status;
+ }
+
+/*****************************************************************************/
+/* XScaler_GetVersion */
+
+ /*Test case 1 */
+ NewScalerReg = XScaler_GetVersion(&ScalerInst);
+ if (NewScalerReg != 0x00000000) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*Test case 3 */
+// XScaler_GetVersion(Null);
+
+/*****************************************************************************/
+ /* XScaler_Disable */
+
+ /*Test case 1 */
+ XScaler_Disable(&ScalerInst);
+ if (0x0 == ((XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_CTL_OFFSET)) & ~(XSCL_CTL_SW_EN_MASK))) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+// XScaler_Disable(&ScalerInst);
+
+/*****************************************************************************/
+ /* XScaler_Enable */
+
+ /* check the bit 0 of control register, default is 0*/
+ /*Test case 1 */
+ XScaler_Enable(&ScalerInst);
+ if(0x00000001 == ((XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_CTL_OFFSET)) | (XSCL_CTL_SW_EN_MASK))){
+ check_status_update(u32, 1, 1);
+ }
+ else{
+ check_status_update(u32, 0, 1);
+ }
+ XScaler_Enable(&ScalerInst);
+
+/*****************************************************************************/
+ /* XScaler_SetPhaseNum */
+
+ /* Test case 1*/
+ VertPhaseNum = 1;
+ ScalerInst.Config.MaxPhaseNum = 1;
+ HoriPhaseNum = 1;
+ ScalerInst.Config.MaxPhaseNum = 1;
+
+ XScaler_SetPhaseNum(&ScalerInst, VertPhaseNum, HoriPhaseNum);
+ OldScalerReg = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_NUMPHASE_OFFSET);
+ NewScalerReg = (VertPhaseNum << XSCL_NUMPHASE_VERT_SHIFT) &
+ XSCL_NUMPHASE_VERT_MASK;
+ NewScalerReg |= HoriPhaseNum & XSCL_NUMPHASE_HORI_MASK;
+ if (NewScalerReg == OldScalerReg) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /* Test case 2 */
+ XScaler_SetPhaseNum(&ScalerInst, VertPhaseNum, HoriPhaseNum);
+ OldScalerReg = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_NUMPHASE_OFFSET);
+ if ((VertPhaseNum == (OldScalerReg & XSCL_NUMPHASE_VERT_MASK) >>
+ XSCL_NUMPHASE_VERT_SHIFT) &&
+ (HoriPhaseNum == (OldScalerReg &
+ XSCL_NUMPHASE_HORI_MASK))) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+
+ /* Test case 3 */
+ //XScaler_SetPhaseNum(Null, VertPhaseNum, HoriPhaseNum);
+
+/*****************************************************************************/
+ /* XScaler_GetPhaseNum */
+ XScaler_GetPhaseNum(&ScalerInst, &VertPhaseNum, &HoriPhaseNum);
+ PhaseRegValue = XScaler_ReadReg((ScalerInst).Config.BaseAddress,
+ XSCL_NUMPHASE_OFFSET);
+ OldScalerReg = (PhaseRegValue & XSCL_NUMPHASE_VERT_MASK) >>
+ XSCL_NUMPHASE_VERT_SHIFT;
+ NewScalerReg = PhaseRegValue & XSCL_NUMPHASE_HORI_MASK;
+ if ((NewScalerReg == HoriPhaseNum) && (OldScalerReg == VertPhaseNum)) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+
+ /* Test case 3 */
+ //XScaler_GetPhaseNum(Null, &VertPhaseNum, &HoriPhaseNum);
+
+/*****************************************************************************/
+ XScaler_SetStartFraction(&ScalerInst, &StartFractionInst);
+
+ LumaLeftH = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTLUMALEFT_OFFSET);
+ LumaTopV = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTLUMATOP_OFFSET);
+ ChromaLeftH = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTCHROMALEFT_OFFSET);
+ ChromaTopV = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTCHROMATOP_OFFSET);
+
+ if(((LumaLeftH)==((u32)StartFractionInst.LumaLeftHori &
+ XSCL_FRCTLUMALEFT_VALUE_MASK)) &&
+ ( LumaTopV == ((u32)StartFractionInst.LumaTopVert &
+ XSCL_FRCTLUMATOP_VALUE_MASK)) &&
+ (ChromaLeftH == ((u32)StartFractionInst.ChromaLeftHori &
+ XSCL_FRCTCHROMALEFT_VALUE_MASK)) &&
+ (ChromaTopV == ((u32)StartFractionInst.ChromaTopVert &
+ XSCL_FRCTCHROMATOP_VALUE_MASK))) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+
+ //XScaler_SetStartFraction(Null, Null1);
+
+/*****************************************************************************/
+ XScaler_GetStartFraction(&ScalerInst, &StartFractionInst);
+
+ LumaLeftH = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTLUMALEFT_OFFSET) &
+ XSCL_FRCTLUMALEFT_VALUE_MASK;
+ LumaTopV = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTLUMATOP_OFFSET) &
+ XSCL_FRCTLUMATOP_VALUE_MASK;
+ ChromaLeftH = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTCHROMALEFT_OFFSET) &
+ XSCL_FRCTCHROMALEFT_VALUE_MASK;
+ ChromaTopV = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTCHROMATOP_OFFSET) &
+ XSCL_FRCTCHROMATOP_VALUE_MASK;
+
+ if ((LumaLeftH == StartFractionInst.LumaLeftHori) &&
+ (LumaTopV == StartFractionInst.LumaTopVert) &&
+ (ChromaLeftH == StartFractionInst.ChromaLeftHori) &&
+ (ChromaTopV == StartFractionInst.ChromaTopVert)) {
+ check_status_update(u32, 1, 1);
+ }
+ else
+ {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+
+ //XScaler_GetStartFraction(Null, Null1);
+
+/*****************************************************************************/
+ XScaler_GetCoeffBankSharingInfo(&ScalerInst,
+ &ChromaFormat,
+ &ChromaLumaShareCoeff,
+ &HoriVertShareCoeff);
+
+ if (ChromaFormat == ScalerInst.Config.ChromaFormat) {
+ check_status_update(u32, 1, 1);
+ }
+ else
+ {
+ check_status_update(u32, 0, 1);
+ }
+ if (ScalerInst.Config.SeparateHvCoef !=0 ) {
+ if (HoriVertShareCoeff == 0) {
+ check_status_update(u32, 1, 1);
+ }
+ else
+ {
+ check_status_update(u32, 0, 1);
+ }
+ }
+ else {
+ if (HoriVertShareCoeff == 1) {
+ check_status_update(u32, 1, 1);
+ }
+ else
+ {
+ check_status_update(u32, 0, 1);
+ }
+ }
+ if (ChromaFormat ==XSCL_CHROMA_FORMAT_422 ) {
+ if(ScalerInst.Config.SeparateYcCoef!=0)
+ {
+ if (ChromaLumaShareCoeff == 0) {
+ check_status_update(u32, 1, 1);
+ }
+ else
+ {
+ check_status_update(u32, 0, 1);
+ }
+ }
+ }
+ if(ChromaFormat == XSCL_CHROMA_FORMAT_422){
+ if (ChromaLumaShareCoeff == 1) {
+ check_status_update(u32, 1, 1);
+ }
+ else
+ {
+ check_status_update(u32, 0, 1);
+ }
+ }
+
+/*****************************************************************************/
+ InLine_1= 23;
+ OutSize_1 = 22;
+ SrcSize_1 = 11 ;
+ InPixel_1 = 63;
+
+ XScaler_CoefValueLookup(InLine_1, OutSize_1, SrcSize_1, InPixel_1);
+ if(Xil_AssertStatus == XIL_ASSERT_NONE) {
+ check_status_update(u32, 1, 1);
+ }
+ else{
+ check_status_update(u32, 0, 1);
+ }
+
+
+/*****************************************************************************/
+ /* Xil_AssertVoid(CoeffBankPtr->SetIndex <
+ InstancePtr->Config.CoeffSetNum);
+ Xil_AssertVoid(CoeffBankPtr->CoeffValueBuf != NULL);
+ Xil_AssertVoid(CoeffBankPtr->PhaseNum >= (XSCL_MIN_PHASE_NUM));
+ Xil_AssertVoid(CoeffBankPtr->PhaseNum <=
+ InstancePtr->Config.MaxPhaseNum);
+ Xil_AssertVoid(CoeffBankPtr->TapNum > 0U);
+ Xil_AssertVoid(CoeffBankPtr->TapNum <= (XSCL_MAX_TAP_NUM)); */
+
+
+ CoeffBankPtr.SetIndex = 1;
+ ScalerInst.Config.CoeffSetNum = 2;
+ CoeffBankPtr.PhaseNum = 6;
+ ScalerInst.Config.MaxPhaseNum = 6;
+ CoeffBankPtr.TapNum = (XSCL_MAX_TAP_NUM);
+ CoeffBankPtr.CoeffValueBuf = XScaler_CoefValueLookup(640, 480,CoeffBankPtr.TapNum, CoeffBankPtr.PhaseNum);
+
+ XScaler_LoadCoeffBank(&ScalerInst, &CoeffBankPtr);
+
+ NewScalerReg = CoeffBankPtr.SetIndex & XSCL_COEFFSETADDR_ADDR_MASK;
+ OldScalerReg = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_COEFFSETADDR_OFFSET);
+
+ if (NewScalerReg == OldScalerReg) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+ //XScaler_LoadCoeffBank(Null, Null2);
+
+/****************************************************************************/
+
+ VertSetIndex = 0 ;
+ ScalerInst.Config.CoeffSetNum = 1 ;
+ HoriSetIndex = 0;
+ ScalerInst.Config.CoeffSetNum = 1;
+
+ XScaler_SetActiveCoeffSet(&ScalerInst, VertSetIndex, HoriSetIndex);
+
+ OldScalerReg = ((u32)HoriSetIndex) & XSCL_COEFFSETS_HORI_MASK;
+ OldScalerReg |= (((u32)VertSetIndex) << XSCL_COEFFSETS_VERT_SHIFT) &
+ XSCL_COEFFSETS_VERT_MASK;
+
+ NewScalerReg = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_COEFFSETS_OFFSET);
+
+ if (NewScalerReg == OldScalerReg) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+ //XScaler_SetActiveCoeffSet(Null, VertSetIndex, HoriSetIndex);
+
+/*****************************************************************************/
+ XScaler_GetActiveCoeffSet(&ScalerInst, &VertSetIndex, &HoriSetIndex);
+ NewScalerReg = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_COEFFSETS_OFFSET);
+ if (((u8)(NewScalerReg & XSCL_COEFFSETS_VERT_MASK) >>
+ XSCL_COEFFSETS_VERT_SHIFT) == VertSetIndex &&
+ (u8)(NewScalerReg & XSCL_COEFFSETS_HORI_MASK) ==
+ HoriSetIndex) {
+ check_status_update(u32, 1, 1);
+ } else {
+ check_status_update(u32, 0, 1);
+ }
+
+/*****************************************************************************/
+ memset((void *)&AperturePtr, 0, sizeof(XScalerAperture));
+ memset((void *)&AperturePtr_1, 0, sizeof(XScalerAperture));
+// memset((void *)&ScalerInst, 0, sizeof(XScaler));
+ AperturePtr.InFirstLine = 0;
+ AperturePtr.InLastLine = 719;
+ AperturePtr.InLastPixel = 1279;
+ AperturePtr.InFirstPixel = 0;
+ AperturePtr.OutVertSize = 1280;
+ AperturePtr.OutHoriSize =720;
+
+ XScaler_SetAperture(&ScalerInst, &AperturePtr);
+ /* Calculate vertical and horizontal scale factors */
+ VertScaleFactor = (double)(AperturePtr.InLastLine -
+ AperturePtr.InFirstLine + 1.0);
+ VertScaleFactor /= (double)(AperturePtr.OutVertSize);
+ HoriScaleFactor = (double)(AperturePtr.InLastPixel -
+ AperturePtr.InFirstPixel + 1.0);
+ HoriScaleFactor /= (double)AperturePtr.OutHoriSize;
+
+ /* Convert HoriScaleFactor and VertScaleFactor values into a format
+ * to write to HSF and VSF registers.
+ */
+ VertScaleFactor = (u32)(VertScaleFactor * XSCL_SHRINK_FACTOR);
+ HoriScaleFactor = (u32)(HoriScaleFactor * XSCL_SHRINK_FACTOR);
+
+ /* Quantize Aperture - feed scale-factor back in to provide the
+ * actual aperture required to generate the desired number of output
+ * samples.
+ */
+ QuantizedHoriSize = AperturePtr.OutHoriSize - 1;
+ QuantizedHoriSize = (u32)(((double)QuantizedHoriSize *
+ HoriScaleFactor) / XSCL_SHRINK_FACTOR);
+ QuantizedHoriSize += 1 + (ScalerInst.Config.HoriTapNum + 1) / 2;
+
+ QuantizedInLastPixel = AperturePtr.InFirstPixel + QuantizedHoriSize
+ - 1;
+ if (QuantizedInLastPixel > AperturePtr.InLastPixel)
+ QuantizedInLastPixel = AperturePtr.InLastPixel;
+
+ QuantizedVertSize = AperturePtr.OutVertSize - 1;
+ QuantizedVertSize = (u32)(((float)QuantizedVertSize *
+ VertScaleFactor) / XSCL_SHRINK_FACTOR);
+ QuantizedVertSize += 1 + (ScalerInst.Config.VertTapNum + 1) / 2;
+
+ QuantizedInLastLine = AperturePtr.InFirstLine + QuantizedVertSize - 1;
+ if (QuantizedInLastLine > AperturePtr.InLastLine)
+ QuantizedInLastLine = AperturePtr.InLastLine;
+
+ /* Calculate input line, pixel and output size values */
+ InLine = AperturePtr.InFirstLine & XSCL_APTVERT_FIRSTLINE_MASK;
+ InLine |= (QuantizedInLastLine << XSCL_APTVERT_LASTLINE_SHIFT)
+ & XSCL_APTVERT_LASTLINE_MASK;
+ InPixel = AperturePtr.InFirstPixel & XSCL_APTHORI_FIRSTPXL_MASK;
+ InPixel |= (QuantizedInLastPixel << XSCL_APTHORI_LASTPXL_SHIFT)
+ & XSCL_APTHORI_LASTPXL_MASK;
+ OutSize = AperturePtr.OutHoriSize & XSCL_OUTSIZE_NUMPXL_MASK;
+ OutSize |= (AperturePtr.OutVertSize << XSCL_OUTSIZE_NUMLINE_SHIFT)
+ & XSCL_OUTSIZE_NUMLINE_MASK;
+
+ SrcSize = AperturePtr.SrcHoriSize & XSCL_SRCSIZE_NUMPXL_MASK;
+ SrcSize |= (AperturePtr.SrcVertSize << XSCL_SRCSIZE_NUMLINE_SHIFT)
+ & XSCL_SRCSIZE_NUMLINE_MASK;
+
+ //InLine_1 = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ // XSCL_FRCTLUMALEFT_OFFSET);
+ InLine_1 = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_APTVERT_OFFSET);
+ InPixel_1 = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_APTHORI_OFFSET);
+ OutSize_1 =XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_OUTSIZE_OFFSET);
+ SrcSize_1 =XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_SRCSIZE_OFFSET);
+ HoriScaleFactor_1 =XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_HSF_OFFSET);
+ HoriScaleFactor_1 = (u32)round(HoriScaleFactor_1);
+ VertScaleFactor_1=XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_VSF_OFFSET);
+ VertScaleFactor_1 = (u32)round(VertScaleFactor_1);
+ /*if ((InLine == XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_FRCTLUMALEFT_OFFSET)) && (InPixel ==
+ XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_APTHORI_OFFSET)) &&
+ (OutSize == XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_OUTSIZE_OFFSET)) &&
+ (SrcSize == XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_SRCSIZE_OFFSET)) &&
+ ((u32)(round(HoriScaleFactor)) ==
+ XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_HSF_OFFSET)) &&
+ ((u32)(round(VertScaleFactor)) ==
+ XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ XSCL_VSF_OFFSET))) */
+ if (InLine == InLine_1 && InPixel == InPixel_1 && OutSize == OutSize_1
+ && SrcSize== SrcSize_1 && HoriScaleFactor == HoriScaleFactor_1
+ && VertScaleFactor == VertScaleFactor_1) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Negative Test Case
+ */
+ //XScaler_SetAperture(Null, Null3);
+
+ /****************************************************************************/
+ AperturePtr.InFirstLine = 0;
+ AperturePtr.InLastLine = 719;
+ AperturePtr.InLastPixel = 1279;
+ AperturePtr.InFirstPixel = 0;
+ AperturePtr.OutVertSize = 1280;
+ AperturePtr.OutHoriSize = 720;
+
+ XScaler_GetAperture(&ScalerInst, &AperturePtr);
+
+ InLine = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ (XSCL_APTVERT_OFFSET));
+ InPixel = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ (XSCL_APTHORI_OFFSET));
+ OutSize = XScaler_ReadReg(ScalerInst.Config.BaseAddress,
+ (XSCL_OUTSIZE_OFFSET));
+
+ /* Parse the info and populate the aperture structure */
+ AperturePtr_1.InFirstLine = (InLine) & (XSCL_APTVERT_FIRSTLINE_MASK);
+ AperturePtr_1.InLastLine = ((InLine) & (XSCL_APTVERT_LASTLINE_MASK)) >>
+ (XSCL_APTVERT_LASTLINE_SHIFT);
+
+ AperturePtr_1.InFirstPixel = (InPixel) & (XSCL_APTHORI_FIRSTPXL_MASK);
+ AperturePtr_1.InLastPixel = ((InPixel) &
+ (XSCL_APTHORI_LASTPXL_MASK)) >>
+ (XSCL_APTHORI_LASTPXL_SHIFT);
+
+ AperturePtr_1.OutHoriSize = (OutSize) & (XSCL_OUTSIZE_NUMPXL_MASK);
+ AperturePtr_1.OutVertSize = ((OutSize) &
+ (XSCL_OUTSIZE_NUMLINE_MASK)) >>
+ (XSCL_OUTSIZE_NUMLINE_SHIFT);
+
+ if(!(memcmp(&AperturePtr, &AperturePtr_1, sizeof(XScalerAperture)))) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+ /*
+ * Run XScaler self test.
+ */
+// Status = XScaler_SelfTest(&ScalerInst);
+// if (Status != XST_SUCCESS) {
+// check_status_update(u32, 0, 1);
+// return XST_FAILURE;
+// }
+// else{
+// check_status_update(u32, 1, 1);
+// }
+ /*
+ * Test case for lookupconfig
+ */
+ Config = XScaler_LookupConfig(XSCALAR_DEVICEID);
+ if(Config == NULL) {
+ check_status_update(u32, 1, 1);
+ }
+ else {
+ check_status_update(u32, 0, 1);
+ }
+
+
+ CT_CMP_NUM(int, Status, XST_SUCCESS);
+ }
+ return (u32)(CT_GetTestFailures());
+
+}
diff --git a/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_intr.c b/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_intr.c
new file mode 100755
index 00000000..5a2dcfbb
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_intr.c
@@ -0,0 +1,237 @@
+/*****************************************************************************
+*
+* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
+* AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
+* SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE,
+* OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
+* APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
+* THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
+* AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
+* FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY
+* WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
+* IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
+* REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
+* INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE.
+*
+* (c) Copyright 2014 Xilinx Inc.
+* All rights reserved.
+*
+*****************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file scaler_intg_intr.c
+*
+* This file contains an integration test on Scaler driver in interrupt mode.
+*
+* @note
+*
+* This code assumes that Zynq702 is the processor in the hardware system.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ---------------------------------------------
+* 7.0 adk 22/08/14 First release.
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "scaler_intgtest.h"
+
+/************************** Constant Definitions *****************************/
+
+
+/************************** Constant Definitions *****************************/
+
+
+/**************************** Type Definitions *******************************/
+
+
+/***************** Macros (Inline Functions) Definitions *********************/
+
+
+/************************** Function Prototypes ******************************/
+
+static int SetupInterruptSystem(XScaler *ScalerInstPtr);
+
+/* void Handler(void *CallBackRef, u32 Event, unsigned int EventData);*/
+void Handler(void *CallBackRef, u32 Event);
+static int ScalerInterruptTest(int TestLoops);
+
+/************************** Variable Definitions *****************************/
+
+/*****************************************************************************/
+/**
+*
+* This function setups the interrupt system so interrupts can occur for the
+* SCALER core. The function is application-specific since the actual system may
+* or may not have an interrupt controller. The SCALER device could be directly
+* connected to a processor without an interrupt controller. The user should
+* modify this function to fit the application.
+*
+* @param ScalerInstPtr contains a pointer to the instance of the XScaler
+* which is going to be connected to the interrupt controller.
+*
+* @return XST_SUCCESS if successful, or a specific error code defined in
+* "xstatus.h" if an error occurs.
+*
+* @note This function assumes a Zynq702 system and no operating system
+* is used.
+*
+******************************************************************************/
+static int SetupInterruptSystem(XScaler * ScalerInstPtr)
+{
+ int Status;
+
+ /* The configuration parameters of the interrupt controller */
+ 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(&InterruptController, IntcConfig,
+ IntcConfig->CpuBaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Connect the interrupt controller interrupt handler to the hardware
+ * interrupt handling logic in the Zynq702 processor.
+ */
+ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
+ (Xil_ExceptionHandler)XScuGic_InterruptHandler,
+ &InterruptController);
+
+ /* 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(&InterruptController,
+ SCALER_INT_IRQ_ID,
+ (Xil_ExceptionHandler)XScaler_IntrHandler,
+ ScalerInstPtr);
+
+ if (Status != XST_SUCCESS) {
+ return Status;
+ }
+
+ /* Enable the interrupt for the Scaler device */
+ XScuGic_Enable(&InterruptController, SCALER_INT_IRQ_ID);
+
+ /* Enable interrupts in the Zynq702 */
+ Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
+
+ return XST_SUCCESS;
+}
+
+/****************************************************************************/
+/**
+*
+* This function tests the interrupt functionality of the Scaler driver.
+*
+* @param TestLoops is the number of times to run the test.
+*
+* @return the number of errors that occurred.
+*
+* @note None.
+*
+****************************************************************************/
+int Scaler_Intg_InterruptTest(int TestLoops)
+{
+ int Status = 0;
+
+ CT_TestReset("Scaler interrupt mode test .. ..");
+
+ while (TestLoops--) {
+ CT_NotifyNextPass();
+ Status = ScalerInterruptTest(TestLoops);
+ }
+
+ CT_CMP_NUM(int, Status, XST_SUCCESS);
+
+ return (CT_GetTestFailures());
+}
+
+/*****************************************************************************/
+/**
+*
+* This function implements the Scaler interrupt mode test functionality.
+*
+* @param TestLoops is the number of times to run the test.
+*
+* @return XST_SUCCESS if successful else XST_FAILURE.
+*
+* @note None.
+*
+******************************************************************************/
+static int ScalerInterruptTest(int TestLoops)
+{
+ int Status;
+ /* u32 LoopCount;
+ u32 IntrMask;
+ u8 Bytes; */
+
+ /* Initialize XScaler instance. */
+ Status = Scaler_Initialize(&ScalerInst, (u16)SCALER_0_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return Status;
+ }
+
+ /* Setup interrupt system */
+ Status = SetupInterruptSystem(&ScalerInst);
+ CT_CMP_NUM(int, Status, XST_SUCCESS);
+ if (Status != XST_SUCCESS) {
+ CT_Message("Failed test(s): %u\n", CT_GetTestFailures());
+ return Status;
+ }
+
+ /* Set Handler, so the application specific processing can be
+ * performed for state change due to interrupt.
+ */
+ XScaler_SetCallBack(&ScalerInst,
+ (XScaler_CallBack)Handler, (void *)(&ScalerInst));
+
+// XScaler_SetCallBack(&ScalerInst, 5,
+// (XScaler_CallBack)Handler, (void *)(&ScalerInst));
+
+
+ /* Enable interrupts for the device. */
+ XScaler_IntrEnable(&ScalerInst);
+
+ /* Disable interrupts for the device. */
+ XScaler_IntrDisable(&ScalerInst);
+
+ /* IntrMask = ;*/
+
+ return (CT_GetTestFailures());
+}
+
+/*****************************************************************************/
+/**
+*
+* This function handles application specific processing for the interrupt.
+*
+* @param CallBackRef pointer to the provided argument.
+* @param Event is event that triggered the interrupt.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+void Handler(void *CallBackRef, u32 Event)
+{
+ xil_printf("Scaler Intr\n");
+
+ /* Implement what you want to after interrupt */
+}
diff --git a/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_main.c b/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_main.c
new file mode 100755
index 00000000..07f2f29d
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/scaler/intgtest/scaler_intg_main.c
@@ -0,0 +1,310 @@
+/******************************************************************************
+*
+* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS"
+* AS A COURTESY TO YOU, SOLELY FOR USE IN DEVELOPING PROGRAMS AND
+* SOLUTIONS FOR XILINX DEVICES. BY PROVIDING THIS DESIGN, CODE,
+* OR INFORMATION AS ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE,
+* APPLICATION OR STANDARD, XILINX IS MAKING NO REPRESENTATION
+* THAT THIS IMPLEMENTATION IS FREE FROM ANY CLAIMS OF INFRINGEMENT,
+* AND YOU ARE RESPONSIBLE FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE
+* FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY DISCLAIMS ANY
+* WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE
+* IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR
+* REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF
+* INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE.
+*
+* (c) Copyright 2014 Xilinx Inc.
+* All rights reserved.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+* @file scaler_intg_main.c
+*
+* This file contains the integration test functions for the SCALER device.
+*
+* This file contains a list of functions providing the menu driven test
+* functionality for various integration tests.
+*
+* @note None
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ------------------------------------------------
+* 7.0 adk 22/08/14 First release.
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "scaler_intgtest.h"
+#include
+
+/************************** Constant Definitions *****************************/
+
+
+/************************** Constant Definitions *****************************/
+
+/*
+ * Main menu selections.
+ */
+#define MENU_MAIN_TEST 1 /**