InPlay API
hal_gpio.h
1 
12 #ifndef HAL_GPIO_H
13 #define HAL_GPIO_H
14 
23 #include <stdint.h>
24 #include "in_mmap.h"
25 #include "in_compile.h"
26 
27 /*
28  * Defines
29  ****************************************************************************************
30  */
31 
32 #define GPIO_CFG_PIN_SHIFT 0
33 #define GPIO_CFG_PIN_MASK 0xF
34 #define GPIO_CFG_PORT_SHIFT 4
35 #define GPIO_CFG_PORT_MASK 0xF
36 #define GPIO_CFG_MUX_SHIFT 8
37 #define GPIO_CFG_MUX_MASK 0xF
38 #define GPIO_CFG_OE_IE_SHIFT 12
39 #define GPIO_CFG_OE_IE_MASK 0xF
40 #define GPIO_CFG_PD_PU_SHIFT 16
41 #define GPIO_CFG_PD_PU_MASK 0xF
42 #define GPIO_CFG_INV_SHIFT 20
43 #define GPIO_CFG_INV_MASK 0x1
44 #define GPIO_CFG_KEYBOARD_MUX_SHIFT 24
45 #define GPIO_CFG_KEYBOARD_MUX_MASK 0x3
46 
47 #define QSPI_CFG_PIN_SHIFT 0
48 #define QSPI_CFG_PIN_MASK 0xF
49 #define QSPI_CFG_MUX_SHIFT 4
50 #define QSPI_CFG_MUX_MASK 0xF
51 #define QSPI_CFG_OE_IE_SHIFT 8
52 #define QSPI_CFG_OE_IE_MASK 0xF
53 #define QSPI_CFG_PD_PU_SHIFT 12
54 #define QSPI_CFG_PD_PU_MASK 0xF
55 
56 #define GPIO_PORT_0_INT_RISE_EDGE_SHIFT 0
57 #define GPIO_PORT_0_INT_FALL_EDGE_SHIFT 9
58 #define GPIO_PORT_0_WUP_SHIFT 18
59 #define GPIO_PORT_0_INT_RISE_EDGE_MASK 0x1FF
60 #define GPIO_PORT_0_INT_FALL_EDGE_MASK (0x1FF << 9)
61 #define GPIO_PORT_0_WUP_MASK (0x1FF << 18)
62 #define GPIO_PORT_1_INT_RISE_EDGE_SHIFT 0
63 #define GPIO_PORT_1_INT_FALL_EDGE_SHIFT 10
64 #define GPIO_PORT_1_WUP_SHIFT 20
65 #define GPIO_PORT_1_INT_RISE_EDGE_MASK 0x3FF
66 #define GPIO_PORT_1_INT_FALL_EDGE_MASK (0x3FF << 10)
67 #define GPIO_PORT_1_WUP_MASK (0x3FF << 20)
68 #define GPIO_PORT_2_INT_RISE_EDGE_SHIFT 0
69 #define GPIO_PORT_2_INT_FALL_EDGE_SHIFT 10
70 #define GPIO_PORT_2_WUP_SHIFT 20
71 #define GPIO_PORT_2_INT_RISE_EDGE_MASK 0x3FF
72 #define GPIO_PORT_2_INT_FALL_EDGE_MASK (0x3FF << 10)
73 #define GPIO_PORT_2_WUP_MASK (0x3FF << 20)
74 #define GPIO_PORT_3_INT_RISE_EDGE_SHIFT 0
75 #define GPIO_PORT_3_INT_FALL_EDGE_SHIFT 6
76 #define GPIO_PORT_3_WUP_SHIFT 12
77 #define GPIO_PORT_3_INT_RISE_EDGE_MASK 0x3F
78 #define GPIO_PORT_3_INT_FALL_EDGE_MASK (0x3F << 6)
79 #define GPIO_PORT_3_WUP_MASK (0x3F << 12)
80 #define GPIO_PORT_4_INT_RISE_EDGE_SHIFT 0
81 #define GPIO_PORT_4_INT_FALL_EDGE_SHIFT 4
82 #define GPIO_PORT_4_WUP_SHIFT 8
83 #define GPIO_PORT_4_INT_RISE_EDGE_MASK 0xF
84 #define GPIO_PORT_4_INT_FALL_EDGE_MASK (0xF << 4)
85 #define GPIO_PORT_4_WUP_MASK (0xF << 8)
86 
87 #define GPIO_PORT_0_NB_PINS 9
88 #define GPIO_PORT_1_NB_PINS 10
89 #define GPIO_PORT_2_NB_PINS 9
90 #define GPIO_PORT_3_NB_PINS 6
91 #define GPIO_PORT_4_NB_PINS 4
92 #define GPIO_NB_PINS (GPIO_PORT_0_NB_PINS+GPIO_PORT_1_NB_PINS+GPIO_PORT_2_NB_PINS+GPIO_PORT_3_NB_PINS+GPIO_PORT_4_NB_PINS)
93 
94 /*
95  * Enumerations
96  ****************************************************************************************
97  */
98 enum gpio_port {
99  GPIO_PORT_0 = 0,
100  GPIO_PORT_1,
101  GPIO_PORT_2,
102  GPIO_PORT_3,
103  GPIO_PORT_4,
104  GPIO_PORT_MAX,
105 };
106 
107 enum gpio_pin {
108  GPIO_PIN_0,
109  GPIO_PIN_1,
110  GPIO_PIN_2,
111  GPIO_PIN_3,
112  GPIO_PIN_4,
113  GPIO_PIN_5,
114  GPIO_PIN_6,
115  GPIO_PIN_7,
116  GPIO_PIN_8,
117  GPIO_PIN_9,
118  GPIO_PIN_MAX,
119 };
120 
121 enum gpio_mux {
122  GPIO_MUX_0,
123  GPIO_MUX_1,
124  GPIO_MUX_2,
125  GPIO_MUX_3,
126  GPIO_MUX_4,
127  GPIO_MUX_5,
128  GPIO_MUX_6,
129  GPIO_MUX_7,
130  GPIO_MUX_MAX,
131 };
132 
133 enum qspi_pin {
134  QSPI_PIN_0,
135  QSPI_PIN_1,
136  QSPI_PIN_2,
137  QSPI_PIN_3,
138  QSPI_PIN_4,
139  QSPI_PIN_5,
140 };
141 
142 enum qspi_mux {
143  QSPI_MUX_0,
144  QSPI_MUX_1,
145  QSPI_MUX_2,
146  QSPI_MUX_3,
147  QSPI_MUX_4,
148  QSPI_MUX_5,
149 };
150 
151 enum gpio_slp_grp_0_port {
152  GPIO_SLP_GRP_0_PORT_0 = 0,
153  GPIO_SLP_GRP_0_PORT_1 = 1,
154  GPIO_SLP_GRP_0_PORT_3 = 3,
155  GPIO_SLP_GRP_0_PORT_4 = 4,
156 };
157 
158 enum gpio_slp_grp_0_port_0_pins {
159  GPIO_SLP_GRP_0_PORT_0_PIN_0 = 0,
160  GPIO_SLP_GRP_0_PORT_0_PIN_4 = 4,
161  GPIO_SLP_GRP_0_PORT_0_PIN_8 = 8,
162 };
163 
164 enum gpio_slp_grp_0_port_1_pins {
165  GPIO_SLP_GRP_0_PORT_1_PIN_2 = 2,
166  GPIO_SLP_GRP_0_PORT_1_PIN_6 = 6,
167 };
168 
169 enum gpio_slp_grp_0_port_3_pins {
170  GPIO_SLP_GRP_0_PORT_3_PIN_5 = 5,
171 };
172 
173 enum gpio_slp_grp_0_port_4_pins {
174  GPIO_SLP_GRP_0_PORT_4_PIN_1 = 1,
175 };
176 
177 enum gpio_slp_grp_1_port {
178  GPIO_SLP_GRP_1_PORT_0 = 0,
179  GPIO_SLP_GRP_1_PORT_1 = 1,
180  GPIO_SLP_GRP_1_PORT_3 = 3,
181  GPIO_SLP_GRP_1_PORT_4 = 4,
182 };
183 
184 enum gpio_slp_grp_1_port_0_pins {
185  GPIO_SLP_GRP_1_PORT_0_PIN_1 = 1,
186  GPIO_SLP_GRP_1_PORT_0_PIN_5 = 5,
187 };
188 
189 enum gpio_slp_grp_1_port_1_pins {
190  GPIO_SLP_GRP_1_PORT_1_PIN_3 = 3,
191  GPIO_SLP_GRP_1_PORT_1_PIN_7 = 7,
192 };
193 
194 enum gpio_slp_grp_1_port_3_pins {
195  GPIO_SLP_GRP_1_PORT_3_PIN_2 = 2,
196 };
197 
198 enum gpio_slp_grp_1_port_4_pins {
199  GPIO_SLP_GRP_1_PORT_4_PIN_2 = 2,
200 };
201 
202 enum gpio_slp_grp_2_port {
203  GPIO_SLP_GRP_2_PORT_0 = 0,
204  GPIO_SLP_GRP_2_PORT_1 = 1,
205  GPIO_SLP_GRP_2_PORT_3 = 3,
206  GPIO_SLP_GRP_2_PORT_4 = 4,
207 };
208 
209 enum gpio_slp_grp_2_port_0_pins {
210  GPIO_SLP_GRP_2_PORT_0_PIN_2 = 2,
211  GPIO_SLP_GRP_2_PORT_0_PIN_6 = 6,
212 };
213 
214 enum gpio_slp_grp_2_port_1_pins {
215  GPIO_SLP_GRP_2_PORT_1_PIN_0 = 0,
216  GPIO_SLP_GRP_2_PORT_1_PIN_4 = 4,
217  GPIO_SLP_GRP_2_PORT_1_PIN_8 = 8,
218 };
219 
220 enum gpio_slp_grp_2_port_3_pins {
221  GPIO_SLP_GRP_2_PORT_3_PIN_3 = 3,
222 };
223 
224 enum gpio_slp_grp_2_port_4_pins {
225  GPIO_SLP_GRP_2_PORT_4_PIN_3 = 3,
226 };
227 
228 enum gpio_slp_grp_3_port {
229  GPIO_SLP_GRP_3_PORT_0 = 0,
230  GPIO_SLP_GRP_3_PORT_1 = 1,
231  GPIO_SLP_GRP_3_PORT_3 = 3,
232  GPIO_SLP_GRP_3_PORT_4 = 4,
233 };
234 
235 enum gpio_slp_grp_3_port_0_pins {
236  GPIO_SLP_GRP_3_PORT_0_PIN_3 = 3,
237  GPIO_SLP_GRP_3_PORT_0_PIN_7 = 7,
238 };
239 
240 enum gpio_slp_grp_3_port_1_pins {
241  GPIO_SLP_GRP_3_PORT_1_PIN_1 = 1,
242  GPIO_SLP_GRP_3_PORT_1_PIN_5 = 5,
243  GPIO_SLP_GRP_3_PORT_1_PIN_9 = 9,
244 };
245 
246 enum gpio_slp_grp_3_port_3_pins {
247  GPIO_SLP_GRP_3_PORT_3_PIN_4 = 4,
248 };
249 
250 enum gpio_slp_grp_3_port_4_pins {
251  GPIO_SLP_GRP_3_PORT_4_PIN_0 = 0,
252 };
253 
254 enum gpio_slp_grp_0_pin_mux {
255  GPIO_SLP_GRP_0_MUX_NONE = 0,
256  GPIO_SLP_GRP_0_MUX_AON_CLK = 1,
257  GPIO_SLP_GRP_0_MUX_PD1_WDT_RESET_PD0 = 2,
258  GPIO_SLP_GRP_0_MUX_SQ_WAVE = 3,
259  GPIO_SLP_GRP_0_MUX_PD1_WDT_RESET_PD1 = 4,
260  GPIO_SLP_GRP_0_MUX_DCDC_EN = 5,
261  GPIO_SLP_GRP_0_MUX_WDT_RESET_PD0 = 6,
262  GPIO_SLP_GRP_0_MUX_WDT_RESET_PD0_INV = 7,
263 };
264 
265 enum gpio_slp_grp_1_pin_mux {
266  GPIO_SLP_GRP_1_MUX_NONE = 0,
267  GPIO_SLP_GRP_1_MUX_PD1_RESET = 1,
268  GPIO_SLP_GRP_1_MUX_PD1_RESET_INV = 2,
269  GPIO_SLP_GRP_1_MUX_FLASH_POW = 3,
270  GPIO_SLP_GRP_1_MUX_OSC_EN = 4,
271  GPIO_SLP_GRP_1_MUX_SQ_WAVE = 5,
272  GPIO_SLP_GRP_1_MUX_WUP_REQ = 6,
273  GPIO_SLP_GRP_1_MUX_BLE_CLK_ON = 7,
274 };
275 
276 enum gpio_slp_grp_2_pin_mux {
277  GPIO_SLP_GRP_2_MUX_NONE = 0,
278  GPIO_SLP_GRP_2_MUX_SLP_REQ = 1,
279  GPIO_SLP_GRP_2_MUX_RTC_CLK = 2,
280  GPIO_SLP_GRP_2_MUX_RC_CLK = 3,
281  GPIO_SLP_GRP_2_MUX_AON_TIMER_0_TMO = 4,
282  GPIO_SLP_GRP_2_MUX_AON_TIMER_1_TMO = 5,
283  GPIO_SLP_GRP_2_MUX_AON_TIMER_2_TMO = 6,
284  GPIO_SLP_GRP_2_MUX_AON_TIMER_3_TMO = 7,
285 };
286 
287 enum gpio_slp_grp_3_pin_mux {
288  GPIO_SLP_GRP_3_MUX_NONE = 0,
289  GPIO_SLP_GRP_3_MUX_EM_16K_EN = 1,
290  GPIO_SLP_GRP_3_MUX_EM_16K_RETN = 2,
291  GPIO_SLP_GRP_3_MUX_DM_32K_A_EN = 3,
292  GPIO_SLP_GRP_3_MUX_DM_32K_RETN = 4,
293  GPIO_SLP_GRP_3_MUX_DM_32K_B_EN = 5,
294  GPIO_SLP_GRP_3_MUX_DM_32K_B_RETN = 6,
295  GPIO_SLP_GRP_3_MUX_SENSOR_POW = 7,
296 };
297 
298 enum gpio_err {
299  GPIO_ERR_NO_ERROR = 0,
300  GPIO_ERR_INVALID_PARAM = -1,
301 };
302 
303 enum gpio_pull_cfg {
304  GPIO_NO_PULL = 0,
305  GPIO_PULL_UP,
306  GPIO_PULL_DOWN,
307 };
308 /*
309  * Type Defines
310  ****************************************************************************************
311  */
312 typedef struct {
313  uint8_t port;
314  uint8_t pin;
315 } gio_aon_grp_t;
316 
317 /*
318  * Inline Functions
319  ****************************************************************************************
320  */
321 
322 static INLINE void gpio_port_0_pin_mux(int pin, int mux, int inv)
323 {
324  uint32_t addr;
325 
326  if (pin >= 8) {
327  pin -= 8;
328  addr = GLOBAL_REG_PIN_MUX_GPIO_01_CONT;
329  } else {
330  addr = GLOBAL_REG_PIN_MUX_GPIO_0;
331  }
332 
333  uint32_t reg = RD_WORD(addr);
334 
335  reg &= ~(0x7 << (pin << 2));
336  reg |= ((mux & 0x7) << (pin << 2));
337  if (inv)
338  reg |= (1 << ((pin << 2) + 3));
339  else
340  reg &= ~(1 << ((pin << 2) + 3));
341 
342  WR_WORD(addr, reg);
343 }
344 
345 static INLINE void gpio_port_1_pin_mux(int pin, int mux, int inv)
346 {
347  uint32_t addr;
348 
349  if (pin >= 8) {
350  pin -= 8;
351  pin += 1;
352  addr = GLOBAL_REG_PIN_MUX_GPIO_01_CONT;
353  } else {
354  addr = GLOBAL_REG_PIN_MUX_GPIO_1;
355  }
356 
357  uint32_t reg = RD_WORD(addr);
358 
359  reg &= ~(0x7 << (pin << 2));
360  reg |= ((mux & 0x7) << (pin << 2));
361  if (inv)
362  reg |= (1 << ((pin << 2) + 3));
363  else
364  reg &= ~(1 << ((pin << 2) + 3));
365 
366 
367  WR_WORD(addr, reg);
368 }
369 
370 
371 static INLINE void gpio_port_2_pin_mux(int pin, int mux, int inv)
372 {
373  uint32_t addr;
374 
375  if (pin >= 8) {
376  pin -= 8;
377  addr = GLOBAL_REG_PIN_MUX_GPIO_23_CONT;
378  } else {
379  addr = GLOBAL_REG_PIN_MUX_GPIO_2;
380  }
381 
382  uint32_t reg = RD_WORD(addr);
383 
384  reg &= ~(0x7 << (pin << 2));
385  reg |= ((mux & 0x7) << (pin << 2));
386  if (inv)
387  reg |= (1 << ((pin << 2) + 3));
388  else
389  reg &= ~(1 << ((pin << 2) + 3));
390 
391 
392  WR_WORD(addr, reg);
393 }
394 
395 static INLINE void gpio_port_3_pin_mux(int pin, int mux, int inv)
396 {
397  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_23_CONT);
398 
399  pin += 1;
400  reg &= ~(0x7 << (pin << 2));
401  reg |= ((mux & 0x7) << (pin << 2));
402  if (inv)
403  reg |= (1 << ((pin << 2) + 3));
404  else
405  reg &= ~(1 << ((pin << 2) + 3));
406 
407  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_23_CONT, reg);
408 }
409 
410 static INLINE void gpio_port_4_pin_mux(int pin, int mux, int inv)
411 {
412  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_4);
413 
414  reg &= ~(0x7 << (pin << 2));
415  reg |= ((mux & 0x7) << (pin << 2));
416  if (inv)
417  reg |= (1 << ((pin << 2) + 3));
418  else
419  reg &= ~(1 << ((pin << 2) + 3));
420 
421  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_4, reg);
422 }
423 
424 static INLINE uint32_t gpio_port_0_pin_mux_get(void)
425 {
426  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_0));
427 }
428 
429 static INLINE uint32_t gpio_port_0_pin_mux_cont_get(void)
430 {
431  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_01_CONT) & 0xF);
432 }
433 
434 static INLINE uint32_t gpio_port_1_pin_mux_get(void)
435 {
436  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_1));
437 }
438 
439 static INLINE uint32_t gpio_port_1_pin_mux_cont_get(void)
440 {
441  return ((RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_01_CONT) >> 4));
442 }
443 
444 static INLINE uint32_t gpio_port_2_pin_mux_get(void)
445 {
446  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_2));
447 }
448 
449 static INLINE uint32_t gpio_port_2_pin_mux_cont_get(void)
450 {
451  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_23_CONT) & 0xF);
452 }
453 
454 static INLINE uint32_t gpio_port_3_pin_mux_get(void)
455 {
456  return ((RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_23_CONT) >> 4));
457 }
458 
459 static INLINE uint32_t gpio_port_4_pin_mux_get(void)
460 {
461  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_4));
462 }
463 
464 static INLINE void gpio_port_0_output_enable(int pin)
465 {
466  WR_WORD(GLOBAL_REG_GPIO_0_OUTPUT_SET, (1 << (GLOBAL_REG_GPIO_0_OUTPUT_SET_CTL_GPIO_0_OUTPUT_EN_SET_SHIFT + pin)));
467 }
468 
469 static INLINE void gpio_port_0_output_disable(int pin)
470 {
471  WR_WORD(GLOBAL_REG_GPIO_0_OUTPUT_CLEAR, (1 << (GLOBAL_REG_GPIO_0_OUTPUT_CLEAR_CTL_GPIO_0_OUTPUT_EN_CLEAR_SHIFT + pin)));
472 
473 }
474 
475 static INLINE void gpio_port_0_output(int pin, int high)
476 {
477  if (high) {
478  WR_WORD(GLOBAL_REG_GPIO_0_OUTPUT_SET, (1 << pin));
479  } else {
480  WR_WORD(GLOBAL_REG_GPIO_0_OUTPUT_CLEAR, (1 << pin));
481  }
482 }
483 
484 static INLINE int gpio_port_0_output_status(int pin)
485 {
486  return ((RD_WORD(GLOBAL_REG_GPIO_0_IO_STATUS) >> (GLOBAL_REG_GPIO_0_IO_STATUS_STS_GPIO_0_CURR_OUTPUT_SHIFT + pin)) & 1);
487 }
488 
489 static INLINE void gpio_port_1_output_enable(int pin)
490 {
491  WR_WORD(GLOBAL_REG_GPIO_1_OUTPUT_SET, (1 << (GLOBAL_REG_GPIO_1_OUTPUT_SET_CTL_GPIO_1_OUTPUT_EN_SET_SHIFT + pin)));
492 }
493 
494 static INLINE void gpio_port_1_output_disable(int pin)
495 {
496  WR_WORD(GLOBAL_REG_GPIO_1_OUTPUT_CLEAR, (1 << (GLOBAL_REG_GPIO_1_OUTPUT_CLEAR_CTL_GPIO_1_OUTPUT_EN_CLEAR_SHIFT + pin)));
497 
498 }
499 
500 static INLINE void gpio_port_1_output(int pin, int high)
501 {
502  if (high) {
503  WR_WORD(GLOBAL_REG_GPIO_1_OUTPUT_SET, (1 << pin));
504  } else {
505  WR_WORD(GLOBAL_REG_GPIO_1_OUTPUT_CLEAR, (1 << pin));
506  }
507 }
508 
509 static INLINE int gpio_port_1_output_status(int pin)
510 {
511  return ((RD_WORD(GLOBAL_REG_GPIO_1_IO_STATUS) >> (GLOBAL_REG_GPIO_1_IO_STATUS_STS_GPIO_1_CURR_OUTPUT_SHIFT + pin)) & 1);
512 }
513 
514 static INLINE void gpio_port_2_output_enable(int pin)
515 {
516  WR_WORD(GLOBAL_REG_GPIO_2_OUTPUT_SET, (1 << (GLOBAL_REG_GPIO_2_OUTPUT_SET_CTL_GPIO_2_OUTPUT_EN_SET_SHIFT + pin)));
517 }
518 
519 static INLINE void gpio_port_2_output_disable(int pin)
520 {
521  WR_WORD(GLOBAL_REG_GPIO_2_OUTPUT_CLEAR, (1 << (GLOBAL_REG_GPIO_2_OUTPUT_CLEAR_CTL_GPIO_2_OUTPUT_EN_CLEAR_SHIFT + pin)));
522 
523 }
524 
525 static INLINE void gpio_port_2_output(int pin, int high)
526 {
527  if (high) {
528  WR_WORD(GLOBAL_REG_GPIO_2_OUTPUT_SET, (1 << pin));
529  } else {
530  WR_WORD(GLOBAL_REG_GPIO_2_OUTPUT_CLEAR, (1 << pin));
531  }
532 }
533 
534 static INLINE int gpio_port_2_output_status(int pin)
535 {
536  return ((RD_WORD(GLOBAL_REG_GPIO_2_IO_STATUS) >> (GLOBAL_REG_GPIO_2_IO_STATUS_STS_GPIO_2_CURR_OUTPUT_SHIFT + pin)) & 1);
537 }
538 
539 static INLINE void gpio_port_3_output_enable(int pin)
540 {
541  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_SET, (1 << (GLOBAL_REG_GPIO_34_OUTPUT_SET_CTL_GPIO_3_OUTPUT_EN_SET_SHIFT + pin)));
542 }
543 
544 static INLINE void gpio_port_3_output_disable(int pin)
545 {
546  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_CLEAR, (1 << (GLOBAL_REG_GPIO_34_OUTPUT_CLEAR_CTL_GPIO_3_OUTPUT_EN_CLEAR_SHIFT + pin)));
547 }
548 
549 static INLINE void gpio_port_3_output(int pin, int high)
550 {
551  if (high) {
552  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_SET, (1 << pin));
553  } else {
554  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_CLEAR, (1 << pin));
555  }
556 }
557 
558 static INLINE int gpio_port_3_output_status(int pin)
559 {
560  return ((RD_WORD(GLOBAL_REG_GPIO_34_IO_STATUS) >> (GLOBAL_REG_GPIO_34_IO_STATUS_STS_GPIO_3_CURR_OUTPUT_SHIFT + pin)) & 1);
561 }
562 
563 static INLINE void gpio_port_4_output_enable(int pin)
564 {
565  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_SET, (1 << (GLOBAL_REG_GPIO_34_OUTPUT_SET_CTL_GPIO_4_OUTPUT_EN_SET_SHIFT + pin)));
566 }
567 
568 static INLINE void gpio_port_4_output_disable(int pin)
569 {
570  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_CLEAR, (1 << (GLOBAL_REG_GPIO_34_OUTPUT_CLEAR_CTL_GPIO_4_OUTPUT_EN_CLEAR_SHIFT + pin)));
571 }
572 
573 static INLINE void gpio_port_4_output(int pin, int high)
574 {
575  if (high) {
576  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_SET, (1 << (pin + GLOBAL_REG_GPIO_34_OUTPUT_SET_CTL_GPIO_4_OUTPUT_SET_SHIFT)));
577  } else {
578  WR_WORD(GLOBAL_REG_GPIO_34_OUTPUT_CLEAR, (1 << (pin + GLOBAL_REG_GPIO_34_OUTPUT_CLEAR_CTL_GPIO_4_OUTPUT_CLEAR_SHIFT)));
579  }
580 }
581 
582 static INLINE int gpio_port_4_output_status(int pin)
583 {
584  return ((RD_WORD(GLOBAL_REG_GPIO_34_IO_STATUS) >> (GLOBAL_REG_GPIO_34_IO_STATUS_STS_GPIO_4_CURR_OUTPUT_SHIFT + pin)) & 1);
585 }
586 
587 static INLINE int gpio_port_0_input(int pin)
588 {
589  return ((RD_WORD(GLOBAL_REG_GPIO_0_IO_STATUS) >> pin) & 1);
590 }
591 
592 static INLINE int gpio_port_1_input(int pin)
593 {
594  return ((RD_WORD(GLOBAL_REG_GPIO_1_IO_STATUS) >> pin) & 1);
595 }
596 
597 static INLINE int gpio_port_2_input(int pin)
598 {
599  return ((RD_WORD(GLOBAL_REG_GPIO_2_IO_STATUS) >> pin) & 1);
600 }
601 
602 static INLINE int gpio_port_3_input(int pin)
603 {
604  return ((RD_WORD(GLOBAL_REG_GPIO_34_IO_STATUS) >> pin) & 1);
605 }
606 
607 static INLINE int gpio_port_4_input(int pin)
608 {
609  return ((RD_WORD(GLOBAL_REG_GPIO_34_IO_STATUS) >> (pin + GLOBAL_REG_GPIO_34_IO_STATUS_STS_GPIO_4_INPUT_SHIFT)) & 1);
610 }
611 
612 static INLINE void gpio_port_0_pad_oe_ie(int pin, int oe, int ie)
613 {
614  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_0_OE_IE);
615 
616  if (oe)
617  reg |= (1 << pin);
618  else
619  reg &= ~(1 << pin);
620 
621  if (ie)
622  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_0_OE_IE_CTL_GPIO_TO_PAD_IE_0_SHIFT));
623  else
624  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_0_OE_IE_CTL_GPIO_TO_PAD_IE_0_SHIFT));
625 
626  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_0_OE_IE, reg);
627 }
628 
629 static INLINE uint32_t gpio_port_0_pad_oe_ie_get(void)
630 {
631  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_0_OE_IE));
632 }
633 
634 static INLINE void gpio_port_1_pad_oe_ie(int pin, int oe, int ie)
635 {
636  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_1_OE_IE);
637 
638  if (oe)
639  reg |= (1 << pin);
640  else
641  reg &= ~(1 << pin);
642 
643  if (ie)
644  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_1_OE_IE_CTL_GPIO_TO_PAD_IE_1_SHIFT));
645  else
646  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_1_OE_IE_CTL_GPIO_TO_PAD_IE_1_SHIFT));
647 
648  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_1_OE_IE, reg);
649 
650 }
651 
652 static INLINE uint32_t gpio_port_1_pad_oe_ie_get(void)
653 {
654  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_1_OE_IE));
655 }
656 
657 static INLINE void gpio_port_2_pad_oe_ie(int pin, int oe, int ie)
658 {
659  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_2_OE_IE);
660 
661  if (oe)
662  reg |= (1 << pin);
663  else
664  reg &= ~(1 << pin);
665 
666  if (ie)
667  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_2_OE_IE_CTL_GPIO_TO_PAD_IE_2_SHIFT));
668  else
669  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_2_OE_IE_CTL_GPIO_TO_PAD_IE_2_SHIFT));
670 
671  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_2_OE_IE, reg);
672 
673 }
674 
675 static INLINE uint32_t gpio_port_2_pad_oe_ie_get(void)
676 {
677  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_2_OE_IE));
678 }
679 
680 static INLINE void gpio_port_3_pad_oe_ie(int pin, int oe, int ie)
681 {
682  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE);
683 
684  if (oe)
685  reg |= (1 << pin);
686  else
687  reg &= ~(1 << pin);
688 
689  if (ie)
690  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE_CTL_GPIO_TO_PAD_IE_3_SHIFT));
691  else
692  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE_CTL_GPIO_TO_PAD_IE_3_SHIFT));
693 
694  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE, reg);
695 
696 }
697 
698 static INLINE void gpio_port_4_pad_oe_ie(int pin, int oe, int ie)
699 {
700  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE);
701 
702  if (oe)
703  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE_CTL_GPIO_TO_PAD_OE_4_SHIFT));
704  else
705  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE_CTL_GPIO_TO_PAD_OE_4_SHIFT));
706 
707  if (ie)
708  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE_CTL_GPIO_TO_PAD_IE_4_SHIFT));
709  else
710  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE_CTL_GPIO_TO_PAD_IE_4_SHIFT));
711 
712  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE, reg);
713 }
714 
715 static INLINE uint32_t gpio_port_34_pad_oe_ie_get(void)
716 {
717  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_OE_IE));
718 }
719 
720 static INLINE void gpio_port_0_pad_pd_pu(int pin, int pd, int pu)
721 {
722  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_0_PD_PU);
723  if (pd)
724  reg |= (1 << pin);
725  else
726  reg &= ~(1 << pin);
727 
728  if (pu)
729  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_0_PD_PU_CTL_GPIO_TO_PAD_PU_0_SHIFT));
730  else
731  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_0_PD_PU_CTL_GPIO_TO_PAD_PU_0_SHIFT));
732 
733  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_0_PD_PU, reg);
734 }
735 
736 static INLINE uint32_t gpio_port_0_pad_pd_pu_get(void)
737 {
738  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_0_PD_PU));
739 }
740 
741 static INLINE void gpio_port_1_pad_pd_pu(int pin, int pd, int pu)
742 {
743  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_1_PD_PU);
744  if (pd)
745  reg |= (1 << pin);
746  else
747  reg &= ~(1 << pin);
748 
749  if (pu)
750  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_1_PD_PU_CTL_GPIO_TO_PAD_PU_1_SHIFT));
751  else
752  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_1_PD_PU_CTL_GPIO_TO_PAD_PU_1_SHIFT));
753 
754  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_1_PD_PU, reg);
755 }
756 
757 static INLINE uint32_t gpio_port_1_pad_pd_pu_get(void)
758 {
759  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_1_PD_PU));
760 }
761 
762 static INLINE void gpio_port_2_pad_pd_pu(int pin, int pd, int pu)
763 {
764  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_2_PD_PU);
765  if (pd)
766  reg |= (1 << pin);
767  else
768  reg &= ~(1 << pin);
769 
770  if (pu)
771  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_2_PD_PU_CTL_GPIO_TO_PAD_PU_2_SHIFT));
772  else
773  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_2_PD_PU_CTL_GPIO_TO_PAD_PU_2_SHIFT));
774 
775  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_2_PD_PU, reg);
776 }
777 
778 static INLINE uint32_t gpio_port_2_pad_pd_pu_get(void)
779 {
780  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_2_PD_PU));
781 }
782 
783 static INLINE void gpio_port_3_pad_pd_pu(int pin, int pd, int pu)
784 {
785  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU);
786  if (pd)
787  reg |= (1 << pin);
788  else
789  reg &= ~(1 << pin);
790 
791  if (pu)
792  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU_CTL_GPIO_TO_PAD_PU_3_SHIFT));
793  else
794  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU_CTL_GPIO_TO_PAD_PU_3_SHIFT));
795 
796  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU, reg);
797 }
798 
799 static INLINE void gpio_port_4_pad_pd_pu(int pin, int pd, int pu)
800 {
801  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU);
802  if (pd)
803  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU_CTL_GPIO_TO_PAD_PD_4_SHIFT));
804  else
805  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU_CTL_GPIO_TO_PAD_PD_4_SHIFT));
806 
807  if (pu)
808  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU_CTL_GPIO_TO_PAD_PU_4_SHIFT));
809  else
810  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU_CTL_GPIO_TO_PAD_PU_4_SHIFT));
811 
812  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU, reg);
813 }
814 
815 static INLINE uint32_t gpio_port_34_pad_pd_pu_get(void)
816 {
817  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_34_PD_PU));
818 }
819 
820 static INLINE void gpio_port_0_pad_pc(int pin, int on)
821 {
822  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_01);
823 
824  pin &= GLOBAL_REG_PIN_MUX_GPIO_PC_01_CTL_GPIO_TO_PAD_PC_0_MASK;
825  if (on)
826  reg |= (1 << pin);
827  else
828  reg &= ~(1 << pin);
829 
830  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_01, reg);
831 }
832 
833 static INLINE void gpio_port_1_pad_pc(int pin, int on)
834 {
835  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_01);
836 
837  pin &= GLOBAL_REG_PIN_MUX_GPIO_PC_01_CTL_GPIO_TO_PAD_PC_1_MASK;
838  if (on)
839  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_PC_01_CTL_GPIO_TO_PAD_PC_1_SHIFT));
840  else
841  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_PC_01_CTL_GPIO_TO_PAD_PC_1_SHIFT));
842 
843  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_01, reg);
844 }
845 
846 static INLINE uint32_t gpio_port_01_pad_pc_get(void)
847 {
848  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_01));
849 }
850 
851 static INLINE void gpio_port_2_pad_pc(int pin, int on)
852 {
853  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234);
854 
855  pin &= GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_2_MASK;
856  if (on)
857  reg |= (1 << pin);
858  else
859  reg &= ~(1 << pin);
860 
861  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234, reg);
862 }
863 
864 static INLINE void gpio_port_3_pad_pc(int pin, int on)
865 {
866  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234);
867 
868  pin &= GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_3_MASK;
869  if (on)
870  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_3_SHIFT));
871  else
872  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_3_SHIFT));
873 
874  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234, reg);
875 }
876 
877 static INLINE void gpio_port_4_pad_pc(int pin, int on)
878 {
879  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234);
880 
881  pin &= GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_4_MASK;
882  if (on)
883  reg |= (1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_4_SHIFT));
884  else
885  reg &= ~(1 << (pin + GLOBAL_REG_PIN_MUX_GPIO_PC_234_CTL_GPIO_TO_PAD_PC_4_SHIFT));
886 
887  WR_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234, reg);
888 }
889 
890 static INLINE uint32_t gpio_port_23_pad_pc_get(void)
891 {
892  return (RD_WORD(GLOBAL_REG_PIN_MUX_GPIO_PC_234));
893 }
894 
895 static INLINE void gpio_qspi_pin_pad_pc(uint8_t pc_mask)
896 {
897  uint32_t reg = RD_WORD(GLOBAL_REG_QSPI_PC);
898 
899  reg &= ~GLOBAL_REG_QSPI_PC_CTL_QSPI_PC;
900  reg |= (pc_mask & GLOBAL_REG_QSPI_PC_CTL_QSPI_PC_MASK) << GLOBAL_REG_QSPI_PC_CTL_QSPI_PC_SHIFT;
901 
902  WR_WORD(GLOBAL_REG_QSPI_PC, reg);
903 }
904 
905 static INLINE void gpio_qspi_pin_pad_pc_set(uint32_t reg)
906 {
907  WR_WORD(GLOBAL_REG_QSPI_PC, reg);
908 }
909 
910 static INLINE uint32_t gpio_qspi_pin_pad_pc_get(void)
911 {
912  return RD_WORD(GLOBAL_REG_QSPI_PC);
913 }
914 
915 static INLINE void gpio_qspi_pin_mux(uint8_t mux0, uint8_t mux2, uint8_t mux3, uint8_t mux4, uint8_t mux5)
916 {
917  uint32_t reg = RD_WORD(GLOBAL_REG_PIN_MUX_QSPI);
918 
919  // pin 0
920  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_0_SEL;
921  reg |= (mux0 & GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_0_SEL_MASK) << GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_0_SEL_SHIFT;
922  if (mux0 & 0x80)
923  reg |= GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_0_INV;
924  else
925  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_0_INV;
926  // pin 1 - clock pin, always mux 1
927  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_1_SEL;
928  reg |= (1 & GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_1_SEL_MASK) << GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_1_SEL_SHIFT;
929  // pin 2
930  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_2_SEL;
931  reg |= (mux2 & GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_2_SEL_MASK) << GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_2_SEL_SHIFT;
932  if (mux2 & 0x80)
933  reg |= GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_2_INV;
934  else
935  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_2_INV;
936  // pin 3
937  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_3_SEL;
938  reg |= (mux3 & GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_3_SEL_MASK) << GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_3_SEL_SHIFT;
939  if (mux3 & 0x80)
940  reg |= GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_3_INV;
941  else
942  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_3_INV;
943  // pin 4
944  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_4_SEL;
945  reg |= (mux4 & GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_4_SEL_MASK) << GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_4_SEL_SHIFT;
946  if (mux4 & 0x80)
947  reg |= GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_4_INV;
948  else
949  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_4_INV;
950  // pin 5
951  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_5_SEL;
952  reg |= (mux5 & GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_5_SEL_MASK) << GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_5_SEL_SHIFT;
953  if (mux5 & 0x80)
954  reg |= GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_5_INV;
955  else
956  reg &= ~GLOBAL_REG_PIN_MUX_QSPI_CTL_PIN_MUX_QSPI_5_INV;
957 
958  // QSPI pin mux based on the above
959  reg |= GLOBAL_REG_PIN_MUX_QSPI_CTL_QSPI_EFUSE0REG1;
960 
961 
962  WR_WORD(GLOBAL_REG_PIN_MUX_QSPI, reg);
963 }
964 
965 static INLINE void gpio_qspi_pin_mux_set(uint32_t reg)
966 {
967  WR_WORD(GLOBAL_REG_PIN_MUX_QSPI, reg);
968 }
969 
970 static INLINE uint32_t gpio_qspi_pin_mux_get(void)
971 {
972  return RD_WORD(GLOBAL_REG_PIN_MUX_QSPI);
973 }
974 
975 static INLINE void gpio_qspi_pin_pad_ie_oe_pu_pd(uint8_t oe_mask, uint8_t ie_mask, uint8_t pu_mask, uint8_t pd_mask)
976 {
977  uint32_t reg = RD_WORD(GLOBAL_REG_QSPI_OE_IE_PU_PD);
978 
979  // oe
980  reg &= ~GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_OE;
981  reg |= (oe_mask & GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_OE_MASK) << GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_OE_SHIFT;
982  // ie
983  reg &= ~GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_IE;
984  reg |= (ie_mask & GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_IE_MASK) << GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_IE_SHIFT;
985  // pu
986  reg &= ~GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_PU;
987  reg |= (pu_mask & GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_PU_MASK) << GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_PU_SHIFT;
988  // pd
989  reg &= ~GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_PD;
990  reg |= (pd_mask & GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_PD_MASK) << GLOBAL_REG_QSPI_OE_IE_PU_PD_CTL_QSPI_PD_SHIFT;
991 
992  WR_WORD(GLOBAL_REG_QSPI_OE_IE_PU_PD, reg);
993 }
994 
995 static INLINE void gpio_qspi_pin_pad_ie_oe_pu_pd_set(uint32_t reg)
996 {
997  WR_WORD(GLOBAL_REG_QSPI_OE_IE_PU_PD, reg);
998 }
999 
1000 static INLINE uint32_t gpio_qspi_pin_pad_ie_oe_pu_pd_get(void)
1001 {
1002  return (RD_WORD(GLOBAL_REG_QSPI_OE_IE_PU_PD));
1003 }
1004 
1005 static INLINE uint32_t gpio_port_0_int_status(void)
1006 {
1007  return (RD_WORD(GLOBAL_REG_INTR_GPIO_0_STATUS));
1008 }
1009 
1010 static INLINE void gpio_port_0_int_clear(uint32_t pin)
1011 {
1012  uint32_t reg = (1 << pin) | (1 << (pin + GPIO_PORT_0_INT_FALL_EDGE_SHIFT)) | (1 << (pin + GPIO_PORT_0_WUP_SHIFT));
1013  WR_WORD(GLOBAL_REG_INTR_GPIO_0_CLEAR, reg);
1014 }
1015 
1016 static INLINE void gpio_port_0_int_clear_all(void)
1017 {
1018  WR_WORD(GLOBAL_REG_INTR_GPIO_0_CLEAR, GLOBAL_REG_INTR_GPIO_0_CLEAR_IRQ);
1019 }
1020 
1021 static INLINE uint32_t gpio_port_0_int_mask_status(void)
1022 {
1023  return (RD_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_STATUS));
1024 }
1025 
1026 static INLINE void gpio_port_0_int_mask_all(void)
1027 {
1028  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_SET, GLOBAL_REG_INTR_GPIO_0_MASK_SET_IRQ);
1029 }
1030 
1031 static INLINE void gpio_port_0_int_mask(uint32_t mask)
1032 {
1033  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_SET, mask);
1034 }
1035 
1036 static INLINE void gpio_port_0_int_mask_rise(int pin)
1037 {
1038  uint32_t reg = (1 << (pin + GPIO_PORT_0_INT_RISE_EDGE_SHIFT));
1039  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_SET, reg);
1040 }
1041 
1042 static INLINE void gpio_port_0_int_mask_fall(int pin)
1043 {
1044  uint32_t reg = (1 << (pin + GPIO_PORT_0_INT_FALL_EDGE_SHIFT));
1045  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_SET, reg);
1046 }
1047 
1048 static INLINE void gpio_port_0_int_mask_wup(int pin)
1049 {
1050  uint32_t reg = (1 << (pin + GPIO_PORT_0_WUP_SHIFT));
1051  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_SET, reg);
1052 }
1053 
1054 static INLINE void gpio_port_0_int_unmask(uint32_t mask)
1055 {
1056  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_CLEAR, mask);
1057 }
1058 
1059 static INLINE void gpio_port_0_int_unmask_rise(int pin)
1060 {
1061  uint32_t reg = (1 << (pin + GPIO_PORT_0_INT_RISE_EDGE_SHIFT));
1062  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_CLEAR, reg);
1063 }
1064 
1065 static INLINE void gpio_port_0_int_unmask_fall(int pin)
1066 {
1067  uint32_t reg = (1 << (pin + GPIO_PORT_0_INT_FALL_EDGE_SHIFT));
1068  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_CLEAR, reg);
1069 }
1070 
1071 static INLINE void gpio_port_0_int_unmask_wup(int pin)
1072 {
1073  uint32_t reg = (1 << (pin + GPIO_PORT_0_WUP_SHIFT));
1074  WR_WORD(GLOBAL_REG_INTR_GPIO_0_MASK_CLEAR, reg);
1075 }
1076 
1077 static INLINE uint32_t gpio_port_1_int_status(void)
1078 {
1079  return (RD_WORD(GLOBAL_REG_INTR_GPIO_1_STATUS));
1080 }
1081 
1082 static INLINE void gpio_port_1_int_clear(uint32_t pin)
1083 {
1084  uint32_t reg = (1 << pin) | (1 << (pin + GPIO_PORT_1_INT_FALL_EDGE_SHIFT)) | (1 << (pin + GPIO_PORT_1_WUP_SHIFT));
1085  WR_WORD(GLOBAL_REG_INTR_GPIO_1_CLEAR, reg);
1086 }
1087 
1088 static INLINE void gpio_port_1_int_clear_all(void)
1089 {
1090  WR_WORD(GLOBAL_REG_INTR_GPIO_1_CLEAR, GLOBAL_REG_INTR_GPIO_1_CLEAR_IRQ);
1091 }
1092 
1093 static INLINE uint32_t gpio_port_1_int_mask_status(void)
1094 {
1095  return (RD_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_STATUS));
1096 }
1097 
1098 static INLINE void gpio_port_1_int_mask_all(void)
1099 {
1100  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_SET, GLOBAL_REG_INTR_GPIO_1_MASK_SET_IRQ);
1101 }
1102 
1103 static INLINE void gpio_port_1_int_mask(uint32_t mask)
1104 {
1105  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_SET, mask);
1106 }
1107 
1108 static INLINE void gpio_port_1_int_mask_rise(int pin)
1109 {
1110  uint32_t reg = (1 << (pin + GPIO_PORT_1_INT_RISE_EDGE_SHIFT));
1111  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_SET, reg);
1112 }
1113 
1114 static INLINE void gpio_port_1_int_mask_fall(int pin)
1115 {
1116  uint32_t reg = (1 << (pin + GPIO_PORT_1_INT_FALL_EDGE_SHIFT));
1117  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_SET, reg);
1118 }
1119 
1120 static INLINE void gpio_port_1_int_mask_wup(int pin)
1121 {
1122  uint32_t reg = (1 << (pin + GPIO_PORT_1_WUP_SHIFT));
1123  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_SET, reg);
1124 }
1125 
1126 static INLINE void gpio_port_1_int_unmask(uint32_t mask)
1127 {
1128  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_CLEAR, mask);
1129 }
1130 
1131 static INLINE void gpio_port_1_int_unmask_rise(int pin)
1132 {
1133  uint32_t reg = (1 << (pin + GPIO_PORT_1_INT_RISE_EDGE_SHIFT));
1134  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_CLEAR, reg);
1135 }
1136 
1137 static INLINE void gpio_port_1_int_unmask_fall(int pin)
1138 {
1139  uint32_t reg = (1 << (pin + GPIO_PORT_1_INT_FALL_EDGE_SHIFT));
1140  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_CLEAR, reg);
1141 }
1142 
1143 static INLINE void gpio_port_1_int_unmask_wup(int pin)
1144 {
1145  uint32_t reg = (1 << (pin + GPIO_PORT_1_WUP_SHIFT));
1146  WR_WORD(GLOBAL_REG_INTR_GPIO_1_MASK_CLEAR, reg);
1147 }
1148 
1149 static INLINE uint32_t gpio_port_2_int_status(void)
1150 {
1151  return (RD_WORD(GLOBAL_REG_INTR_GPIO_2_STATUS));
1152 }
1153 
1154 static INLINE void gpio_port_2_int_clear(uint32_t pin)
1155 {
1156  uint32_t reg = (1 << pin) | (1 << (pin + GPIO_PORT_2_INT_FALL_EDGE_SHIFT)) | (1 << (pin + GPIO_PORT_2_WUP_SHIFT));
1157  WR_WORD(GLOBAL_REG_INTR_GPIO_2_CLEAR, reg);
1158 }
1159 
1160 static INLINE void gpio_port_2_int_clear_all(void)
1161 {
1162  WR_WORD(GLOBAL_REG_INTR_GPIO_2_CLEAR, GLOBAL_REG_INTR_GPIO_2_CLEAR_IRQ);
1163 }
1164 
1165 static INLINE uint32_t gpio_port_2_int_mask_status(void)
1166 {
1167  return (RD_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_STATUS));
1168 }
1169 
1170 static INLINE void gpio_port_2_int_mask_all(void)
1171 {
1172  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_SET, GLOBAL_REG_INTR_GPIO_2_MASK_SET_IRQ);
1173 }
1174 
1175 static INLINE void gpio_port_2_int_mask(uint32_t mask)
1176 {
1177  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_SET, mask);
1178 }
1179 
1180 static INLINE void gpio_port_2_int_mask_rise(int pin)
1181 {
1182  uint32_t reg = (1 << (pin + GPIO_PORT_2_INT_RISE_EDGE_SHIFT));
1183  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_SET, reg);
1184 }
1185 
1186 static INLINE void gpio_port_2_int_mask_fall(int pin)
1187 {
1188  uint32_t reg = (1 << (pin + GPIO_PORT_2_INT_FALL_EDGE_SHIFT));
1189  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_SET, reg);
1190 }
1191 
1192 static INLINE void gpio_port_2_int_mask_wup(int pin)
1193 {
1194  uint32_t reg = (1 << (pin + GPIO_PORT_2_WUP_SHIFT));
1195  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_SET, reg);
1196 }
1197 
1198 static INLINE void gpio_port_2_int_unmask(uint32_t mask)
1199 {
1200  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_CLEAR, mask);
1201 }
1202 
1203 static INLINE void gpio_port_2_int_unmask_rise(int pin)
1204 {
1205  uint32_t reg = (1 << (pin + GPIO_PORT_2_INT_RISE_EDGE_SHIFT));
1206  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_CLEAR, reg);
1207 }
1208 
1209 static INLINE void gpio_port_2_int_unmask_fall(int pin)
1210 {
1211  uint32_t reg = (1 << (pin + GPIO_PORT_2_INT_FALL_EDGE_SHIFT));
1212  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_CLEAR, reg);
1213 }
1214 
1215 static INLINE void gpio_port_2_int_unmask_wup(int pin)
1216 {
1217  uint32_t reg = (1 << (pin + GPIO_PORT_2_WUP_SHIFT));
1218  WR_WORD(GLOBAL_REG_INTR_GPIO_2_MASK_CLEAR, reg);
1219 }
1220 
1221 static INLINE uint32_t gpio_port_3_int_status(void)
1222 {
1223  return (RD_WORD(GLOBAL_REG_INTR_GPIO_3_STATUS));
1224 }
1225 
1226 static INLINE void gpio_port_3_int_clear(uint32_t pin)
1227 {
1228  uint32_t reg = (1 << pin) | (1 << (pin + GPIO_PORT_3_INT_FALL_EDGE_SHIFT)) | (1 << (pin + GPIO_PORT_3_WUP_SHIFT));
1229  WR_WORD(GLOBAL_REG_INTR_GPIO_3_CLEAR, reg);
1230 }
1231 
1232 static INLINE void gpio_port_3_int_clear_all(void)
1233 {
1234  WR_WORD(GLOBAL_REG_INTR_GPIO_3_CLEAR, GLOBAL_REG_INTR_GPIO_3_CLEAR_IRQ);
1235 }
1236 
1237 static INLINE uint32_t gpio_port_3_int_mask_status(void)
1238 {
1239  return (RD_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_STATUS));
1240 }
1241 
1242 static INLINE void gpio_port_3_int_mask_all(void)
1243 {
1244  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_SET, GLOBAL_REG_INTR_GPIO_3_MASK_SET_IRQ);
1245 }
1246 
1247 static INLINE void gpio_port_3_int_mask(uint32_t mask)
1248 {
1249  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_SET, mask);
1250 }
1251 
1252 static INLINE void gpio_port_3_int_mask_rise(int pin)
1253 {
1254  uint32_t reg = (1 << (pin + GPIO_PORT_3_INT_RISE_EDGE_SHIFT));
1255  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_SET, reg);
1256 }
1257 
1258 static INLINE void gpio_port_3_int_mask_fall(int pin)
1259 {
1260  uint32_t reg = (1 << (pin + GPIO_PORT_3_INT_FALL_EDGE_SHIFT));
1261  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_SET, reg);
1262 }
1263 
1264 static INLINE void gpio_port_3_int_mask_wup(int pin)
1265 {
1266  uint32_t reg = (1 << (pin + GPIO_PORT_3_WUP_SHIFT));
1267  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_SET, reg);
1268 }
1269 
1270 static INLINE void gpio_port_3_int_unmask(uint32_t mask)
1271 {
1272  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_CLEAR, mask);
1273 }
1274 
1275 static INLINE void gpio_port_3_int_unmask_rise(int pin)
1276 {
1277  uint32_t reg = (1 << (pin + GPIO_PORT_3_INT_RISE_EDGE_SHIFT));
1278  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_CLEAR, reg);
1279 }
1280 
1281 static INLINE void gpio_port_3_int_unmask_fall(int pin)
1282 {
1283  uint32_t reg = (1 << (pin + GPIO_PORT_3_INT_FALL_EDGE_SHIFT));
1284  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_CLEAR, reg);
1285 }
1286 
1287 static INLINE void gpio_port_3_int_unmask_wup(int pin)
1288 {
1289  uint32_t reg = (1 << (pin + GPIO_PORT_3_WUP_SHIFT));
1290  WR_WORD(GLOBAL_REG_INTR_GPIO_3_MASK_CLEAR, reg);
1291 }
1292 
1293 static INLINE uint32_t gpio_port_4_int_status(void)
1294 {
1295  return (RD_WORD(GLOBAL_REG_INTR_GPIO_4_STATUS));
1296 }
1297 
1298 static INLINE void gpio_port_4_int_clear(uint32_t pin)
1299 {
1300  uint32_t reg = (1 << pin) | (1 << (pin + GPIO_PORT_4_INT_FALL_EDGE_SHIFT)) | (1 << (pin + GPIO_PORT_4_WUP_SHIFT));
1301  WR_WORD(GLOBAL_REG_INTR_GPIO_4_CLEAR, reg);
1302 }
1303 
1304 static INLINE void gpio_port_4_int_clear_all(void)
1305 {
1306  WR_WORD(GLOBAL_REG_INTR_GPIO_4_CLEAR, GLOBAL_REG_INTR_GPIO_4_CLEAR_IRQ);
1307 }
1308 
1309 static INLINE uint32_t gpio_port_4_int_mask_status(void)
1310 {
1311  return (RD_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_STATUS));
1312 }
1313 
1314 static INLINE void gpio_port_4_int_mask_all(void)
1315 {
1316  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_SET, GLOBAL_REG_INTR_GPIO_4_MASK_SET_IRQ);
1317 }
1318 
1319 static INLINE void gpio_port_4_int_mask(uint32_t mask)
1320 {
1321  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_SET, mask);
1322 }
1323 
1324 static INLINE void gpio_port_4_int_mask_rise(int pin)
1325 {
1326  uint32_t reg = (1 << (pin + GPIO_PORT_4_INT_RISE_EDGE_SHIFT));
1327  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_SET, reg);
1328 }
1329 
1330 static INLINE void gpio_port_4_int_mask_fall(int pin)
1331 {
1332  uint32_t reg = (1 << (pin + GPIO_PORT_4_INT_FALL_EDGE_SHIFT));
1333  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_SET, reg);
1334 }
1335 
1336 static INLINE void gpio_port_4_int_mask_wup(int pin)
1337 {
1338  uint32_t reg = (1 << (pin + GPIO_PORT_4_WUP_SHIFT));
1339  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_SET, reg);
1340 }
1341 
1342 static INLINE void gpio_port_4_int_unmask(uint32_t mask)
1343 {
1344  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_CLEAR, mask);
1345 }
1346 
1347 static INLINE void gpio_port_4_int_unmask_rise(int pin)
1348 {
1349  uint32_t reg = (1 << (pin + GPIO_PORT_4_INT_RISE_EDGE_SHIFT));
1350  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_CLEAR, reg);
1351 }
1352 
1353 static INLINE void gpio_port_4_int_unmask_fall(int pin)
1354 {
1355  uint32_t reg = (1 << (pin + GPIO_PORT_4_INT_FALL_EDGE_SHIFT));
1356  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_CLEAR, reg);
1357 }
1358 
1359 static INLINE void gpio_port_4_int_unmask_wup(int pin)
1360 {
1361  uint32_t reg = (1 << (pin + GPIO_PORT_4_WUP_SHIFT));
1362  WR_WORD(GLOBAL_REG_INTR_GPIO_4_MASK_CLEAR, reg);
1363 }
1364 
1365 #define INTR_GPIO_STATUS_OFFSET 0x0
1366 #define INTR_GPIO_MASK_STATUS_OFFSET 0x4
1367 #define INTR_GPIO_CLEAR_OFFSET 0x8
1368 #define INTR_GPIO_SET_OFFSET 0xC
1369 #define INTR_GPIO_MASK_SET_OFFSET 0x10
1370 #define INTR_GPIO_MASK_CLEAR_OFFSET 0x14
1371 
1372 static INLINE uint32_t gpio_int_status(uint32_t addr)
1373 {
1374  return RD_WORD((addr + INTR_GPIO_STATUS_OFFSET));
1375 }
1376 
1377 static INLINE uint32_t gpio_int_mask_status(uint32_t addr)
1378 {
1379  return RD_WORD((addr + INTR_GPIO_MASK_STATUS_OFFSET));
1380 }
1381 
1382 static INLINE void gpio_int_clear_all(uint32_t addr, uint32_t status)
1383 {
1384  WR_WORD((addr + INTR_GPIO_CLEAR_OFFSET), status);
1385 }
1386 
1387 static INLINE void gpio_int_clear(uint32_t addr, uint32_t npin, uint32_t pin)
1388 {
1389  WR_WORD((addr + INTR_GPIO_CLEAR_OFFSET), ((1 << pin)|(1 << (npin + pin))));
1390 }
1391 
1392 static INLINE void gpio_int_mask_all(uint32_t addr, uint32_t mask)
1393 {
1394  WR_WORD((addr + INTR_GPIO_MASK_SET_OFFSET), mask);
1395 }
1396 
1397 static INLINE void gpio_int_mask(uint32_t addr, uint32_t pin)
1398 {
1399  WR_WORD((addr + INTR_GPIO_MASK_SET_OFFSET), (1 << pin));
1400 }
1401 
1402 static INLINE void gpio_int_unmask(uint32_t addr, uint32_t pin)
1403 {
1404  WR_WORD((addr + INTR_GPIO_MASK_CLEAR_OFFSET), (1 << pin));
1405 }
1406 
1407 static INLINE void gpio_int_unmask_all(uint32_t addr, uint32_t unmask)
1408 {
1409  WR_WORD((addr + INTR_GPIO_MASK_CLEAR_OFFSET), unmask);
1410 }
1411 
1412 static INLINE void gpio_port_0_pad_latch(int pin, int latch)
1413 {
1414  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_LE_CTRL);
1415 
1416  if (latch)
1417  reg |= (1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_0_LE_SHIFT));
1418  else
1419  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_0_LE_SHIFT));
1420 
1421  WR_WORD(GLOBAL2_REG_GPIO_LE_CTRL, reg);
1422 }
1423 
1424 static INLINE void gpio_port_1_pad_latch(int pin, int latch)
1425 {
1426  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_LE_CTRL);
1427 
1428  if (latch)
1429  reg |= (1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_1_LE_SHIFT));
1430  else
1431  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_1_LE_SHIFT));
1432 
1433  WR_WORD(GLOBAL2_REG_GPIO_LE_CTRL, reg);
1434 }
1435 
1436 static INLINE void gpio_port_2_pad_latch(int pin, int latch)
1437 {
1438  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_LE_CTRL);
1439 
1440  if (latch)
1441  reg |= (1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_2_LE_SHIFT));
1442  else
1443  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_2_LE_SHIFT));
1444 
1445  WR_WORD(GLOBAL2_REG_GPIO_LE_CTRL, reg);
1446 }
1447 
1448 static INLINE void gpio_port_3_pad_latch(int pin, int latch)
1449 {
1450  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_LE_CTRL_2);
1451 
1452  if (latch)
1453  reg |= (1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_2_CTL_GPIO_3_LE_SHIFT));
1454  else
1455  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_2_CTL_GPIO_3_LE_SHIFT));
1456 
1457  WR_WORD(GLOBAL2_REG_GPIO_LE_CTRL_2, reg);
1458 }
1459 
1460 static INLINE void gpio_port_4_pad_latch(int pin, int latch)
1461 {
1462  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_LE_CTRL_2);
1463 
1464  if (latch)
1465  reg |= (1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_2_CTL_GPIO_4_LE_SHIFT));
1466  else
1467  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_LE_CTRL_2_CTL_GPIO_4_LE_SHIFT));
1468 
1469  WR_WORD(GLOBAL2_REG_GPIO_LE_CTRL_2, reg);
1470 }
1471 
1472 static INLINE void gpio_pad_latch(int port, int pin, int latch)
1473 {
1474  uint32_t addr;
1475  uint32_t reg;
1476  uint32_t shift = 0;
1477 
1478  if (port == GPIO_PORT_0) {
1479  addr = GLOBAL2_REG_GPIO_LE_CTRL;
1480  } else if (port == GPIO_PORT_1) {
1481  addr = GLOBAL2_REG_GPIO_LE_CTRL;
1482  shift = GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_1_LE_SHIFT;
1483  } else if (port == GPIO_PORT_2) {
1484  addr = GLOBAL2_REG_GPIO_LE_CTRL;
1485  shift = GLOBAL2_REG_GPIO_LE_CTRL_CTL_GPIO_2_LE_SHIFT;
1486  } else if (port == GPIO_PORT_3) {
1487  addr = GLOBAL2_REG_GPIO_LE_CTRL_2;
1488  shift = GLOBAL2_REG_GPIO_LE_CTRL_2_CTL_GPIO_3_LE_SHIFT;
1489  } else {
1490  addr = GLOBAL2_REG_GPIO_LE_CTRL_2;
1491  shift = GLOBAL2_REG_GPIO_LE_CTRL_2_CTL_GPIO_4_LE_SHIFT;
1492  }
1493 
1494  reg = RD_WORD(addr);
1495  if (latch) {
1496  reg |= (1 << (shift + pin));
1497  } else {
1498  reg &= ~(1 << (shift + pin));
1499  }
1500  WR_WORD(addr, reg);
1501 }
1502 
1503 static INLINE int gpio_pad_latch_status(int port, int pin)
1504 {
1505  uint32_t addr;
1506  uint32_t shift = 0;
1507 
1508  if (port == GPIO_PORT_0) {
1509  addr = GLOBAL2_REG_GPIO_LE_STS;
1510  } else if (port == GPIO_PORT_1) {
1511  addr = GLOBAL2_REG_GPIO_LE_STS;
1512  shift = GLOBAL2_REG_GPIO_LE_STS_STS_GPIO_1_LE_SHIFT;
1513  } else if (port == GPIO_PORT_2) {
1514  addr = GLOBAL2_REG_GPIO_LE_STS;
1515  shift = GLOBAL2_REG_GPIO_LE_STS_STS_GPIO_2_LE_SHIFT;
1516  } else if (port == GPIO_PORT_3) {
1517  addr = GLOBAL2_REG_GPIO_LE_STS_2;
1518  shift = GLOBAL2_REG_GPIO_LE_STS_2_STS_GPIO_3_LE_SHIFT;
1519  } else {
1520  addr = GLOBAL2_REG_GPIO_LE_STS_2;
1521  shift = GLOBAL2_REG_GPIO_LE_STS_2_STS_GPIO_4_LE_SHIFT;
1522  }
1523 
1524  return ((RD_WORD(addr) >> (shift + pin)) & 1);
1525 }
1526 
1527 static INLINE void gpio_port_0_pad_maskb(int pin, int en)
1528 {
1529  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL);
1530 
1531  if (en)
1532  reg |= (1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_0_MASKB_SHIFT));
1533  else
1534  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_0_MASKB_SHIFT));
1535 
1536  WR_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL, reg);
1537 }
1538 
1539 static INLINE void gpio_port_1_pad_maskb(int pin, int en)
1540 {
1541  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL);
1542 
1543  if (en)
1544  reg |= (1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_1_MASKB_SHIFT));
1545  else
1546  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_1_MASKB_SHIFT));
1547 
1548  WR_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL, reg);
1549 }
1550 
1551 static INLINE void gpio_port_2_pad_maskb(int pin, int en)
1552 {
1553  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL);
1554 
1555  if (en)
1556  reg |= (1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_2_MASKB_SHIFT));
1557  else
1558  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_2_MASKB_SHIFT));
1559 
1560  WR_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL, reg);
1561 }
1562 
1563 static INLINE void gpio_port_3_pad_maskb(int pin, int en)
1564 {
1565  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL_2);
1566 
1567  if (en)
1568  reg |= (1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_2_CTL_GPIO_3_MASKB_SHIFT));
1569  else
1570  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_2_CTL_GPIO_3_MASKB_SHIFT));
1571 
1572  WR_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL, reg);
1573 }
1574 
1575 static INLINE void gpio_port_4_pad_maskb(int pin, int en)
1576 {
1577  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL_2);
1578 
1579  if (en)
1580  reg |= (1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_2_CTL_GPIO_4_MASKB_SHIFT));
1581  else
1582  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_MASKB_CTRL_2_CTL_GPIO_4_MASKB_SHIFT));
1583 
1584  WR_WORD(GLOBAL2_REG_GPIO_MASKB_CTRL, reg);
1585 }
1586 
1587 static INLINE void gpio_pad_maskb(int port, int pin, int en)
1588 {
1589  uint32_t addr;
1590  uint32_t reg;
1591  uint32_t shift = 0;
1592 
1593  if (port == GPIO_PORT_0) {
1594  addr = GLOBAL2_REG_GPIO_MASKB_CTRL;
1595  } else if (port == GPIO_PORT_1) {
1596  addr = GLOBAL2_REG_GPIO_MASKB_CTRL;
1597  shift = GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_1_MASKB_SHIFT;
1598  } else if (port == GPIO_PORT_2) {
1599  addr = GLOBAL2_REG_GPIO_MASKB_CTRL;
1600  shift = GLOBAL2_REG_GPIO_MASKB_CTRL_CTL_GPIO_2_MASKB_SHIFT;
1601  } else if (port == GPIO_PORT_3) {
1602  addr = GLOBAL2_REG_GPIO_MASKB_CTRL_2;
1603  shift = GLOBAL2_REG_GPIO_MASKB_CTRL_2_CTL_GPIO_3_MASKB_SHIFT;
1604  } else {
1605  addr = GLOBAL2_REG_GPIO_MASKB_CTRL_2;
1606  shift = GLOBAL2_REG_GPIO_MASKB_CTRL_2_CTL_GPIO_4_MASKB_SHIFT;
1607  }
1608 
1609  reg = RD_WORD(addr);
1610  if (en) {
1611  reg |= (1 << (shift + pin));
1612  } else {
1613  reg &= ~(1 << (shift + pin));
1614  }
1615  WR_WORD(addr, reg);
1616 }
1617 
1618 static INLINE int gpio_pad_maskb_status(int port, int pin)
1619 {
1620  uint32_t addr;
1621  uint32_t shift = 0;
1622 
1623  if (port == GPIO_PORT_0) {
1624  addr = GLOBAL2_REG_GPIO_MASKB_STS;
1625  } else if (port == GPIO_PORT_1) {
1626  addr = GLOBAL2_REG_GPIO_MASKB_STS;
1627  shift = GLOBAL2_REG_GPIO_MASKB_STS_STS_GPIO_1_MASKB_SHIFT;
1628  } else if (port == GPIO_PORT_2) {
1629  addr = GLOBAL2_REG_GPIO_MASKB_STS;
1630  shift = GLOBAL2_REG_GPIO_MASKB_STS_STS_GPIO_2_MASKB_SHIFT;
1631  } else if (port == GPIO_PORT_3) {
1632  addr = GLOBAL2_REG_GPIO_MASKB_STS_2;
1633  shift = GLOBAL2_REG_GPIO_MASKB_STS_2_STS_GPIO_3_MASKB_SHIFT;
1634  } else {
1635  addr = GLOBAL2_REG_GPIO_MASKB_STS_2;
1636  shift = GLOBAL2_REG_GPIO_MASKB_STS_2_STS_GPIO_4_MASKB_SHIFT;
1637  }
1638 
1639  return ((RD_WORD(addr) >> (pin + shift)) & 1);
1640 }
1641 
1642 static INLINE void gpio_port_0_wup_mask(int pin, int mask)
1643 {
1644  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL);
1645 
1646  if (mask)
1647  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_0_WAKEUP_MASK_SHIFT));
1648  else
1649  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_0_WAKEUP_MASK_SHIFT));
1650 
1651  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL, reg);
1652 }
1653 
1654 static INLINE void gpio_port_1_wup_mask(int pin, int mask)
1655 {
1656  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL);
1657 
1658  if (mask)
1659  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_1_WAKEUP_MASK_SHIFT));
1660  else
1661  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_1_WAKEUP_MASK_SHIFT));
1662 
1663  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL, reg);
1664 }
1665 
1666 static INLINE void gpio_port_2_wup_mask(int pin, int mask)
1667 {
1668  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL);
1669 
1670  if (mask)
1671  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_2_WAKEUP_MASK_SHIFT));
1672  else
1673  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_2_WAKEUP_MASK_SHIFT));
1674 
1675  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL, reg);
1676 }
1677 
1678 static INLINE void gpio_port_3_wup_mask(int pin, int mask)
1679 {
1680  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2);
1681 
1682  if (mask)
1683  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2_CTL_GPIO_3_WAKEUP_MASK_SHIFT));
1684  else
1685  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2_CTL_GPIO_3_WAKEUP_MASK_SHIFT));
1686 
1687  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2, reg);
1688 }
1689 
1690 static INLINE void gpio_port_4_wup_mask(int pin, int mask)
1691 {
1692  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2);
1693 
1694  if (mask)
1695  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2_CTL_GPIO_4_WAKEUP_MASK_SHIFT));
1696  else
1697  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2_CTL_GPIO_4_WAKEUP_MASK_SHIFT));
1698 
1699  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2, reg);
1700 }
1701 
1702 static INLINE void gpio_wup_mask(int port, int pin, int mask)
1703 {
1704  uint32_t addr;
1705  uint32_t reg;
1706  uint32_t shift = 0;
1707 
1708  if (port == GPIO_PORT_0) {
1709  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL;
1710  } else if (port == GPIO_PORT_1) {
1711  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL;
1712  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_1_WAKEUP_MASK_SHIFT;
1713  } else if (port == GPIO_PORT_2) {
1714  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL;
1715  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_CTL_GPIO_2_WAKEUP_MASK_SHIFT;
1716  } else if (port == GPIO_PORT_3) {
1717  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2;
1718  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2_CTL_GPIO_3_WAKEUP_MASK_SHIFT;
1719  } else {
1720  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2;
1721  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_CTRL_2_CTL_GPIO_4_WAKEUP_MASK_SHIFT;
1722  }
1723 
1724  reg = RD_WORD(addr);
1725  if (mask) {
1726  reg &= ~(1 << (shift + pin));
1727  } else {
1728  reg |= (1 << (shift + pin));
1729  }
1730  WR_WORD(addr, reg);
1731 }
1732 
1733 static INLINE int gpio_wup_mask_status(int port, int pin)
1734 {
1735  uint32_t addr;
1736  uint32_t shift = 0;
1737 
1738  if (port == GPIO_PORT_0) {
1739  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS;
1740  } else if (port == GPIO_PORT_1) {
1741  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS;
1742  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS_STS_GPIO_1_WAKEUP_MASK_SHIFT;
1743  } else if (port == GPIO_PORT_2) {
1744  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS;
1745  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS_STS_GPIO_2_WAKEUP_MASK_SHIFT;
1746  } else if (port == GPIO_PORT_3) {
1747  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS_2;
1748  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS_2_STS_GPIO_3_WAKEUP_MASK_SHIFT;
1749  } else {
1750  addr = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS_2;
1751  shift = GLOBAL2_REG_GPIO_WAKEUP_MASK_STS_2_STS_GPIO_4_WAKEUP_MASK_SHIFT;
1752  }
1753 
1754  return ((RD_WORD(addr) >> (shift + pin)) & 1);
1755 }
1756 
1757 static INLINE void gpio_port_0_wup_pol(int pin, int polarity)
1758 {
1759  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL);
1760 
1761  if (polarity)
1762  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_0_WAKEUP_POLARITY_SHIFT));
1763  else
1764  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_0_WAKEUP_POLARITY_SHIFT));
1765 
1766  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL, reg);
1767 }
1768 
1769 static INLINE void gpio_port_1_wup_pol(int pin, int polarity)
1770 {
1771  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL);
1772 
1773  if (polarity)
1774  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_1_WAKEUP_POLARITY_SHIFT));
1775  else
1776  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_1_WAKEUP_POLARITY_SHIFT));
1777 
1778  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL, reg);
1779 }
1780 
1781 static INLINE void gpio_port_2_wup_pol(int pin, int polarity)
1782 {
1783  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL);
1784 
1785  if (polarity)
1786  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_2_WAKEUP_POLARITY_SHIFT));
1787  else
1788  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_2_WAKEUP_POLARITY_SHIFT));
1789 
1790  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL, reg);
1791 }
1792 
1793 static INLINE void gpio_port_3_wup_pol(int pin, int polarity)
1794 {
1795  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2);
1796 
1797  if (polarity)
1798  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2_CTL_GPIO_3_WAKEUP_POLARITY_SHIFT));
1799  else
1800  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2_CTL_GPIO_3_WAKEUP_POLARITY_SHIFT));
1801 
1802  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2, reg);
1803 }
1804 
1805 static INLINE void gpio_port_4_wup_pol(int pin, int polarity)
1806 {
1807  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2);
1808 
1809  if (polarity)
1810  reg &= ~(1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2_CTL_GPIO_4_WAKEUP_POLARITY_SHIFT));
1811  else
1812  reg |= (1 << (pin + GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2_CTL_GPIO_4_WAKEUP_POLARITY_SHIFT));
1813 
1814  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2, reg);
1815 }
1816 
1817 static INLINE void gpio_wup_polarity(int port, int pin, int polarity)
1818 {
1819  uint32_t addr;
1820  uint32_t reg;
1821  uint32_t shift = 0;
1822 
1823  if (port == GPIO_PORT_0) {
1824  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL;
1825  } else if (port == GPIO_PORT_1) {
1826  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL;
1827  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_1_WAKEUP_POLARITY_SHIFT;
1828  } else if (port == GPIO_PORT_2) {
1829  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL;
1830  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_CTL_GPIO_2_WAKEUP_POLARITY_SHIFT;
1831  } else if (port == GPIO_PORT_3) {
1832  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2;
1833  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2_CTL_GPIO_3_WAKEUP_POLARITY_SHIFT;
1834  } else {
1835  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2;
1836  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL_2_CTL_GPIO_4_WAKEUP_POLARITY_SHIFT;
1837  }
1838 
1839  reg = RD_WORD(addr);
1840  if (polarity) {
1841  reg &= ~(1 << (shift + pin));
1842  } else {
1843  reg |= (1 << (shift + pin));
1844  }
1845  WR_WORD(addr, reg);
1846 }
1847 
1848 static INLINE int gpio_wup_polarity_status(int port, int pin)
1849 {
1850  uint32_t addr;
1851  uint32_t shift = 0;
1852 
1853  if (port == GPIO_PORT_0) {
1854  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS;
1855  } else if (port == GPIO_PORT_1) {
1856  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS;
1857  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS_STS_GPIO_1_WAKEUP_POLARITY_SHIFT;
1858  } else if (port == GPIO_PORT_2) {
1859  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS;
1860  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS_STS_GPIO_2_WAKEUP_POLARITY_SHIFT;
1861  } else if (port == GPIO_PORT_3) {
1862  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS_2;
1863  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS_2_STS_GPIO_3_WAKEUP_POLARITY_SHIFT;
1864  } else {
1865  addr = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS_2;
1866  shift = GLOBAL2_REG_GPIO_WAKEUP_POLARITY_STS_2_STS_GPIO_4_WAKEUP_POLARITY_SHIFT;
1867  }
1868 
1869  return ((RD_WORD(addr) >> (shift + pin)) & 1);
1870 }
1871 
1872 
1873 static INLINE void gpio_edge_clear(int port, int pin)
1874 {
1875  uint32_t addr;
1876  uint32_t shift = 0;
1877 
1878  if (port == GPIO_PORT_0) {
1879  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR;
1880  } else if (port == GPIO_PORT_1) {
1881  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR;
1882  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_CTL_GPIO_1_EDGE_MANUAL_CLR_SHIFT;
1883  } else if (port == GPIO_PORT_2) {
1884  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR;
1885  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_CTL_GPIO_2_EDGE_MANUAL_CLR_SHIFT;
1886  } else if (port == GPIO_PORT_3) {
1887  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_2;
1888  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_2_CTL_GPIO_3_EDGE_MANUAL_CLR_SHIFT;
1889  } else {
1890  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_2;
1891  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_2_CTL_GPIO_4_EDGE_MANUAL_CLR_SHIFT;
1892  }
1893 
1894  WR_WORD(addr, (1 << (pin + shift)));
1895 }
1896 
1897 static INLINE int gpio_edge_clear_status(int port, int pin)
1898 {
1899  uint32_t addr;
1900  uint32_t shift = 0;
1901 
1902  if (port == GPIO_PORT_0) {
1903  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS;
1904  } else if (port == GPIO_PORT_1) {
1905  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS;
1906  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS_STS_GPIO_1_EDGE_MANUAL_CLR_SHIFT;
1907  } else if (port == GPIO_PORT_2) {
1908  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS;
1909  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS_STS_GPIO_2_EDGE_MANUAL_CLR_SHIFT;
1910  } else if (port == GPIO_PORT_3) {
1911  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS_2;
1912  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS_2_STS_GPIO_3_EDGE_MANUAL_CLR_SHIFT;
1913  } else {
1914  addr = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS_2;
1915  shift = GLOBAL2_REG_GPIO_EDGE_MANUAL_CLR_STS_2_STS_GPIO_4_EDGE_MANUAL_CLR_SHIFT;
1916  }
1917 
1918  return ((RD_WORD(addr) >> (shift + pin)) & 1);
1919 }
1920 
1921 static INLINE void gpio_aon_edge_rise(int port, int pin, int en)
1922 {
1923  uint32_t addr;
1924  uint32_t shift = 0;
1925  uint32_t reg;
1926 
1927  if (port == GPIO_PORT_0) {
1928  addr = AON_REG_GPIO_EDGE_RISING_EN;
1929  } else if (port == GPIO_PORT_1) {
1930  addr = AON_REG_GPIO_EDGE_RISING_EN;
1931  shift = 9;
1932  } else if (port == GPIO_PORT_2) {
1933  addr = AON_REG_GPIO_EDGE_RISING_EN;
1934  shift = 19;
1935  } else if (port == GPIO_PORT_3) {
1936  addr = AON_REG_GPIO_EDGE_RISING_EN_2;
1937  shift = 0;
1938  } else {
1939  addr = AON_REG_GPIO_EDGE_RISING_EN_2;
1940  shift = 6;
1941  }
1942 
1943  reg = RD_WORD(addr);
1944  if (en)
1945  reg |= 1 << (pin + shift);
1946  else
1947  reg &= ~(1 << (pin + shift));
1948  WR_WORD(addr, reg);
1949 }
1950 
1951 static INLINE void gpio_aon_edge_fall(int port, int pin, int en)
1952 {
1953  uint32_t addr;
1954  uint32_t shift = 0;
1955  uint32_t reg;
1956 
1957  if (port == GPIO_PORT_0) {
1958  addr = AON_REG_GPIO_EDGE_FALLING_EN;
1959  } else if (port == GPIO_PORT_1) {
1960  addr = AON_REG_GPIO_EDGE_FALLING_EN;
1961  shift = 9;
1962  } else if (port == GPIO_PORT_2) {
1963  addr = AON_REG_GPIO_EDGE_FALLING_EN;
1964  shift = 19;
1965  } else if (port == GPIO_PORT_3) {
1966  addr = AON_REG_GPIO_EDGE_FALLING_EN_2;
1967  shift = 0;
1968  } else {
1969  addr = AON_REG_GPIO_EDGE_FALLING_EN_2;
1970  shift = 6;
1971  }
1972 
1973  reg = RD_WORD(addr);
1974  if (en)
1975  reg |= 1 << (pin + shift);
1976  else
1977  reg &= ~(1 << (pin + shift));
1978  WR_WORD(addr, reg);
1979 }
1980 
1981 static INLINE void gpio_aon_edge_clear_on_sleep(int port, int pin, int en)
1982 {
1983  uint32_t addr;
1984  uint32_t shift = 0;
1985  uint32_t reg;
1986 
1987  if (port == GPIO_PORT_0) {
1988  addr = AON_REG_GPIO_EDGE_AUTO_CLEAR_ON_SLEEP;
1989  } else if (port == GPIO_PORT_1) {
1990  addr = AON_REG_GPIO_EDGE_AUTO_CLEAR_ON_SLEEP;
1991  shift = 9;
1992  } else if (port == GPIO_PORT_2) {
1993  addr = AON_REG_GPIO_EDGE_AUTO_CLEAR_ON_SLEEP;
1994  shift = 19;
1995  } else if (port == GPIO_PORT_3) {
1996  addr = AON_REG_GPIO_EDGE_AUTO_CLEAR_ON_SLEEP_2;
1997  shift = 0;
1998  } else {
1999  addr = AON_REG_GPIO_EDGE_AUTO_CLEAR_ON_SLEEP_2;
2000  shift = 6;
2001  }
2002 
2003  reg = RD_WORD(addr);
2004  if (en)
2005  reg |= 1 << (pin + shift);
2006  else
2007  reg &= ~(1 << (pin + shift));
2008  WR_WORD(addr, reg);
2009 }
2010 
2011 static INLINE void gpio_aon_edge_detect_in_sleep(int port, int pin, int en)
2012 {
2013  uint32_t addr;
2014  uint32_t shift = 0;
2015  uint32_t reg;
2016 
2017  if (port == GPIO_PORT_0) {
2018  addr = AON_REG_GPIO_EDGE_DETECT_SLEEP_ONLY;
2019  } else if (port == GPIO_PORT_1) {
2020  addr = AON_REG_GPIO_EDGE_DETECT_SLEEP_ONLY;
2021  shift = 9;
2022  } else if (port == GPIO_PORT_2) {
2023  addr = AON_REG_GPIO_EDGE_DETECT_SLEEP_ONLY;
2024  shift = 19;
2025  } else if (port == GPIO_PORT_3) {
2026  addr = AON_REG_GPIO_EDGE_DETECT_SLEEP_ONLY_2;
2027  shift = 0;
2028  } else {
2029  addr = AON_REG_GPIO_EDGE_DETECT_SLEEP_ONLY_2;
2030  shift = 6;
2031  }
2032 
2033  reg = RD_WORD(addr);
2034  if (en)
2035  reg |= 1 << (pin + shift);
2036  else
2037  reg &= ~(1 << (pin + shift));
2038  WR_WORD(addr, reg);
2039 }
2040 
2041 static INLINE void gpio_aon_port_0_sel(uint32_t pin, int en)
2042 {
2043  uint32_t reg = RD_WORD(AON_REG_GPIO_01_AON_SEL);
2044  if (en)
2045  reg |= (1 << pin);
2046  else
2047  reg &= ~(1 << pin);
2048 
2049  WR_WORD(AON_REG_GPIO_01_AON_SEL, reg);
2050 }
2051 
2052 static INLINE void gpio_aon_port_1_sel(uint32_t pin, int en)
2053 {
2054  uint32_t reg = RD_WORD(AON_REG_GPIO_01_AON_SEL);
2055  if (en)
2056  reg |= (1 << (pin + 16));
2057  else
2058  reg &= ~(1 << (pin + 16));
2059 
2060  WR_WORD(AON_REG_GPIO_01_AON_SEL, reg);
2061 }
2062 
2063 static INLINE void gpio_aon_port_3_sel(uint32_t pin, int en)
2064 {
2065  uint32_t reg = RD_WORD(AON_REG_GPIO_3_AON_SEL);
2066  if (en)
2067  reg |= (1 << pin);
2068  else
2069  reg &= ~(1 << pin);
2070 
2071  WR_WORD(AON_REG_GPIO_3_AON_SEL, reg);
2072 }
2073 
2074 static INLINE void gpio_aon_port_4_sel(uint32_t pin, int en)
2075 {
2076  uint32_t reg = RD_WORD(AON_REG_GPIO_3_AON_SEL);
2077  if (en)
2078  reg |= (1 << (pin + 8));
2079  else
2080  reg &= ~(1 << (pin + 8));
2081 
2082  WR_WORD(AON_REG_GPIO_3_AON_SEL, reg);
2083 }
2084 
2085 static INLINE void gpio_aon_port_0_output_sel(uint32_t pin, int mux)
2086 {
2087  uint32_t addr = AON_REG_GPIO_01_AON_OUTPUT_SEL;
2088  uint32_t reg;
2089 
2090  if (pin >= 8) {
2091  pin -= 8;
2092  addr = AON_REG_GPIO_01_AON_OUTPUT_SEL_2;
2093  }
2094 
2095  reg = RD_WORD(addr);
2096  reg &= ~(0x7 << (pin << 2));
2097  reg |= ((mux & 0x7) << (pin << 2));
2098  WR_WORD(addr, reg);
2099 }
2100 
2101 static INLINE void gpio_aon_port_1_output_sel(uint32_t pin, int mux)
2102 {
2103  uint32_t addr = AON_REG_GPIO_01_AON_OUTPUT_SEL_2;
2104  uint32_t reg;
2105 
2106  if (pin >= 7) {
2107  pin -= 7;
2108  addr = AON_REG_GPIO_13_AON_OUTPUT_SEL;
2109  } else {
2110  pin += 1;
2111  }
2112 
2113  reg = RD_WORD(addr);
2114  reg &= ~(0x7 << (pin << 2));
2115  reg |= ((mux & 0x7) << (pin << 2));
2116  WR_WORD(addr, reg);
2117 }
2118 
2119 static INLINE void gpio_aon_port_3_output_sel(uint32_t pin, int mux)
2120 {
2121  uint32_t addr = AON_REG_GPIO_13_AON_OUTPUT_SEL;
2122  uint32_t reg;
2123 
2124  if (pin >= 5) {
2125  pin -= 5;
2126  addr = AON_REG_GPIO_3_AON_OUTPUT_SEL;
2127  } else {
2128  pin += 3;
2129  }
2130 
2131  reg = RD_WORD(addr);
2132  reg &= ~(0x7 << (pin << 2));
2133  reg |= ((mux & 0x7) << (pin << 2));
2134  WR_WORD(addr, reg);
2135 }
2136 
2137 static INLINE void gpio_aon_port_4_output_sel(uint32_t pin, int mux)
2138 {
2139  uint32_t addr = AON_REG_GPIO_3_AON_OUTPUT_SEL;
2140  uint32_t reg;
2141 
2142  pin += 1;
2143  reg = RD_WORD(addr);
2144  reg &= ~(0x7 << (pin << 2));
2145  reg |= ((mux & 0x7) << (pin << 2));
2146  WR_WORD(addr, reg);
2147 }
2148 
2149 
2150 static INLINE void gpio_aon_wup_polarity(int port, int pin, int pol)
2151 {
2152  uint32_t reg = RD_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL);
2153  int shift;
2154 
2155  if (port == 0) {
2156  shift = 0 + pin;
2157  } else if (port == 1) {
2158  shift = 6 + pin;
2159  } else if (port == 2) {
2160  shift = 15 + pin;
2161  } else {
2162  shift = 24 + pin;
2163  }
2164 
2165  // input ^ polarity = wake up
2166  // 1 ^ 1 = 0
2167  // 1 ^ 0 = 1
2168  // 0 ^ 1 = 1
2169  // 0 ^ 0 = 0
2170  if (pol) {
2171  reg &= ~(1 << shift);
2172  } else {
2173  reg |= (1 << shift);
2174  }
2175 
2176  WR_WORD(GLOBAL2_REG_GPIO_WAKEUP_POLARITY_CTRL, reg);
2177 }
2178 
2179 static INLINE void gpio_aon_edge_reset_pd1_clk(int en)
2180 {
2181  uint32_t reg = RD_WORD(AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0);
2182  if (en) {
2183  reg |= AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_CLK_EN;
2184  } else {
2185  reg &= ~AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_CLK_EN;
2186  }
2187  WR_WORD(AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0, reg);
2188 }
2189 
2190 static INLINE void gpio_aon_edge_reset_pd1_enable(int idx)
2191 {
2192  uint32_t addr = AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0 + idx*4;
2193  uint32_t reg = RD_WORD(addr);
2194  reg |= AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_EN_0;
2195  WR_WORD(addr, reg);
2196 }
2197 
2198 static INLINE void gpio_aon_edge_reset_pd1_disable(int idx)
2199 {
2200  uint32_t addr = AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0 + idx*4;
2201  uint32_t reg = RD_WORD(addr);
2202  reg &= ~AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_EN_0;
2203  WR_WORD(addr, reg);
2204 }
2205 
2206 static INLINE void gpio_aon_edge_reset_pd1(int idx, int sidx, int fall, int deb)
2207 {
2208  uint32_t addr = AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0 + idx*4;
2209  uint32_t reg = RD_WORD(addr);
2210 
2211  reg &= ~AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_SEL_0;
2212  reg |= (sidx & AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_SEL_0_MASK) << AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_SEL_0_SHIFT;
2213  if (fall)
2214  reg |= AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_EDGE_SEL_0;
2215  reg &= ~AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_DEB_LMT_0;
2216  reg |= (deb & AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_DEB_LMT_0_MASK) << AON_REG_GPIO_EDGE_FOR_PD1_RST_CTRL_0_CTL_GPIO_EDGE_FOR_PD1_RST_DEB_LMT_0_SHIFT;
2217  WR_WORD(addr, reg);
2218 }
2219 
2220 static INLINE void gpio_aon_edge_reset_cm4_enable(void)
2221 {
2222  uint32_t reg = RD_WORD(AON_REG_GPIO_EDGE_FOR_CM4_RST);
2223  reg |= AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_EN;
2224  WR_WORD(AON_REG_GPIO_EDGE_FOR_CM4_RST, reg);
2225 }
2226 
2227 static INLINE void gpio_aon_edge_reset_cm4_disable(void)
2228 {
2229  uint32_t reg = RD_WORD(AON_REG_GPIO_EDGE_FOR_CM4_RST);
2230  reg &= ~AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_EN;
2231  WR_WORD(AON_REG_GPIO_EDGE_FOR_CM4_RST, reg);
2232 }
2233 
2234 static INLINE void gpio_aon_edge_reset_cm4(int sidx, int fall, int deb, int sys_rst)
2235 {
2236  uint32_t reg = RD_WORD(AON_REG_GPIO_EDGE_FOR_CM4_RST);
2237  reg &= ~AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_SEL;
2238  reg |= (sidx & AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_SEL_MASK) << AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_SEL_SHIFT;
2239  if (fall)
2240  reg |= AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_EDGE_SEL;
2241  reg |= (deb & AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_DEB_LMT_MASK) << AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_DEB_LMT_SHIFT;
2242  if (sys_rst)
2243  reg |= AON_REG_GPIO_EDGE_FOR_CM4_RST_CTL_GPIO_EDGE_FOR_CM4_RST_FUNC_SEL;
2244  WR_WORD(AON_REG_GPIO_EDGE_FOR_CM4_RST, reg);
2245 }
2246 
2247 static INLINE void gpio_aon_edge_det_clk(int en, int port)
2248 {
2249  uint32_t reg = RD_WORD(AON_REG_AON_TIMER_CLK_CTRL);
2250 
2251  if (en) {
2252  if (port == GPIO_PORT_0) {
2253  reg |= AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_0_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_0_EDGE_DETECT_DEB_CLK_EN;
2254  } else if (port == GPIO_PORT_1) {
2255  reg |= AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_1_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_1_EDGE_DETECT_DEB_CLK_EN;
2256  } else if (port == GPIO_PORT_2) {
2257  reg |= AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_2_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_2_EDGE_DETECT_DEB_CLK_EN;
2258  } else if (port == GPIO_PORT_3) {
2259  reg |= AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_3_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_3_EDGE_DETECT_DEB_CLK_EN;
2260  } else {
2261  reg |= AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_4_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_4_EDGE_DETECT_DEB_CLK_EN;
2262  }
2263  } else {
2264  if (port == GPIO_PORT_0) {
2265  reg &= ~(AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_0_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_0_EDGE_DETECT_DEB_CLK_EN);
2266  } else if (port == GPIO_PORT_1) {
2267  reg &= ~(AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_1_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_1_EDGE_DETECT_DEB_CLK_EN);
2268  } else if (port == GPIO_PORT_2) {
2269  reg &= ~(AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_2_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_2_EDGE_DETECT_DEB_CLK_EN);
2270  } else if (port == GPIO_PORT_3) {
2271  reg &= ~(AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_3_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_3_EDGE_DETECT_DEB_CLK_EN);
2272  } else {
2273  reg &= ~(AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_4_EDGE_DETECT_CLK_EN|AON_REG_AON_TIMER_CLK_CTRL_CTL_GPIO_4_EDGE_DETECT_DEB_CLK_EN);
2274  }
2275  }
2276  WR_WORD(AON_REG_AON_TIMER_CLK_CTRL, reg);
2277 }
2278 
2279 static INLINE void gpio_qspi_pad_latch(int latch_mask)
2280 {
2281  uint32_t reg = RD_WORD(AON_REG_QSPI_LE_MASKB);
2282 
2283  reg &= ~(AON_REG_QSPI_LE_MASKB_CTL_QSPI_LE);
2284  reg |= (latch_mask&AON_REG_QSPI_LE_MASKB_CTL_QSPI_LE_MASK)<<AON_REG_QSPI_LE_MASKB_CTL_QSPI_LE_SHIFT;
2285 
2286 
2287  WR_WORD(AON_REG_QSPI_LE_MASKB, reg);
2288 }
2289 static INLINE int gpio_get_cfg_port(uint32_t pin_cfg)
2290 {
2291  return (pin_cfg >> GPIO_CFG_PORT_SHIFT) & 0xF;
2292 }
2293 static INLINE int gpio_get_cfg_pin(uint32_t pin_cfg)
2294 {
2295  return pin_cfg & 0xF;
2296 }
2297 static INLINE int gpio_get_cfg_mux(uint32_t pin_cfg)
2298 {
2299  return (pin_cfg >> GPIO_CFG_MUX_SHIFT) & 0xF;
2300 }
2301 /*
2302  * Internal Functions
2303  ****************************************************************************************
2304  */
2305 
2315 void hal_gpio_init(void);
2316 
2327 void hal_gpio_pin_cfg(uint32_t pin_cfg);
2328 
2339 void hal_gpio_pin_dft(uint32_t pin_cfg);
2340 
2353 int hal_gpio_pin_mux(int port, int pin, int mux);
2354 
2368 int hal_gpio_pad_oe_ie(int port, int pin, int oe, int ie);
2369 
2384 int hal_gpio_pad_pd_pu(int port, int pin, int pd, int pu);
2385 
2386 
2387 
2388 
2389 
2402 int hal_gpio_sleep_pad_mask(int port, int pin, int mask);
2403 
2404 
2416 int hal_gpio_sleep_wup_mask(int port, int pin, int mask);
2417 
2418 
2430 int hal_gpio_sleep_wup_polarity(int port, int pin, int pol);
2431 
2444 int hal_gpio_sleep_wup_edge(int port, int pin, int rise, int fall);
2445 
2446 
2457 int hal_gpio_sleep_wup_edge_clear_manual(int port, int pin);
2458 
2470 int hal_gpio_sleep_wup_edge_clear_auto(int port, int pin, int en);
2471 
2483 int hal_gpio_sleep_wup_edge_detect(int port, int pin, int en);
2484 
2496 int hal_gpio_sleep_wup_edge_latch(int port, int pin, int en);
2497 
2498 
2507 void hal_gpio_suspend(void);
2508 
2517 void hal_gpio_resume(void);
2518 
2519 
2520 
2521 /*
2522  * GPIO API
2523  ****************************************************************************************
2524  */
2525 
2536 int hal_gpio_cfg_output(int port, int pin);
2537 
2549 int hal_gpio_cfg_input(int port, int pin, int pull_cfg);
2550 
2562 int hal_gpio_output_status(int port, int pin);
2563 
2575 int hal_gpio_input_status(int port, int pin);
2576 
2590 int hal_gpio_pad_pc(int port, int pin, int on);
2591 
2604 int hal_gpio_output(int port, int pin, int high);
2605 
2618 int hal_gpio_pin_inv(int port, int pin, int inv);
2619 
2630 int hal_gpio_ext_int_prio(int port, int prio);
2643 int hal_gpio_ext_int_reg(int port, int pin, void *arg, void (*callback)(void *, int, int, int));
2644 
2655 int hal_gpio_ext_int_unreg(int port, int pin);
2656 
2671 int hal_gpio_ext_int_mask(int port, int pin, int rise, int fall, int wup);
2672 
2686 int hal_gpio_ext_int_unmask(int port, int pin, int rise, int fall, int wup);
2687 
2700 int hal_gpio_cfg_wup_level(int port, int pin, int polarity);
2701 
2714 int hal_gpio_cfg_wup_edge(int port, int pin, int rise, int fall);
2715 
2726 int hal_gpio_wup_dis(int port, int pin);
2727 
2741 int hal_gpio_sleep_pad_latch(int port, int pin, int latch, int manual);
2756 int hal_gpio_sleep_output_grp_0(int en, int port, int pin, int mux);
2757 int hal_gpio_sleep_output_grp_1(int en, int port, int pin, int mux);
2758 int hal_gpio_sleep_output_grp_2(int en, int port, int pin, int mux);
2759 int hal_gpio_sleep_output_grp_3(int en, int port, int pin, int mux);
2760 
2776 void hal_gpio_reset_chip(int idx, int en, int port, int pin, int fall, int deb);
2777 
2793 void hal_gpio_reset_arm(int en, int port, int pin, int fall, int deb, int sys_rst);
2794 
2795 
2797 #endif // HAL_GPIO_H
2798 
hal_gpio_ext_int_reg
int hal_gpio_ext_int_reg(int port, int pin, void *arg, void(*callback)(void *, int, int, int))
Register external GPIO pin as interrupt.
hal_gpio_sleep_wup_edge_clear_manual
int hal_gpio_sleep_wup_edge_clear_manual(int port, int pin)
Manually clear wake up GPIO edge.
hal_gpio_sleep_wup_edge
int hal_gpio_sleep_wup_edge(int port, int pin, int rise, int fall)
Wake up GPIO edge selection.
hal_gpio_ext_int_unreg
int hal_gpio_ext_int_unreg(int port, int pin)
Unregister external GPIO pin as interrupt.
hal_gpio_sleep_wup_mask
int hal_gpio_sleep_wup_mask(int port, int pin, int mask)
Config GPIO pin as wake up pin during deep sleep.
hal_gpio_pad_pc
int hal_gpio_pad_pc(int port, int pin, int on)
Config GPIO PAD drive strength.
hal_gpio_suspend
void hal_gpio_suspend(void)
GPIO pin configuration store before power down.
hal_gpio_sleep_wup_edge_clear_auto
int hal_gpio_sleep_wup_edge_clear_auto(int port, int pin, int en)
Clear the wake up GPIO edge automatically.
hal_gpio_ext_int_unmask
int hal_gpio_ext_int_unmask(int port, int pin, int rise, int fall, int wup)
Unmask GPIO pin interrupt.
hal_gpio_sleep_pad_latch
int hal_gpio_sleep_pad_latch(int port, int pin, int latch, int manual)
Enable GPIO pad during deep sleep.
hal_gpio_ext_int_mask
int hal_gpio_ext_int_mask(int port, int pin, int rise, int fall, int wup)
Mask GPIO pin interrupt.
hal_gpio_reset_arm
void hal_gpio_reset_arm(int en, int port, int pin, int fall, int deb, int sys_rst)
Reset ARM CPU by exteranl GPIO rise/fall edge. : This can reset only cpu but not other HW...
hal_gpio_sleep_wup_edge_latch
int hal_gpio_sleep_wup_edge_latch(int port, int pin, int en)
Latch the wake up GPIO edge.
hal_gpio_pad_oe_ie
int hal_gpio_pad_oe_ie(int port, int pin, int oe, int ie)
Config GPIO PAD as output or input.
hal_gpio_cfg_wup_edge
int hal_gpio_cfg_wup_edge(int port, int pin, int rise, int fall)
Config GPIO pin to edge wake up.
hal_gpio_resume
void hal_gpio_resume(void)
GPIO pin configuration restore after power up.
hal_gpio_cfg_input
int hal_gpio_cfg_input(int port, int pin, int pull_cfg)
Config pin to GPIO input.
hal_gpio_sleep_wup_polarity
int hal_gpio_sleep_wup_polarity(int port, int pin, int pol)
Change wake up GPIO pin polarity.
hal_gpio_cfg_wup_level
int hal_gpio_cfg_wup_level(int port, int pin, int polarity)
Config GPIO pin to level wake up.
hal_gpio_output
int hal_gpio_output(int port, int pin, int high)
Config GPIO output level.
hal_gpio_output_status
int hal_gpio_output_status(int port, int pin)
GPIO output status. : The status is only valid if the output is enabled.
hal_gpio_sleep_wup_edge_detect
int hal_gpio_sleep_wup_edge_detect(int port, int pin, int en)
Detect the wake up GPIO edge.
hal_gpio_pin_mux
int hal_gpio_pin_mux(int port, int pin, int mux)
Config GPIO pin mux.
hal_gpio_cfg_output
int hal_gpio_cfg_output(int port, int pin)
Config pin to GPIO output.
hal_gpio_reset_chip
void hal_gpio_reset_chip(int idx, int en, int port, int pin, int fall, int deb)
Reset chip&#39;s PD1 domain by exteranl GPIO rise/fall edge. : This can reset cpu and peripherals but not...
hal_gpio_pin_dft
void hal_gpio_pin_dft(uint32_t pin_cfg)
Restore GPIO pin to its default state.
hal_gpio_init
void hal_gpio_init(void)
Initialize GPIO port values.
hal_gpio_pad_pd_pu
int hal_gpio_pad_pd_pu(int port, int pin, int pd, int pu)
Config GPIO PAD as pull up or pull down.
hal_gpio_pin_cfg
void hal_gpio_pin_cfg(uint32_t pin_cfg)
Config GPIO from the user&#39;s configuration settings .
hal_gpio_pin_inv
int hal_gpio_pin_inv(int port, int pin, int inv)
Config GPIO pin invert.
hal_gpio_sleep_pad_mask
int hal_gpio_sleep_pad_mask(int port, int pin, int mask)
Enable GPIO pad input during deep sleep.
hal_gpio_wup_dis
int hal_gpio_wup_dis(int port, int pin)
Disable GPIO pin wake up.
hal_gpio_input_status
int hal_gpio_input_status(int port, int pin)
Get GPIO input value.
hal_gpio_sleep_output_grp_0
int hal_gpio_sleep_output_grp_0(int en, int port, int pin, int mux)
Output always on domain (AON) signals thru GPIO mux. : The mux are divided into 4 group (see enum gpi...
hal_gpio_ext_int_prio
int hal_gpio_ext_int_prio(int port, int prio)
Set GPIO interrupt polarity. One port only have one polarity.