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; }
/* This is a default implementation of what is otherwise an application defined callback function used to install the tick interrupt handler. It is provided as an application callback because the kernel will run on lots of different MicroBlaze and FPGA configurations - not all of which will have the same timer peripherals defined or available. vApplicationSetupTimerInterrupt() is declared as a weak symbol, allowing the application writer to provide their own implementation, if this default implementation is not suitable. */ void vApplicationSetupTimerInterrupt( void ) { portBASE_TYPE xStatus; const unsigned char ucTickTimerCounterNumber = ( unsigned char ) 0U; const unsigned char ucRunTimeStatsCounterNumber = ( unsigned char ) 1U; const unsigned long ulCounterValue = ( ( XPAR_TMRCTR_0_CLOCK_FREQ_HZ / configTICK_RATE_HZ ) - 1UL ); extern void vPortTickISR( void *pvUnused ); /* Initialise the timer/counter. */ xStatus = XTmrCtr_Initialize( &xTickTimerInstance, XPAR_TMRCTR_0_DEVICE_ID ); if( xStatus == XST_SUCCESS ) { /* Install the tick interrupt handler as the timer ISR. *NOTE* The xPortInstallInterruptHandler() API function must be used for this purpose. */ xStatus = xPortInstallInterruptHandler( XPAR_INTC_0_TMRCTR_0_VEC_ID, vPortTickISR, NULL ); } if( xStatus == pdPASS ) { /* Enable the timer interrupt in the interrupt controller. *NOTE* The vPortEnableInterrupt() API function must be used for this purpose. */ vPortEnableInterrupt( XPAR_INTC_0_TMRCTR_0_VEC_ID ); /* Configure the timer interrupt handler. This installs the handler directly, rather than through the Xilinx driver. This is done for efficiency. */ XTmrCtr_SetHandler( &xTickTimerInstance, ( void * ) vPortTickISR, NULL ); /* Set the correct period for the timer. */ XTmrCtr_SetResetValue( &xTickTimerInstance, ucTickTimerCounterNumber, ulCounterValue ); /* Enable the interrupts. Auto-reload mode is used to generate a periodic tick. Note that interrupts are disabled when this function is called, so interrupts will not start to be processed until the first task has started to run. */ XTmrCtr_SetOptions( &xTickTimerInstance, ucTickTimerCounterNumber, ( XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION ) ); /* Start the timer. */ XTmrCtr_Start( &xTickTimerInstance, ucTickTimerCounterNumber ); /* The second timer is used as the time base for the run time stats. Auto-reload mode is used to ensure the timer does not stop. */ XTmrCtr_SetOptions( &xTickTimerInstance, ucRunTimeStatsCounterNumber, XTC_AUTO_RELOAD_OPTION ); /* Start the timer. */ XTmrCtr_Start( &xTickTimerInstance, ucRunTimeStatsCounterNumber ); } /* Sanity check that the function executed as expected. */ configASSERT( ( xStatus == pdPASS ) ); }
void initTimer(XIntc controller) { timerIntCtrl = controller; XTmrCtr_Initialize(&timer, XPAR_TMRCTR_0_DEVICE_ID); XTmrCtr_SetOptions(&timer, 0, XTC_CAPTURE_MODE_OPTION | XTC_INT_MODE_OPTION); XTmrCtr_SetOptions(&timer, 1, XTC_ENABLE_ALL_OPTION | XTC_CAPTURE_MODE_OPTION | XTC_INT_MODE_OPTION); XTmrCtr_SetHandler(&timer, TimerInterrupt, (void *)&timer); XIntc_Connect(&timerIntCtrl, XPAR_INTC_0_TMRCTR_0_VEC_ID, XTmrCtr_InterruptHandler, &timer); XIntc_Enable(&timerIntCtrl, XPAR_INTC_0_TMRCTR_0_VEC_ID); }
/* This is an application defined callback function used to install the tick interrupt handler. It is provided as an application callback because the kernel will run on lots of different MicroBlaze and FPGA configurations - not all of which will have the same timer peripherals defined or available. This example uses the AXI Timer 0. If that is available on your hardware platform then this example callback implementation should not require modification. The name of the interrupt handler that should be installed is vPortTickISR(), which the function below declares as an extern. */ void vApplicationSetupTimerInterrupt( void ) { portBASE_TYPE xStatus; const unsigned char ucTimerCounterNumber = ( unsigned char ) 0U; const unsigned long ulCounterValue = ( ( TIMER_CLOCK_FREQ / configTICK_RATE_HZ ) - 1UL ); extern void vPortTickISR( void *pvUnused ); /* Initialise the timer/counter. */ xStatus = XTmrCtr_Initialize( &xTimer0Instance, TIMER_DEVICE_ID ); if (xStatus == XST_DEVICE_IS_STARTED) { xTimer0Instance.IsReady = XIL_COMPONENT_IS_READY; XTmrCtr_Stop( &xTimer0Instance, TIMER_DEVICE_ID ); XTmrCtr_Reset( &xTimer0Instance, TIMER_DEVICE_ID ); xStatus = XTmrCtr_Initialize( &xTimer0Instance, TIMER_DEVICE_ID ); xStatus = XST_SUCCESS; } if( xStatus == XST_SUCCESS ) { /* Install the tick interrupt handler as the timer ISR. *NOTE* The xPortInstallInterruptHandler() API function must be used for this purpose. */ xStatus = xPortInstallInterruptHandler(TIMER_INTR_ID, vPortTickISR, NULL ); } if( xStatus == pdPASS ) { /* Enable the timer interrupt in the interrupt controller. *NOTE* The vPortEnableInterrupt() API function must be used for this purpose. */ vPortEnableInterrupt(TIMER_INTR_ID); /* Configure the timer interrupt handler. */ XTmrCtr_SetHandler( &xTimer0Instance, ( void * ) vPortTickISR, NULL ); /* Set the correct period for the timer. */ XTmrCtr_SetResetValue( &xTimer0Instance, ucTimerCounterNumber, ulCounterValue ); /* Enable the interrupts. Auto-reload mode is used to generate a periodic tick. Note that interrupts are disabled when this function is called, so interrupts will not start to be processed until the first task has started to run. */ XTmrCtr_SetOptions( &xTimer0Instance, ucTimerCounterNumber, ( XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION ) ); /* Start the timer. */ XTmrCtr_Start( &xTimer0Instance, ucTimerCounterNumber ); } /* Sanity check that the function executed as expected. */ configASSERT( ( xStatus == pdPASS ) ); }
int init_timer(int deviceID, XTmrCtr *timer, u32 timer_freq, u32 target_freq, XTmrCtr_Handler interruptHandler) { // Init timer if(XTmrCtr_Initialize(timer, deviceID) != XST_SUCCESS) return XST_FAILURE; // Self test if(XTmrCtr_SelfTest(timer, 0) != XST_SUCCESS) return XST_FAILURE; // Setup handler to be called when timer expires XTmrCtr_SetHandler(timer, interruptHandler, (void*) timer); // Enable interrupts and auto-reset so timer runs forever XTmrCtr_SetOptions(timer, 0, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION); // Set reset value to cause timer to roll-over before it reaches zero at the specified frequency XTmrCtr_SetResetValue(timer, 0, ((unsigned int) 0xFFFFFFFF) - (timer_freq / target_freq)); // Yey! return XST_SUCCESS; }
//---------------------------------------------------- // MAIN FUNCTION //---------------------------------------------------- int main (void) { printf("Animation Test\n\r"); int status; char c; //---------------------------------------------------- // INITIALIZE THE PERIPHERALS & SET DIRECTIONS OF GPIO //---------------------------------------------------- // Initialize Push Buttons status = XGpio_Initialize(&BTNInst, BTNS_DEVICE_ID); if(status != XST_SUCCESS) return XST_FAILURE; // Set all buttons direction to inputs XGpio_SetDataDirection(&BTNInst, 1, 0xFF); //---------------------------------------------------- // SETUP THE TIMER //---------------------------------------------------- status = XTmrCtr_Initialize(&TMRInst, TMR_DEVICE_ID); if(status != XST_SUCCESS) return XST_FAILURE; XTmrCtr_SetHandler(&TMRInst, TMR_Intr_Handler, &TMRInst); XTmrCtr_SetOptions(&TMRInst, 0, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION); XTmrCtr_SetResetValue(&TMRInst, 0, TMR_LOAD); XTmrCtr_Start(&TMRInst,0); // Initialize interrupt controller status = IntcInitFunction(INTC_DEVICE_ID, &TMRInst, &BTNInst,&DmaInstance); if(status != XST_SUCCESS) return XST_FAILURE; //Lab7 addition starts here //Initialize DMA controller // XDma_Config(DMA_DEVICE_ID); //Lab7 addition ends here while(1){ // Infinite loop - Do nothing } // Never reached on normal execution return (0); }
void Timer_Init(XTmrCtr *TmrCtrInstancePtr, u8 TmrCtrNumber, u16 DeviceId) { /* * Initialize the timer counter so that it's ready to use, * specify the device ID that is generated in xparameters.h */ XTmrCtr_Initialize(TmrCtrInstancePtr, DeviceId); /* * Setup the handler for the timer counter that will be called from the * interrupt context when the timer expires, specify a pointer to the * timer counter driver instance as the callback reference so the handler * is able to access the instance data */ XTmrCtr_SetHandler(TmrCtrInstancePtr, TimerCounterHandler, TmrCtrInstancePtr); /* * Enable the interrupt of the timer counter so interrupts will occur * and use auto reload mode such that the timer counter will reload * itself automatically and continue repeatedly, without this option * it would expire once only */ XTmrCtr_SetOptions(TmrCtrInstancePtr, TmrCtrNumber, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION); /* * Set a reset value for the timer counter such that it will expire * eariler than letting it roll over from 0, the reset value is loaded * into the timer counter when it is started */ XTmrCtr_SetResetValue(TmrCtrInstancePtr, TmrCtrNumber, RESET_VALUE); /* * Start the timer counter such that it's incrementing by default, * then wait for it to timeout a number of times */ XTmrCtr_Start(TmrCtrInstancePtr, TmrCtrNumber); }
int main (void) { int old_count = 0; gpio_init(); XGpio_DiscreteWrite(&led,1,0); XGpio_DiscreteWrite(&ledPush,1,0x1); xil_printf("-- Entering main() --\r\n"); XTmrCtr_Initialize(&XTC, XPAR_OPB_TIMER_1_DEVICE_ID ); XTmrCtr_SetOptions(&XTC, 0, XTC_DOWN_COUNT_OPTION | XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION ); XTmrCtr_SetHandler(&XTC, TimerCounterHandler, &XTC); microblaze_register_handler( (XInterruptHandler)XTmrCtr_InterruptHandler, &XTC ); microblaze_enable_interrupts(); XTmrCtr_SetResetValue ( &XTC, 0, 50*1000000L ); XTmrCtr_Start( &XTC, 0 ); XGpio_DiscreteWrite(&ledPush,1,0x3); while(1) { if (gpio_check()) break; if ( old_count != intr_count ) { xil_printf(" TmrCtr update %d\r\n", intr_count ); XGpio_DiscreteWrite(&led,1,3); XGpio_DiscreteWrite(&ledPush,1,0x10 | (intr_count&0xF)); old_count = intr_count; } } if ( XTmrCtr_IsExpired( &XTC, 0 ) ) { xil_printf(" TmrCtr Timed out\r\n" ); } else { xil_printf(" TmrCtr un-Timeout\r\n" ); } XTmrCtr_Stop(&XTC, 0 ); microblaze_disable_interrupts(); XGpio_DiscreteWrite(&ledPush,1,0x10); xil_printf("-- Exiting main() --\r\n"); return 0; }
void vApplicationSetupHardware( void ) { XScuGic * InterruptController = prvGetInterruptControllerInstance(); int iPinNumberEMIO = 54; u32 uPinDirectionEMIO = 0x0; u32 uPinDirection = 0x1; print("##### Application Starts #####\n\r"); print("\r\n"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-1 :AXI GPIO Initialization //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ u32 xStatus = XGpio_Initialize(&GPIOInstance_Ptr,XPAR_AXI_GPIO_0_DEVICE_ID); if(XST_SUCCESS != xStatus) print("GPIO INIT FAILED\n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-2 :AXI GPIO Set the Direction //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XGpio_SetDataDirection(&GPIOInstance_Ptr, 1,1); //set up GPIO interrupt XGpio_InterruptEnable(&GPIOInstance_Ptr, 0x1); XGpio_InterruptGlobalEnable(&GPIOInstance_Ptr); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-3 :AXI Timer Initialization //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ xStatus = XTmrCtr_Initialize(&TimerInstancePtr, XPAR_AXI_TIMER_0_DEVICE_ID); if(XST_SUCCESS != xStatus) print("TIMER INIT FAILED \n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-4 :Set Timer Handler //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XTmrCtr_SetHandler(&TimerInstancePtr, Timer_InterruptHandler, &TimerInstancePtr); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-5 :Setting timer Reset Value //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XTmrCtr_SetResetValue(&TimerInstancePtr, 0, 0x0F000000); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-6 :Setting timer Option (Interrupt Mode And Auto Reload ) //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XTmrCtr_SetOptions(&TimerInstancePtr, XPAR_AXI_TIMER_0_DEVICE_ID, (XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION)); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-7 :PS GPIO Intialization //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GpioConfigPtr = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID); if(GpioConfigPtr == NULL) print(" PS GPIO config lookup FAILED \n\r"); xStatus = XGpioPs_CfgInitialize(&psGpioInstancePtr, GpioConfigPtr, GpioConfigPtr->BaseAddr); if(XST_SUCCESS != xStatus) print(" PS GPIO INIT FAILED \n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-8 :PS GPIO pin setting to Output //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XGpioPs_SetDirectionPin(&psGpioInstancePtr, 54, uPinDirection); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, 54,1); // XGpioPs_SetDirectionPin(&psGpioInstancePtr, 8,uPinDirection); // XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, 8, 1); print(" INITED MIO \n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-9 :EMIO PIN Setting to Input port //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XGpioPs_SetDirectionPin(&psGpioInstancePtr, iPinNumberEMIO, uPinDirectionEMIO); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, iPinNumberEMIO, 0); //XGpioPs_IntrEnable(&psGpioInstancePtr, XGPIOPS_BANK2, 0x1); // instance, bank, edge, rising, single edge XGpioPs_IntrEnablePin(&psGpioInstancePtr, iPinNumberEMIO); XGpioPs_SetIntrType(&psGpioInstancePtr, XGPIOPS_BANK2, 1, 1, 0); XGpioPs_SetCallbackHandler(&psGpioInstancePtr, (void *) &psGpioInstancePtr, EMIO_Button_InterruptHandler); print(" INITED FIRST EMIO \n\r"); // EMIO output XGpioPs_SetDirectionPin(&psGpioInstancePtr, 55, uPinDirection); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, 55, 1); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-10 : SCUGIC interrupt controller Initialization //Registration of the Timer ISR //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ u32 Status = XScuGic_Connect(InterruptController, XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR, (Xil_ExceptionHandler)XTmrCtr_InterruptHandler, (void *)&TimerInstancePtr); if (Status != XST_SUCCESS) { print(" Error connection timer interrupt \n \r"); } Status = XScuGic_Connect(InterruptController, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR, (Xil_ExceptionHandler)Button_InterruptHandler, (void *)&GPIOInstance_Ptr); if (Status != XST_SUCCESS) { print(" Error connection button interrupt \n \r"); } /* * Connect the device driver handler that will be called when an * interrupt for the device occurs, the handler defined above performs * the specific interrupt processing for the device. */ Status = XScuGic_Connect(InterruptController, XPS_GPIO_INT_ID, (Xil_ExceptionHandler)XGpioPs_IntrHandler, (void *)&psGpioInstancePtr); if (Status != XST_SUCCESS) { print(" Error connection button EMIO interrupt \n \r"); } /* * Enable the interrupt for the device and then cause (simulate) an * interrupt so the handlers will be called */ XScuGic_Enable(InterruptController, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR); XScuGic_Enable(InterruptController, XPS_GPIO_INT_ID); XScuGic_Enable(InterruptController, XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR); // turn off all LEDs XGpioPs_WritePin(&psGpioInstancePtr, iPinNumber, 0); XGpioPs_WritePin(&psGpioInstancePtr, 55, 0); print(" End of init \n\r"); }
/** * This function does a minimal test on the timer counter device and driver as a * design example. The purpose of this function is to illustrate how to use the * XTmrCtr component. It initializes a timer counter and then sets it up in * compare mode with auto reload such that a periodic interrupt is generated. * * This function uses interrupt driven mode of the timer counter. * * @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 Test is successful * - XST_FAILURE if the Test is not successful * * @note This function contains an infinite loop such that if interrupts * are not working it may never return. * *****************************************************************************/ int TmrCtrFastIntrExample(XIntc* IntcInstancePtr, XTmrCtr* TmrCtrInstancePtr, u16 DeviceId, u16 IntrId, u8 TmrCtrNumber) { int Status; int LastTimerExpired = 0; /* * Initialize the timer counter so that it's ready to use, * specify the device ID that is generated in xparameters.h */ Status = XTmrCtr_Initialize(TmrCtrInstancePtr, DeviceId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Perform a self-test to ensure that the hardware was built * correctly, use the 1st timer in the device (0) */ Status = XTmrCtr_SelfTest(TmrCtrInstancePtr, TmrCtrNumber); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect the timer counter to the interrupt subsystem such that * interrupts can occur. This function is application specific. */ Status = TmrCtrSetupIntrSystem(IntcInstancePtr, TmrCtrInstancePtr, DeviceId, IntrId, TmrCtrNumber); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the handler for the timer counter that will be called from the * interrupt context when the timer expires, specify a pointer to the * timer counter driver instance as the callback reference so the * handler is able to access the instance data */ XTmrCtr_SetHandler(TmrCtrInstancePtr, TimerCounterHandler, TmrCtrInstancePtr); /* * Enable the interrupt of the timer counter so interrupts will occur * and use auto reload mode such that the timer counter will reload * itself automatically and continue repeatedly, without this option * it would expire once only */ XTmrCtr_SetOptions(TmrCtrInstancePtr, TmrCtrNumber, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION); /* * Set a reset value for the timer counter such that it will expire * eariler than letting it roll over from 0, the reset value is loaded * into the timer counter when it is started */ XTmrCtr_SetResetValue(TmrCtrInstancePtr, TmrCtrNumber, RESET_VALUE); /* * Start the timer counter such that it's incrementing by default, * then wait for it to timeout a number of times */ XTmrCtr_Start(TmrCtrInstancePtr, TmrCtrNumber); while (1) { /* * Wait for the first timer counter to expire as indicated by * the shared variable which the handler will increment */ while (TimerExpired == LastTimerExpired) { } LastTimerExpired = TimerExpired; /* * If it has expired a number of times, then stop the timer * counter and stop this example */ if (TimerExpired == 3) { XTmrCtr_Stop(TmrCtrInstancePtr, TmrCtrNumber); break; } } TmrCtrDisableIntr(IntcInstancePtr, DeviceId); return XST_SUCCESS; }
int main(void) { XIntc intc; XTmrCtr tmrctr; int Status; Xil_ICacheEnable(); Xil_DCacheEnable(); // Initialize the timer counter so that it's ready to use, // specify the device ID that is generated in xparameters.h Status = XTmrCtr_Initialize(&tmrctr, XPAR_TMRCTR_0_DEVICE_ID); if (Status != XST_SUCCESS) { return 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(&intc, XPAR_INTC_0_DEVICE_ID); if (Status != XST_SUCCESS) { return Status; } // 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(&intc, XPAR_INTC_0_TMRCTR_0_VEC_ID, XTmrCtr_InterruptHandler, &tmrctr); if (Status != XST_SUCCESS) { return Status; } // Enable the interrupt for the timer counter XIntc_Enable(&intc, XPAR_INTC_0_TMRCTR_0_VEC_ID ); // 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 thru the interrupt controller. Status = XIntc_Start(&intc, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return Status; } // 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, &intc); // Enable non-critical exceptions. Xil_ExceptionEnable(); // Setup the handler for the timer counter that will be called from the // interrupt context when the timer expires, specify a pointer to the // timer counter driver instance as the callback reference so the handler // is able to access the instance data XTmrCtr_SetHandler(&tmrctr, TimerCounterHandler, &tmrctr); // Enable the interrupt of the timer counter so interrupts will occur // and use auto reload mode such that the timer counter will reload // itself automatically and continue repeatedly, without this option // it would expire once only XTmrCtr_SetOptions(&tmrctr, 0, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION); // Set a reset value for the timer counter such that it will expire // when it rolls under to 0, the reset value is loaded // into the timer counter when it is started XTmrCtr_SetResetValue(&tmrctr, 0, XPAR_AXI_TIMER_0_CLOCK_FREQ_HZ-1); // Start the timer counter XTmrCtr_Start(&tmrctr, 0); while (1) { } Xil_DCacheDisable(); Xil_ICacheDisable(); return 0; }
/* * Initialize Timer Interrupt * In: interrupt frequency in Hz */ int initTmrInt(u32 int_freq) { //Variables int status; u32 reset_val; XScuGic_Config* IntcConfig; //Timer //Initialize Timer Controller status = XTmrCtr_Initialize(&tmrCtr, TMR_DEVICE_ID); if (status != XST_SUCCESS) { return XST_FAILURE; } //Set Interrupt Handler for Timer Controller XTmrCtr_SetHandler(&tmrCtr, (XTmrCtr_Handler) tmrIntrHandler, &tmrCtr); //Reset Timer Value int_freq = (u32) (FPGA_FREQ / int_freq); reset_val = ~int_freq; //Reset Timer Value XTmrCtr_SetResetValue(&tmrCtr, 0, reset_val); //Set Options XTmrCtr_SetOptions(&tmrCtr, 0, TMR_OPTIONS); //GIC //Initialize Xil Exceptions Xil_ExceptionInit(); //Initialize GIC IntcConfig = XScuGic_LookupConfig(INTC_DEVICE_ID); status = XScuGic_CfgInitialize(&Intc, IntcConfig, IntcConfig->CpuBaseAddress); if (status != XST_SUCCESS) { myprintf("mpu_utils.c: Error initializing SCU GIC Config.\r\n"); return XST_FAILURE; } //Connect interrupt controller interrupt handler to HW interrupt handling logic in PS Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler) XScuGic_InterruptHandler, &Intc); //Connect driver handler (GIC) called when interrupt occurs to HW defined above XScuGic_Connect(&Intc, INTC_TMR_INT_ID, (Xil_ExceptionHandler) XTmrCtr_InterruptHandler, (void*) &tmrCtr); //Set Callback Handler for Timer Interrupts XTmrCtr_SetHandler(&tmrCtr, (XTmrCtr_Handler) tmrIntrHandler, &tmrCtr); //Enable Timer Interrupts XTmrCtr_EnableIntr(tmrCtr.BaseAddress, 0); //Enable Interrupts for Timer XScuGic_Enable(&Intc, INTC_TMR_INT_ID); //Enable Interrupts in Processor Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ); //Start Timer XTmrCtr_Start(&tmrCtr, 0); //Return return XST_SUCCESS; }
void wlan_mac_util_init( u32 type, u32 eth_dev_num ){ int Status; u32 i; u32 gpio_read; u32 queue_len; u64 timestamp; u32 log_size; tx_frame_info* tx_mpdu; // Initialize callbacks eth_rx_callback = (function_ptr_t)nullCallback; mpdu_rx_callback = (function_ptr_t)nullCallback; fcs_bad_rx_callback = (function_ptr_t)nullCallback; mpdu_tx_done_callback = (function_ptr_t)nullCallback; pb_u_callback = (function_ptr_t)nullCallback; pb_m_callback = (function_ptr_t)nullCallback; pb_d_callback = (function_ptr_t)nullCallback; uart_callback = (function_ptr_t)nullCallback; ipc_rx_callback = (function_ptr_t)nullCallback; check_queue_callback = (function_ptr_t)nullCallback; mpdu_tx_accept_callback = (function_ptr_t)nullCallback; wlan_mac_ipc_init(); for(i=0;i < NUM_TX_PKT_BUFS; i++){ tx_mpdu = (tx_frame_info*)TX_PKT_BUF_TO_ADDR(i); tx_mpdu->state = TX_MPDU_STATE_EMPTY; } tx_pkt_buf = 0; #ifdef _DEBUG_ xil_printf("locking tx_pkt_buf = %d\n", tx_pkt_buf); #endif if(lock_pkt_buf_tx(tx_pkt_buf) != PKT_BUF_MUTEX_SUCCESS){ warp_printf(PL_ERROR,"Error: unable to lock pkt_buf %d\n",tx_pkt_buf); } tx_mpdu = (tx_frame_info*)TX_PKT_BUF_TO_ADDR(tx_pkt_buf); tx_mpdu->state = TX_MPDU_STATE_TX_PENDING; //Initialize the central DMA (CDMA) driver XAxiCdma_Config *cdma_cfg_ptr; cdma_cfg_ptr = XAxiCdma_LookupConfig(XPAR_AXI_CDMA_0_DEVICE_ID); Status = XAxiCdma_CfgInitialize(&cdma_inst, cdma_cfg_ptr, cdma_cfg_ptr->BaseAddress); if (Status != XST_SUCCESS) { warp_printf(PL_ERROR,"Error initializing CDMA: %d\n", Status); } XAxiCdma_IntrDisable(&cdma_inst, XAXICDMA_XR_IRQ_ALL_MASK); Status = XGpio_Initialize(&Gpio, GPIO_DEVICE_ID); gpio_timestamp_initialize(); if (Status != XST_SUCCESS) { warp_printf(PL_ERROR, "Error initializing GPIO\n"); return; } Status = XUartLite_Initialize(&UartLite, UARTLITE_DEVICE_ID); if (Status != XST_SUCCESS) { warp_printf(PL_ERROR, "Error initializing XUartLite\n"); return; } gpio_read = XGpio_DiscreteRead(&Gpio, GPIO_INPUT_CHANNEL); if(gpio_read&GPIO_MASK_DRAM_INIT_DONE){ xil_printf("DRAM SODIMM Detected\n"); if(memory_test()==0){ queue_dram_present(1); dram_present = 1; } else { queue_dram_present(0); dram_present = 0; } } else { queue_dram_present(0); dram_present = 0; timestamp = get_usec_timestamp(); while((get_usec_timestamp() - timestamp) < 100000){ if((XGpio_DiscreteRead(&Gpio, GPIO_INPUT_CHANNEL)&GPIO_MASK_DRAM_INIT_DONE)){ xil_printf("DRAM SODIMM Detected\n"); if(memory_test()==0){ queue_dram_present(1); dram_present = 1; } else { queue_dram_present(0); dram_present = 0; } break; } } } queue_len = queue_init(); if( dram_present ) { //The event_list lives in DRAM immediately following the queue payloads. if(MAX_EVENT_LOG == -1){ log_size = (DDR3_SIZE - queue_len); } else { log_size = min( (DDR3_SIZE - queue_len), MAX_EVENT_LOG ); } event_log_init( (void*)(DDR3_BASEADDR + queue_len), log_size ); } else { log_size = 0; } #ifdef USE_WARPNET_WLAN_EXP // Communicate the log size to WARPNet node_info_set_event_log_size( log_size ); #endif wlan_eth_init(); //Set direction of GPIO channels XGpio_SetDataDirection(&Gpio, GPIO_INPUT_CHANNEL, 0xFFFFFFFF); XGpio_SetDataDirection(&Gpio, GPIO_OUTPUT_CHANNEL, 0); Status = XTmrCtr_Initialize(&TimerCounterInst, TMRCTR_DEVICE_ID); if (Status != XST_SUCCESS) { xil_printf("XTmrCtr failed to initialize\n"); return; } //Set the handler for Timer XTmrCtr_SetHandler(&TimerCounterInst, timer_handler, &TimerCounterInst); //Enable interrupt of timer and auto-reload so it continues repeatedly XTmrCtr_SetOptions(&TimerCounterInst, TIMER_CNTR_FAST, XTC_DOWN_COUNT_OPTION | XTC_INT_MODE_OPTION); XTmrCtr_SetOptions(&TimerCounterInst, TIMER_CNTR_SLOW, XTC_DOWN_COUNT_OPTION | XTC_INT_MODE_OPTION); timer_running[TIMER_CNTR_FAST] = 0; timer_running[TIMER_CNTR_SLOW] = 0; // Get the type of node from the input parameter hw_info.type = type; hw_info.wn_exp_eth_device = eth_dev_num; #ifdef USE_WARPNET_WLAN_EXP // We cannot initialize WARPNet until after the lower CPU sends all the HW information to us through the IPC call warpnet_initialized = 0; #endif wlan_mac_ltg_sched_init(); }
/**************************************************************************** * * FUNCTION: * * main * * DESCRIPTION: * * This is the entry point for the example. The embedded system automatically * calls main. * * ARGUMENTS: * * None. * * RETURN VALUE: * * None. * * NOTES: * * None. * ****************************************************************************/ int main() { XStatus Status; int PreviousCount = 0; /* Using printf with the UART Lite assumes that the layer 0 device * driver was selected for the UART Lite in the XPS and the standard * I/O peripheral in XPS was set to the UART Lite */printf("\n\rStarting the Application\n\r"); /*************************** GPIO Setup *******************************/ /* The second GPIO example uses the higher level (layer 1) driver to * blink the LEDs, First initialize the GPIO component */ Status = XGpio_Initialize(&Gpio, XPAR_AXI_GPIO_0_DEVICE_ID); if (Status != XST_SUCCESS) { printf("GPIO initialization error\n\r\r"); } /* Set the direction for all signals to be inputs except the LED * outputs */ XGpio_SetDataDirection(&Gpio, 1, ~LED); /************************* Timer Setup ********************************/ /* Initialize the timer counter so that it's ready to use, * specify the device ID that is generated in xparameters.h */ Status = XTmrCtr_Initialize(&TimerCounter, XPAR_AXI_TIMER_0_DEVICE_ID); if (Status != XST_SUCCESS) { printf("Timer counter initialization error\n\r\r"); } /* Perform a self-test to ensure that the hardware was built * correctly, use the 1st timer in the device (0) */ Status = XTmrCtr_SelfTest(&TimerCounter, TIMER_COUNTER_0); if (Status != XST_SUCCESS) { printf("Timer counter self-test error\n\r"); } /* Setup the handler for the timer counter that will be called from the * interrupt context when the timer expires, specify a pointer to the * timer counter driver instance as the callback reference so the handler * is able to access the instance data */ XTmrCtr_SetHandler(&TimerCounter, TimerCounterHandler, &TimerCounter); /* Enable the interrupt of the timer counter so interrupts will occur * and use auto reload mode such that the timer counter will reload * itself automatically and continue repeatedly, without this option * it would expire once only */ XTmrCtr_SetOptions(&TimerCounter, TIMER_COUNTER_0, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION); /* Set a reset value for the timer counter such that it will expire * earlier than letting it roll over from 0, the reset value is loaded * into the timer counter when it is started */ XTmrCtr_SetResetValue(&TimerCounter, TIMER_COUNTER_0, resetTime /*RESET_VALUE*/); /* Start the timer counter such that it's incrementing */ XTmrCtr_Start(&TimerCounter, TIMER_COUNTER_0); /********************** Interrupt Controller Setup *********************/ /* * Initialize the interrupt controller driver so that it's ready to use, * using the device ID that is generated in xparameters.h */ Status = XIntc_Initialize(&InterruptController, XPAR_AXI_INTC_0_DEVICE_ID); if (Status != XST_SUCCESS) { printf("Interrupt controller initialization error\n\r"); } /* * Connect the 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, XPAR_AXI_INTC_0_AXI_TIMER_0_INTERRUPT_INTR, // we don't know what this is, but it's probably 0 (XInterruptHandler) XTmrCtr_InterruptHandler, &TimerCounter); if (Status != XST_SUCCESS) { printf("Interrupt controller connect error\n\r"); } /* * Start the interrupt controller so interrupts are enabled for all * devices that cause interrupts. Specify real mode so that the timer * counter can cause interrupts through the interrupt controller. */ Status = XIntc_Start(&InterruptController, XIN_REAL_MODE); if (Status != XST_SUCCESS) { printf("Interrupt controller start error\n\r"); } /* Enable the interrupt for the timer counter and enable interrupts in * the microblaze processor */ XIntc_Enable(&InterruptController, XPAR_AXI_INTC_0_AXI_TIMER_0_INTERRUPT_INTR); microblaze_enable_interrupts(); /********************** Application Processing *********************/ /* Insert foreground processing here, interrupts will handle * processing in the background */ while (1) { char get = (char)*(volatile int *)(XPAR_RS232_UART_1_BASEADDR); if (get >= ' ' && get <= '~') break; } // stop the timer microblaze_disable_interrupts(); // break out of the while look /* The application should not ever execute the following code, but it is * present to indicate if the application does exit because of an error */printf("Exiting the Application\n\r"); }