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; }