1 /*
2 * Copyright (C) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 */
18
19 #include <linux/module.h>
20 #include <linux/version.h>
21 #ifdef __KERNEL__
22 #include <linux/interrupt.h>
23 #endif
24
25 #include "drv_gpio.h"
26 #include "hi_log.h"
27 #include "hi_error_mpi.h"
28 #include "hi_drv_gpio.h"
29 #include "hi_common.h"
30 #include "hi_module.h"
31
32 #if !defined(CFG_HI_USER_DRV)
33 #include "hi_drv_sys.h"
34 #endif
35
36 #define GPIO_MAX_BUF 100
37 #define GPIO_ONE_GROUP_BIT_NUM 8
38
39 #define GPIO_BUF_HEAD g_st_gpio_attr.gpio_int_buf[g_st_gpio_attr.head]
40 #define GPIO_BUF_TAIL g_st_gpio_attr.gpio_int_buf[g_st_gpio_attr.tail]
41
42 #define inc_buf(x, len) (((x) + 1) % (len))
43
44 #define INT_TYPE_NONE 0x0
45 #define INT_TYPE_EDGE_RISING 0x1
46 #define INT_TYPE_EDGE_FALLING 0x2
47 #define INT_TYPE_EDGE_BOTH (INT_TYPE_EDGE_FALLING | INT_TYPE_EDGE_RISING)
48 #define INT_TYPE_LEVEL_HIGH 0x4
49 #define INT_TYPE_LEVEL_LOW 0x8
50 #define GPIO_IRQF_ONESHOT 0x00002000
51
52 typedef struct {
53 hi_bool gpio_int_enable;
54 gpio_inttpye gpio_int_type;
55 hi_void (*gpio_server)(hi_u32 gpio_no);
56 } gpio_int_attr;
57
58 typedef struct {
59 hi_u32 head;
60 hi_u32 tail;
61 hi_u32 gpio_int_buf[GPIO_MAX_BUF];
62 hi_u32 gpio_buf_len;
63 hi_u32 gpio_block_time;
64 gpio_int_attr gpio_int_attr[HI_GPIO_MAX_BIT_NUM];
65 osal_wait gpio_int_wait_queue;
66 } gpio_attr;
67
68 static gpio_attr g_st_gpio_attr;
69
70 #define GPIO_IRQ_NUM 2
71
72 static gpio_ext_func g_st_gpio_export_funcs = {
73 .pfn_gpio_dir_get_bit = hi_drv_gpio_get_dir_bit,
74 .pfn_gpio_dir_set_bit = hi_drv_gpio_set_dir_bit,
75 .pfn_gpio_read_bit = hi_drv_gpio_read_bit,
76 .pfn_gpio_write_bit = hi_drv_gpio_write_bit,
77 .pfn_gpio_get_num = hi_drv_gpio_get_gpio_num,
78 .pfn_gpio_register_server_func = hi_drv_gpio_register_server_func,
79 .pfn_gpio_unregister_server_func = hi_drv_gpio_unregister_server_func,
80 .pfn_gpio_set_int_type = hi_drv_gpio_set_int_type,
81 .pfn_gpio_set_int_enable = hi_drv_gpio_set_bit_int_enable,
82 .pfn_gpio_clear_group_int = hi_drv_gpio_clear_group_int,
83 .pfn_gpio_clear_bit_int = hi_drv_gpio_clear_bit_int,
84 .pfn_gpio_get_usr_addr = hi_drv_gpio_get_usr_addr
85 };
86
87 static gpio_get_gpionum g_gpio_num;
88 static hi_u32 g_gpio_inttype[HI_GPIO_MAX_BIT_NUM] = {0};
89 static hi_s32 g_gpio_to_irq[HI_GPIO_MAX_BIT_NUM] = {0};
90 #ifndef CHIP_TYPE_hi3751v350
91 static hi_u8 *g_gpio_irq_name[] = {
92 "hi_gpio_irq",
93 "hi_stb_gpio_irq"
94 };
95 #endif
96 #define GPIO_OUTPUT 0
97 #define GPIO_INPUT 1
98
99 #ifndef HI_FPGA
100 #define GPIO_IRQ_STB_NO (126 + 32)
101 #define GPIO_IRQ_NO (108 + 32)
102 static gpio_irq g_gpio_irq_table[] = {
103 { GPIO_IRQ_NO, "hi_gpio_irq" },
104 { GPIO_IRQ_STB_NO, "hi_stb_gpio_irq" }
105 };
106 #endif
107
108 volatile hi_void *g_gpio_usr_addr[HI_GPIO_MAX_GROUP_NUM];
109 EXPORT_SYMBOL(g_gpio_usr_addr);
110
111 static HI_U8 g_gpio_grp_num;
112 static HI_U8 g_gpio_max_num;
113
114 hi_s32 gpio_isr(hi_s32 irq, hi_void *dev_id);
115 hi_s32 drv_gpio_isr(hi_s32 irq, hi_void *dev_id);
116
gpio_drv_get_gpio_ext_func(gpio_ext_func ** st_gpio_export_funcs)117 hi_void gpio_drv_get_gpio_ext_func(gpio_ext_func **st_gpio_export_funcs)
118 {
119 *st_gpio_export_funcs = &g_st_gpio_export_funcs;
120 }
121 EXPORT_SYMBOL(gpio_drv_get_gpio_ext_func);
122
gpio_drv_get_chip_version(hi_void)123 hi_u32 gpio_drv_get_chip_version(hi_void)
124 {
125 HI_CHIP_VERSION_E chip_version = HI_CHIP_VERSION_BUTT;
126 gpio_drv_chip chip = GPIO_DRV_CHIP_V350;
127 #if !defined(CFG_HI_USER_DRV)
128 HI_CHIP_TYPE_E chip_type;
129 hi_drv_sys_get_chip_version(&chip_type, &chip_version);
130 #else
131 chip_version = HI_CHIP_VERSION_V350;
132 #endif
133
134 if (chip_version == HI_CHIP_VERSION_BUTT) {
135 chip = GPIO_DRV_CHIP_V350;
136 } else {
137 switch (chip_version) {
138 case HI_CHIP_VERSION_V350:
139 case HI_CHIP_VERSION_V351:
140 chip = GPIO_DRV_CHIP_V350;
141 break;
142 default:
143 break;
144 }
145 }
146
147 HI_LOG_DBG("get chip version:0x%x\n", chip);
148 return chip;
149 }
150
151 #ifndef CHIP_TYPE_hi3751v350
gpio_get_vir_no(hi_u32 chip,hi_u32 gpio_grp,hi_u32 gpio_bit)152 static hi_u32 gpio_get_vir_no(hi_u32 chip, hi_u32 gpio_grp, hi_u32 gpio_bit)
153 {
154 hi_u32 vir_gpio_no;
155
156 vir_gpio_no = gpio_grp * GPIO_ONE_GROUP_BIT_NUM + gpio_bit;
157
158 if (chip == GPIO_DRV_CHIP_V350) {
159 if (gpio_grp > 17) { /* 17 : unused gpio group */
160 vir_gpio_no += GPIO_ONE_GROUP_BIT_NUM * 2; /* 2:unused gpio group num */
161 } else if (gpio_grp < 16) { /* 16 : unused gpio group */
162 vir_gpio_no += GPIO_ONE_GROUP_BIT_NUM * 8; /* 8:unused gpio group num */
163 }
164 }
165
166 return vir_gpio_no;
167 }
168 #endif
169
drv_gpio_convert(hi_u32 gpio_no,hi_u32 * p_group_no,hi_u32 * p_bit_no)170 static hi_bool drv_gpio_convert(hi_u32 gpio_no, hi_u32 *p_group_no, hi_u32 *p_bit_no)
171 {
172 if (gpio_no >= g_gpio_max_num || p_group_no == HI_NULL || p_bit_no == HI_NULL) {
173 HI_LOG_ERR("para gpio_no is invalid.\n");
174 hi_err_print_u32(gpio_no);
175 return HI_FALSE;
176 }
177
178 if (g_gpio_usr_addr[(gpio_no / HI_GPIO_BIT_NUM)] == NULL) {
179 HI_LOG_ERR("para gpio_no is reserved.\n");
180 hi_err_print_u32(gpio_no);
181 return HI_FALSE;
182 }
183 *p_group_no = gpio_no / HI_GPIO_BIT_NUM;
184 *p_bit_no = gpio_no % HI_GPIO_BIT_NUM;
185
186 return HI_TRUE;
187 }
188
hi_drv_gpio_set_dir_bit(hi_u32 gpio_no,hi_u32 dir_bit)189 hi_s32 hi_drv_gpio_set_dir_bit(hi_u32 gpio_no, hi_u32 dir_bit)
190 {
191 hi_u32 gpio_dirt_value;
192 volatile hi_void *gpio_usr_addr = HI_NULL;
193 hi_u32 group_no = 0;
194 hi_u32 bit_no = 0;
195
196 hi_dbg_func_enter();
197 if (HI_FALSE == drv_gpio_convert(gpio_no, &group_no, &bit_no)) {
198 HI_LOG_ERR("para gpio_no is invalid.GpioNo is %u\n", gpio_no);
199 return HI_ERR_GPIO_INVALID_PARA;
200 }
201
202 if (dir_bit != HI_TRUE && dir_bit != HI_FALSE) {
203 HI_LOG_ERR("para dir_bit is invalid.\n");
204 hi_err_print_u32(group_no);
205 hi_err_print_u32(bit_no);
206 return HI_ERR_GPIO_INVALID_PARA;
207 }
208
209 gpio_usr_addr = g_gpio_usr_addr[group_no];
210 gpio_dirt_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_DIR_REG);
211
212 if (!dir_bit) { /* 0 output */
213 gpio_dirt_value |= (HI_GPIO_OUTPUT << bit_no);
214 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_DIR_REG) = gpio_dirt_value;
215 } else { /* 1 input */
216 gpio_dirt_value &= (~(1 << bit_no));
217 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_DIR_REG) = gpio_dirt_value;
218 }
219
220 hi_dbg_func_exit();
221
222 return HI_SUCCESS;
223 }
224
hi_drv_gpio_get_dir_bit(hi_u32 gpio_no,hi_u32 * pdir_bit)225 hi_s32 hi_drv_gpio_get_dir_bit(hi_u32 gpio_no, hi_u32 *pdir_bit)
226 {
227 hi_u32 group_no, bit_no;
228 hi_u32 gpio_dirt_value;
229 volatile hi_void *gpio_usr_addr = HI_NULL;
230
231 hi_dbg_func_enter();
232
233 if (drv_gpio_convert(gpio_no, &group_no, &bit_no) == HI_FALSE) {
234 HI_LOG_ERR("para gpio_no is invalid. GpioNo is %u\n", gpio_no);
235 return HI_ERR_GPIO_INVALID_PARA;
236 }
237
238 if (pdir_bit == NULL) {
239 HI_LOG_ERR("para pdir_bit is null.\n");
240 hi_err_print_u32(group_no);
241 hi_err_print_u32(bit_no);
242 return HI_ERR_GPIO_NULL_PTR;
243 }
244
245 gpio_usr_addr = g_gpio_usr_addr[group_no];
246 gpio_dirt_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_DIR_REG);
247 gpio_dirt_value &= (1 << bit_no);
248 if (gpio_dirt_value == 0) {
249 *pdir_bit = HI_TRUE;
250 } else {
251 *pdir_bit = HI_FALSE;
252 }
253
254 hi_dbg_func_exit();
255
256 return HI_SUCCESS;
257 }
258
hi_drv_gpio_write_bit(hi_u32 gpio_no,hi_u32 bit_value)259 hi_s32 hi_drv_gpio_write_bit(hi_u32 gpio_no, hi_u32 bit_value)
260 {
261 hi_u32 gpio_dirt_value;
262 volatile hi_void *gpio_usr_addr = HI_NULL;
263 hi_u32 group_no = 0;
264 hi_u32 bit_no = 0;
265
266 hi_dbg_func_enter();
267
268 if (HI_FALSE == drv_gpio_convert(gpio_no, &group_no, &bit_no)) {
269 HI_LOG_ERR("para gpio_no is invalid. GpioNo is %u\n", gpio_no);
270 return HI_ERR_GPIO_INVALID_PARA;
271 }
272
273 if ((bit_value != HI_TRUE)
274 && (bit_value != HI_FALSE)) {
275 HI_LOG_ERR("para bit_value is invalid.\n");
276 hi_err_print_u32(group_no);
277 hi_err_print_u32(bit_no);
278 return HI_ERR_GPIO_INVALID_PARA;
279 }
280
281 gpio_usr_addr = g_gpio_usr_addr[group_no];
282 gpio_dirt_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_DIR_REG);
283 gpio_dirt_value &= (1 << bit_no);
284 gpio_dirt_value = gpio_dirt_value >> bit_no;
285 if (gpio_dirt_value != HI_GPIO_OUTPUT) {
286 HI_LOG_ERR("GPIO Direction is input, write can not operate.\n");
287 hi_err_print_u32(group_no);
288 hi_err_print_u32(bit_no);
289 return HI_ERR_GPIO_INVALID_OPT;
290 }
291
292 if (bit_value) {
293 REG_USR_ADDR(gpio_usr_addr + (4 << bit_no)) = 1 << bit_no; // 4 :offsetr
294 } else {
295 REG_USR_ADDR(gpio_usr_addr + (4 << bit_no)) = 0; // 4 :offsetr
296 }
297
298 hi_dbg_func_exit();
299
300 return HI_SUCCESS;
301 }
302
hi_drv_gpio_read_bit(hi_u32 gpio_no,hi_u32 * bit_value)303 hi_s32 hi_drv_gpio_read_bit(hi_u32 gpio_no, hi_u32 *bit_value)
304 {
305 volatile hi_void *gpio_usr_addr = HI_NULL;
306 hi_u32 group_no = 0;
307 hi_u32 bit_no = 0;
308
309 hi_dbg_func_enter();
310
311 if (HI_FALSE == drv_gpio_convert(gpio_no, &group_no, &bit_no)) {
312 HI_LOG_ERR("para gpio_no is invalid.\n");
313 hi_err_print_u32(group_no);
314 return HI_ERR_GPIO_INVALID_PARA;
315 }
316
317 if (bit_value == NULL) {
318 HI_LOG_ERR("para bit_value is null.\n");
319 hi_err_print_u32(group_no);
320 hi_err_print_u32(bit_no);
321 return HI_ERR_GPIO_NULL_PTR;
322 }
323
324 gpio_usr_addr = g_gpio_usr_addr[group_no];
325 *bit_value = REG_USR_ADDR(gpio_usr_addr +
326 (4 << bit_no)) >> bit_no; // 4: 0ffset
327
328 hi_dbg_func_exit();
329
330 return HI_SUCCESS;
331 }
332
333 /*
334 gpio_group: gpio group number
335 u32BitX: gpio bit offset
336 en_int_tri_mode: interruput type ,please see gpio_inttpye
337 */
gpio_set_edge_trigger_type(hi_u32 bit_no,hi_u32 group_no,gpio_inttpye en_int_tri_mode)338 static hi_void gpio_set_edge_trigger_type(hi_u32 bit_no,
339 hi_u32 group_no, gpio_inttpye en_int_tri_mode)
340 {
341 volatile hi_void *gpio_usr_addr = HI_NULL;
342 hi_u32 gpio_value, gpio_no;
343
344 gpio_no = group_no * 8 + bit_no; /* 8 : one group bit */
345 gpio_usr_addr = g_gpio_usr_addr[group_no];
346 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IS_REG);
347 gpio_value &= (~(1 << bit_no));
348 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IS_REG) = gpio_value;
349 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IBE_REG);
350
351 if (en_int_tri_mode == GPIO_INTTYPE_UP) {
352 gpio_value &= (~(1 << bit_no)); /* single edge trigger */
353 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IBE_REG) = gpio_value;
354
355 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG);
356 gpio_value |= (1 << bit_no); /* up edge */
357 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG) = gpio_value;
358 g_gpio_inttype[gpio_no] = INT_TYPE_EDGE_RISING;
359 } else if (en_int_tri_mode == GPIO_INTTYPE_DOWN) {
360 gpio_value &= (~(1 << bit_no)); /* single edge trigger */
361 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IBE_REG) = gpio_value;
362
363 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG);
364 gpio_value &= (~(1 << bit_no)); /* down edge */
365 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG) = gpio_value;
366 g_gpio_inttype[gpio_no] = INT_TYPE_EDGE_FALLING;
367 } else {
368 gpio_value |= (1 << bit_no); /* double edge */
369 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IBE_REG) = gpio_value;
370 g_gpio_inttype[gpio_no] = INT_TYPE_EDGE_BOTH;
371 }
372 return;
373 }
374
gpio_set_level_trigger_type(hi_u32 bit_no,hi_u32 group_no,gpio_inttpye en_int_tri_mode)375 static hi_void gpio_set_level_trigger_type(hi_u32 bit_no,
376 hi_u32 group_no, gpio_inttpye en_int_tri_mode)
377 {
378 volatile hi_void *gpio_usr_addr = HI_NULL;
379 hi_u32 gpio_value, gpio_no;
380
381 gpio_no = group_no * 8 + bit_no; /* 8 : one group bit */
382 gpio_usr_addr = g_gpio_usr_addr[group_no];
383 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IS_REG);
384 gpio_value |= (1 << bit_no);
385 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IS_REG) = gpio_value;
386
387 if (en_int_tri_mode == GPIO_INTTYPE_HIGH) {
388 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG);
389 gpio_value |= (1 << bit_no); /* high level trigger */
390 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG) = gpio_value;
391 /* level trigger type must use IRQF_ONESHOT interrupt is not re-enabled after the hardirq handler finished */
392 g_gpio_inttype[gpio_no] = INT_TYPE_LEVEL_HIGH | GPIO_IRQF_ONESHOT;
393 } else {
394 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG);
395 gpio_value &= (~(1 << bit_no)); /* low level trigger */
396 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IEV_REG) = gpio_value;
397 /* level trigger type must use IRQF_ONESHOT interrupt is not re-enabled after the hardirq handler finished */
398 g_gpio_inttype[gpio_no] = INT_TYPE_LEVEL_HIGH | GPIO_IRQF_ONESHOT;
399 }
400 return;
401 }
402
hi_drv_gpio_set_int_type(hi_u32 gpio_no,gpio_inttpye en_int_tri_mode)403 hi_s32 hi_drv_gpio_set_int_type(hi_u32 gpio_no, gpio_inttpye en_int_tri_mode)
404 {
405 hi_u32 group_no = 0;
406 hi_u32 bit_no = 0;
407
408 hi_dbg_func_enter();
409
410 if (HI_FALSE == drv_gpio_convert(gpio_no, &group_no, &bit_no)) {
411 HI_LOG_ERR("para gpio_no is invalid. GpioNo is %u\n", gpio_no);
412 return HI_ERR_GPIO_INVALID_PARA;
413 }
414
415 if (en_int_tri_mode >= GPIO_INTTYPE_BUTT) {
416 HI_LOG_ERR("para en_int_tri_mode is invalid. GpioNo is %u\n", gpio_no);
417 return HI_ERR_GPIO_INVALID_PARA;
418 }
419
420 /* edge trigger */
421 if (en_int_tri_mode <= GPIO_INTTYPE_UPDOWN) {
422 gpio_set_edge_trigger_type(bit_no, group_no, en_int_tri_mode);
423 } else if (en_int_tri_mode > GPIO_INTTYPE_UPDOWN) { /* level trigger */
424 gpio_set_level_trigger_type(bit_no, group_no, en_int_tri_mode);
425 }
426
427 hi_dbg_print_u32(group_no);
428 hi_dbg_print_u32(bit_no);
429 hi_dbg_print_u32(en_int_tri_mode);
430 hi_dbg_func_exit();
431
432 return HI_SUCCESS;
433 }
434
gpio_set_irq_ctrl_reg(hi_u32 group_no,hi_u32 bit_no,hi_bool enable)435 static hi_void gpio_set_irq_ctrl_reg(hi_u32 group_no, hi_u32 bit_no, hi_bool enable)
436 {
437 hi_u32 gpio_value, gpio_no;
438 volatile hi_void *gpio_usr_addr = HI_NULL;
439
440 gpio_no = group_no * GPIO_ONE_GROUP_BIT_NUM + bit_no;
441 gpio_usr_addr = g_gpio_usr_addr[group_no];
442 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IE_REG);
443
444 if (enable) { /* not marsk */
445 gpio_value |= (1 << bit_no);
446 g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_int_enable = HI_TRUE;
447 } else { /* marsk */
448 gpio_value &= (~(1 << bit_no));
449 g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_int_enable = HI_FALSE;
450 }
451 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IE_REG) = gpio_value;
452 return;
453 }
454
gpio_set_bit_irq_disable(hi_u32 chip,hi_u32 gpio_no,hi_u32 group_no,hi_u32 bit_no)455 static hi_void gpio_set_bit_irq_disable(hi_u32 chip, hi_u32 gpio_no, hi_u32 group_no, hi_u32 bit_no)
456 {
457 hi_u32 index;
458
459 index = (group_no <= 15) ? (0) : (1); /* hi_gpio_irq: group 0 ~ 15; hi_stb_gpio_irq: group 18 ~ 22 */
460 #ifdef ENABLE_GPIO_IRQ_FREE
461 osal_irq_free(g_gpio_irq_table[index].irq_no, NULL);
462 #endif
463 g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_int_enable = HI_FALSE;
464
465 return;
466 }
467
gpio_set_bit_irq_enable(hi_u32 chip,hi_u32 gpio_no,hi_u32 group_no,hi_u32 bit_no)468 static hi_s32 gpio_set_bit_irq_enable(hi_u32 chip, hi_u32 gpio_no, hi_u32 group_no, hi_u32 bit_no)
469 {
470 hi_s32 ret, index;
471
472 index = (group_no <= 15) ? (0) : (1); /* hi_gpio_irq: group 0 ~ 15; hi_stb_gpio_irq: group 18 ~ 22 */
473 ret = osal_irq_request(g_gpio_irq_table[index].irq_no, drv_gpio_isr, 0,
474 g_gpio_irq_table[index].name, HI_NULL);
475 if (ret != HI_SUCCESS) {
476 HI_LOG_INFO("register GPIO INT failed return 0x%x.\n", ret);
477 return HI_FAILURE;
478 }
479 g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_int_enable = HI_TRUE;
480
481 return HI_SUCCESS;
482 }
483
hi_drv_gpio_set_bit_int_enable(hi_u32 gpio_no,hi_bool b_enable)484 hi_s32 hi_drv_gpio_set_bit_int_enable(hi_u32 gpio_no, hi_bool b_enable)
485 {
486 hi_u32 chip;
487 hi_u32 group_no = 0;
488 hi_u32 bit_no = 0;
489 hi_s32 ret;
490
491 hi_dbg_func_enter();
492
493 if (drv_gpio_convert(gpio_no, &group_no, &bit_no) == HI_FALSE) {
494 HI_LOG_ERR("para gpio_no is invalid\n");
495 hi_err_print_u32(group_no);
496 return HI_ERR_GPIO_INVALID_PARA;
497 }
498
499 if ((b_enable != HI_TRUE) && (b_enable != HI_FALSE)) {
500 HI_LOG_ERR("para b_enable is invalid. \n");
501 return HI_ERR_GPIO_INVALID_PARA;
502 }
503
504 chip = gpio_drv_get_chip_version();
505 gpio_set_irq_ctrl_reg(group_no, bit_no, b_enable);
506
507 if (b_enable == HI_FALSE ||
508 ((g_gpio_inttype[gpio_no] == INT_TYPE_LEVEL_HIGH || g_gpio_inttype[gpio_no] == INT_TYPE_LEVEL_LOW)
509 && g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_int_enable == HI_TRUE)) {
510 gpio_set_bit_irq_disable(chip, gpio_no, group_no, bit_no);
511 return HI_SUCCESS;
512 }
513
514 ret = gpio_set_bit_irq_enable(chip, gpio_no, group_no, bit_no);
515 if (ret != HI_SUCCESS) {
516 return ret;
517 }
518
519 HI_LOG_DBG("group_no = %u, group_no = %u, b_enable = %u\n", group_no, bit_no, b_enable);
520 hi_dbg_func_exit();
521
522 return HI_SUCCESS;
523 }
524
hi_drv_gpio_set_group_int_enable(hi_u32 group_no,hi_bool b_enable)525 hi_s32 hi_drv_gpio_set_group_int_enable(hi_u32 group_no, hi_bool b_enable)
526 {
527 hi_u32 gpio_value, chip;
528 volatile hi_void *gpio_usr_addr = HI_NULL;
529
530 hi_dbg_func_enter();
531
532 if (group_no >= g_gpio_num.gpio_grp_num || g_gpio_usr_addr[group_no] == HI_NULL) {
533 HI_LOG_ERR("invalid param. GroupNo is %u.\n", group_no);
534 return HI_ERR_GPIO_INVALID_PARA;
535 }
536
537 if ((b_enable != HI_TRUE) && (b_enable != HI_FALSE)) {
538 HI_LOG_ERR("para b_enable is invalid. \n");
539 return HI_ERR_GPIO_INVALID_PARA;
540 }
541
542 chip = gpio_drv_get_chip_version();
543 gpio_usr_addr = g_gpio_usr_addr[group_no];
544
545 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IE_REG);
546
547 if (b_enable) { /* enable one group */
548 gpio_value |= 0xff;
549 } else { /* disable one group */
550 gpio_value = 0;
551 }
552 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IE_REG) = gpio_value;
553 HI_LOG_INFO("gpio_group = %d b_enable = %d \n", group_no, b_enable);
554
555 hi_dbg_func_exit();
556
557 return HI_SUCCESS;
558 }
559
hi_drv_gpio_set_all_int_enable(hi_bool b_enable)560 hi_s32 hi_drv_gpio_set_all_int_enable(hi_bool b_enable)
561 {
562 hi_s32 ret = HI_SUCCESS;
563 hi_u32 i = 0;
564
565 hi_dbg_func_enter();
566
567 if ((b_enable != HI_TRUE) && (b_enable != HI_FALSE)) {
568 HI_LOG_ERR("para b_enable is invalid. \n");
569 return HI_ERR_GPIO_INVALID_PARA;
570 }
571
572 for (i = 0; i < g_gpio_num.gpio_grp_num; i++) {
573 if (g_gpio_usr_addr[i] == NULL) {
574 continue;
575 }
576
577 ret = hi_drv_gpio_set_group_int_enable(i, b_enable);
578 if (ret != HI_SUCCESS) {
579 HI_LOG_ERR("GpioGrpNum %d is invalid.\n", i);
580 return HI_FAILURE;
581 }
582 }
583
584 hi_dbg_func_exit();
585
586 return HI_SUCCESS;
587 }
588
osal_wait_condition(const hi_void * param)589 static hi_s32 osal_wait_condition (const hi_void *param)
590 {
591 hi_s32 ret = 0;
592 if (g_st_gpio_attr.head != g_st_gpio_attr.tail) {
593 ret = 1;
594 return ret;
595 }
596 return ret;
597 }
598
drv_gpio_query_int(gpio_int * p_gpio_int_value)599 hi_s32 drv_gpio_query_int(gpio_int *p_gpio_int_value)
600 {
601 hi_s32 ret = 0;
602 hi_u32 gpio_int_num = 0;
603
604 if (p_gpio_int_value == NULL) {
605 HI_LOG_ERR("param null ptr.\n");
606 return HI_FAILURE;
607 }
608
609 g_st_gpio_attr.gpio_block_time = p_gpio_int_value->timeout_ms;
610
611 while ((g_st_gpio_attr.head) == (g_st_gpio_attr.tail)) {
612 if (g_st_gpio_attr.gpio_block_time == 0xffffffff) {
613 ret = osal_wait_interruptible(&g_st_gpio_attr.gpio_int_wait_queue, osal_wait_condition, NULL);
614 if (ret < 0) {
615 HI_LOG_INFO("wait data err.\n");
616 return -ERESTARTSYS;
617 }
618 } else {
619 ret = osal_wait_timeout_interruptible(&g_st_gpio_attr.gpio_int_wait_queue,
620 osal_wait_condition, NULL, g_st_gpio_attr.gpio_block_time);
621 if (ret < 0) {
622 HI_LOG_INFO("wait data err.\n");
623 return -ERESTARTSYS;
624 } else if (ret == 0) {
625 HI_LOG_INFO("wait data timeout.\n");
626 return HI_ERR_GPIO_GETINT_TIMEOUT;
627 }
628 }
629 }
630
631 if ((g_st_gpio_attr.head) != (g_st_gpio_attr.tail)) {
632 gpio_int_num = GPIO_BUF_TAIL;
633 g_st_gpio_attr.tail = inc_buf(g_st_gpio_attr.tail, g_st_gpio_attr.gpio_buf_len);
634 p_gpio_int_value->gpio_no = gpio_int_num;
635 }
636
637 return HI_SUCCESS;
638 }
639
drv_gpio_open(hi_void * private_data)640 hi_s32 drv_gpio_open(hi_void *private_data)
641 {
642 g_st_gpio_attr.head = 0;
643 g_st_gpio_attr.tail = 0;
644 return HI_SUCCESS;
645 }
646
drv_gpio_close(hi_void * private_data)647 hi_s32 drv_gpio_close(hi_void *private_data)
648 {
649 g_st_gpio_attr.head = 0;
650 g_st_gpio_attr.tail = 0;
651 return HI_SUCCESS;
652 }
653
drv_gpio_set_output_type(hi_u32 gpio_no,gpio_outputtype en_output_type)654 hi_s32 drv_gpio_set_output_type(hi_u32 gpio_no, gpio_outputtype en_output_type)
655 {
656 if (gpio_no >= g_gpio_max_num) {
657 HI_LOG_ERR("para gpio_no is invalid.GpioNo is %u\n", gpio_no);
658 return HI_FALSE;
659 }
660
661 if (en_output_type >= GPIO_OUTPUTTYPE_BUTT) {
662 HI_LOG_ERR("invalid param.\n");
663 return HI_FAILURE;
664 }
665
666 return HI_SUCCESS;
667 }
668
drv_gpio_get_output_type(hi_u32 gpio_no,gpio_outputtype * en_output_type)669 hi_s32 drv_gpio_get_output_type(hi_u32 gpio_no, gpio_outputtype *en_output_type)
670 {
671 if (gpio_no >= g_gpio_max_num) {
672 HI_LOG_ERR("para gpio_no is invalid.GpioNo is %u\n", gpio_no);
673 return HI_FALSE;
674 }
675
676 if (en_output_type == NULL) {
677 HI_LOG_ERR("param null ptr.\n");
678 return HI_FAILURE;
679 }
680
681 return HI_SUCCESS;
682 }
683
hi_drv_gpio_register_server_func(hi_u32 gpio_no,hi_void (* func)(hi_u32))684 hi_s32 hi_drv_gpio_register_server_func(hi_u32 gpio_no, hi_void (*func)(hi_u32))
685 {
686 hi_dbg_func_enter();
687
688 if (gpio_no >= g_gpio_num.gpio_max_num) {
689 HI_LOG_INFO(" para gpio number out of range , int_value = %d\n", gpio_no);
690 return HI_FAILURE;
691 }
692
693 if (g_gpio_usr_addr[gpio_no / HI_GPIO_BIT_NUM] == HI_NULL) {
694 HI_LOG_ERR("para gpio_no is invalid.GpioNo is %u\n", gpio_no);
695 return HI_FALSE;
696 }
697
698 if (HI_NULL == func) {
699 HI_LOG_INFO(" register func para is null, int_value = %d\n", gpio_no);
700 return HI_FAILURE;
701 }
702
703 if (g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_server != HI_NULL) {
704 HI_LOG_INFO(" GPIO %d had registered gpio server pragram \n", gpio_no);
705 return HI_FAILURE;
706 }
707
708 g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_server = func;
709 HI_LOG_INFO("gpio %d finished register gpio server function \n", gpio_no);
710
711 hi_dbg_func_exit();
712
713 return HI_SUCCESS;
714 }
715
hi_drv_gpio_unregister_server_func(hi_u32 gpio_no)716 hi_s32 hi_drv_gpio_unregister_server_func(hi_u32 gpio_no)
717 {
718 hi_dbg_func_enter();
719
720 if (gpio_no >= g_gpio_num.gpio_max_num) {
721 HI_LOG_INFO(" para gpio number out of range , int_value = %u\n", gpio_no);
722 return HI_FAILURE;
723 }
724
725 if (g_gpio_usr_addr[gpio_no / HI_GPIO_BIT_NUM] == HI_NULL) {
726 HI_LOG_ERR("para gpio_no is invalid.GpioNo is %u\n", gpio_no);
727 return HI_FALSE;
728 }
729
730 g_st_gpio_attr.gpio_int_attr[gpio_no].gpio_server = HI_NULL;
731
732 hi_dbg_func_exit();
733
734 return HI_SUCCESS;
735 }
736
hi_drv_gpio_clear_bit_int(hi_u32 gpio_no)737 hi_s32 hi_drv_gpio_clear_bit_int(hi_u32 gpio_no)
738 {
739 volatile hi_void *gpio_usr_addr = NULL;
740 hi_u32 reg_val;
741 hi_u32 group_no = 0;
742 hi_u32 bit_no = 0;
743
744 hi_dbg_func_enter();
745
746 if (HI_FALSE == drv_gpio_convert(gpio_no, &group_no, &bit_no)) {
747 HI_LOG_ERR("para gpio_no is invalid. GpioNo is %u\n", gpio_no);
748 return HI_ERR_GPIO_INVALID_PARA;
749 }
750
751 gpio_usr_addr = g_gpio_usr_addr[group_no];
752 reg_val = REG_USR_ADDR((gpio_usr_addr + HI_GPIO_IC_REG));
753 reg_val |= (0x1 << bit_no);
754
755 REG_USR_ADDR((gpio_usr_addr + HI_GPIO_IC_REG)) = reg_val;
756
757 hi_dbg_func_exit();
758
759 return HI_SUCCESS;
760 }
761
hi_drv_gpio_get_usr_addr(hi_u32 group_no,hi_void ** pv_vir_addr)762 hi_s32 hi_drv_gpio_get_usr_addr(hi_u32 group_no, hi_void **pv_vir_addr)
763 {
764 hi_dbg_func_enter();
765
766 if (group_no >= g_gpio_grp_num || g_gpio_usr_addr[group_no] == HI_NULL) {
767 HI_LOG_ERR("para group_no is invalid.group_no is %u\n", group_no);
768 return HI_FALSE;
769 }
770
771 if (pv_vir_addr == NULL) {
772 HI_LOG_ERR("param null ptr.\n");
773 return HI_FAILURE;
774 }
775
776 *(volatile hi_void **)pv_vir_addr = g_gpio_usr_addr[group_no];
777
778 hi_dbg_func_exit();
779
780 return HI_SUCCESS;
781 }
782
hi_drv_gpio_clear_group_int(hi_u32 gpio_group)783 hi_s32 hi_drv_gpio_clear_group_int(hi_u32 gpio_group)
784 {
785 volatile hi_void *gpio_usr_addr = HI_NULL;
786
787 hi_dbg_func_enter();
788
789 if (gpio_group >= g_gpio_num.gpio_grp_num || g_gpio_usr_addr[gpio_group] == NULL) {
790 HI_LOG_ERR("invalid parameter(%u).\n", gpio_group);
791 return HI_ERR_GPIO_INVALID_PARA;
792 }
793
794 gpio_usr_addr = g_gpio_usr_addr[gpio_group];
795 REG_USR_ADDR((gpio_usr_addr + HI_GPIO_IC_REG)) = 0xff;
796
797 hi_dbg_func_exit();
798
799 return HI_SUCCESS;
800 }
801
gpio_clear_all_int(hi_void)802 hi_s32 gpio_clear_all_int(hi_void)
803 {
804 hi_s32 ret = HI_SUCCESS;
805 hi_u32 i = 0;
806
807 for (i = 0; i < g_gpio_num.gpio_grp_num; i++) {
808 if (g_gpio_usr_addr[i] == NULL) {
809 continue;
810 }
811
812 ret = hi_drv_gpio_clear_group_int(i);
813 if (ret != HI_SUCCESS) {
814 HI_LOG_ERR("GpioGrpNum %u is invalid.\n", i);
815 return HI_FAILURE;
816 }
817 }
818
819 return HI_SUCCESS;
820 }
821
822 /* add this for 350 */
gpio_isr_response(hi_u32 gpio_num)823 hi_void gpio_isr_response(hi_u32 gpio_num)
824 {
825 if (g_st_gpio_attr.gpio_int_attr[gpio_num].gpio_int_enable == HI_TRUE) {
826 if (g_st_gpio_attr.gpio_int_attr[gpio_num].gpio_server != HI_NULL) {
827 g_st_gpio_attr.gpio_int_attr[gpio_num].gpio_server(gpio_num);
828 HI_LOG_INFO(" ----- execute gpio[%d].gpio_server \n", gpio_num);
829 }
830 GPIO_BUF_HEAD = gpio_num;
831 g_st_gpio_attr.head = inc_buf(g_st_gpio_attr.head, g_st_gpio_attr.gpio_buf_len);
832 osal_wait_wakeup(&(g_st_gpio_attr.gpio_int_wait_queue));
833 }
834
835 return;
836 }
837
drv_gpio_isr(hi_s32 irq,hi_void * dev_id)838 hi_s32 drv_gpio_isr(hi_s32 irq, hi_void *dev_id)
839 {
840 hi_u32 int_value, gpio_value, gpio_num;
841 hi_u32 gpio_group = 0;
842 hi_u32 i = 0;
843 volatile hi_void *gpio_usr_addr = HI_NULL;
844 // Traverse all groups, a total of 22 groups, 10-17 groups, 21, 22 groups are invalid
845 for (gpio_group = 0; gpio_group <= 22; ++gpio_group) {
846 if (gpio_group == GPIO_ERROR_MIN_NO || gpio_group == GPIO_ERROR_MAX_NO ||
847 (gpio_group >= HI_GPIO_10_VIR_ADDR && gpio_group <= HI_GPIO_15_VIR_ADDR)
848 || gpio_group > HI_GPIO_20_VIR_ADDR) {
849 continue;
850 }
851
852 gpio_usr_addr = g_gpio_usr_addr[gpio_group];
853 gpio_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IE_REG);
854 if (gpio_value == 0) {
855 continue;
856 }
857
858 gpio_usr_addr = g_gpio_usr_addr[gpio_group];
859 int_value = REG_USR_ADDR(gpio_usr_addr + HI_GPIO_MIS_REG);
860
861 for (i = 0; i < 8; i++) { // Each group has 8 io ports
862 if ((int_value & (1 << i)) == 0) { /* check each bit */
863 continue;
864 }
865 gpio_num = gpio_group * 8 + i; // A group has 8 io, so the calculation can get the io number
866 gpio_isr_response(gpio_num);
867 REG_USR_ADDR((gpio_usr_addr + HI_GPIO_IC_REG)) = (0X1 << i); /* clear one bit interruput flag */
868 /* trigger type is high/low level, disable interrupt */
869 if (g_gpio_inttype[gpio_num] == (INT_TYPE_LEVEL_HIGH | GPIO_IRQF_ONESHOT)
870 || g_gpio_inttype[gpio_num] == (INT_TYPE_LEVEL_LOW | GPIO_IRQF_ONESHOT)) {
871 gpio_value &= (~(1 << i));
872 g_st_gpio_attr.gpio_int_attr[gpio_num].gpio_int_enable = HI_FALSE;
873 REG_USR_ADDR(gpio_usr_addr + HI_GPIO_IE_REG) = gpio_value;
874 }
875 break;
876 }
877 }
878
879 return OSAL_IRQ_HANDLED;
880 }
881
gpio_isr(hi_s32 irq,hi_void * dev_id)882 hi_s32 gpio_isr(hi_s32 irq, hi_void *dev_id)
883 {
884 hi_u32 gpio_num = 0;
885 (void)dev_id;
886 for (gpio_num = 0; gpio_num < HI_GPIO_MAX_BIT_NUM; ++gpio_num) {
887 if (g_gpio_to_irq[gpio_num] == irq) {
888 gpio_isr_response(gpio_num);
889 break;
890 }
891 }
892
893 return OSAL_IRQ_HANDLED;
894 }
895
hi_drv_gpio_get_gpio_num(gpio_get_gpionum * gpio_num)896 hi_s32 hi_drv_gpio_get_gpio_num(gpio_get_gpionum *gpio_num)
897 {
898 hi_dbg_func_enter();
899
900 if (gpio_num == HI_NULL) {
901 HI_LOG_ERR("param null ptr.\n");
902 return HI_ERR_GPIO_NULL_PTR;
903 }
904
905 gpio_num->gpio_grp_num = g_gpio_grp_num;
906 gpio_num->gpio_max_num = g_gpio_max_num;
907
908 hi_dbg_func_exit();
909
910 return HI_SUCCESS;
911 }
912
gpio_usr_addr_remap(hi_u32 chip)913 static hi_s32 gpio_usr_addr_remap(hi_u32 chip)
914 {
915 hi_s32 i = 0;
916
917 /* remap gpio reg address */
918 for (i = 0; i < HI_GPIO_MAX_GROUP_NUM; i++) {
919 g_gpio_usr_addr[i] = NULL;
920 }
921
922 HI_GPIO_REG_REMAP(g_gpio_usr_addr[0], HI_GPIO_0_ADDR); /* gpio 0 base addr */
923 HI_GPIO_REG_REMAP(g_gpio_usr_addr[1], HI_GPIO_1_ADDR); /* gpio 1 base addr */
924 HI_GPIO_REG_REMAP(g_gpio_usr_addr[2], HI_GPIO_2_ADDR); /* gpio 2 base addr */
925 HI_GPIO_REG_REMAP(g_gpio_usr_addr[3], HI_GPIO_3_ADDR); /* gpio 3 base addr */
926 HI_GPIO_REG_REMAP(g_gpio_usr_addr[4], HI_GPIO_4_ADDR); /* gpio 4 base addr */
927 HI_GPIO_REG_REMAP(g_gpio_usr_addr[5], HI_GPIO_5_ADDR); /* gpio 5 base addr */
928 HI_GPIO_REG_REMAP(g_gpio_usr_addr[6], HI_GPIO_6_ADDR); /* gpio 6 base addr */
929 HI_GPIO_REG_REMAP(g_gpio_usr_addr[7], HI_GPIO_7_ADDR); /* gpio 7 base addr */
930 HI_GPIO_REG_REMAP(g_gpio_usr_addr[8], HI_GPIO_8_ADDR); /* gpio 8 base addr */
931 HI_GPIO_REG_REMAP(g_gpio_usr_addr[9], HI_GPIO_9_ADDR); /* gpio 9 base addr */
932 HI_GPIO_REG_REMAP(g_gpio_usr_addr[18], HI_GPIO_18_ADDR); /* gpio 18 base addr */
933 HI_GPIO_REG_REMAP(g_gpio_usr_addr[19], HI_GPIO_19_ADDR); /* gpio 19 base addr */
934 HI_GPIO_REG_REMAP(g_gpio_usr_addr[20], HI_GPIO_20_ADDR); /* gpio 20 base addr */
935
936 return HI_SUCCESS;
937 }
938
gpio_set_gpio_attr(hi_void)939 static hi_void gpio_set_gpio_attr(hi_void)
940 {
941 hi_s32 ret;
942 hi_s32 i = 0;
943 hi_u32 gpio_grp;
944
945 g_st_gpio_attr.head = 0;
946 g_st_gpio_attr.tail = 0;
947 g_st_gpio_attr.gpio_buf_len = GPIO_MAX_BUF;
948 g_st_gpio_attr.gpio_block_time = 0xffffffff;
949
950 ret = hi_drv_gpio_get_gpio_num(&g_gpio_num);
951 if (ret != HI_SUCCESS) {
952 return;
953 }
954
955 for (i = 0; i < g_gpio_num.gpio_max_num; i++) {
956 g_gpio_to_irq[i] = -1;
957 gpio_grp = i / HI_GPIO_BIT_NUM;
958 if (gpio_grp >= HI_GPIO_MAX_GROUP_NUM) {
959 HI_LOG_ERR("param invalid.\n");
960 return;
961 }
962 if (g_gpio_usr_addr[gpio_grp] == NULL) {
963 continue;
964 }
965
966 g_st_gpio_attr.gpio_int_attr[i].gpio_int_enable = HI_FALSE;
967 g_st_gpio_attr.gpio_int_attr[i].gpio_int_type = GPIO_INTTYPE_DOWN;
968 g_st_gpio_attr.gpio_int_attr[i].gpio_server = HI_NULL;
969 }
970
971 return;
972 }
973
hi_drv_gpio_set_irq_ctrl(hi_u32 gpio_no,hi_bool b_enable)974 hi_void hi_drv_gpio_set_irq_ctrl(hi_u32 gpio_no, hi_bool b_enable)
975 {
976 hi_u32 group_no = 0;
977 hi_u32 bit_no = 0;
978
979 if (drv_gpio_convert(gpio_no, &group_no, &bit_no) == HI_FALSE) {
980 HI_LOG_ERR("para gpio_no is invalid\n");
981 hi_err_print_u32(group_no);
982 return;
983 }
984
985 if ((b_enable != HI_TRUE) && (b_enable != HI_FALSE)) {
986 HI_LOG_ERR("para b_enable is invalid. \n");
987 return;
988 }
989
990 gpio_set_irq_ctrl_reg(group_no, bit_no, b_enable);
991 }
992
hi_drv_gpio_init(hi_void)993 hi_s32 hi_drv_gpio_init(hi_void)
994 {
995 hi_s32 ret;
996 hi_u32 i, chip;
997
998 hi_dbg_func_enter();
999
1000 i = 0; /* don't delete it */
1001
1002 ret = osal_exportfunc_register(HI_ID_GPIO, "HI_GPIO", (hi_void *)&g_st_gpio_export_funcs);
1003 if (ret != HI_SUCCESS) {
1004 HI_LOG_INFO(" GPIO Module register failed 0x%x.\n", ret);
1005 return HI_FAILURE;
1006 }
1007
1008 chip = gpio_drv_get_chip_version();
1009
1010 g_gpio_grp_num = HI_GPIO_GROUP_NUM;
1011 g_gpio_max_num = g_gpio_grp_num * HI_GPIO_BIT_NUM;
1012
1013 ret = gpio_usr_addr_remap(chip);
1014 if (ret != HI_SUCCESS) {
1015 return ret;
1016 }
1017
1018 gpio_set_gpio_attr();
1019
1020 osal_wait_init(&g_st_gpio_attr.gpio_int_wait_queue);
1021 #ifdef __KERNEL__
1022 ret = hi_drv_gpio_set_all_int_enable(HI_FALSE);
1023 if (ret != HI_SUCCESS) {
1024 HI_LOG_INFO(" GPIO disable INT failed 0x%x.\n", ret);
1025 return HI_FAILURE;
1026 }
1027
1028 ret = gpio_clear_all_int();
1029 if (ret != HI_SUCCESS) {
1030 HI_LOG_INFO(" GPIO clear all INT failed 0x%x.\n", ret);
1031 return HI_FAILURE;
1032 }
1033 #endif
1034 hi_dbg_func_exit();
1035
1036 return HI_SUCCESS;
1037 }
1038
hi_drv_gpio_de_init(hi_void)1039 hi_void hi_drv_gpio_de_init(hi_void)
1040 {
1041 hi_u32 i, chip, gpio_grp;
1042 hi_s32 ret;
1043
1044 hi_dbg_func_enter();
1045
1046 chip = gpio_drv_get_chip_version();
1047
1048 ret = hi_drv_gpio_set_all_int_enable(HI_FALSE); // disable all group interruput
1049 if (ret != HI_SUCCESS) {
1050 HI_LOG_INFO(" GPIO disable INT failed 0x%x.\n", ret);
1051 }
1052
1053 for (i = 0; i < g_gpio_num.gpio_max_num; i++) {
1054 gpio_grp = i / HI_GPIO_BIT_NUM;
1055 if (gpio_grp >= HI_GPIO_MAX_GROUP_NUM) {
1056 HI_LOG_ERR("param invalid.\n");
1057 return;
1058 }
1059 if (g_gpio_usr_addr[gpio_grp] == NULL) {
1060 continue;
1061 }
1062
1063 g_st_gpio_attr.gpio_int_attr[i].gpio_int_enable = HI_FALSE;
1064 g_st_gpio_attr.gpio_int_attr[i].gpio_int_type = GPIO_INTTYPE_DOWN;
1065 g_st_gpio_attr.gpio_int_attr[i].gpio_server = HI_NULL;
1066 }
1067
1068 ret = osal_exportfunc_unregister(HI_ID_GPIO);
1069 if (ret != HI_SUCCESS) {
1070 HI_LOG_INFO(" GPIO Module unregister failed 0x%x.\n", ret);
1071 }
1072
1073 /* unmap gpio reg address */
1074 for (i = 0; i < HI_GPIO_MAX_GROUP_NUM; i++) {
1075 if (g_gpio_usr_addr[i] == NULL) {
1076 continue;
1077 }
1078
1079 HI_GPIO_REG_UNMAP((hi_void *)g_gpio_usr_addr[i]);
1080 g_gpio_usr_addr[i] = NULL;
1081 }
1082
1083 hi_dbg_func_exit();
1084
1085 return;
1086 }
1087
1088 MODULE_LICENSE("GPL");
1089 MODULE_DESCRIPTION("HISILICON");
1090 #ifdef MODULE
1091 EXPORT_SYMBOL(hi_drv_gpio_init);
1092 EXPORT_SYMBOL(hi_drv_gpio_de_init);
1093 #endif
1094
1095 EXPORT_SYMBOL(hi_drv_gpio_get_dir_bit);
1096 EXPORT_SYMBOL(hi_drv_gpio_set_dir_bit);
1097 EXPORT_SYMBOL(hi_drv_gpio_write_bit);
1098 EXPORT_SYMBOL(hi_drv_gpio_read_bit);
1099 EXPORT_SYMBOL(hi_drv_gpio_get_gpio_num);
1100 EXPORT_SYMBOL(hi_drv_gpio_register_server_func);
1101 EXPORT_SYMBOL(hi_drv_gpio_unregister_server_func);
1102 EXPORT_SYMBOL(hi_drv_gpio_set_int_type);
1103 EXPORT_SYMBOL(hi_drv_gpio_set_bit_int_enable);
1104 EXPORT_SYMBOL(hi_drv_gpio_clear_group_int);
1105 EXPORT_SYMBOL(hi_drv_gpio_clear_bit_int);
1106 EXPORT_SYMBOL(hi_drv_gpio_set_irq_ctrl);
1107