static int response_la_do_data(struct http_state *http)
{
struct response_la_priv_s *priv = http->response_priv;
if (priv->command != 2)
{
httpd_put_sendbuffer_string(http, "OK\n");
return 0;
}
int av = httpd_available_sendbuffer(http);
if (!av)
return 1;
if (av > (priv->size - priv->ptr))
av = priv->size - priv->ptr;
if (av > priv->len)
av = priv->len;
while (av)
{
int maxread = 1024;
if (maxread > av)
maxread = av;
microblaze_init_dcache_range((int)(priv->ptr + priv->base), maxread);
hdprintf("sending %08x..%08x, len %08x, size %08x\n", priv->ptr, priv->ptr+maxread, priv->len, priv->size);
httpd_put_sendbuffer(http, (void*)(priv->ptr + priv->base), maxread);
priv->ptr += maxread;
priv->len -= maxread;
av -= maxread;
}
if (priv->ptr == priv->size)
{
/* wrap */
priv->ptr = 0;
}
if (!priv->len)
return 0;
return 1;
}
int main(int argc, char *argv[])
{
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE);
microblaze_enable_icache();
#endif
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
microblaze_enable_dcache();
#endif
rows imago;
int crom_flag,i,j,lvl,temprows,tempblocks,offset[]={0,4,32,36},simb,size;
int luminance_table[]={16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 56, 68, 109, 103, 77,
24, 35, 55, 64, 81, 104, 113, 92,
49, 64, 78, 87, 103, 121, 120, 101,
72, 92, 95, 98, 112, 100, 103, 99};
int crominance_table[]={17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,};
int lum_tab_corr[64], crom_tab_corr[64];
info infoimago;
int_rows intimago;
huffman_tab tbl_dclum, tbl_aclum, tbl_dccrom, tbl_accrom;
FILE *file_in, *file_out;
unsigned char buffer,field_free_space=8;
buffer = 0x0; //UCCIDI UCCIDI UCCIDI
/*
xil_printf("\n\rINIZIO COMPRESSIONE!!!");
*/
if (argc > 1)
{
file_in=fopen(argv[1],"r");
}
else
file_in=fopen("./software/apps/jpeg/img.ppm","r"); //binario?
if (!file_in) return(0);
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
imago=rdppm(&infoimago, file_in);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rlettura file: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
if (imago==NULL) return(0);
fclose(file_in);
intimago=(p_intblock *) malloc (infoimago.numrows*sizeof(p_intblock));
for (i=0;i<infoimago.numrows;i++)
*(intimago+i)=(intblock *) malloc (infoimago.numblocks*sizeof(intblock));
if (infoimago.color==1)
{
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
RGBtoYUV(&(*(imago+i)+j)->comp1[0],&(*(imago+i)+j)->comp2[0],&(*(imago+i)+j)->comp3[0]);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rrgb to yuv: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
}
if (infoimago.color==1)
{
rows tempimago;
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
tempimago=expand_image(imago,infoimago.numrows,infoimago.numblocks,&temprows,&tempblocks);
for (i=0;i<temprows;i++)
for (j=0;j<tempblocks;j++)
downsample((*(tempimago+i)+j),(*(imago+i/2)+j/2),offset[j%2+(i%2)*2]);
for (i=0;i<temprows;i++)
free(*(tempimago+i));
free(tempimago);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rdownsample e espandsione: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
}
lvl= 80;
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
set_quantization_tbl(lvl, &luminance_table[0]);
set_quantization_tbl(lvl, &crominance_table[0]);
correct_quantization_tbl(luminance_table, lum_tab_corr);
correct_quantization_tbl(crominance_table, crom_tab_corr);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rrset quantization table: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
{
if ((infoimago.color==1)&&(i<temprows/2)&&(j<tempblocks/2)) crom_flag=1;
else crom_flag=0;
DCT_and_quantization(*(imago+i)+j,lum_tab_corr,crom_tab_corr,*(intimago+i)+j,crom_flag);
}
for (i=0;i<infoimago.numrows;i++)
free(*(imago+i));
free(imago);
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
arrange(*(intimago+i)+j);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rdct and quantization: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
//Avvio del timer
/*XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
initialize_huff_tbl(&tbl_dclum,0);
initialize_huff_tbl(&tbl_aclum,16);
initialize_huff_tbl(&tbl_dccrom,1);
initialize_huff_tbl(&tbl_accrom,17);
arrange_table(&luminance_table[0]);
arrange_table(&crominance_table[0]);
if (argc > 2)
file_out=fopen(argv[2],"w");
else
file_out=fopen("img_out.jpg","w"); //binario??
writeheaders (file_out, infoimago, &luminance_table[0], &crominance_table[0],
tbl_aclum,tbl_accrom,tbl_dclum,tbl_dccrom);
if (infoimago.color==1)
{
int oldlum=0, oldcrom1=0, oldcrom2=0;
for (i=0;i<infoimago.numrows;i+=2)
for (j=0;j<infoimago.numblocks;j+=2)
{
writescan(oldlum,(*(intimago+i)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
if ((j+1)<infoimago.numblocks)
{
writescan((*(intimago+i)+j)->intcomp1[0],(*(intimago+i)+j+1)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
if ((i+1)<infoimago.numrows)
{
writescan((*(intimago+i)+j+1)->intcomp1[0],(*(intimago+i+1)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
writescan((*(intimago+i+1)+j)->intcomp1[0],(*(intimago+i+1)+j+1)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
oldlum=(*(intimago+i+1)+j+1)->intcomp1[0];
}
else
{
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
oldlum=(*(intimago+i)+j+1)->intcomp1[0];
}
}
else
{
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
if ((i+1)<infoimago.numrows)
{
writescan((*(intimago+i)+j)->intcomp1[0],(*(intimago+i+1)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
oldlum=(*(intimago+i+1)+j)->intcomp1[0];
}
else
{
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
}
}
writescan(oldcrom1,(*(intimago+i/2)+j/2)->intcomp2,&field_free_space,&buffer,file_out,tbl_accrom,tbl_dccrom,infoimago);
writescan(oldcrom2,(*(intimago+i/2)+j/2)->intcomp3,&field_free_space,&buffer,file_out,tbl_accrom,tbl_dccrom,infoimago);
oldcrom1=(*(intimago+i/2)+j/2)->intcomp2[0];
oldcrom2=(*(intimago+i/2)+j/2)->intcomp3[0];
}
}
else
{
int oldlum=0;
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
{
writescan(oldlum,(*(intimago+i)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
oldlum=(*(intimago+i)+j)->intcomp1[0];
}
}
write_end_of_image(file_out);
fclose(file_out);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rcodifiche entropiche: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
xil_printf("\n\rFINE COMPRESSIONE!!!");
*/
return 0;
}
/**
*
* This function gets the calibration value.
*
* @param InstancePtr is a pointer to an XMpmc instance to be worked on.
*
* @return XST_SUCCESS if the DCM Phase shift decrement is completed
* else XST_FAILURE.
*
* @note None.
*
*****************************************************************************/
int MpmcGetCalibrate(XMpmc *InstancePtr, u32 MemoryStartAddr,
MpmcCalibReturnValue *CalibStatus)
{
int Count;
MpmcCalibValue LocalCalibValue;
int ValidCount;
u32 RegValue;
u8 Toggle = 0;
u32 Status;
LocalCalibValue.FoundValid = FALSE;
RegValue = MPMC_RDEN_DELAY_MIN_VAL;
/*
* Get the initial value from the register.
*/
LocalCalibValue.OrigTapValue = XMpmc_GetStaticPhyReg(InstancePtr) &
XMPMC_SPIR_DCM_TAP_VALUE_MASK;
if (LocalCalibValue.OrigTapValue > MPMC_MAX_TAPS) {
LocalCalibValue.OrigTapValue =
LocalCalibValue.OrigTapValue - 0x100;
}
/*
* Try to find valid calibration settings.
*/
while (LocalCalibValue.FoundValid == FALSE) {
LocalCalibValue.MinValue = MPMC_MAX_TAPS - 1;
LocalCalibValue.MaxValue = MPMC_MIN_TAPS + 1;
/*
* Reset DCM to minimum value
*/
Status = MpmcResetDcmPhaseShift(InstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read the memory and check that data versus the expected
* value.
*
* If the value matches, read the current calibration value.
* Repeat this to ensure that this is not on a transition.
* If the value is incorrect in any of these increments, the
* value must be re-established.
*
* If the value at 0 does match then we are probably in a case
* where the window is a wrap case. This means that we are
* looking for the upper bound not the lower bound.
*/
ValidCount = 0;
for (Count = MPMC_MIN_TAPS; Count < MPMC_MAX_TAPS; Count++) {
MpmcWriteTestPattern(MemoryStartAddr, Toggle);
if (MpmcCheckPattern(MemoryStartAddr, Toggle) !=
XST_SUCCESS) {
/*
* Found invalid calibration setting.
*/
if (ValidCount > MPMC_EDGE_TAPS) {
LocalCalibValue.MaxValue = Count;
}
ValidCount = 0;
} else {
/*
* Found valid calibration setting
* Check to make sure that cache reads work.
*/
#ifdef __MICROBLAZE__
#if XPAR_MICROBLAZE_0_USE_DCACHE
/*
* Initialize and Enable the data cache.
*/
microblaze_init_dcache_range(0,
XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
microblaze_enable_dcache();
#endif
#endif
#ifdef __PPC__
/*
* Enable the Dcache for all memory regions
* except the boot region of the PPC.
*/
XCache_InvalidateDCacheLine(MemoryStartAddr);
XCache_EnableDCache(0xFFFFFFFE);
#endif
Status = MpmcCheckPattern(MemoryStartAddr,
Toggle);
/*
* Disable and reinitialize the data cache.
*/
#ifdef __MICROBLAZE__
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_disable_dcache();
microblaze_init_dcache_range(0,
XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
#endif
#endif
#ifdef __PPC__
XCache_DisableDCache();
XCache_InvalidateDCacheLine(MemoryStartAddr);
#endif
if (Status != XST_SUCCESS) {
/*
* Found invalid calibration setting
*/
if (ValidCount > MPMC_EDGE_TAPS) {
LocalCalibValue.MaxValue =
Count;
}
ValidCount = 0;
} else {
/*
* Found valid calibration setting
*/
if (ValidCount == MPMC_EDGE_TAPS) {
LocalCalibValue.MinValue =
Count - MPMC_EDGE_TAPS;
LocalCalibValue.MaxValue =
Count;
}
else if (ValidCount > MPMC_EDGE_TAPS) {
LocalCalibValue.MaxValue =
Count;
}
ValidCount++;
if (ValidCount>MPMC_EDGE_TAPS) {
LocalCalibValue.FoundValid =
TRUE;
}
}
}
Status = MpmcIncDcmPhaseShift(InstancePtr, RegValue);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
if (Toggle == 0) {
Toggle = 1;
} else {
Toggle = 0;
}
}
if ((LocalCalibValue.FoundValid == FALSE) &&
(((RegValue & XMPMC_SPIR_RDEN_DELAY_MASK)
!= MPMC_RDEN_DELAY_MAX_VAL) ||
((RegValue & XMPMC_SPIR_RDDATA_CLK_SEL_MASK) !=
XMPMC_SPIR_RDDATA_CLK_SEL_MASK) ||
((RegValue & XMPMC_SPIR_RDDATA_SWAP_RISE_MASK) !=
XMPMC_SPIR_RDDATA_SWAP_RISE_MASK))){
if ((RegValue & XMPMC_SPIR_RDEN_DELAY_MASK) !=
MPMC_RDEN_DELAY_MAX_VAL) {
RegValue = RegValue + MPMC_RDEN_DELAY_INC;
}
else if ((RegValue & XMPMC_SPIR_RDDATA_CLK_SEL_MASK) !=
XMPMC_SPIR_RDDATA_CLK_SEL_MASK) {
RegValue =
(RegValue |
XMPMC_SPIR_RDEN_DELAY_MASK) -
XMPMC_SPIR_RDEN_DELAY_MASK +
MPMC_RDEN_DELAY_MIN_VAL +
XMPMC_SPIR_RDDATA_CLK_SEL_MASK;
}
else if ((RegValue & XMPMC_SPIR_RDDATA_SWAP_RISE_MASK)
!=
XMPMC_SPIR_RDDATA_SWAP_RISE_MASK) {
RegValue =
(RegValue |
XMPMC_SPIR_RDEN_DELAY_MASK) -
XMPMC_SPIR_RDEN_DELAY_MASK +
MPMC_RDEN_DELAY_MIN_VAL -
XMPMC_SPIR_RDDATA_CLK_SEL_MASK +
XMPMC_SPIR_RDDATA_SWAP_RISE_MASK;
}
} else if (LocalCalibValue.FoundValid == FALSE) {
xil_printf("\r\n ERROR: Could not calibrate.\r\n");
return XST_FAILURE;
}
}
CalibStatus->FoundValid = LocalCalibValue.FoundValid;
CalibStatus->MinValue = LocalCalibValue.MinValue;
CalibStatus->MaxValue = LocalCalibValue.MaxValue;
CalibStatus->RegValue = RegValue;
if (LocalCalibValue.MaxValue >= LocalCalibValue.MinValue) {
CalibStatus->CalibTapValue = (LocalCalibValue.MinValue +
LocalCalibValue.MaxValue)/2;
} else {
CalibStatus->CalibTapValue = (LocalCalibValue.MinValue +
LocalCalibValue.MaxValue +
MPMC_NUMBER_TAPS)/2;
if (CalibStatus->CalibTapValue > MPMC_MAX_TAPS) {
CalibStatus->CalibTapValue =
(CalibStatus->CalibTapValue - MPMC_NUMBER_TAPS);
}
}
return XST_SUCCESS;
}
/**
*
* The purpose of this function is to illustrate how to use the MPMC
* driver for the Calibration of the Static Phy.
*
* @param DeviceId is device ID of the XMpmc Device, typically
* XPAR_<MPMC_instance>_DEVICE_ID value from xparameters.h.
*
* @return XST_SUCCESS to indicate success, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
int MpmcCalibrationExample(u16 DeviceId)
{
XMpmc_Config *CfgPtr;
int Status;
MpmcCalibReturnValue CalibStatus;
/*
* Disable the data cache and reinitialize it.
*/
#ifdef __MICROBLAZE__
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_disable_dcache();
microblaze_init_dcache_range(0,
XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
#endif
#endif
#ifdef __PPC__
XCache_DisableDCache();
XCache_InvalidateDCacheLine(MPMC_CALIBRATON_STARTADDR);
#endif
//xil_printf("\r\n Starting the Calibration Example \n\n");
/*
* Initialize the MPMC device.
*/
CfgPtr = XMpmc_LookupConfig(DeviceId);
if (CfgPtr == XNULL) {
return XST_FAILURE;
}
Status = XMpmc_CfgInitialize(&Mpmc, CfgPtr, CfgPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait for the initial initialization sequence to be complete.
*/
while ((XMpmc_GetStaticPhyReg(&Mpmc) & XMPMC_SPIR_INIT_DONE_MASK) !=
XMPMC_SPIR_INIT_DONE_MASK);
/*
* Begin Calibration.
*/
Status = MpmcGetCalibrate(&Mpmc, MPMC_CALIBRATON_STARTADDR,
&CalibStatus);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the calibrated value in the Static Phy Register.
*/
if (CalibStatus.FoundValid == TRUE) {
/*
xil_printf("\r Setting the phase shift to %0d. ",
CalibStatus.CalibTapValue);
xil_printf("Min Value = %d. Max Value = %d.\r\n",
CalibStatus.MinValue,
CalibStatus.MaxValue);
*/
MpmcSetCalibrate(&Mpmc, CalibStatus.CalibTapValue,
CalibStatus.RegValue);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
}
//xil_printf("\r\n Calibration is Successful \r\n");
return XST_SUCCESS;
}
int main (void) {
static XIntc intc;
/*
* Enable and initialize cache
*/
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE);
microblaze_enable_icache();
#endif
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
microblaze_enable_dcache();
#endif
static XEmacLite Ethernet_MAC_EmacLite;
print("-- Entering main() --\r\n");
{
XStatus status;
print("\r\n Runnning IntcSelfTestExample() for xps_intc_0...\r\n");
status = IntcSelfTestExample(XPAR_XPS_INTC_0_DEVICE_ID);
if (status == 0) {
print("IntcSelfTestExample PASSED\r\n");
}
else {
print("IntcSelfTestExample FAILED\r\n");
}
}
{
XStatus Status;
Status = IntcInterruptSetup(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
if (Status == 0) {
print("Intc Interrupt Setup PASSED\r\n");
}
else {
print("Intc Interrupt Setup FAILED\r\n");
}
}
/*
* Peripheral SelfTest will not be run for RS232_Uart_1
* because it has been selected as the STDOUT device
*/
{
Xuint32 status;
print("\r\nRunning GpioOutputExample() for LEDs_8Bit...\r\n");
status = GpioOutputExample(XPAR_LEDS_8BIT_DEVICE_ID,8);
if (status == 0) {
print("GpioOutputExample PASSED.\r\n");
}
else {
print("GpioOutputExample FAILED.\r\n");
}
}
{
XStatus status;
print("\r\nRunning EMACLiteSelfTestExample() for Ethernet_MAC...\r\n");
status = EMACLiteSelfTestExample(XPAR_ETHERNET_MAC_DEVICE_ID);
if (status == 0) {
print("EMACLiteSelfTestExample PASSED\r\n");
}
else {
print("EMACLiteSelfTestExample FAILED\r\n");
}
}
{
XStatus Status;
print("\r\n Running Interrupt Test for Ethernet_MAC...\r\n");
Status = EmacLiteExample(&intc, &Ethernet_MAC_EmacLite, \
XPAR_ETHERNET_MAC_DEVICE_ID, \
XPAR_XPS_INTC_0_ETHERNET_MAC_IP2INTC_IRPT_INTR);
if (Status == 0) {
print("EmacLite Interrupt Test PASSED\r\n");
}
else {
print("EmacLite Interrupt Test FAILED\r\n");
}
}
{
XStatus status;
print("\r\n Running TmrCtrSelfTestExample() for xps_timer_1...\r\n");
status = TmrCtrSelfTestExample(XPAR_XPS_TIMER_1_DEVICE_ID, 0x0);
if (status == 0) {
print("TmrCtrSelfTestExample PASSED\r\n");
}
else {
print("TmrCtrSelfTestExample FAILED\r\n");
}
}
{
XStatus status;
print("\r\nRunning UartLiteSelfTestExample() for debug_module...\r\n");
status = UartLiteSelfTestExample(XPAR_DEBUG_MODULE_DEVICE_ID);
if (status == 0) {
print("UartLiteSelfTestExample PASSED\r\n");
}
else {
print("UartLiteSelfTestExample FAILED\r\n");
}
}
/*
* Disable cache and reinitialize it so that other
* applications can be run with no problems
*/
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_disable_dcache();
microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
#endif
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_disable_icache();
microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE);
#endif
print("-- Exiting main() --\r\n");
return 0;
}
