/******************************************************************************
*
* 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.
*
* <pre>
*
* MODIFICATION HISTORY:
*
* Ver Who Date Changes
* ----- ------ -------- ---------------------------------------------
* 7.0 adk 22/08/14 First release.
* </pre>
*
******************************************************************************/
/***************************** 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:
*
* <pre>
* 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)
* </pre>
*
* @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(<type>, 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());
}