/* * * This function setups the interrupt system so interrupts can occur for the * DMA. This function assumes INTC component exists in the hardware system. * * @param AxiDmaPtr is a pointer to the instance of the DMA engine * @param ReadIntrId is the read channel Interrupt ID. * @param WriteIntrId is the write channel Interrupt ID. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ static int SetupIntrSystem(XAxiVdma *AxiVdmaPtr, u16 ReadIntrId, u16 WriteIntrId) { int Status; XIntc *IntcInstancePtr =&Intc; /* Initialize the interrupt controller and connect the ISRs */ Status = XIntc_Initialize(IntcInstancePtr, XPAR_INTC_0_DEVICE_ID); if (Status != XST_SUCCESS) { xil_printf( "Failed init intc\r\n"); return XST_FAILURE; } Status = XIntc_Connect(IntcInstancePtr, ReadIntrId, (XInterruptHandler)XAxiVdma_ReadIntrHandler, AxiVdmaPtr); if (Status != XST_SUCCESS) { xil_printf("Failed read channel connect intc %d\r\n", Status); return XST_FAILURE; } Status = XIntc_Connect(IntcInstancePtr, WriteIntrId, (XInterruptHandler)XAxiVdma_WriteIntrHandler, AxiVdmaPtr); if (Status != XST_SUCCESS) { xil_printf("Failed write channel connect intc %d\r\n", Status); return XST_FAILURE; } /* Start the interrupt controller */ Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { xil_printf( "Failed to start intc\r\n"); return XST_FAILURE; } /* Enable interrupts from the hardware */ XIntc_Enable(IntcInstancePtr, ReadIntrId); XIntc_Enable(IntcInstancePtr, WriteIntrId); Xil_ExceptionInit(); Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_InterruptHandler, (void *)IntcInstancePtr); Xil_ExceptionEnable(); /* Register call-back functions */ XAxiVdma_SetCallBack(AxiVdmaPtr, XAXIVDMA_HANDLER_GENERAL, ReadCallBack, (void *)AxiVdmaPtr, XAXIVDMA_READ); XAxiVdma_SetCallBack(AxiVdmaPtr, XAXIVDMA_HANDLER_ERROR, ReadErrorCallBack, (void *)AxiVdmaPtr, XAXIVDMA_READ); XAxiVdma_SetCallBack(AxiVdmaPtr, XAXIVDMA_HANDLER_GENERAL, WriteCallBack, (void *)AxiVdmaPtr, XAXIVDMA_WRITE); XAxiVdma_SetCallBack(AxiVdmaPtr, XAXIVDMA_HANDLER_ERROR, WriteErrorCallBack, (void *)AxiVdmaPtr, XAXIVDMA_WRITE); return XST_SUCCESS; }
int TmrCtrIntr(XIntc * IntcInstancePtr, XTmrCtr * TmrCtrInstancePtr, u16 DeviceID, u16 IntrID, u8 TmrCtrNumber){ int Status; /*连接一个设备句柄,当识别中断后,与中断源相关的句柄将运行。IntcInstancePtr为中断控制器, IntrID为定时器的中断号,XTmrCtr_InterruptHandler为中断的句柄,TmrCtrInstancePtr为回调参数。*/ Status = XIntc_Connect(IntcInstancePtr, IntrID, (XInterruptHandler)XTmrCtr_InterruptHandler, (void *)TmrCtrInstancePtr); if(Status != XST_SUCCESS) return XST_FAILURE; //启动中断控制器 Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if(Status != XST_SUCCESS) return XST_FAILURE; //使能中断 XIntc_Enable(IntcInstancePtr, IntrID); //允许处理器处理中断 microblaze_enable_interrupts(); if(Status != XST_SUCCESS) return XST_FAILURE; //设定用于定时器的句柄 XTmrCtr_SetHandler(TmrCtrInstancePtr, timer_int_handler, TmrCtrInstancePtr); //设置定时器选项 XTmrCtr_SetOptions(TmrCtrInstancePtr, TmrCtrNumber, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION); //设置定时器计数的周期数加到1s(在50MHZ条件下) //中断为 = 0xFFFFFFFF - 0x2FAF080(=50000000) => 0xFD050F80 XTmrCtr_SetResetValue(TmrCtrInstancePtr, TmrCtrNumber, 0xFD050F80); //启动定时器 XTmrCtr_Start(TmrCtrInstancePtr, TmrCtrNumber); xil_printf("The value of count = %d\n\r", count); return XST_SUCCESS; }
XStatus InitInterruptController(INTC* intc) { int Status; // Start the interrupt controller #ifdef XPAR_INTC_0_DEVICE_ID // Initialize the driver instance RETURN_ON_FAILURE(XIntc_Initialize(intc, INTC_DEVICE_ID)); RETURN_ON_FAILURE(XIntc_Start(intc, XIN_REAL_MODE)); #else XScuGic_Config *GicConfig; GicConfig = XScuGic_LookupConfig(INTC_DEVICE_ID); XScuGic_CfgInitialize(intc, GicConfig, GicConfig->CpuBaseAddress); Status = XScuGic_SelfTest(intc); if (Status != XST_SUCCESS) { return XST_FAILURE; } #endif Xil_ExceptionInit(); /* * register the interrupt controller handler with the exception table. * This is in fact the ISR dispatch routine, calling our ISRs */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler) INTC_HANDLER, intc); Xil_ExceptionEnable(); return XST_SUCCESS; }
/***** * do_init() - initialize the system * * This function is executed once at start-up and after a reset. It initializes * the peripherals and registers the interrupt handlers *****/ XStatus do_init(void) { XStatus Status; // status from Xilinx Lib calls // initialize the N3EIF driver // rotary encoder is set to increment from 0 by 1 // NOTE: it's the relative change from the last time the rotary encoder was sampled // not the absolute change that matters. The actual change is handled in main() so we // can apply a "speedup" factor if the knob is being turned quickly. N3EIF_init(N3EIF_BASEADDR); ROT_init(1, false); ROT_clear(); // initialize the GPIO instance Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } // GPIO channel 1 is an 8-bit output port that your application can // use. None of the bits are used by this program XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xF0); XGpio_DiscreteWrite(&GPIOInst, GPIO_OUTPUT_CHANNEL, gpio_port); // initialize the PWM timer/counter instance but do not start it // do not enable PWM interrupts Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false); if (Status != XST_SUCCESS) { return XST_FAILURE; } // initialize the PmodCtlSys Status = PmodCtlSys_init(&SPIInst, SPI_DEVICEID); if (Status != XST_SUCCESS) { return XST_FAILURE; } // initialize the interrupt controller Status = XIntc_Initialize(&IntrptCtlrInst, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } // connect the fixed interval timer (FIT) handler to the interrupt Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID, (XInterruptHandler) FIT_Handler, (void *) 0); if (Status != XST_SUCCESS) { return XST_FAILURE; } // start the interrupt controller such that interrupts are enabled for // all devices that cause interrupts, specifically real mode so that // the the FIT can cause interrupts thru the interrupt controller. Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } // enable the FIT interrupt XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID); return XST_SUCCESS; }
int SetUpInterruptSystem(XIntc *XIntcInstancePtr) { int Status; Status = XIntc_Connect(XIntcInstancePtr, INTC_DEVICE_INT_ID, (XInterruptHandler)DeviceDriverHandler, (void *)0); if (Status != XST_SUCCESS) { return XST_FAILURE; } Status = XIntc_Start(XIntcInstancePtr, XIN_SIMULATION_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } XIntc_Enable(XIntcInstancePtr, INTC_DEVICE_INT_ID); Xil_ExceptionInit(); Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_InterruptHandler, XIntcInstancePtr); Xil_ExceptionEnable(); return XST_SUCCESS; }
void platform_setup_interrupts() { XIntc *intcp; intcp = &intc; XIntc_Initialize(intcp, XPAR_XPS_INTC_0_DEVICE_ID); XIntc_Start(intcp, XIN_REAL_MODE); /* Start the interrupt controller */ XIntc_MasterEnable(XPAR_XPS_INTC_0_BASEADDR); #ifdef __PPC__ Xil_ExceptionInit(); Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (XExceptionHandler)XIntc_DeviceInterruptHandler, (void*) XPAR_XPS_INTC_0_DEVICE_ID); #elif __MICROBLAZE__ microblaze_register_handler((XInterruptHandler)XIntc_InterruptHandler, intcp); #endif platform_setup_timer(); #ifdef XPAR_ETHERNET_MAC_IP2INTC_IRPT_MASK /* Enable timer and EMAC interrupts in the interrupt controller */ XIntc_EnableIntr(XPAR_XPS_INTC_0_BASEADDR, #ifdef __MICROBLAZE__ PLATFORM_TIMER_INTERRUPT_MASK | #endif XPAR_ETHERNET_MAC_IP2INTC_IRPT_MASK); #endif }
void init_interrupt_controller() { XIntc *intcp; intcp = &intc; XIntc_Initialize(intcp, XPAR_INTC_0_DEVICE_ID); XIntc_Start(intcp, XIN_REAL_MODE); // Démarrage du gestionnaire d'interruption XIntc_MasterEnable(XPAR_INTC_0_BASEADDR); microblaze_register_handler((XInterruptHandler)XIntc_InterruptHandler, intcp); // Configuration spécifique au core présent dans le système init_network_timer_int(); init_ps2_int(); init_sound_int(); init_display_timer_int(); XIntc_Enable(intcp, XPAR_XPS_INTC_0_XPS_TIMER_0_INTERRUPT_INTR); XIntc_Enable(intcp, XPAR_XPS_INTC_0_PS2CORE_0_PS2_INTERRUPT_INTR); XIntc_Enable(intcp, XPAR_XPS_INTC_0_PLB_AC97_0_INTERRUPT_INTR); XIntc_Enable(intcp, XPAR_INTC_0_LLTEMAC_0_VEC_ID); //XIntc_SetIntrSvcOption(XPAR_INTC_0_BASEADDR,/*XIN_SVC_ALL_ISRS_OPTION*/XIN_SVC_SGL_ISR_OPTION); }
void platform_setup_interrupts() { XIntc *intcp; intcp = &intc; XIntc_Initialize(intcp, XPAR_INTC_0_DEVICE_ID); XIntc_Start(intcp, XIN_REAL_MODE); platform_setup_timer(); /* * Initialize the exception table. */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler) XIntc_InterruptHandler, intcp); #ifdef XPAR_ETHERNET_MAC_IP2INTC_IRPT_MASK /* Enable timer and EMAC interrupts in the interrupt controller */ XIntc_EnableIntr(XPAR_XPS_INTC_0_BASEADDR, #ifdef __MICROBLAZE__ PLATFORM_TIMER_INTERRUPT_MASK | #endif XPAR_ETHERNET_MAC_IP2INTC_IRPT_MASK); #endif #ifdef XPAR_INTC_0_LLTEMAC_0_VEC_ID #ifdef __MICROBLAZE__ XIntc_Enable(intcp, PLATFORM_TIMER_INTERRUPT_INTR); #endif XIntc_Enable(intcp, XPAR_INTC_0_LLTEMAC_0_VEC_ID); #endif #ifdef XPAR_INTC_0_AXIETHERNET_0_VEC_ID XIntc_Enable(intcp, PLATFORM_TIMER_INTERRUPT_INTR); XIntc_Enable(intcp, XPAR_INTC_0_AXIETHERNET_0_VEC_ID); #endif #ifdef XPAR_INTC_0_EMACLITE_0_VEC_ID #ifdef __MICROBLAZE__ XIntc_Enable(intcp, PLATFORM_TIMER_INTERRUPT_INTR); #endif XIntc_Enable(intcp, XPAR_INTC_0_EMACLITE_0_VEC_ID); #endif }
void Initialize() { XGpio_Initialize(&Dips, XPAR_DIP_DEVICE_ID); XGpio_SetDataDirection(&Dips, 1, 0xff); XGpio_Initialize(&Btns, XPAR_BUTTON_DEVICE_ID); XGpio_SetDataDirection(&Btns, 1, 0xff); XIntc_Initialize(&intCtrl, XPAR_AXI_INTC_0_DEVICE_ID); XGpio_InterruptEnable(&Btns, 1); XGpio_InterruptGlobalEnable(&Btns); XGpio_InterruptEnable(&Dips, 1); XGpio_InterruptGlobalEnable(&Dips); XIntc_Enable(&intCtrl, XPAR_AXI_INTC_0_BUTTON_IP2INTC_IRPT_INTR); XIntc_Enable(&intCtrl, XPAR_AXI_INTC_0_DIP_IP2INTC_IRPT_INTR); XIntc_Connect(&intCtrl, XPAR_AXI_INTC_0_BUTTON_IP2INTC_IRPT_INTR, (XInterruptHandler)PushBtnHandler, (void *)0); XIntc_Connect(&intCtrl, XPAR_AXI_INTC_0_DIP_IP2INTC_IRPT_INTR, (XInterruptHandler)SwitchHandler,(void *)0); microblaze_enable_interrupts(); microblaze_register_handler((XInterruptHandler)XIntc_InterruptHandler, (void *)&intCtrl); XIntc_Start(&intCtrl, XIN_REAL_MODE); }
/** * * This function setups the interrupt system such that interrupts can occur * for IIC. This function is application specific since the actual system may * or may not have an interrupt controller. The IIC device could be directly * connected to a processor without an interrupt controller. The user should * modify this function to fit the application. * * @param IicPtr contains a pointer to the instance of the IIC component * which is going to be connected to the interrupt controller. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @notes None. * ****************************************************************************/ static int SetupInterruptSystem(XIic *IicPtr) { int Status; /* * Initialize the interrupt controller driver so that it's ready to use, * specify the device ID that is generated in xparameters.h */ Status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect a device driver handler that will be called when an interrupt * for the device occurs, the device driver handler performs the * specific interrupt processing for the device */ Status = XIntc_Connect(&InterruptController, INTC_IIC_INTERRUPT_ID, XIic_InterruptHandler, IicPtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Start the interrupt controller such that interrupts are recognized * and handled by the processor. */ Status = XIntc_Start(&InterruptController, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Enable the interrupts for the IIC device. */ XIntc_Enable(&InterruptController, INTC_IIC_INTERRUPT_ID); /* * Initialize the exception table. */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler) XIntc_InterruptHandler, &InterruptController); /* * Enable non-critical exceptions. */ Xil_ExceptionEnable(); return XST_SUCCESS; }
/** * * This function sets up the interrupt system such that interrupts can occur * for the USB. This function is application specific since the actual * system may or may not have an interrupt controller. The USB could be * directly connected to a processor without an interrupt controller. The * user should modify this function to fit the application. * * @param InstancePtr contains a pointer to the instance of the USB * component, which is going to be connected to the interrupt * controller. * * @return * - XST_SUCCESS if successful. * - XST_FAILURE. if it fails. * * @note None * *******************************************************************************/ static int SetupInterruptSystem(XUsb * InstancePtr) { int Status; /* * Initialize the interrupt controller driver. */ Status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect a device driver handler that will be called when an interrupt * for the USB device occurs. */ Status = XIntc_Connect(&InterruptController, USB_INTR, (XInterruptHandler) XUsb_IntrHandler, (void *) InstancePtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Start the interrupt controller such that interrupts are enabled for * all devices that cause interrupts, specific real mode so that * the USB can cause interrupts through the interrupt controller. */ Status = XIntc_Start(&InterruptController, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Enable the interrupt for the USB. */ XIntc_Enable(&InterruptController, USB_INTR); /* * Initialize the exception table */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_InterruptHandler, &InterruptController); /* * Enable non-critical exceptions */ Xil_ExceptionEnable(); return XST_SUCCESS; }
/* * * This function setups the interrupt system so interrupts can occur for the * DMA. This function assumes INTC component exists in the hardware system. * * @param AxiDmaPtr is a pointer to the instance of the DMA engine * @param ReadIntrId is the read channel Interrupt ID. * @param WriteIntrId is the write channel Interrupt ID. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ static int SetupIntrSystem(XAxiVdma *AxiVdmaPtr, u16 ReadIntrId, u16 WriteIntrId) { xil_printf("\r\nEnabling interrupts..."); int Status; XIntc *IntcInstancePtr = &Intc; /* Initialize the interrupt controller and connect the ISRs */ // Status = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID); // if (Status != XST_SUCCESS) { // // xil_printf( "Failed init intc\r\n"); // return XST_FAILURE; // } // Status = XIntc_Connect(IntcInstancePtr, ReadIntrId, // (XInterruptHandler)XAxiVdma_ReadIntrHandler, AxiVdmaPtr); // if (Status != XST_SUCCESS) { // // xil_printf( // "Failed read channel connect intc %d\r\n", Status); // return XST_FAILURE; // } Status = XIntc_Connect(IntcInstancePtr, WriteIntrId, (XInterruptHandler)XAxiVdma_WriteIntrHandler, AxiVdmaPtr); if (Status != XST_SUCCESS) { xil_printf( "Failed write channel connect intc %d\r\n", Status); return XST_FAILURE; } /* Start the interrupt controller */ Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { xil_printf( "Failed to start intc\r\n"); return XST_FAILURE; } /* Enable interrupts from the hardware */ // XIntc_Enable(IntcInstancePtr, ReadIntrId); XIntc_Enable(IntcInstancePtr, WriteIntrId); Xil_ExceptionInit(); Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_InterruptHandler, (void *)IntcInstancePtr); Xil_ExceptionEnable(); xil_printf("done"); return XST_SUCCESS; }
/***** * do_init() - initialize the system * * This function is executed once at start-up and after resets. It initializes * the peripherals and registers the interrupt handlers *****/ XStatus do_init(void) { XStatus Status; // status from Xilinx Lib calls // initialize the S3E starter board interface // rotary encoder is set to increment from 0 by DUTY_CYCLE_CHANGE N3EIF_init(N3EIF_BASEADDR); ROT_init(DUTY_CYCLE_CHANGE, true); ROT_clear(); // initialize the GPIO instance Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } // GPIO channel 1 is an 8-bit input port. bit[7:1] = reserved, bit[0] = PWM output (for duty cycle calculation) // GPIO channel 2 is an 8-bit output port. bit[7:1] = reserved, bit[0] = FIT clock XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xFE); // initialize the PWM timer/counter instance but do not start it // do not enable PWM interrupts Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false); if (Status != XST_SUCCESS) { return XST_FAILURE; } // initialize the interrupt controller Status = XIntc_Initialize(&IntrptCtlrInst,INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } // connect the fixed interval timer (FIT) handler to the interrupt Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID, (XInterruptHandler)FIT_Handler, (void *)0); if (Status != XST_SUCCESS) { return XST_FAILURE; } // start the interrupt controller such that interrupts are enabled for // all devices that cause interrupts. Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } // enable the FIT interrupt XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID); return XST_SUCCESS; }
void initButtonInterrupt(XIntc controller) { btnIntCtrl = controller; xil_printf("\r\nInitialising button interrupts..."); lBtnStateOld = 0x00000000; XGpio_Initialize(&pshBtns, BTNS_DEVICE_ID); XIntc_Connect(&controller, BTNS_IRPT_ID, PushBtnHandler, &pshBtns); XIntc_Enable(&controller, BTNS_IRPT_ID); microblaze_register_handler(XIntc_DeviceInterruptHandler, INTC_DEVICE_ID); microblaze_enable_interrupts(); XIntc_Start(&controller, XIN_REAL_MODE); xil_printf("done"); }
/** * * This function is used by the TestAppGen generated application to setup * the interrupt controller. * * @param IntcInstancePtr is the reference to the Interrupt Controller * instance. * @param DeviceId is device ID of the Interrupt Controller Device, * typically XPAR_<INTC_instance>_DEVICE_ID value from * xparameters.h. * * @return XST_SUCCESS to indicate success, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ int IntcInterruptSetup(XIntc *IntcInstancePtr, u16 DeviceId) { int Status; /* * Initialize the interrupt controller driver so that it is * ready to use. */ Status = XIntc_Initialize(IntcInstancePtr, DeviceId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Perform a self-test to ensure that the hardware was built correctly. */ Status = XIntc_SelfTest(IntcInstancePtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Initialize the exception table. */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_DeviceInterruptHandler, (void*) 0); /* * Enable exceptions. */ Xil_ExceptionEnable(); /* * Start the interrupt controller such that interrupts are enabled for * all devices that cause interrupts. */ Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } return XST_SUCCESS; }
int btn_method(){ XStatus Status= XST_SUCCESS; if(btn_initialize()!=XST_SUCCESS) return XST_FAILURE; Status = XIntc_Initialize(&intCtrl_Btn, INTC_DEVICE_ID); if ( Status != XST_SUCCESS ) { if( Status == XST_DEVICE_NOT_FOUND ) { xil_printf("Interrupt Controller: XST_DEVICE_NOT_FOUND...\r\n"); } else { xil_printf("Interrupt Controller: A different error from XST_DEVICE_NOT_FOUND...\r\n"); } xil_printf("Interrupt controller: driver failed to be initialized...\r\n"); return XST_FAILURE; } xil_printf("Interrupt controller: driver initialized!\r\n"); Status = XIntc_Connect(&intCtrl_Btn, BTN_IR_ID, btn_handler, &Btn); if ( Status != XST_SUCCESS ) { xil_printf("Failed to connect the application handlers to the interrupt controller...\r\n"); return XST_FAILURE; } xil_printf("Connected to Interrupt Controller!\r\n"); XIntc_Enable(&intCtrl_Btn, BTN_IR_ID); microblaze_register_handler((XInterruptHandler)XIntc_DeviceInterruptHandler,INTC_DEVICE_ID);//Because it is 0? microblaze_enable_interrupts(); XGpio_InterruptEnable(&Btn,BTN_IR_MASK); XGpio_InterruptGlobalEnable(&Btn); Status = XIntc_Start(&intCtrl_Btn, XIN_REAL_MODE); if (Status != XST_SUCCESS) { xil_printf("Failed to start the interrupt controller...\r\n"); return XST_FAILURE; } print("Interrupt controller Started!\n\r "); return XST_SUCCESS; }
/* * This function setups the interrupt system so interrupts can occur for the * IIC device. The function is application-specific since the actual system may * or may not have an interrupt controller. The IIC device could be directly * connected to a processor without an interrupt controller. The user should * modify this function to fit the application. * * @param IicInstPtr contains a pointer to the instance of the IIC device * which is going to be connected to the interrupt controller. * * @return XST_SUCCESS if successful else XST_FAILURE. * * @note None. */ int SetupInterruptSystem(XIic * IicInstPtr) { int Status; if (InterruptController.IsStarted == XIL_COMPONENT_IS_STARTED) { return XST_SUCCESS; } /* * Initialize the interrupt controller driver so that it's ready to use. */ Status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * 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 = XIntc_Connect(&InterruptController, IIC_INTR_ID, (XInterruptHandler) XIic_InterruptHandler, IicInstPtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Start the interrupt controller so interrupts are enabled for all * devices that cause interrupts. */ Status = XIntc_Start(&InterruptController, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Enable the interrupts for the IIC device. */ XIntc_Enable(&InterruptController, IIC_INTR_ID); /* * Enable the Microblaze Interrupts. */ microblaze_enable_interrupts(); return XST_SUCCESS; }
//*************************************************************** //******************* INTERRUPT FUNCTIONS *********************** //*************************************************************** void Interrupt_Init(void) { //PUSH BUTTON INTERRUPT /* Code */ XIntc_Initialize(&Intc, INTC_DEVICE_ID); XGpio_Initialize(&Gpio, GPIO_DEVICE_ID); XIntc_Connect(&Intc, INTR_ID, GpioIsr, &Gpio); /* Buttons are all inputs */ XGpio_SetDataDirection(&Gpio, BUTTON_CHANNEL, GPIO_ALL_BUTTONS); XGpio_InterruptEnable(&Gpio, BUTTON_INTERRUPT); XGpio_InterruptGlobalEnable(&Gpio); /* Enable the Interrupt vector at the interrupt controller */ XIntc_Enable(&Intc, INTR_ID); XExc_Init(); /***************************************************************** * Initialize the PPC405 exception table and register the interrupt * controller handler with the exception table ******************************************************************/ XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT, (XExceptionHandler)XIntc_InterruptHandler, &Intc); /* Now Register Timer Interrupt */ XExc_RegisterHandler(XEXC_ID_PIT_INT, (XExceptionHandler)TimerIsr, (void *)0); /* Enable non-critical exceptions in the PowerPC */ XExc_mEnableExceptions(XEXC_NON_CRITICAL); /******************************************************************* * Start the interrput controller such that interrupts are recognized * and handled by the processor. ********************************************************************/ XIntc_Start(&Intc, XIN_REAL_MODE); //TIMER INTERRUPT /* Set Timer Interval (1 Sec) */ XTime_PITSetInterval(0x0F000000); /* Automatically Restarts Timer */ XTime_PITEnableAutoReload(); /* Clear Timer Reg */ XTime_TSRClearStatusBits(XREG_TSR_CLEAR_ALL); /* Clear Queued Timer Interrupts */ XTime_PITClearInterrupt(); /* Enable Interrupt */ XTime_PITEnableInterrupt(); }
void RxIntrHandler(void *Callback){ XAxiDma_BdRing *RxRingPtr = (XAxiDma_BdRing *) Callback; u32 IrqStatus; XIntc_Stop(Intc_ptr); IrqStatus = XAxiDma_BdRingGetIrq(RxRingPtr); XAxiDma_BdRingAckIrq(RxRingPtr, IrqStatus); if ((IrqStatus & (XAXIDMA_IRQ_DELAY_MASK | XAXIDMA_IRQ_IOC_MASK))) { wlan_poll_eth(); } XIntc_Start(Intc_ptr, XIN_REAL_MODE); return; }
void vPortSetupInterruptController( void ) { extern void vPortISRWrapper( void ); /* Perform all library calls necessary to initialise the exception table and interrupt controller. This assumes only one interrupt controller is in use. */ XExc_mDisableExceptions( XEXC_NON_CRITICAL ); XExc_Init(); /* The library functions save the context - we then jump to a wrapper to save the stack into the TCB. The wrapper then calls the handler defined above. */ XExc_RegisterHandler( XEXC_ID_NON_CRITICAL_INT, ( XExceptionHandler ) vPortISRWrapper, NULL ); XIntc_Initialize( &xInterruptController, XPAR_XPS_INTC_0_DEVICE_ID ); XIntc_Start( &xInterruptController, XIN_REAL_MODE ); }
/** * * This function setups the interrupt system such that interrupts can occur * for the Spi device. This function is application specific since the actual * system may or may not have an interrupt controller. The Spi device could be * directly connected to a processor without an interrupt controller. The * user should modify this function to fit the application. * * @param IntcInstancePtr is a pointer to the instance of the Intc device. * @param SpiInstancePtr is a pointer to the instance of the Spi device. * @param SpiIntrId is the interrupt Id and is typically * XPAR_<INTC_instance>_<SPI_instance>_VEC_ID value from * xparameters.h * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note None * ******************************************************************************/ static int SpiSetupIntrSystem(XIntc *IntcInstancePtr, XSpi *SpiInstancePtr, u16 SpiIntrId) { int Status; /* * Initialize the interrupt controller driver so that it is ready to * use. */ Status = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { xil_printf("Could not initialize interrupt controller.\n"); return XST_FAILURE; } /* * Connect a device driver handler that will be called when an interrupt * for the device occurs, the device driver handler performs the * specific interrupt processing for the device. */ Status = XIntc_Connect(IntcInstancePtr, SpiIntrId, (XInterruptHandler) XSpi_InterruptHandler, (void *)SpiInstancePtr); if (Status != XST_SUCCESS) { xil_printf("Could not connect interrupt controller to SPI.\n"); return XST_FAILURE; } /* * Start the interrupt controller such that interrupts are enabled for * all devices that cause interrupts, specific real mode so that * the SPI can cause interrupts through the interrupt controller. */ Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { xil_printf("Could not enable interrupts.\n"); return XST_FAILURE; } /* * Enable the interrupt for the SPI device. */ XIntc_Enable(IntcInstancePtr, SpiIntrId); return XST_SUCCESS; }
void enable_interrupt_controller() { /* * Initialize the exception table */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XScuGic_InterruptHandler, &m_gic); /* * Enable non-critical exceptions */ Xil_ExceptionEnable(); /* Start axi interrupt controller */ XIntc_Start(&m_axi_intc, XIN_REAL_MODE); }
XStatus fnInitInterruptController(intc *psIntc) { int result = 0; #ifdef XPAR_XINTC_NUM_INSTANCES // Init driver instance RETURN_ON_FAILURE(XIntc_Initialize(psIntc, INTC_DEVICE_ID)); // Start interrupt controller RETURN_ON_FAILURE(XIntc_Start(psIntc, XIN_REAL_MODE)); Xil_ExceptionInit(); // Register the interrupt controller handler with the exception table. // This is in fact the ISR dispatch routine, which calls our ISRs Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_InterruptHandler, psIntc); #endif #ifdef XPAR_SCUGIC_0_DEVICE_ID 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; } result = XScuGic_CfgInitialize(psIntc, IntcConfig, IntcConfig->CpuBaseAddress); if (result != XST_SUCCESS) { return XST_FAILURE; } #endif //Xil_ExceptionEnable(); return XST_SUCCESS; }
static int32_t prvInitialiseInterruptController( void ) { int32_t lStatus; lStatus = XIntc_Initialize( &xInterruptControllerInstance, configINTERRUPT_CONTROLLER_TO_USE ); if( lStatus == XST_SUCCESS ) { /* Initialise the exception table. */ Xil_ExceptionInit(); /* Service all pending interrupts each time the handler is entered. */ XIntc_SetIntrSvcOption( xInterruptControllerInstance.BaseAddress, XIN_SVC_ALL_ISRS_OPTION ); /* Install exception handlers if the MicroBlaze is configured to handle exceptions, and the application defined constant configINSTALL_EXCEPTION_HANDLERS is set to 1. */ #if ( MICROBLAZE_EXCEPTIONS_ENABLED == 1 ) && ( configINSTALL_EXCEPTION_HANDLERS == 1 ) { vPortExceptionsInstallHandlers(); } #endif /* MICROBLAZE_EXCEPTIONS_ENABLED */ /* Start the interrupt controller. Interrupts are enabled when the scheduler starts. */ lStatus = XIntc_Start( &xInterruptControllerInstance, XIN_REAL_MODE ); if( lStatus == XST_SUCCESS ) { lStatus = pdPASS; } else { lStatus = pdFAIL; } } configASSERT( lStatus == pdPASS ); return lStatus; }
//----------------------------------------------------------------------------------------------------// // @func - int_system_init //! @desc //! Initialize PPC405 interrupt handling system in the prescence of an interrupt controller. //! @param //! - none //! @return //! - nothing //! @note //! - none //----------------------------------------------------------------------------------------------------// void int_system_init (void) { XStatus status; status = XIntc_Initialize (&sys_intc, SYSINTC_DEVICE_ID); if (status != XST_SUCCESS) { DBG_PRINT ("XMK: init_int_system: XIntc_Initialize failed.\r\n"); return; } XIntc_SetIntrSvcOption(SYSINTC_BASEADDR, XIN_SVC_ALL_ISRS_OPTION); // IntC ISR should service all interrupts Xil_ExceptionRegisterHandler (XIL_EXCEPTION_ID_NON_CRITICAL_INT, // Now tie the INTC's interrupt handler to the PPC Non-Critical Interrupt Handler (Xil_ExceptionHandler)XIntc_DeviceInterruptHandler, (void*)SYSINTC_DEVICE_ID); status = XIntc_Start (&sys_intc, XIN_REAL_MODE); // Start the interrupt controller if (status != XST_SUCCESS) { DBG_PRINT ("XMK: init_int_system: XIntc_Start failed.\r\n"); return; } }
//Add a new IP to the Interrupt controller void Interrupt_Config(XIntc *InstancePtr, u16 DeviceId) { Xuint32 IntMasc; int Status; if (InstancePtr->IsReady == 0) { Status = XIntc_Initialize(InstancePtr, DeviceId); if (Status != XST_SUCCESS) { xil_printf("Interruptions Initialization Fail \n\r"); } } u32 dir; //Interrupts Connected Status = XIntc_Connect(InstancePtr, 1,(XInterruptHandler) Interrupt_coreA_HW, (void *)dir); Status = XIntc_Connect(InstancePtr, 2,(XInterruptHandler) Interrupt_coreC_HW, (void *)dir); Status = XIntc_Connect(InstancePtr, 3,(XInterruptHandler) Interrupt_coreD_HW, (void *)dir); Status = XIntc_Connect(InstancePtr, 4,(XInterruptHandler) Interrupt_coreE_HW, (void *)dir); //Initialize interruptions Status = XIntc_Start(InstancePtr, XIN_REAL_MODE); IntMasc = 0xFF; XIntc_EnableIntr(InstancePtr->BaseAddress, IntMasc); microblaze_enable_interrupts(); }
void init_interrupt_controller() { XStatus Status; XStatus StatusRC5; XIo_Out32(XPAR_VGA_PERIPH_MEM_0_S_AXI_MEM0_BASEADDR + 0x54, 0x1E0); //init terminal counter on 524 XIo_Out32(XPAR_VGA_PERIPH_MEM_0_S_AXI_MEM0_BASEADDR + 0x58, 1); //enable timer //initialize interrupt controller Status = XIntc_Initialize (&Intc, XPAR_INTC_0_DEVICE_ID); if (Status != XST_SUCCESS) xil_printf ("\r\nInterrupt controller initialization failure"); else xil_printf("\r\nInterrupt controller initialized"); // Connect interrupt_handler Status = XIntc_Connect (&Intc, 0, (XInterruptHandler) vga_interrupt_handler, (void *)0); //StatusRC5 = XIntc_Connect (&Intc, 1, (XInterruptHandler) rc5_interrupt_handler, (void *)0); if (Status != XST_SUCCESS) xil_printf ("\r\nRegistering MY_TIMER Interrupt Failed"); else xil_printf("\r\nMY_TIMER Interrupt registered"); //if (StatusRC5 != XST_SUCCESS) // xil_printf ("\r\nRegistering MY_TIMER Interrupt Failed"); // else // xil_printf("\r\nMY_TIMER Interrupt registered"); //Start the interrupt controller in real mode Status = XIntc_Start(&Intc, XIN_REAL_MODE); //Enable interrupt controller XIntc_Enable (&Intc, 0); microblaze_enable_interrupts(); }
/** * * This function sets up the interrupt system so interrupts can occur for the * DisplayPort RX Subsystem core. The function is application-specific since * the actual system may or may not have an interrupt controller. The DPRX * Subsystem core could be directly connected to a processor without an * interrupt controller. The user should modify this function to fit the * application. * * @param None * * @return * - XST_SUCCESS if interrupt setup was successful. * - A specific error code defined in "xstatus.h" if an error * occurs. * * @note None. * ******************************************************************************/ u32 DpRxSs_SetupIntrSystem(void) { u32 Status; XINTC *IntcInstPtr = &IntcInst; /* Set callbacks for the required interrupts */ XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_VM_CHG_EVENT, DpRxSs_VideoModeHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_NO_VID_EVENT, DpRxSs_NoVideoHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_VBLANK_EVENT, DpRxSs_VerticalBlankHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_TLOST_EVENT, DpRxSs_TrainingLostHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_TDONE_EVENT, DpRxSs_TrainingDoneHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_DWN_REQ_EVENT, DpRxSs_DownReqestHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_DP_DWN_REP_EVENT, DpRxSs_DownReplyHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_UNPLUG_EVENT, DpRxSs_UnplugHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_LINKBW_EVENT, DpRxSs_LinkBandwidthHandler, &DpRxSsInst); XDpRxSs_SetCallBack(&DpRxSsInst, XDPRXSS_HANDLER_PLL_RESET_EVENT, DpRxSs_PllResetHandler, &DpRxSsInst); #ifdef XPAR_INTC_0_DEVICE_ID /* Initialize the interrupt controller driver so that it's ready to * use, specify the device ID that was generated in xparameters.h */ Status = XIntc_Initialize(IntcInstPtr, XINTC_DEVICE_ID); if (Status != XST_SUCCESS) { xil_printf("Intc initialization failed!\n\r"); return XST_FAILURE; } /* Hook up interrupt service routine */ Status = XIntc_Connect(IntcInstPtr, XINTC_DPRXSS_DP_INTERRUPT_ID, (XInterruptHandler)XDpRxSs_DpIntrHandler, &DpRxSsInst); if (Status != XST_SUCCESS) { xil_printf("ERR: DP RX SS DP interrupt connect failed!\n\r"); return XST_FAILURE; } /* Enable the interrupt vector at the interrupt controller */ XIntc_Enable(IntcInstPtr, XINTC_DPRXSS_DP_INTERRUPT_ID); /* Start the interrupt controller such that interrupts are recognized * and handled by the processor */ Status = XIntc_Start(IntcInstPtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } #else /* 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(XINTC_DEVICE_ID); if (NULL == IntcConfig) { return XST_FAILURE; } Status = XScuGic_CfgInitialize(IntcInstPtr, IntcConfig, IntcConfig->CpuBaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* 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(IntcInstPtr, XINTC_DPRXSS_DP_INTERRUPT_ID, (Xil_InterruptHandler)XDpRxSs_DpIntrHandler, &DpRxSsInst); if (Status != XST_SUCCESS) { xil_printf("ERR: DP RX SS DP interrupt connect failed!\n\r"); return XST_FAILURE; } /* Enable the interrupt for the Pixel Splitter device */ XScuGic_Enable(IntcInstance, XINTC_DPRXSS_DP_INTERRUPT_ID); #endif /* Initialize the exception table. */ Xil_ExceptionInit(); /* Register the interrupt controller handler with the exception * table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XINTC_HANDLER, IntcInstPtr); /* Enable exceptions. */ Xil_ExceptionEnable(); return (XST_SUCCESS); }
/** * This function setups the interrupt system such that interrupts can occur * for the timer counter. This function is application specific since the actual * system may or may not have an interrupt controller. The timer counter could * be directly connected to a processor without an interrupt controller. The * user should modify this function to fit the application. * * @param IntcInstancePtr is a pointer to the Interrupt Controller * driver Instance. * @param TmrCtrInstancePtr is a pointer to the XTmrCtr driver Instance. * @param DeviceId is the XPAR_<TmrCtr_instance>_DEVICE_ID value from * xparameters.h. * @param IntrId is XPAR_<INTC_instance>_<TmrCtr_instance>_VEC_ID * value from xparameters.h. * @param TmrCtrNumber is the number of the timer to which this * handler is associated with. * * @return * - XST_SUCCESS if the initialization is successful * - XST_FAILURE if the initialization is not successful * * @note None * * ******************************************************************************/ static int TmrCtrSetupIntrSystem(XIntc* IntcInstancePtr, XTmrCtr* TmrCtrInstancePtr, u16 DeviceId, u16 IntrId, u8 TmrCtrNumber) { int Status; /* * Initialize the interrupt controller driver so that * it's ready to use, specify the device ID that is generated in * xparameters.h */ Status = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect a Fast handler that will be called when an interrupt * for the device occurs. */ Status = XIntc_ConnectFastHandler(IntcInstancePtr, IntrId, (XFastInterruptHandler)TmrCtr_FastHandler); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Start the interrupt controller such that interrupts are enabled for * all devices that cause interrupts, specific real mode so that * the timer counter can cause interrupts through the * interrupt controller. */ Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Enable the interrupt for the timer counter */ XIntc_Enable(IntcInstancePtr, IntrId); /* * Initialize the exception table. */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler) XIntc_InterruptHandler, IntcInstancePtr); /* * Enable non-critical exceptions. */ Xil_ExceptionEnable(); return XST_SUCCESS; }
/** * * This function sets up the interrupt system so interrupts can occur for the * System Monitor/ADC. The function is application-specific since the actual * system may or may not have an interrupt controller. The System Monitor/ADC * device could be directly connected to a processor without an interrupt * controller. The user should modify this function to fit the application. * * @param IntcInstancePtr is a pointer to the Interrupt Controller * driver Instance * @param SysMonPtr is a pointer to the driver instance for the System * Monitor device which is going to be connected to the interrupt * controller * @param IntrId is XPAR_<INTC_instance>_<SYSMON_ADC_instance>_VEC_ID * value from xparameters.h * * @return XST_SUCCESS if successful, or XST_FAILURE. * * @note None. * * ****************************************************************************/ static int SysMonSetupInterruptSystem(XIntc* IntcInstancePtr, XSysMon *SysMonPtr, u16 IntrId ) { int Status; #ifndef TESTAPP_GEN /* * Initialize the interrupt controller driver so that it's ready to use. */ Status = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } #endif /* * Connect the 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 = XIntc_Connect(IntcInstancePtr, IntrId, (XInterruptHandler) SysMonInterruptHandler, SysMonPtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } #ifndef TESTAPP_GEN /* * Start the interrupt controller so interrupts are enabled for all * devices that cause interrupts. Specify real mode so that the System * Monitor/ACD device can cause interrupts through the interrupt * controller. */ Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } #endif /* * Enable the interrupt for the System Monitor/ADC device */ XIntc_Enable(IntcInstancePtr, IntrId); #ifndef TESTAPP_GEN /* * Initialize the exception table. */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler) XIntc_InterruptHandler, IntcInstancePtr); /* * Enable exceptions. */ Xil_ExceptionEnable(); #endif /* TESTAPP_GEN */ return XST_SUCCESS; }