1 // Copyright (C) 2022 Beken Corporation
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #pragma once
16
17 #include <soc/soc.h>
18 #include "gpio_hw.h"
19
20 #ifdef __cplusplus
21 extern "C" {
22 #endif
23
24 typedef volatile struct {
25 uint32_t gpio_0_31_int_status;
26 uint32_t gpio_32_64_int_status;
27 } gpio_interrupt_status_t;
28
29 #define GPIO_LL_REG_BASE (SOC_AON_GPIO_REG_BASE)
30 #define GPIO_LL_SYSTEM_REG_BASE (SOC_SYSTEM_REG_BASE + 0x30 * 4)
31 #define GPIO_NUM_MAX (SOC_GPIO_NUM)
32 #define GPIO_EXIST (0xffffffffffff)
33
34 static system_gpio_func_mode_hw_t *gpio_system_gpio_func_mode;
35
gpio_ll_init(gpio_hw_t * hw)36 static inline void gpio_ll_init(gpio_hw_t *hw)
37 {
38 gpio_system_gpio_func_mode = (system_gpio_func_mode_hw_t *)GPIO_LL_SYSTEM_REG_BASE;
39 }
40
gpio_ll_set_io_mode(gpio_hw_t * hw,uint32 index,const gpio_config_t * config)41 static inline void gpio_ll_set_io_mode(gpio_hw_t *hw, uint32 index, const gpio_config_t *config)
42 {
43 uint32 io_mode = 0;
44
45 switch (config->io_mode) {
46 case GPIO_OUTPUT_ENABLE:
47 io_mode = 0;
48 break;
49
50 case GPIO_INPUT_ENABLE:
51 io_mode = 3;
52 break;
53
54 case GPIO_IO_DISABLE:
55 io_mode = 2;
56 break;
57
58 default:
59 break;
60 }
61
62 REG_SET_BITS(&hw->gpio_num[index], GPIO_F_IO_MODE_SET(io_mode), GPIO_F_IO_MODE_EN_M) ;
63
64 }
65
66
gpio_ll_set_pull_mode(gpio_hw_t * hw,uint32 index,const gpio_config_t * config)67 static inline void gpio_ll_set_pull_mode(gpio_hw_t *hw, uint32 index, const gpio_config_t *config)
68 {
69 uint32 pull_mode = 0;
70
71 switch (config->pull_mode) {
72 case GPIO_PULL_DISABLE:
73 pull_mode = 0;
74 break;
75
76 case GPIO_PULL_DOWN_EN:
77 pull_mode = 2;
78 break;
79
80 case GPIO_PULL_UP_EN:
81 pull_mode = 3;
82 break;
83
84 default:
85 break;
86 }
87
88 REG_SET_BITS(&hw->gpio_num[index], GPIO_F_PULL_SET(pull_mode), GPIO_F_PULL_EN_M) ;
89
90 }
91
gpio_ll_set_func_mode(gpio_hw_t * hw,uint32 index,const gpio_config_t * config)92 static inline void gpio_ll_set_func_mode(gpio_hw_t *hw, uint32 index, const gpio_config_t *config)
93 {
94 switch (config->func_mode) {
95 case GPIO_SECOND_FUNC_DISABLE:
96 REG_CLR_BIT(&hw->gpio_num[index], BIT(6));
97 break;
98 case GPIO_SECOND_FUNC_ENABLE:
99 REG_SET_BIT(&hw->gpio_num[index], BIT(6));
100 break;
101 default:
102 break;
103 }
104 }
105
gpio_ll_set_mode(gpio_hw_t * hw,uint32 index,const gpio_config_t * config)106 static inline void gpio_ll_set_mode(gpio_hw_t *hw, uint32 index, const gpio_config_t *config)
107 {
108 gpio_ll_set_io_mode(hw, index, config);
109 gpio_ll_set_pull_mode(hw, index, config);
110 gpio_ll_set_func_mode(hw, index, config);
111 }
112
113
114 //GPIO output enbale low active
gpio_ll_output_enable(gpio_hw_t * hw,uint32 index,uint32_t enable)115 static inline void gpio_ll_output_enable(gpio_hw_t *hw, uint32 index, uint32_t enable)
116 {
117 if (enable)
118 enable = 0;
119 else
120 enable = 1;
121
122 hw->gpio_num[index].cfg.gpio_output_en = enable;
123 }
124
125 //GPIO input enable, high active
gpio_ll_input_enable(gpio_hw_t * hw,uint32 index,uint32_t enable)126 static inline void gpio_ll_input_enable(gpio_hw_t *hw, uint32 index, uint32_t enable)
127 {
128 hw->gpio_num[index].cfg.gpio_input_en = enable;
129 }
130
gpio_ll_pull_up_enable(gpio_hw_t * hw,uint32 index,uint32_t enable)131 static inline void gpio_ll_pull_up_enable(gpio_hw_t *hw, uint32 index, uint32_t enable)
132 {
133 hw->gpio_num[index].cfg.gpio_pull_mode = enable;
134 }
135
gpio_ll_pull_enable(gpio_hw_t * hw,uint32 index,uint32_t enable)136 static inline void gpio_ll_pull_enable(gpio_hw_t *hw, uint32 index, uint32_t enable)
137 {
138 hw->gpio_num[index].cfg.gpio_pull_mode_en = enable;
139 }
140
gpio_ll_second_function_enable(gpio_hw_t * hw,uint32 index,uint32_t enable)141 static inline void gpio_ll_second_function_enable(gpio_hw_t *hw, uint32 index, uint32_t enable)
142 {
143
144 hw->gpio_num[index].cfg.gpio_2_func_en = enable;
145 }
146
gpio_ll_monitor_input_value_enable(gpio_hw_t * hw,uint32 index,uint32_t enable)147 static inline void gpio_ll_monitor_input_value_enable(gpio_hw_t *hw, uint32 index, uint32_t enable)
148 {
149 hw->gpio_num[index].cfg.gpio_input_monitor = enable;
150 }
151
gpio_ll_set_capacity(gpio_hw_t * hw,uint32 index,uint32_t capacity)152 static inline void gpio_ll_set_capacity(gpio_hw_t *hw, uint32 index, uint32_t capacity)
153 {
154 hw->gpio_num[index].cfg.gpio_capacity = capacity;
155 }
156
157
gpio_ll_check_func_mode_enable(gpio_hw_t * hw,uint32 index)158 static inline uint32 gpio_ll_check_func_mode_enable(gpio_hw_t *hw, uint32 index)
159 {
160 return (hw->gpio_num[index].cfg.gpio_2_func_en == 1);
161 }
162
gpio_ll_check_output_enable(gpio_hw_t * hw,uint32 index)163 static inline uint32 gpio_ll_check_output_enable(gpio_hw_t *hw, uint32 index)
164 {
165 return (hw->gpio_num[index].cfg.gpio_output_en == 0);
166 }
167
gpio_ll_check_input_enable(gpio_hw_t * hw,uint32 index)168 static inline uint32 gpio_ll_check_input_enable(gpio_hw_t *hw, uint32 index)
169 {
170 return (hw->gpio_num[index].cfg.gpio_input_en == 1);
171 }
172
173
gpio_ll_set_output_value(gpio_hw_t * hw,uint32 index,bool value)174 static inline void gpio_ll_set_output_value(gpio_hw_t *hw, uint32 index, bool value)
175 {
176 hw->gpio_num[index].cfg.gpio_output = value;
177 }
178
gpio_ll_get_input_value(gpio_hw_t * hw,uint32 index)179 static inline bool gpio_ll_get_input_value(gpio_hw_t *hw, uint32 index)
180 {
181 return hw->gpio_num[index].cfg.gpio_input;
182 }
183
184
185 #define gpio_ll_set_gpio_output_value(hw,index,value) gpio_ll_set_output_value(hw, index, value)
186 #define gpio_ll_get_gpio_input_value(hw,index) gpio_ll_get_input_value(hw, index)
187
188
gpio_ll_set_interrupt_type(gpio_hw_t * hw,uint32 index,gpio_int_type_t mode)189 static inline void gpio_ll_set_interrupt_type(gpio_hw_t *hw, uint32 index, gpio_int_type_t mode)
190 {
191 if (index < GPIO_16)
192 REG_MCHAN_SET_FIELD(index, &hw->gpio_0_15_int_type, GPIO_F_INT_TYPE_MODE, mode);
193 else if (index < GPIO_32)
194 REG_MCHAN_SET_FIELD(index-GPIO_16, &hw->gpio_16_31_int_type, GPIO_F_INT_TYPE_MODE, mode);
195 else
196 REG_MCHAN_SET_FIELD(index-GPIO_32, &hw->gpio_32_47_int_type, GPIO_F_INT_TYPE_MODE, mode);
197
198 }
199
gpio_ll_enable_interrupt(gpio_hw_t * hw,uint32 index)200 static inline void gpio_ll_enable_interrupt(gpio_hw_t *hw, uint32 index)
201 {
202 if (index < GPIO_32)
203 REG_SET_BIT(&hw->gpio_0_31_int_enable, 1 << index);
204 else
205 REG_SET_BIT(&hw->gpio_32_47_int_enable, 1 << (index-GPIO_32));
206
207 }
208
gpio_ll_disable_interrupt(gpio_hw_t * hw,uint32 index)209 static inline void gpio_ll_disable_interrupt(gpio_hw_t *hw, uint32 index)
210 {
211 if (index < GPIO_32)
212 REG_MCHAN_SET_FIELD(index, &hw->gpio_0_31_int_enable, GPIO_F_INT_EN, 0);
213 else
214 REG_MCHAN_SET_FIELD(index-GPIO_32, &hw->gpio_32_47_int_enable, GPIO_F_INT_EN, 0);
215 }
216
gpio_ll_get_interrupt_status(gpio_hw_t * hw,gpio_interrupt_status_t * gpio_status)217 static inline uint32 gpio_ll_get_interrupt_status(gpio_hw_t *hw, gpio_interrupt_status_t* gpio_status)
218 {
219 gpio_status->gpio_0_31_int_status = REG_READ(&hw->gpio_0_31_int_st);
220 gpio_status->gpio_32_64_int_status = REG_READ(&hw->gpio_32_47_int_st);
221
222 return 0;
223
224 }
225
gpio_ll_clear_interrupt_status(gpio_hw_t * hw,gpio_interrupt_status_t * gpio_status)226 static inline void gpio_ll_clear_interrupt_status(gpio_hw_t *hw, gpio_interrupt_status_t *gpio_status)
227 {
228 if (gpio_status->gpio_0_31_int_status)
229 REG_WRITE(&hw->gpio_0_31_int_clr, gpio_status->gpio_0_31_int_status);
230 if (gpio_status->gpio_32_64_int_status)
231 REG_WRITE(&hw->gpio_32_47_int_clr, gpio_status->gpio_32_64_int_status);
232
233 }
234
gpio_ll_clear_chan_interrupt_status(gpio_hw_t * hw,uint32 index)235 static inline void gpio_ll_clear_chan_interrupt_status(gpio_hw_t *hw, uint32 index)
236 {
237 if (index < GPIO_32)
238 REG_MCHAN_SET_FIELD(index, &hw->gpio_0_31_int_clr, GPIO_F_INT_EN, 1);
239 else
240 REG_MCHAN_SET_FIELD(index-GPIO_32, &hw->gpio_32_47_int_clr, GPIO_F_INT_EN, 1);
241 }
242
gpio_ll_is_interrupt_triggered(gpio_hw_t * hw,uint32 index,gpio_interrupt_status_t * gpio_status)243 static inline bool gpio_ll_is_interrupt_triggered(gpio_hw_t *hw, uint32 index, gpio_interrupt_status_t *gpio_status)
244 {
245 if (index < GPIO_32)
246 return !!((gpio_status->gpio_0_31_int_status) & (GPIO_F_INT_EN << (GPIO_F_INT_EN_MS(index))));
247 else
248 return !!((gpio_status->gpio_32_64_int_status) & (GPIO_F_INT_EN << (GPIO_F_INT_EN_MS(index-GPIO_32))));
249
250 }
251
252
gpio_ll_set_perial_mode(gpio_hw_t * hw,uint32 index,uint32_t mode)253 static inline void gpio_ll_set_perial_mode(gpio_hw_t *hw, uint32 index, uint32_t mode)
254 {
255 if (index < GPIO_8)
256 REG_MCHAN_SET_FIELD(index, &gpio_system_gpio_func_mode->gpio_sys_num[0], GPIO_F_PERIAL_MODE, mode);
257 else if (index < GPIO_16)
258 REG_MCHAN_SET_FIELD(index-GPIO_8, &gpio_system_gpio_func_mode->gpio_sys_num[1], GPIO_F_PERIAL_MODE, mode);
259 else if (index < GPIO_24)
260 REG_MCHAN_SET_FIELD(index-GPIO_16, &gpio_system_gpio_func_mode->gpio_sys_num[2], GPIO_F_PERIAL_MODE, mode);
261 else if (index < GPIO_32)
262 REG_MCHAN_SET_FIELD(index-GPIO_24, &gpio_system_gpio_func_mode->gpio_sys_num[3], GPIO_F_PERIAL_MODE, mode);
263 else if (index < GPIO_40)
264 REG_MCHAN_SET_FIELD(index-GPIO_32, &gpio_system_gpio_func_mode->gpio_sys_num[4], GPIO_F_PERIAL_MODE, mode);
265 else
266 REG_MCHAN_SET_FIELD(index-GPIO_40, &gpio_system_gpio_func_mode->gpio_sys_num[5], GPIO_F_PERIAL_MODE, mode);
267
268 }
269
gpio_ll_get_perial_mode(gpio_hw_t * hw,uint32 index)270 static inline uint32 gpio_ll_get_perial_mode(gpio_hw_t *hw, uint32 index)
271 {
272 if (index < GPIO_8)
273 return (REG_MCHAN_GET_FIELD(index, &gpio_system_gpio_func_mode->gpio_sys_num[0], GPIO_F_PERIAL_MODE));
274 else if (index < GPIO_16)
275 return ((REG_MCHAN_GET_FIELD(index-GPIO_8, &gpio_system_gpio_func_mode->gpio_sys_num[1], GPIO_F_PERIAL_MODE)));
276 else if (index < GPIO_24)
277 return ((REG_MCHAN_GET_FIELD(index-GPIO_16, &gpio_system_gpio_func_mode->gpio_sys_num[2], GPIO_F_PERIAL_MODE)));
278 else if (index < GPIO_32)
279 return ((REG_MCHAN_GET_FIELD(index-GPIO_24, &gpio_system_gpio_func_mode->gpio_sys_num[3], GPIO_F_PERIAL_MODE)));
280 else if (index < GPIO_40)
281 return ((REG_MCHAN_GET_FIELD(index-GPIO_32, &gpio_system_gpio_func_mode->gpio_sys_num[4], GPIO_F_PERIAL_MODE)));
282 else
283 return ((REG_MCHAN_GET_FIELD(index-GPIO_40, &gpio_system_gpio_func_mode->gpio_sys_num[5], GPIO_F_PERIAL_MODE)));
284 }
285
286 #define gpio_ll_set_gpio_perial_mode(hw, index, mode) gpio_ll_set_perial_mode(hw, index, mode)
287 #define gpio_ll_get_gpio_perial_mode(hw, index) gpio_ll_get_perial_mode(hw, index)
288
289 #if CONFIG_GPIO_WAKEUP_SUPPORT
290 /* gpio bak configs:just bak only low 16bits of GPIO config:input/output/pull en/... , not include interrupt */
gpio_ll_bak_configs(uint16_t * gpio_cfg,uint32_t count)291 static inline void gpio_ll_bak_configs(uint16_t *gpio_cfg, uint32_t count)
292 {
293 uint32_t i = 0;
294
295 if(gpio_cfg == NULL)
296 return;
297
298 for(i = 0; i < count; i++)
299 {
300 gpio_cfg[i] = (uint16_t)REG_READ(GPIO_LL_REG_BASE+i*4);
301 }
302 }
303
304 /* gpio bak configs:just restore only low 16bits of GPIO config:input/output/pull en/... , not include interrupt */
gpio_ll_restore_configs(uint16_t * gpio_cfg,uint32_t count)305 static inline void gpio_ll_restore_configs(uint16_t *gpio_cfg, uint32_t count)
306 {
307 uint32_t i = 0;
308 uint32_t val = 0;
309
310 if(gpio_cfg == NULL)
311 return;
312
313 for(i = 0; i < count; i++)
314 {
315 val = REG_READ(GPIO_LL_REG_BASE+i*4);
316 val &= 0xffff0000;
317 val |= gpio_cfg[i];
318 REG_WRITE((GPIO_LL_REG_BASE+i*4), val);
319 }
320 }
321
gpio_ll_bak_int_type_configs(uint32_t * gpio_int_cfg,uint32_t count)322 static inline void gpio_ll_bak_int_type_configs(uint32_t *gpio_int_cfg, uint32_t count)
323 {
324 uint32_t i = 0;
325
326 if(gpio_int_cfg == NULL)
327 return;
328
329 for(i = 0; i < count; i++)
330 {
331 gpio_int_cfg[i] = REG_READ(GPIO_LL_REG_BASE+(i + 0x40)*4);
332 }
333 }
334
gpio_ll_restore_int_type_configs(uint32_t * gpio_int_cfg,uint32_t count)335 static inline void gpio_ll_restore_int_type_configs(uint32_t *gpio_int_cfg, uint32_t count)
336 {
337 uint32_t i = 0;
338
339 if(gpio_int_cfg == NULL)
340 return;
341
342 for(i = 0; i < count; i ++)
343 {
344 REG_WRITE((GPIO_LL_REG_BASE+(i + 0x40)*4), gpio_int_cfg[i]);
345 }
346 }
347
gpio_ll_bak_int_enable_configs(uint32_t * gpio_int_cfg,uint32_t count)348 static inline void gpio_ll_bak_int_enable_configs(uint32_t *gpio_int_cfg, uint32_t count)
349 {
350 uint32_t i = 0;
351
352 if(gpio_int_cfg == NULL)
353 return;
354
355 for(i = 0; i < count; i++)
356 {
357 gpio_int_cfg[i] = REG_READ(GPIO_LL_REG_BASE+(i + 0x43)*4);
358 }
359 }
360
gpio_ll_restore_int_enable_configs(uint32_t * gpio_int_cfg,uint32_t count)361 static inline void gpio_ll_restore_int_enable_configs(uint32_t *gpio_int_cfg, uint32_t count)
362 {
363 uint32_t i = 0;
364
365 if(gpio_int_cfg == NULL)
366 return;
367
368 for(i = 0; i < count; i ++)
369 {
370 REG_WRITE((GPIO_LL_REG_BASE+(i + 0x43)*4), gpio_int_cfg[i]);
371 }
372 }
373
374 /* gpio switch to low power status:set all gpios to input mode */
gpio_ll_switch_to_low_power_status(void)375 static inline void gpio_ll_switch_to_low_power_status(void)
376 {
377 uint32_t i = 0;
378 uint32_t val = 0;
379
380 for(i = 0; i < GPIO_NUM_MAX; i ++)
381 {
382 val = REG_READ(GPIO_LL_REG_BASE+i*4);
383 val &= 0xffff0000;
384 val |= 0x0008;
385 REG_WRITE((GPIO_LL_REG_BASE+i*4), val);
386 }
387 }
388
389 #else
390 /* gpio save */
gpio_ll_reg_save(uint32_t * gpio_cfg)391 static inline void gpio_ll_reg_save(uint32_t* gpio_cfg)
392 {
393 int i = 0;
394 if(gpio_cfg == NULL)
395 return;
396
397 for(i = 0; i < GPIO_NUM_MAX; i ++)
398 {
399 //if(GPIO_EXIST & BIT(i))//temp modify
400 {
401 gpio_cfg[i] = REG_READ(GPIO_LL_REG_BASE+i*4);
402 }
403 }
404 }
405
406 /* gpio restore */
gpio_ll_reg_restore(uint32_t * gpio_cfg)407 static inline void gpio_ll_reg_restore(uint32_t* gpio_cfg)
408 {
409 int i = 0;
410 if(gpio_cfg == NULL)
411 return;
412 for(i = 0; i < GPIO_NUM_MAX; i ++)
413 {
414 //if(GPIO_EXIST & BIT(i))//temp modify
415 {
416 REG_WRITE(GPIO_LL_REG_BASE+i*4, gpio_cfg[i]);
417 }
418 }
419 }
420
421 /* config gpio wakeup type and enable. @type_l: low/high or pos/nege. @type_h: level or edge */
gpio_ll_wakeup_enable(uint64_t index,uint64_t type_l,uint64_t type_h)422 static inline void gpio_ll_wakeup_enable(uint64_t index, uint64_t type_l, uint64_t type_h)
423 {
424 int i = 0;
425 uint32_t rdata = 0;
426 uint64_t index_ini = index;
427
428 /* clear all int enable */
429 REG_WRITE(GPIO_LL_REG_BASE+0x43*4, 0x0);
430 REG_WRITE(GPIO_LL_REG_BASE+0x44*4, 0x0);
431
432 rdata = REG_READ(GPIO_LL_REG_BASE+0x40*4);
433 for(i = 0; i < 16; i ++)
434 {
435 if(index & BIT(i))
436 {
437 REG_WRITE(GPIO_LL_REG_BASE+i*4, 0x0c);
438 rdata &= ~(0x3 << i*2);
439 if(type_l & BIT(i)) rdata |= BIT(2*i);
440 if(type_h & BIT(i)) rdata |= BIT(2*i+1);
441 }
442 else
443 {
444 REG_WRITE(GPIO_LL_REG_BASE+i*4, 0x08);
445 }
446 }
447 REG_WRITE(GPIO_LL_REG_BASE+0x40*4, rdata);
448
449
450
451 index = index >> 16;
452 type_l = type_l >> 16;
453 type_h = type_h >> 16;
454
455 rdata = REG_READ(GPIO_LL_REG_BASE+0x41*4);
456 for(i = 0; i < 16; i ++)
457 {
458 if(index & BIT(i))
459 {
460 REG_WRITE(GPIO_LL_REG_BASE+0x40+i*4, 0x0c);
461 rdata &= ~(0x3 << i*2);
462 if(type_l & BIT(i)) rdata |= BIT(2*i);
463 if(type_h & BIT(i)) rdata |= BIT(2*i+1);
464 }
465 else
466 {
467 REG_WRITE(GPIO_LL_REG_BASE+0x40+i*4, 0x08);
468 }
469 }
470
471 REG_WRITE(GPIO_LL_REG_BASE+0x41*4, rdata);
472
473
474
475 index = index >> 16;
476 type_l = type_l >> 16;
477 type_h = type_h >> 16;
478
479 rdata = REG_READ(GPIO_LL_REG_BASE+0x42*4);
480 for(i = 0; i < 16; i ++)
481 {
482 if(index & BIT(i))
483 {
484 REG_WRITE(GPIO_LL_REG_BASE+0x80+i*4, 0x0c);
485 rdata &= ~(0x3 << i*2);
486 if(type_l & BIT(i)) rdata |= BIT(2*i);
487 if(type_h & BIT(i)) rdata |= BIT(2*i+1);
488 }
489 else
490 {
491 REG_WRITE(GPIO_LL_REG_BASE+0x80+i*4, 0x08);
492 }
493 }
494
495 REG_WRITE(GPIO_LL_REG_BASE+0x42*4, rdata);
496
497 extern void delay(INT32 num);
498 delay(10);
499 REG_WRITE(GPIO_LL_REG_BASE+0x47*4, 0xffffffff);
500 REG_WRITE(GPIO_LL_REG_BASE+0x48*4, 0xffffffff);
501
502 index = index_ini;
503 rdata = 0;
504 for(i = 0; i < 32; i ++)
505 {
506 if(index & BIT(i))
507 {
508 rdata |= BIT(i);
509 }
510 }
511
512 REG_WRITE(GPIO_LL_REG_BASE+0x43*4, rdata);
513
514
515 index = index >> 32;
516 rdata = 0;
517 for(i = 0; i < 16; i ++)
518 {
519 if(index & BIT(i))
520 {
521 rdata |= BIT(i);
522 }
523 }
524
525 REG_WRITE(GPIO_LL_REG_BASE+0x44*4, rdata);
526
527 }
gpio_ll_wakeup_interrupt_clear()528 static inline void gpio_ll_wakeup_interrupt_clear()
529 {
530 uint64_t int_state = 0;
531 uint32_t int_state1 = 0;
532 uint32_t int_en_state = 0;
533 uint32_t int_en_state1 = 0;
534
535 uint32_t i = 0;
536
537 int_state = REG_READ(GPIO_LL_REG_BASE+0x46*4);
538 int_state1 = REG_READ(GPIO_LL_REG_BASE+0x45*4);
539
540 int_en_state = REG_READ(GPIO_LL_REG_BASE+0x43*4);
541 int_en_state1 = REG_READ(GPIO_LL_REG_BASE+0x44*4);
542
543 int_state = (int_state << 32) | (int_state1);
544
545 for(i = 0; i < GPIO_NUM_MAX; i ++)
546 {
547 if(int_state & BIT(i))
548 {
549 break;
550 }
551 }
552 if(i > 31)
553 {
554
555 int_en_state1 &= ~(BIT(i));
556 REG_WRITE(GPIO_LL_REG_BASE+0x44*4, int_en_state1);
557 }
558 else
559 {
560 int_en_state &= ~(BIT(i));
561 REG_WRITE(GPIO_LL_REG_BASE+0x43*4, int_en_state);
562 }
563
564 REG_WRITE(GPIO_LL_REG_BASE+0x47*4, (REG_READ(GPIO_LL_REG_BASE+0x47*4))|int_state);
565 REG_WRITE(GPIO_LL_REG_BASE+0x48*4, (REG_READ(GPIO_LL_REG_BASE+0x48*4))|(int_state >> 32));
566
567 extern void delay(INT32 num);
568 delay(10);
569 REG_WRITE(GPIO_LL_REG_BASE+0x47*4, 0xffffffff);
570 REG_WRITE(GPIO_LL_REG_BASE+0x48*4, 0xffffffff);
571
572 }
573
574 #endif
575
576 #ifdef __cplusplus
577 }
578 #endif
579
580