1 /*
2 * Copyright (c) 2009-2012 Xilinx, Inc. All rights reserved.
3 *
4 * Xilinx, Inc.
5 * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
6 * COURTESY TO YOU. BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
7 * ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, APPLICATION OR
8 * STANDARD, XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION
9 * IS FREE FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE
10 * FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
11 * XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
12 * THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO
13 * ANY WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE
14 * FROM CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE.
16 *
17 */
18
19 /*
20 * helloworld.c: simple test application
21 *
22 * This application configures UART 16550 to baud rate 9600.
23 * PS7 UART (Zynq) is not initialized by this application, since
24 * bootrom/bsp configures it to baud rate 115200
25 *
26 * ------------------------------------------------
27 * | UART TYPE BAUD RATE |
28 * ------------------------------------------------
29 * uartns550 9600
30 * uartlite Configurable only in HW design
31 * ps7_uart 115200 (configured by bootrom/bsp)
32 */
33
34 #include <stdio.h>
35 #include "platform.h"
36 #include "xgpiops.h"
37
38 #include "xparameters.h"
39 #include "xstatus.h"
40 #include "xscugic.h"
41 #include "xil_exception.h"
42
43 //void print(char *str);
44
45 #define GPIO_DIR 0x0000 /*All work in input mode*/
46 #define GPIO_DEVICE_ID XPAR_XGPIOPS_0_DEVICE_ID // 0
47 #define INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID // 0
48 #define GPIO_INTERRUPT_ID XPAR_XGPIOPS_0_INTR // All gpio in four banks to one output (IRQ ID#52) to interrupt controller
49
50
51 /************************** Function Prototypes ******************************/
52
53 static void IntrHandler(void *CallBackRef, int Bank, u32 Status);
54 static int SetupInterruptSystem(XScuGic *Intc, XGpioPs *Gpio, u16 GpioIntrId);
55 int ScuGicInterruptSetup(XScuGic *IntcInstancePtr, u16 DeviceId);
56
57 /************************** Variable Definitions *****************************/
58
59 /*
60 * The following are declared globally so they are zeroed and so they are
61 * easily accessible from a debugger.
62 */
63 static XGpioPs Gpio; /* The Instance of the GPIO Driver */
64
65 XScuGic IntcInstance; /* The Instance of the Interrupt Controller Driver */
66
67 int main()
68 {
69 init_platform();
70
71 print("Hello World\n\r");
72
73 /*****************************************************************/
74 //Set GPIO Interrupt
75 /*****************************************************************/
76 XGpioPs_Config *ConfigPtr;
77 int Status = 0;
78 XGpioPs Gpio;
79 /*
80 * Initialize the Gpio driver.
81 */
82 //printf("Initialize the Gpio driver.\n\r");
83 ConfigPtr = XGpioPs_LookupConfig(GPIO_DEVICE_ID);
84 if (ConfigPtr == NULL) {
85 return XST_FAILURE;
86 }
87
88 XGpioPs_CfgInitialize(&Gpio, ConfigPtr, ConfigPtr->BaseAddr);
89
90 /*
91 * Setup direction register of bank2, so that all the pins are configured as inputs.
92 */
93 //printf("Set gpio direction.\n\r");
94 XGpioPs_SetDirection(&Gpio, 2, GPIO_DIR); // bank2 set to all input
95
96 #ifdef GPIOIOTEST
97 //printf("GPIO bank2 value is 0x%x \n\r",i);
98 // set gpio direction output,'1' for output
99 XGpioPs_SetDirection(&Gpio, 2, 0xff);
100 // set gpio output enable
101 XGpioPs_SetOutputEnable(&Gpio, 2, 0xff);
102 // write value
103 XGpioPs_Write(&Gpio, 2, 0xff);
104 #endif
105
106 /***********************************************************************/
107 /* How to Set Interrupt */
108 /***********************************************************************/
109
110 IntCtl_Init();
111
112 // GPIO is Num.52 interrupt
113 Status = SetupInterruptSystem(&IntcInstance, &Gpio, GPIO_INTERRUPT_ID);
114
115 if (Status != XST_SUCCESS) {
116 print("Set GPIO interrupt Failure \n\r");
117 }
118 else{
119 print("Set GPIO interrupt Successful \n\r");
120 }
121
122 /***********************************************************************/
123
124 while(1)
125 {
126 sleep(5);
127 print("While(1) ing \n\r");
128 }
129
130 return 0;
131 }
132
133
134
135
136
137 /*****************************************************************************/
138 /**
139 *
140 * This function is used by the TestAppGen generated application to setup
141 * the interrupt controller.
142 *
143 * @param IntcInstancePtr is the reference to the Interrupt Controller
144 * instance.
145 * @param DeviceId is device ID of the Interrupt Controller Device,
146 * typically XPAR_<INTC_instance>_DEVICE_ID value from
147 * xparameters.h.
148 *
149 * @return XST_SUCCESS to indicate success, otherwise XST_FAILURE.
150 *
151 * @note None.
152 *
153 ******************************************************************************/
154 int IntCtl_Init(void)
155 {
156 int Status;
157
158 Status = ScuGicInterruptSetup(&IntcInstance, XPAR_PS7_SCUGIC_0_DEVICE_ID);
159 if (Status == 0) {
160 print("ScuGic Interrupt Setup PASSED\r\n");
161 }
162 else {
163 print("ScuGic Interrupt Setup FAILED\r\n");
164 }
165 }
166
167
168
169 /*****************************************************************************/
170 /**
171 *
172 * This function is used by the TestAppGen generated application to setup
173 * the interrupt controller.
174 *
175 * @param IntcInstancePtr is the reference to the Interrupt Controller
176 * instance.
177 * @param DeviceId is device ID of the Interrupt Controller Device,
178 * typically XPAR_<INTC_instance>_DEVICE_ID value from
179 * xparameters.h.
180 *
181 * @return XST_SUCCESS to indicate success, otherwise XST_FAILURE.
182 *
183 * @note None.
184 *
185 ******************************************************************************/
186 int ScuGicInterruptSetup(XScuGic *IntcInstancePtr, u16 DeviceId)
187 {
188
189 int Status;
190 static XScuGic_Config *GicConfig;
191
192 /*
193 * Initialize the interrupt controller driver so that it is ready to
194 * use.
195 */
196 GicConfig = XScuGic_LookupConfig(DeviceId);
197 if (NULL == GicConfig) {
198 return XST_FAILURE;
199 }
200
201 Status = XScuGic_CfgInitialize(IntcInstancePtr, GicConfig, GicConfig->CpuBaseAddress);
202 if (Status != XST_SUCCESS) {
203 return XST_FAILURE;
204 }
205
206 /*
207 * Initialize the exception table.
208 */
209 Xil_ExceptionInit();
210
211
212 /*
213 * Connect the interrupt controller interrupt handler to the hardware
214 * interrupt handling logic in the processor.
215 */
216 Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT,
217 (Xil_ExceptionHandler)XScuGic_InterruptHandler,
218 IntcInstancePtr);
219
220 /*
221 * Enable exceptions.
222 */
223 Xil_ExceptionEnable();
224
225
226 return XST_SUCCESS;
227
228 }
229 /*****************************************************************************/
230 /**
231 *
232 * This function sets up the interrupt system for the example. It enables rasing
233 * edge interrupts for all the pins of bank 2 in the GPIO device.
234 *
235 * @param GicInstancePtr is a pointer to the XScuGic driver Instance.
236 * @param GpioInstancePtr contains a pointer to the instance of the GPIO
237 * component which is going to be connected to the interrupt
238 * controller.
239 * @param GpioIntrId is the interrupt Id and is typically
240 * XPAR_<GICPS>_<GPIOPS_instance>_VEC_ID value from
241 * xparameters.h.
242 *
243 * @return XST_SUCCESS if successful, otherwise XST_FAILURE.
244 *
245 * @note None.
246 *
247 ****************************************************************************/
248 static int SetupInterruptSystem(XScuGic *GicInstancePtr, XGpioPs *Gpio, u16 GpioIntrId)
249 {
250 int Status;
251
252 XScuGic_Config *IntcConfig; /* Instance of the interrupt controller */
253
254 /*
255 * Connect the device driver handler that will be called when an
256 * interrupt for the device occurs, the handler defined above performs
257 * the specific interrupt processing for the device.
258 *
259 *
260 */
261 printf("Connect the device driver handler to interrupt processing \n\r");
262 Status = XScuGic_Connect(GicInstancePtr, GpioIntrId,
263 (Xil_ExceptionHandler)XGpioPs_IntrHandler,
264 (void *)Gpio);
265 if (Status != XST_SUCCESS) {
266 return Status;
267 }
268
269 /*
270 * @param GpioInstancePtr contains a pointer to the instance of the GPIO
271 * component which is going to be connected to the interrupt
272 * controller.
273 * @param set Interrupt Type 0 level ,1 edge
274 * @param Interrupt Polarity 1 rising or high level ,0 falling or low level
275 * @param Interrupt Any Edge Sensitive 0 single edge, 1 both edge
276 * Enable rising edge interrupts for all the pins in bank 2.
277 */
278
279 XGpioPs_SetIntrType(Gpio, 2, 0xffffffff, 0xFFFFFFFF, 0x00); // rising edge only
280
281 /*
282 * Set the handler for gpio interrupts.
283 */
284 printf("Set the handler for gpio interrupts.\n\r");
285 XGpioPs_SetCallbackHandler(Gpio, (void *)Gpio, IntrHandler);
286
287
288 /*
289 * Enable the GPIO interrupts of Bank 2.
290 */
291 printf("Enable the GPIO interrupts of Bank 2.\n\r");
292 XGpioPs_IntrEnable(Gpio, 2, 0xffffffff);
293
294
295 /*
296 * Enable the interrupt for the GPIO device.
297 */
298 printf("Enable the interrupt for the GPIO device. \n\r");
299 XScuGic_Enable(GicInstancePtr, GpioIntrId);
300
301
302 /*
303 * Enable interrupts in the Processor.
304 */
305 printf("Enable interrupts in the Processor \n\r");
306 Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
307
308 return XST_SUCCESS;
309 }
310
311
312 /****************************************************************************/
313 /**
314 * This function is the user layer callback function for the bank 0 interrupts of
315 * the GPIO device. It checks if all the switches have been pressed to stop the
316 * interrupt processing and exit from the example.
317 *
318 * @param CallBackRef is a pointer to the upper layer callback reference.
319 * @param Status is the Interrupt status of the GPIO bank.
320 *
321 * @return None.
322 *
323 * @note None.
324 *
325 ******************************************************************************/
326 static void IntrHandler(void *CallBackRef, int Bank, u32 Status)
327 {
328 // Is it necessary to close interrupt ?
329 printf("Enter interrupt \n\r");
330
331 /*
332 * Do nothing if the intr is generated for a different bank.
333 */
334 if (Bank == 2) {
335
336 switch (Status)
337 {
338 // Get interrupt source
339 case 1:
340 printf("The trigger is EMIO GPIO 0 of bank %d \n\r", Bank);
341 break;
342
343 }
344 } else {
345 return;
346 }
347 }
浙公网安备 33010602011771号