1 /*
2 * Copyright (C) 2021 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 "sys_bind.h"
20 #include "securec.h"
21 #include "hi_osal.h"
22 #include "mm_ext.h"
23 #include "mod_ext.h"
24 #include "proc_ext.h"
25
26 #include "hi_comm_sys.h"
27 #include "sys_ext.h"
28 #include "mkp_sys.h"
29 #include "sys_drv.h"
30
31 #define BIND_NAME_MAX_LEN 16
32
33 static osal_spinlock_t g_sys_bind_lock;
34 static osal_semaphore_t g_sys_dev_sem;
35
36 #define bind_spin_lock_init() osal_spin_lock_init(&g_sys_bind_lock)
37 #define bind_spin_lock_uninit() osal_spin_lock_destroy(&g_sys_bind_lock)
38 #define bind_spin_lock(flags) osal_spin_lock_irqsave(&g_sys_bind_lock, &(flags))
39 #define bind_spin_unlock(flags) osal_spin_unlock_irqrestore(&g_sys_bind_lock, &(flags))
40
41 #define sys_lock_may_in_interrupt_return(flags) \
42 do { \
43 if (osal_in_interrupt()) { \
44 bind_spin_lock(flags); \
45 } else { \
46 bind_sem_down_return(); \
47 } \
48 } while (0)
49
50 #define sys_unlock_may_in_interrupt_return(flags) \
51 do { \
52 if (osal_in_interrupt()) { \
53 bind_spin_unlock(flags); \
54 } else { \
55 bind_sem_up(); \
56 } \
57 } while (0)
58
bind_get_mod_name(hi_mod_id mod)59 static char *bind_get_mod_name(hi_mod_id mod)
60 {
61 char *mod_name = cmpi_get_module_name(mod);
62 if (mod_name == HI_NULL) {
63 return "unknown mod";
64 }
65
66 return mod_name;
67 }
68
69 #define bind_sem_init() osal_sema_init(&g_sys_dev_sem, 1)
70 #define bind_sem_uninit() osal_sema_destroy(&g_sys_dev_sem)
71
72 #define bind_sem_down_return() \
73 do { \
74 if (osal_down_interruptible(&g_sys_dev_sem)) { \
75 return (-ERESTARTSYS); \
76 } \
77 } while (0)
78
79 #define bind_sem_up() osal_up(&g_sys_dev_sem)
80
81 typedef struct {
82 struct osal_list_head list;
83 hi_mpp_chn mpp_chn;
84 } sys_bind_node;
85
86 typedef struct {
87 struct osal_list_head list_head;
88 hi_u32 dest_num;
89 } sys_bind_src;
90
91 typedef struct {
92 hi_bool is_bind_src;
93 hi_mpp_chn bind_src;
94 hi_u32 send_cnt;
95 hi_u32 reset_cnt;
96 } sys_bind_dest;
97
98 typedef struct {
99 hi_mod_id mod_id;
100 hi_char name[BIND_NAME_MAX_LEN];
101 hi_u32 max_dev_cnt;
102 hi_u32 max_chn_cnt;
103 hi_s32 (*call_back)(hi_s32 dev_id, hi_s32 chn_id, hi_bool block, mpp_data_type data_type, hi_void *pv_data);
104 hi_s32 (*reset_call_back)(hi_s32 dev_id, hi_s32 chn_id, hi_void *v_data);
105 hi_s32 (*give_bind_call_back)(hi_s32 dev_id, hi_s32 chn_id, hi_mpp_bind_dest *bind_send);
106
107 hi_u32 tbl_size;
108 sys_bind_src *src_tbl;
109 sys_bind_dest *dest_tbl;
110
111 hi_bool support_delay_data;
112 } sys_binder_ctx;
113
114 typedef struct {
115 hi_u32 max_index;
116 hi_mpp_bind_dest **send_bind_src;
117 } sys_binder_send;
118
119 static sys_binder_ctx *g_sender_tbl[HI_ID_BUTT] = {HI_NULL};
120
121 static sys_binder_ctx *g_receiver_tbl[HI_ID_BUTT] = {HI_NULL};
122
123 static sys_binder_send g_bind_send[HI_ID_BUTT];
124
sys_get_idx_by_dev_chn(sys_binder_ctx * binder_ctx,hi_s32 dev_id,hi_s32 chn_id)125 static hi_s32 sys_get_idx_by_dev_chn(sys_binder_ctx *binder_ctx, hi_s32 dev_id, hi_s32 chn_id)
126 {
127 return (binder_ctx->max_chn_cnt * dev_id) + chn_id;
128 }
129
sys_get_dev_chn_by_idx(sys_binder_ctx * binder_ctx,hi_s32 index,hi_s32 * dev_id,hi_s32 * chn_id)130 static hi_void sys_get_dev_chn_by_idx(sys_binder_ctx *binder_ctx, hi_s32 index, hi_s32 *dev_id, hi_s32 *chn_id)
131 {
132 if (binder_ctx->max_chn_cnt != 0) {
133 *dev_id = index / binder_ctx->max_chn_cnt;
134 *chn_id = index % binder_ctx->max_chn_cnt;
135 }
136
137 return;
138 }
139
sys_check_bind_mod_id(hi_mod_id mod_id)140 static hi_s32 sys_check_bind_mod_id(hi_mod_id mod_id)
141 {
142 if (mod_id >= HI_ID_BUTT) {
143 sys_err_trace("sender/receiver mod_id:%d invalid !\n", mod_id);
144 return HI_ERR_SYS_ILLEGAL_PARAM;
145 }
146
147 return HI_SUCCESS;
148 }
149
sys_check_bind_dev_chn_id(hi_mpp_chn * bind_chn,sys_binder_ctx * bind_ctx)150 static hi_s32 sys_check_bind_dev_chn_id(hi_mpp_chn *bind_chn, sys_binder_ctx *bind_ctx)
151 {
152 if ((bind_chn->dev_id <= -1) ||
153 (bind_chn->chn_id <= -1) ||
154 ((hi_u32)bind_chn->dev_id >= bind_ctx->max_dev_cnt) ||
155 ((hi_u32)bind_chn->chn_id >= bind_ctx->max_chn_cnt)) {
156 sys_err_trace("bind dev or chn is invalid, dev:%d, chn:%d !\n",
157 bind_chn->dev_id, bind_chn->chn_id);
158 return HI_ERR_SYS_ILLEGAL_PARAM;
159 }
160
161 return HI_SUCCESS;
162 }
163
sys_check_bind_tbl_size(hi_u32 bind_tbl_size)164 static hi_s32 sys_check_bind_tbl_size(hi_u32 bind_tbl_size)
165 {
166 if (bind_tbl_size == 0) {
167 sys_err_trace("max_dev_cnt or max_chn_cnt invalid !\n");
168 return HI_ERR_SYS_ILLEGAL_PARAM;
169 }
170
171 return HI_SUCCESS;
172 }
173
sys_get_bind_valid_send_ctx(hi_mpp_chn * src_chn,hi_mpp_bind_dest ** send_bind_src)174 static hi_s32 sys_get_bind_valid_send_ctx(hi_mpp_chn *src_chn, hi_mpp_bind_dest **send_bind_src)
175 {
176 hi_u32 src_tbl_idx;
177 hi_mpp_bind_dest *send_bind_src_tmp = HI_NULL;
178
179 if (g_sender_tbl[src_chn->mod_id] == HI_NULL) {
180 sys_err_trace("mod %d have not register !\n", src_chn->mod_id);
181 return HI_ERR_SYS_NOT_PERM;
182 }
183
184 if (sys_check_bind_dev_chn_id(src_chn, g_sender_tbl[src_chn->mod_id]) != HI_SUCCESS) {
185 return HI_ERR_SYS_ILLEGAL_PARAM;
186 }
187
188 src_tbl_idx = sys_get_idx_by_dev_chn(g_sender_tbl[src_chn->mod_id], src_chn->dev_id, src_chn->chn_id);
189
190 send_bind_src_tmp = g_bind_send[src_chn->mod_id].send_bind_src[src_tbl_idx];
191 if (send_bind_src_tmp == HI_NULL) {
192 sys_info_trace("mod %d, dev %d, chn %d, have not bind !\n", src_chn->mod_id, src_chn->dev_id, src_chn->chn_id);
193 return HI_ERR_SYS_NOT_PERM;
194 }
195
196 *send_bind_src = send_bind_src_tmp;
197
198 return HI_SUCCESS;
199 }
200
sys_get_bind_valid_dest_tbl(hi_mpp_chn * dest_chn,sys_bind_dest ** dest_bind)201 static hi_s32 sys_get_bind_valid_dest_tbl(hi_mpp_chn *dest_chn, sys_bind_dest **dest_bind)
202 {
203 sys_binder_ctx *receiver_ctx = HI_NULL;
204 hi_u32 dest_tbl_idx;
205
206 if (sys_check_bind_mod_id(dest_chn->mod_id) != HI_SUCCESS) {
207 return HI_ERR_SYS_ILLEGAL_PARAM;
208 }
209
210 receiver_ctx = g_receiver_tbl[dest_chn->mod_id];
211 if (receiver_ctx == HI_NULL) {
212 sys_err_trace("mod_id:%d(%s) is not supported !\n", dest_chn->mod_id, bind_get_mod_name(dest_chn->mod_id));
213 return HI_ERR_SYS_NULL_PTR;
214 }
215
216 if (sys_check_bind_dev_chn_id(dest_chn, receiver_ctx) != HI_SUCCESS) {
217 return HI_ERR_SYS_ILLEGAL_PARAM;
218 }
219
220 dest_tbl_idx = sys_get_idx_by_dev_chn(receiver_ctx, dest_chn->dev_id, dest_chn->chn_id);
221 *dest_bind = &receiver_ctx->dest_tbl[dest_tbl_idx];
222
223 return HI_SUCCESS;
224 }
225
sys_get_bind_valid_src_tbl(hi_mpp_chn * src_chn,sys_bind_src ** src_bind)226 static hi_s32 sys_get_bind_valid_src_tbl(hi_mpp_chn *src_chn, sys_bind_src **src_bind)
227 {
228 sys_binder_ctx *sender_ctx = HI_NULL;
229 hi_u32 src_tbl_idx;
230
231 if (sys_check_bind_mod_id(src_chn->mod_id) != HI_SUCCESS) {
232 return HI_ERR_SYS_ILLEGAL_PARAM;
233 }
234
235 sender_ctx = g_sender_tbl[src_chn->mod_id];
236 if (sender_ctx == HI_NULL) {
237 sys_err_trace("mod_id:%d(%s) is not supported !\n", src_chn->mod_id, bind_get_mod_name(src_chn->mod_id));
238 return HI_ERR_SYS_NULL_PTR;
239 }
240
241 if (sys_check_bind_dev_chn_id(src_chn, sender_ctx) != HI_SUCCESS) {
242 return HI_ERR_SYS_ILLEGAL_PARAM;
243 }
244
245 src_tbl_idx = sys_get_idx_by_dev_chn(sender_ctx, src_chn->dev_id, src_chn->chn_id);
246 *src_bind = &sender_ctx->src_tbl[src_tbl_idx];
247
248 return HI_SUCCESS;
249 }
250
sys_get_binder_by_src(hi_mpp_chn * src_chn,hi_mpp_bind_dest * bind_dest)251 static hi_s32 sys_get_binder_by_src(hi_mpp_chn *src_chn, hi_mpp_bind_dest *bind_dest)
252 {
253 hi_s32 ret;
254 sys_bind_node *node = HI_NULL;
255 sys_bind_src *src_bind = HI_NULL;
256 struct osal_list_head *list_tmp = HI_NULL;
257 struct osal_list_head *list_node = HI_NULL;
258
259 sys_check_null_ptr_return(src_chn);
260 sys_check_null_ptr_return(bind_dest);
261
262 ret = sys_get_bind_valid_src_tbl(src_chn, &src_bind);
263 if (ret != HI_SUCCESS) {
264 return ret;
265 }
266
267 bind_dest->num = 0;
268 osal_list_for_each_safe(list_node, list_tmp, &src_bind->list_head) {
269 node = osal_list_entry(list_node, sys_bind_node, list);
270 (hi_void)memcpy_s(&bind_dest->mpp_chn[bind_dest->num], sizeof(hi_mpp_chn),
271 &node->mpp_chn, sizeof(hi_mpp_chn));
272
273 bind_dest->num++;
274
275 if (bind_dest->num >= BIND_DEST_MAXNUM) {
276 sys_err_trace("bind src(mod:%d,dev:%d,chn:%d) too many \n",
277 src_chn->mod_id, src_chn->dev_id, src_chn->chn_id);
278 break;
279 }
280 }
281
282 return ret;
283 }
284
_get_bind_num_by_src(hi_mpp_chn * src_chn,hi_u32 * bind_num)285 static hi_s32 _get_bind_num_by_src(hi_mpp_chn *src_chn, hi_u32 *bind_num)
286 {
287 hi_s32 ret;
288 sys_bind_src *src_bind = HI_NULL;
289
290 sys_check_null_ptr_return(src_chn);
291
292 ret = sys_get_bind_valid_src_tbl(src_chn, &src_bind);
293 *bind_num = src_bind->dest_num;
294
295 return ret;
296 }
297
sys_get_bind_num_by_src(hi_mpp_chn * src_chn,hi_u32 * bind_num)298 hi_s32 sys_get_bind_num_by_src(hi_mpp_chn *src_chn, hi_u32 *bind_num)
299 {
300 hi_s32 ret;
301 unsigned long flags;
302
303 bind_spin_lock(flags);
304 ret = _get_bind_num_by_src(src_chn, bind_num);
305 bind_spin_unlock(flags);
306
307 return ret;
308 }
309
sys_deinit_sender(sys_binder_ctx * binder_ctx,hi_u32 bind_tbl_size)310 static hi_void sys_deinit_sender(sys_binder_ctx *binder_ctx, hi_u32 bind_tbl_size)
311 {
312 hi_u32 i;
313 sys_bind_node *node = HI_NULL;
314 struct osal_list_head *list_tmp = HI_NULL;
315 struct osal_list_head *list_node = HI_NULL;
316 sys_bind_src *src_bind = HI_NULL;
317
318 for (i = 0; i < bind_tbl_size; i++) {
319 src_bind = &binder_ctx->src_tbl[i];
320
321 osal_list_for_each_safe(list_node, list_tmp, &src_bind->list_head) {
322 node = osal_list_entry(list_node, sys_bind_node, list);
323 osal_list_del(list_node);
324 osal_kfree(node);
325 node = HI_NULL;
326 }
327 }
328 osal_kfree(binder_ctx->src_tbl);
329 binder_ctx->src_tbl = HI_NULL;
330 }
331
sys_deinit_receiver(sys_binder_ctx * binder_ctx)332 static hi_void sys_deinit_receiver(sys_binder_ctx *binder_ctx)
333 {
334 osal_kfree(binder_ctx->dest_tbl);
335 binder_ctx->dest_tbl = HI_NULL;
336 }
337
sys_init_sender_ctx(bind_sender_info * sender,hi_mod_id mod_id,sys_binder_ctx * binder_ctx)338 static hi_s32 sys_init_sender_ctx(bind_sender_info *sender, hi_mod_id mod_id, sys_binder_ctx *binder_ctx)
339 {
340 hi_u32 i;
341 hi_u32 size;
342
343 binder_ctx->src_tbl = (sys_bind_src *)osal_kmalloc(binder_ctx->tbl_size * sizeof(sys_bind_src), osal_gfp_kernel);
344 if (binder_ctx->src_tbl == HI_NULL) {
345 sys_err_trace("no memory for bind table!\n");
346 return HI_ERR_SYS_NOMEM;
347 }
348
349 if (g_bind_send[mod_id].send_bind_src == HI_NULL) {
350 g_bind_send[mod_id].max_index = sender->max_dev_cnt * sender->max_chn_cnt;
351 g_bind_send[mod_id].send_bind_src =
352 (hi_mpp_bind_dest **)osal_kmalloc(sizeof(hi_mpp_bind_dest *) * g_bind_send[mod_id].max_index,
353 osal_gfp_kernel);
354 if (g_bind_send[mod_id].send_bind_src == HI_NULL) {
355 sys_err_trace("no memory for bind SRC!\n");
356 osal_kfree(binder_ctx->src_tbl);
357 binder_ctx->src_tbl = HI_NULL;
358 return HI_ERR_SYS_NOMEM;
359 }
360
361 size = (sizeof(hi_mpp_bind_dest *) * g_bind_send[mod_id].max_index);
362 (hi_void)memset_s(g_bind_send[mod_id].send_bind_src, size, 0, size);
363 }
364
365 for (i = 0; i < binder_ctx->tbl_size; i++) {
366 OSAL_INIT_LIST_HEAD(&binder_ctx->src_tbl[i].list_head);
367 binder_ctx->src_tbl[i].dest_num = 0;
368 }
369
370 binder_ctx->mod_id = sender->mod_id;
371 binder_ctx->max_dev_cnt = sender->max_dev_cnt;
372 binder_ctx->max_chn_cnt = sender->max_chn_cnt;
373 binder_ctx->give_bind_call_back = sender->give_bind_call_back;
374
375 return HI_SUCCESS;
376 }
377
sys_init_receiver_ctx(const bind_receiver_info * receiver,sys_binder_ctx * binder_ctx)378 static hi_s32 sys_init_receiver_ctx(const bind_receiver_info *receiver, sys_binder_ctx *binder_ctx)
379 {
380 hi_u32 i;
381
382 binder_ctx->dest_tbl = (sys_bind_dest *)osal_kmalloc(binder_ctx->tbl_size * sizeof(sys_bind_dest), osal_gfp_kernel);
383 if (binder_ctx->dest_tbl == HI_NULL) {
384 sys_err_trace("no memory for bind table!\n");
385 return HI_ERR_SYS_NOMEM;
386 }
387
388 for (i = 0; i < binder_ctx->tbl_size; i++) {
389 binder_ctx->dest_tbl[i].is_bind_src = HI_FALSE;
390 }
391
392 binder_ctx->mod_id = receiver->mod_id;
393 binder_ctx->max_dev_cnt = receiver->max_dev_cnt;
394 binder_ctx->max_chn_cnt = receiver->max_chn_cnt;
395 binder_ctx->call_back = receiver->call_back;
396 binder_ctx->reset_call_back = receiver->reset_call_back;
397 binder_ctx->support_delay_data = receiver->support_delay_data;
398
399 return HI_SUCCESS;
400 }
401
sys_receiver_is_bind(sys_bind_dest * dest_bind)402 static inline hi_s32 sys_receiver_is_bind(sys_bind_dest *dest_bind)
403 {
404 return dest_bind->is_bind_src;
405 }
406
sys_bind_check_bindship(hi_mpp_chn * src_chn,sys_bind_dest * dest_bind)407 static hi_s32 sys_bind_check_bindship(hi_mpp_chn *src_chn, sys_bind_dest *dest_bind)
408 {
409 if ((dest_bind->bind_src.mod_id != src_chn->mod_id) ||
410 (dest_bind->bind_src.dev_id != src_chn->dev_id) ||
411 (dest_bind->bind_src.chn_id != src_chn->chn_id)) {
412 sys_err_trace("src and dest is not bound!\n");
413 return HI_ERR_SYS_ILLEGAL_PARAM;
414 }
415
416 return HI_SUCCESS;
417 }
418
sys_deinit_send_bind_src_mem(hi_mpp_chn * src_chn)419 static hi_s32 sys_deinit_send_bind_src_mem(hi_mpp_chn *src_chn)
420 {
421 hi_u32 src_tbl_idx;
422 sys_binder_ctx *sender_ctx = HI_NULL;
423
424 sender_ctx = g_sender_tbl[src_chn->mod_id];
425 src_tbl_idx = sys_get_idx_by_dev_chn(sender_ctx, src_chn->dev_id, src_chn->chn_id);
426 if (g_bind_send[src_chn->mod_id].send_bind_src[src_tbl_idx] != HI_NULL) {
427 osal_kfree(g_bind_send[src_chn->mod_id].send_bind_src[src_tbl_idx]);
428 g_bind_send[src_chn->mod_id].send_bind_src[src_tbl_idx] = HI_NULL;
429 }
430
431 return HI_SUCCESS;
432 }
433
sys_init_send_bind_src_mem(hi_mpp_chn * src_chn)434 static hi_s32 sys_init_send_bind_src_mem(hi_mpp_chn *src_chn)
435 {
436 hi_mpp_bind_dest *send_bind_src = HI_NULL;
437 hi_u32 src_tbl_idx;
438 sys_binder_ctx *sender_ctx = HI_NULL;
439
440 sender_ctx = g_sender_tbl[src_chn->mod_id];
441 src_tbl_idx = sys_get_idx_by_dev_chn(sender_ctx, src_chn->dev_id, src_chn->chn_id);
442
443 send_bind_src = g_bind_send[src_chn->mod_id].send_bind_src[src_tbl_idx];
444 if (send_bind_src == HI_NULL) {
445 send_bind_src = (hi_mpp_bind_dest *)osal_kmalloc(sizeof(hi_mpp_bind_dest), osal_gfp_kernel);
446 if (send_bind_src == HI_NULL) {
447 sys_err_trace("no memory for bind SRC!\n");
448 return HI_ERR_SYS_NOMEM;
449 }
450
451 (hi_void)memset_s(send_bind_src, sizeof(hi_mpp_bind_dest), 0, sizeof(hi_mpp_bind_dest));
452
453 g_bind_send[src_chn->mod_id].send_bind_src[src_tbl_idx] = send_bind_src;
454 }
455
456 return HI_SUCCESS;
457 }
458
sys_bind_check_sender_dest_num(sys_bind_src * src_bind)459 static inline hi_s32 sys_bind_check_sender_dest_num(sys_bind_src *src_bind)
460 {
461 if (src_bind->dest_num > BIND_DEST_MAXNUM) {
462 sys_err_trace("src bind max(%d) err!\n", src_bind->dest_num);
463 return HI_ERR_SYS_NOT_PERM;
464 }
465
466 return HI_SUCCESS;
467 }
468
sys_give_bind_call_back(hi_mpp_chn * src_chn)469 static hi_void sys_give_bind_call_back(hi_mpp_chn *src_chn)
470 {
471 hi_s32 ret;
472 sys_binder_ctx *sender_ctx = g_sender_tbl[src_chn->mod_id];
473
474 if ((src_chn->mod_id == HI_ID_VPSS) || (src_chn->mod_id == HI_ID_VI)) {
475 static hi_mpp_bind_dest bind_src;
476 (hi_void)memset_s(&bind_src, sizeof(hi_mpp_bind_dest), 0, sizeof(hi_mpp_bind_dest));
477 ret = sys_get_binder_by_src(src_chn, &bind_src);
478 if (ret == HI_SUCCESS) {
479 if (sender_ctx->give_bind_call_back != HI_NULL) {
480 sender_ctx->give_bind_call_back(src_chn->dev_id, src_chn->chn_id, &bind_src);
481 }
482 }
483 }
484 }
485
sys_bind_reset_callback(hi_mpp_chn * src_chn,hi_mpp_chn * dest_chn)486 static inline hi_void sys_bind_reset_callback(hi_mpp_chn *src_chn, hi_mpp_chn *dest_chn)
487 {
488 sys_binder_ctx *receiver_ctx = g_receiver_tbl[dest_chn->mod_id];
489
490 if (src_chn->mod_id == HI_ID_VDEC) {
491 if (receiver_ctx->reset_call_back != HI_NULL) {
492 receiver_ctx->reset_call_back(dest_chn->dev_id, dest_chn->chn_id, HI_NULL);
493 }
494 }
495 }
496
sys_really_unbind(hi_mpp_chn * src_chn,hi_mpp_chn * dest_chn,sys_bind_dest * dest_bind)497 static hi_s32 sys_really_unbind(hi_mpp_chn *src_chn, hi_mpp_chn *dest_chn, sys_bind_dest *dest_bind)
498 {
499 unsigned long flags;
500 hi_s32 ret;
501 sys_bind_src *src_bind = HI_NULL;
502 sys_bind_node *node = HI_NULL;
503 struct osal_list_head *list_tmp = HI_NULL;
504 struct osal_list_head *list_node = HI_NULL;
505
506 ret = sys_get_bind_valid_src_tbl(src_chn, &src_bind);
507 if (ret != HI_SUCCESS) {
508 return ret;
509 }
510
511 bind_spin_lock(flags);
512
513 osal_list_for_each_safe(list_node, list_tmp, &src_bind->list_head) {
514 node = osal_list_entry(list_node, sys_bind_node, list);
515 if ((dest_chn->mod_id == node->mpp_chn.mod_id) &&
516 (dest_chn->dev_id == node->mpp_chn.dev_id) &&
517 (dest_chn->chn_id == node->mpp_chn.chn_id)) {
518 osal_list_del(list_node);
519 osal_kfree(node);
520 node = HI_NULL;
521 HI_ASSERT(src_bind->dest_num > 0);
522 src_bind->dest_num--;
523 break;
524 }
525 }
526
527 dest_bind->is_bind_src = HI_FALSE;
528
529 bind_spin_unlock(flags);
530
531 return HI_SUCCESS;
532 }
533
sys_really_bind(hi_mpp_chn * src_chn,hi_mpp_chn * dest_chn,sys_bind_src * src_bind,sys_bind_dest * dest_bind)534 static hi_s32 sys_really_bind(hi_mpp_chn *src_chn, hi_mpp_chn *dest_chn, sys_bind_src *src_bind,
535 sys_bind_dest *dest_bind)
536 {
537 hi_s32 ret;
538 unsigned long flags;
539 sys_bind_node *node = HI_NULL;
540
541 ret = sys_init_send_bind_src_mem(src_chn);
542 if (ret != HI_SUCCESS) {
543 return ret;
544 }
545
546 node = (sys_bind_node *)osal_kmalloc(sizeof(sys_bind_node), osal_gfp_kernel);
547 if (node == HI_NULL) {
548 sys_err_trace("kmalloc err!\n");
549 sys_deinit_send_bind_src_mem(src_chn);
550 return HI_ERR_SYS_NOMEM;
551 }
552
553 bind_spin_lock(flags);
554
555 if (memcpy_s(&dest_bind->bind_src, sizeof(hi_mpp_chn), src_chn, sizeof(hi_mpp_chn)) != EOK) {
556 bind_spin_unlock(flags);
557 osal_kfree(node);
558 node = HI_NULL;
559 sys_deinit_send_bind_src_mem(src_chn);
560 return HI_ERR_SYS_ILLEGAL_PARAM;
561 }
562 dest_bind->is_bind_src = HI_TRUE;
563 dest_bind->send_cnt = 0;
564 dest_bind->reset_cnt = 0;
565
566 if (memcpy_s(&node->mpp_chn, sizeof(hi_mpp_chn), dest_chn, sizeof(hi_mpp_chn)) != EOK) {
567 bind_spin_unlock(flags);
568 osal_kfree(node);
569 node = HI_NULL;
570 sys_deinit_send_bind_src_mem(src_chn);
571 return HI_ERR_SYS_ILLEGAL_PARAM;
572 }
573
574 osal_list_add_tail(&node->list, &src_bind->list_head);
575 src_bind->dest_num++;
576
577 bind_spin_unlock(flags);
578 return HI_SUCCESS;
579 }
580
sys_bind(hi_mpp_chn * src_chn,hi_mpp_chn * dest_chn)581 hi_s32 sys_bind(hi_mpp_chn *src_chn, hi_mpp_chn *dest_chn)
582 {
583 hi_s32 ret;
584 sys_bind_src *src_bind = HI_NULL;
585 sys_bind_dest *dest_bind = HI_NULL;
586
587 sys_check_null_ptr_return(src_chn);
588 sys_check_null_ptr_return(dest_chn);
589
590 ret = sys_get_bind_valid_src_tbl(src_chn, &src_bind);
591 if (ret != HI_SUCCESS) {
592 return ret;
593 }
594
595 ret = sys_get_bind_valid_dest_tbl(dest_chn, &dest_bind);
596 if (ret != HI_SUCCESS) {
597 return ret;
598 }
599
600 bind_sem_down_return();
601
602 if (sys_receiver_is_bind(dest_bind) == HI_TRUE) {
603 sys_err_trace("dest have bind src:(%s,%d,%d) !\n", bind_get_mod_name(dest_bind->bind_src.mod_id),
604 dest_bind->bind_src.dev_id, dest_bind->bind_src.chn_id);
605 ret = HI_ERR_SYS_NOT_PERM;
606 goto exit;
607 }
608
609 ret = sys_bind_check_sender_dest_num(src_bind);
610 if (ret != HI_SUCCESS) {
611 goto exit;
612 }
613
614 ret = sys_really_bind(src_chn, dest_chn, src_bind, dest_bind);
615 if (ret != HI_SUCCESS) {
616 goto exit;
617 }
618
619 sys_give_bind_call_back(src_chn);
620
621 exit:
622 bind_sem_up();
623 return ret;
624 }
625
sys_unbind(hi_mpp_chn * src_chn,hi_mpp_chn * dest_chn)626 hi_s32 sys_unbind(hi_mpp_chn *src_chn, hi_mpp_chn *dest_chn)
627 {
628 hi_s32 ret;
629 sys_bind_dest *dest_bind = HI_NULL;
630
631 sys_check_null_ptr_return(src_chn);
632 sys_check_null_ptr_return(dest_chn);
633
634 ret = sys_get_bind_valid_dest_tbl(dest_chn, &dest_bind);
635 if (ret != HI_SUCCESS) {
636 return ret;
637 }
638
639 bind_sem_down_return();
640
641 if (sys_receiver_is_bind(dest_bind) == HI_FALSE) {
642 sys_warn_trace("src and dest is not bound!\n");
643 ret = HI_SUCCESS;
644 goto exit;
645 }
646
647 ret = sys_bind_check_bindship(src_chn, dest_bind);
648 if (ret != HI_SUCCESS) {
649 goto exit;
650 }
651
652 ret = sys_really_unbind(src_chn, dest_chn, dest_bind);
653 if (ret != HI_SUCCESS) {
654 goto exit;
655 }
656 sys_give_bind_call_back(&dest_bind->bind_src);
657 sys_bind_reset_callback(src_chn, dest_chn);
658
659 exit:
660 bind_sem_up();
661 return ret;
662 }
663
sys_get_bind_by_dest_inner(hi_mpp_chn * dest_chn,hi_mpp_chn * src_chn)664 hi_s32 sys_get_bind_by_dest_inner(hi_mpp_chn *dest_chn, hi_mpp_chn *src_chn)
665 {
666 return sys_get_bind_by_dest(dest_chn, src_chn, HI_TRUE);
667 }
668
sys_get_bind_by_dest(hi_mpp_chn * dest_chn,hi_mpp_chn * src_chn,hi_bool inner_call)669 hi_s32 sys_get_bind_by_dest(hi_mpp_chn *dest_chn, hi_mpp_chn *src_chn, hi_bool inner_call)
670 {
671 hi_s32 ret;
672 sys_bind_dest *dest_bind = HI_NULL;
673 unsigned long flags;
674
675 sys_check_null_ptr_return(src_chn);
676 sys_check_null_ptr_return(dest_chn);
677
678 bind_spin_lock(flags);
679
680 ret = sys_get_bind_valid_dest_tbl(dest_chn, &dest_bind);
681 if (ret != HI_SUCCESS) {
682 bind_spin_unlock(flags);
683 return ret;
684 }
685
686 if (dest_bind->is_bind_src == HI_FALSE) {
687 if (inner_call) {
688 sys_warn_trace("dest have not bind any src \n");
689 } else {
690 sys_err_trace("dest have not bind any src \n");
691 }
692
693 bind_spin_unlock(flags);
694 return HI_ERR_SYS_ILLEGAL_PARAM;
695 }
696
697 if (memcpy_s(src_chn, sizeof(hi_mpp_chn), &dest_bind->bind_src, sizeof(hi_mpp_chn)) != EOK) {
698 bind_spin_unlock(flags);
699 return HI_ERR_SYS_ILLEGAL_PARAM;
700 }
701
702 bind_spin_unlock(flags);
703
704 return HI_SUCCESS;
705 }
706
sys_get_bind_by_src(hi_mpp_chn * src_chn,hi_mpp_bind_dest * bind_dest)707 hi_s32 sys_get_bind_by_src(hi_mpp_chn *src_chn, hi_mpp_bind_dest *bind_dest)
708 {
709 hi_s32 ret;
710
711 bind_sem_down_return();
712 ret = sys_get_binder_by_src(src_chn, bind_dest);
713
714 bind_sem_up();
715
716 return ret;
717 }
718
sys_get_bind_by_src_with_lock(hi_mpp_chn * src_chn,hi_mpp_bind_dest * bind_dest)719 hi_s32 sys_get_bind_by_src_with_lock(hi_mpp_chn *src_chn, hi_mpp_bind_dest *bind_dest)
720 {
721 hi_s32 ret;
722 unsigned long flags;
723
724 bind_spin_lock(flags);
725 ret = sys_get_binder_by_src(src_chn, bind_dest);
726
727 bind_spin_unlock(flags);
728
729 return ret;
730 }
731
sys_bind_register_sender(bind_sender_info * sender)732 hi_s32 sys_bind_register_sender(bind_sender_info *sender)
733 {
734 hi_s32 ret;
735 hi_mod_id mod_id;
736 hi_u32 bind_tbl_size;
737 sys_binder_ctx *binder_ctx = HI_NULL;
738
739 sys_check_null_ptr_return(sender);
740
741 mod_id = sender->mod_id;
742 bind_tbl_size = sender->max_dev_cnt * sender->max_chn_cnt;
743
744 if (sys_check_bind_mod_id(mod_id) != HI_SUCCESS) {
745 return HI_ERR_SYS_ILLEGAL_PARAM;
746 }
747
748 if (sys_check_bind_tbl_size(bind_tbl_size) != HI_SUCCESS) {
749 return HI_ERR_SYS_ILLEGAL_PARAM;
750 }
751
752 if (g_sender_tbl[mod_id] != HI_NULL) {
753 sys_err_trace("mod %d have register !\n", mod_id);
754 return HI_ERR_SYS_NOT_PERM;
755 }
756
757 binder_ctx = (sys_binder_ctx *)osal_kmalloc(sizeof(sys_binder_ctx), osal_gfp_kernel);
758 if (binder_ctx == HI_NULL) {
759 sys_err_trace("malloc binder_ctx null !\n");
760 return HI_ERR_SYS_NOMEM;
761 }
762
763 ret = snprintf_s(binder_ctx->name, BIND_NAME_MAX_LEN, BIND_NAME_MAX_LEN - 1, "%s", bind_get_mod_name(mod_id));
764 if (ret < 0) {
765 osal_kfree(binder_ctx);
766 return HI_ERR_SYS_ILLEGAL_PARAM;
767 }
768 binder_ctx->tbl_size = bind_tbl_size;
769
770 ret = sys_init_sender_ctx(sender, mod_id, binder_ctx);
771 if (ret != HI_SUCCESS) {
772 goto fail;
773 }
774 g_sender_tbl[mod_id] = binder_ctx;
775 return HI_SUCCESS;
776
777 fail:
778 osal_kfree(binder_ctx);
779 return ret;
780 }
781
sys_bind_register_receiver(bind_receiver_info * receiver)782 hi_s32 sys_bind_register_receiver(bind_receiver_info *receiver)
783 {
784 hi_s32 ret;
785 hi_mod_id mod_id;
786 hi_u32 bind_tbl_size;
787 sys_binder_ctx *binder_ctx = HI_NULL;
788
789 sys_check_null_ptr_return(receiver);
790 sys_check_null_ptr_return(receiver->call_back);
791
792 mod_id = receiver->mod_id;
793 bind_tbl_size = receiver->max_dev_cnt * receiver->max_chn_cnt;
794
795 if (sys_check_bind_mod_id(mod_id) != HI_SUCCESS) {
796 return HI_ERR_SYS_ILLEGAL_PARAM;
797 }
798
799 if (sys_check_bind_tbl_size(bind_tbl_size) != HI_SUCCESS) {
800 return HI_ERR_SYS_ILLEGAL_PARAM;
801 }
802
803 if (g_receiver_tbl[mod_id] != HI_NULL) {
804 sys_err_trace("mod %d have register !\n", mod_id);
805 return HI_ERR_SYS_NOT_PERM;
806 }
807
808 binder_ctx = (sys_binder_ctx *)osal_kmalloc(sizeof(sys_binder_ctx), osal_gfp_kernel);
809 if (binder_ctx == HI_NULL) {
810 sys_err_trace("malloc binder_ctx null !\n");
811 return HI_ERR_SYS_NOMEM;
812 }
813
814 ret = snprintf_s(binder_ctx->name, BIND_NAME_MAX_LEN, BIND_NAME_MAX_LEN - 1, "%s", bind_get_mod_name(mod_id));
815 if (ret < 0) {
816 osal_kfree(binder_ctx);
817 binder_ctx = HI_NULL;
818 return HI_ERR_SYS_ILLEGAL_PARAM;
819 }
820 binder_ctx->tbl_size = bind_tbl_size;
821
822 ret = sys_init_receiver_ctx(receiver, binder_ctx);
823 if (ret != HI_SUCCESS) {
824 goto fail;
825 }
826
827 g_receiver_tbl[mod_id] = binder_ctx;
828 return HI_SUCCESS;
829
830 fail:
831 osal_kfree(binder_ctx);
832 binder_ctx = HI_NULL;
833 return ret;
834 }
835
sys_bind_unregister_sender(hi_mod_id mod_id)836 hi_s32 sys_bind_unregister_sender(hi_mod_id mod_id)
837 {
838 unsigned long flags;
839
840 if (sys_check_bind_mod_id(mod_id) != HI_SUCCESS) {
841 return HI_ERR_SYS_ILLEGAL_PARAM;
842 }
843
844 bind_spin_lock(flags);
845 if (g_sender_tbl[mod_id] == HI_NULL) {
846 sys_err_trace("mod:%d have not register ! \n", mod_id);
847 bind_spin_unlock(flags);
848 return HI_ERR_SYS_NOT_PERM;
849 }
850
851 sys_deinit_sender(g_sender_tbl[mod_id], g_sender_tbl[mod_id]->tbl_size);
852 osal_kfree(g_sender_tbl[mod_id]);
853 g_sender_tbl[mod_id] = HI_NULL;
854 bind_spin_unlock(flags);
855
856 return HI_SUCCESS;
857 }
858
sys_bind_unregister_receiver(hi_mod_id mod_id)859 hi_s32 sys_bind_unregister_receiver(hi_mod_id mod_id)
860 {
861 unsigned long flags;
862
863 if (sys_check_bind_mod_id(mod_id) != HI_SUCCESS) {
864 return HI_ERR_SYS_ILLEGAL_PARAM;
865 }
866
867 bind_spin_lock(flags);
868 if (g_receiver_tbl[mod_id] == HI_NULL) {
869 sys_err_trace("mod:%d have not register ! \n", mod_id);
870 bind_spin_unlock(flags);
871 return HI_ERR_SYS_NOT_PERM;
872 }
873
874 sys_deinit_receiver(g_receiver_tbl[mod_id]);
875
876 osal_kfree(g_receiver_tbl[mod_id]);
877 g_receiver_tbl[mod_id] = HI_NULL;
878 bind_spin_unlock(flags);
879
880 return HI_SUCCESS;
881 }
882
sys_send_check_reciever_valid(hi_mod_id mod_id,hi_u32 flag)883 static hi_s32 sys_send_check_reciever_valid(hi_mod_id mod_id, hi_u32 flag)
884 {
885 sys_binder_ctx *receiver = g_receiver_tbl[mod_id];
886
887 if (receiver == HI_NULL) {
888 sys_warn_trace("mod %d have not register !\n", mod_id);
889 return HI_FAILURE;
890 }
891
892 if (receiver->call_back == HI_NULL) {
893 return HI_FAILURE;
894 }
895
896 if ((((flag & SYS_SEND_DATA_DELAY_MASK) == SYS_SEND_DATA_LOWDELAY) &&
897 (!receiver->support_delay_data)) ||
898 (((flag & SYS_SEND_DATA_DELAY_MASK) == SYS_SEND_DATA_LOWDELAY_FINISH) &&
899 (receiver->support_delay_data))) {
900 return HI_FAILURE;
901 }
902
903 return HI_SUCCESS;
904 }
905
sys_bind_really_send_data(hi_mpp_bind_dest * send_bind_src,hi_u32 flag,mpp_data_type data_type,hi_void * v_data)906 hi_s32 sys_bind_really_send_data(hi_mpp_bind_dest *send_bind_src, hi_u32 flag, mpp_data_type data_type,
907 hi_void *v_data)
908 {
909 hi_u32 i;
910 unsigned long flags;
911 hi_s32 ret = HI_SUCCESS;
912 hi_s32 tmp_ret;
913 hi_u32 dest_tbl_idx;
914 sys_bind_dest *dest_bind = HI_NULL;
915 sys_binder_ctx *receiver = HI_NULL;
916
917 if (send_bind_src->num == 0) {
918 sys_warn_trace("have not binder !\n");
919 return HI_ERR_SYS_NOT_PERM;
920 }
921
922 if ((flag & SYS_SEND_DATA_BLOCK_MASK) == SYS_SEND_DATA_NOBLOCK) {
923 ret = HI_FAILURE;
924 }
925
926 for (i = 0; i < send_bind_src->num; i++) {
927 bind_spin_lock(flags);
928
929 HI_ASSERT(send_bind_src->mpp_chn[i].mod_id < HI_ID_BUTT);
930 receiver = g_receiver_tbl[send_bind_src->mpp_chn[i].mod_id];
931
932 if (sys_send_check_reciever_valid(send_bind_src->mpp_chn[i].mod_id, flag) != HI_SUCCESS) {
933 bind_spin_unlock(flags);
934 continue;
935 }
936
937 dest_tbl_idx = sys_get_idx_by_dev_chn(receiver, send_bind_src->mpp_chn[i].dev_id,
938 send_bind_src->mpp_chn[i].chn_id);
939 dest_bind = &receiver->dest_tbl[dest_tbl_idx];
940 dest_bind->send_cnt++;
941
942 bind_spin_unlock(flags);
943 tmp_ret = receiver->call_back(send_bind_src->mpp_chn[i].dev_id,
944 send_bind_src->mpp_chn[i].chn_id, (flag & SYS_SEND_DATA_BLOCK_MASK), data_type, v_data);
945 if ((flag & SYS_SEND_DATA_BLOCK_MASK) == SYS_SEND_DATA_NOBLOCK) {
946 ret = (hi_u32)ret & (hi_u32)tmp_ret;
947 } else {
948 ret = (hi_u32)ret | (hi_u32)tmp_ret;
949 }
950 }
951
952 return ret;
953 }
954
sys_bind_send_data(hi_mod_id mod_id,hi_s32 dev_id,hi_s32 chn_id,hi_u32 flag,mpp_data_type data_type,hi_void * v_data)955 hi_s32 sys_bind_send_data(hi_mod_id mod_id, hi_s32 dev_id, hi_s32 chn_id, hi_u32 flag,
956 mpp_data_type data_type, hi_void *v_data)
957 {
958 hi_s32 ret;
959 hi_mpp_chn bind_chn;
960 hi_mpp_bind_dest *send_bind_src = HI_NULL;
961 unsigned long flags;
962
963 HI_ASSERT(mod_id < HI_ID_BUTT);
964 HI_ASSERT(data_type < MPP_DATA_BUTT);
965 sys_check_null_ptr_return(v_data);
966
967 bind_adjust_src_dev_id(mod_id, dev_id);
968 bind_adjust_src_chn_id(mod_id, chn_id);
969
970 bind_spin_lock(flags);
971
972 bind_chn.mod_id = mod_id;
973 bind_chn.dev_id = dev_id;
974 bind_chn.chn_id = chn_id;
975 ret = sys_get_bind_valid_send_ctx(&bind_chn, &send_bind_src);
976 if (ret != HI_SUCCESS) {
977 bind_spin_unlock(flags);
978 return HI_ERR_SYS_NOT_PERM;
979 }
980
981 send_bind_src->num = 0;
982 ret = sys_get_binder_by_src(&bind_chn, send_bind_src);
983 HI_ASSERT(ret == HI_SUCCESS);
984
985 bind_spin_unlock(flags);
986
987 return sys_bind_really_send_data(send_bind_src, flag, data_type, v_data);
988 }
989
sys_bind_really_reset_data(hi_mpp_bind_dest * send_bind_src,hi_void * private)990 hi_s32 sys_bind_really_reset_data(hi_mpp_bind_dest *send_bind_src, hi_void *private)
991 {
992 hi_u32 i;
993 unsigned long flags;
994 sys_bind_dest *dest_bind = HI_NULL;
995 sys_binder_ctx *receiver = HI_NULL;
996
997 if (send_bind_src->num == 0) {
998 sys_warn_trace("have not binder !\n");
999 return HI_SUCCESS;
1000 }
1001
1002 for (i = 0; i < send_bind_src->num; i++) {
1003 sys_lock_may_in_interrupt_return(flags);
1004
1005 HI_ASSERT(send_bind_src->mpp_chn[i].mod_id < HI_ID_BUTT);
1006 receiver = g_receiver_tbl[send_bind_src->mpp_chn[i].mod_id];
1007
1008 if (sys_get_bind_valid_dest_tbl(&send_bind_src->mpp_chn[i], &dest_bind)) {
1009 sys_unlock_may_in_interrupt_return(flags);
1010 continue;
1011 }
1012 dest_bind->reset_cnt++;
1013
1014 if (receiver->reset_call_back == HI_NULL) {
1015 sys_unlock_may_in_interrupt_return(flags);
1016 continue;
1017 }
1018
1019 sys_unlock_may_in_interrupt_return(flags);
1020
1021 receiver->reset_call_back(send_bind_src->mpp_chn[i].dev_id, send_bind_src->mpp_chn[i].chn_id, private);
1022 }
1023
1024 return HI_SUCCESS;
1025 }
1026
sys_bind_reset_data(hi_mod_id mod_id,hi_s32 dev_id,hi_s32 chn_id,hi_void * private)1027 hi_s32 sys_bind_reset_data(hi_mod_id mod_id, hi_s32 dev_id, hi_s32 chn_id, hi_void *private)
1028 {
1029 hi_s32 ret;
1030 hi_mpp_chn bind_chn;
1031 hi_mpp_bind_dest *send_bind_src = HI_NULL;
1032 unsigned long flags;
1033
1034 HI_ASSERT(mod_id < HI_ID_BUTT);
1035 sys_check_null_ptr_return(private);
1036
1037 bind_adjust_src_dev_id(mod_id, dev_id);
1038 bind_adjust_src_chn_id(mod_id, chn_id);
1039
1040 sys_lock_may_in_interrupt_return(flags);
1041
1042 bind_chn.mod_id = mod_id;
1043 bind_chn.dev_id = dev_id;
1044 bind_chn.chn_id = chn_id;
1045 ret = sys_get_bind_valid_send_ctx(&bind_chn, &send_bind_src);
1046 if (ret != HI_SUCCESS) {
1047 sys_unlock_may_in_interrupt_return(flags);
1048 return ret;
1049 }
1050
1051 send_bind_src->num = 0;
1052 ret = sys_get_binder_by_src(&bind_chn, send_bind_src);
1053 HI_ASSERT(ret == HI_SUCCESS);
1054
1055 sys_unlock_may_in_interrupt_return(flags);
1056
1057 return sys_bind_really_reset_data(send_bind_src, private);
1058 }
1059
sys_proc_show_sec_bindship(osal_proc_entry_t * s,sys_bind_node * node,sys_binder_ctx * sec_sender,sys_bind_dest * dest_bind,hi_mpp_chn * fir_mpp_chn)1060 hi_void sys_proc_show_sec_bindship(osal_proc_entry_t *s, sys_bind_node *node, sys_binder_ctx *sec_sender,
1061 sys_bind_dest *dest_bind, hi_mpp_chn *fir_mpp_chn)
1062 {
1063 hi_u32 k;
1064 hi_s32 sec_index, sec_src_chn;
1065 struct osal_list_head *list_tmp2 = HI_NULL;
1066 struct osal_list_head *list_node2 = HI_NULL;
1067 sys_bind_src *sec_bind_src = HI_NULL;
1068 sys_bind_node *node2 = HI_NULL;
1069 hi_bool print_sec = HI_FALSE;
1070
1071 for (k = 0; k < sec_sender->max_chn_cnt; k++) {
1072 sec_src_chn = k;
1073 sec_index = k + sec_sender->max_chn_cnt * node->mpp_chn.dev_id;
1074 sec_bind_src = &sec_sender->src_tbl[sec_index];
1075
1076 bind_adjust_dest_chn_id(node->mpp_chn.mod_id, sec_src_chn);
1077
1078 if ((node->mpp_chn.chn_id == sec_src_chn) &&
1079 (!osal_list_empty(&sec_bind_src->list_head))) {
1080 osal_list_for_each_safe(list_node2, list_tmp2, &sec_bind_src->list_head) {
1081 node2 = osal_list_entry(list_node2, sys_bind_node, list);
1082 osal_seq_printf(s, "%8s" "%8d" "%8d" "%8s" "%8d" "%8u" "%8s" "%8d" "%8d" "%11d" "%11u" "\n",
1083 bind_get_mod_name(fir_mpp_chn->mod_id), fir_mpp_chn->dev_id, fir_mpp_chn->chn_id,
1084 bind_get_mod_name(node->mpp_chn.mod_id), node->mpp_chn.dev_id, k,
1085 bind_get_mod_name(node2->mpp_chn.mod_id), node2->mpp_chn.dev_id, node2->mpp_chn.chn_id,
1086 dest_bind->send_cnt, dest_bind->reset_cnt);
1087 }
1088 print_sec = HI_TRUE;
1089 }
1090 }
1091
1092 if (print_sec == HI_FALSE) {
1093 osal_seq_printf(s, "%8s" "%8d" "%8d" "%8s" "%8d" "%8d" "%8s" "%8d" "%8d" "%11d" "%11u" "\n",
1094 bind_get_mod_name(fir_mpp_chn->mod_id), fir_mpp_chn->dev_id, fir_mpp_chn->chn_id,
1095 bind_get_mod_name(node->mpp_chn.mod_id), node->mpp_chn.dev_id, node->mpp_chn.chn_id,
1096 "null", 0, 0, dest_bind->send_cnt, dest_bind->reset_cnt);
1097 }
1098 }
1099
1100 #ifdef CONFIG_HI_PROC_SHOW_SUPPORT
sys_bind_proc_show(osal_proc_entry_t * s)1101 hi_void sys_bind_proc_show(osal_proc_entry_t *s)
1102 {
1103 hi_u32 i, j;
1104 hi_mpp_chn fir_mpp_chn;
1105 hi_u32 dest_tbl_idx;
1106 sys_binder_ctx *fir_sender = HI_NULL;
1107 sys_binder_ctx *sec_sender = HI_NULL;
1108 sys_binder_ctx *receiver = HI_NULL;
1109 sys_bind_dest *dest_bind = HI_NULL;
1110 sys_bind_src *fir_bind_src = HI_NULL;
1111 struct osal_list_head *list_tmp = HI_NULL;
1112 struct osal_list_head *list_node = HI_NULL;
1113 sys_bind_node *node = HI_NULL;
1114 unsigned long flags;
1115
1116 osal_seq_printf(s, "\n-----BIND RELATION TABLE--------------------------------------------------------\n");
1117 osal_seq_printf(s, "%8s" "%8s" "%8s" "%8s" "%8s" "%8s" "%8s" "%8s" "%8s" "%11s" "%11s" "\n",
1118 "FirMod", "FirDev", "FirChn", "SecMod", "SecDev", "SecChn", "TirMod", "TirDev", "TirChn", "SendCnt", "rstCnt");
1119
1120 bind_spin_lock(flags);
1121
1122 for (i = 0; i < HI_ID_BUTT; i++) {
1123 fir_sender = g_sender_tbl[i];
1124 if (fir_sender == HI_NULL) {
1125 continue;
1126 }
1127
1128 fir_mpp_chn.mod_id = i;
1129 for (j = 0; j < fir_sender->tbl_size; j++) {
1130 fir_bind_src = &fir_sender->src_tbl[j];
1131
1132 sys_get_dev_chn_by_idx(fir_sender, j, &fir_mpp_chn.dev_id, &fir_mpp_chn.chn_id);
1133
1134 osal_list_for_each_safe(list_node, list_tmp, &fir_bind_src->list_head) {
1135 node = osal_list_entry(list_node, sys_bind_node, list);
1136
1137 receiver = g_receiver_tbl[node->mpp_chn.mod_id];
1138 if (receiver == HI_NULL) {
1139 continue;
1140 }
1141 dest_tbl_idx = sys_get_idx_by_dev_chn(receiver, node->mpp_chn.dev_id, node->mpp_chn.chn_id);
1142 dest_bind = &receiver->dest_tbl[dest_tbl_idx];
1143
1144 sec_sender = g_sender_tbl[node->mpp_chn.mod_id];
1145 if (sec_sender == HI_NULL) {
1146 osal_seq_printf(s, "%8s" "%8d" "%8d" "%8s" "%8d" "%8d" "%8s" "%8d" "%8d" "%11d" "%11u" "\n",
1147 bind_get_mod_name(i), fir_mpp_chn.dev_id, fir_mpp_chn.chn_id,
1148 bind_get_mod_name(node->mpp_chn.mod_id), node->mpp_chn.dev_id, node->mpp_chn.chn_id,
1149 "null", 0, 0, dest_bind->send_cnt, dest_bind->reset_cnt);
1150 continue;
1151 }
1152
1153 sys_proc_show_sec_bindship(s, node, sec_sender, dest_bind, &fir_mpp_chn);
1154 }
1155 }
1156 }
1157 bind_spin_unlock(flags);
1158 }
1159 #endif
1160
sys_bind_mod_init(hi_void)1161 hi_s32 sys_bind_mod_init(hi_void)
1162 {
1163 if (bind_spin_lock_init() < 0) {
1164 return HI_FAILURE;
1165 }
1166
1167 if (bind_sem_init() < 0) {
1168 bind_spin_lock_uninit();
1169 return HI_FAILURE;
1170 }
1171
1172 return HI_SUCCESS;
1173 }
1174
sys_bind_init(hi_void)1175 hi_s32 sys_bind_init(hi_void)
1176 {
1177 (hi_void)memset_s(g_sender_tbl, sizeof(g_sender_tbl), 0, sizeof(g_sender_tbl));
1178 (hi_void)memset_s(g_receiver_tbl, sizeof(g_receiver_tbl), 0, sizeof(g_receiver_tbl));
1179 (hi_void)memset_s(g_bind_send, sizeof(g_bind_send), 0, sizeof(g_bind_send));
1180 return HI_SUCCESS;
1181 }
1182
sys_bind_mod_exit(hi_void)1183 hi_void sys_bind_mod_exit(hi_void)
1184 {
1185 bind_spin_lock_uninit();
1186 bind_sem_uninit();
1187
1188 return;
1189 }
1190
sys_free_mod_send_src_bind_mem(MOD_ID_E mod)1191 static hi_void sys_free_mod_send_src_bind_mem(MOD_ID_E mod)
1192 {
1193 hi_u32 j;
1194
1195 for (j = 0; j < g_bind_send[mod].max_index; j++) {
1196 if (g_bind_send[mod].send_bind_src[j] != HI_NULL) {
1197 osal_kfree(g_bind_send[mod].send_bind_src[j]);
1198 g_bind_send[mod].send_bind_src[j] = HI_NULL;
1199 }
1200 }
1201 }
1202
sys_bind_exit(hi_void)1203 hi_void sys_bind_exit(hi_void)
1204 {
1205 hi_s32 i;
1206
1207 for (i = 0; i < HI_ID_BUTT; i++) {
1208 if (g_bind_send[i].send_bind_src != HI_NULL) {
1209 sys_free_mod_send_src_bind_mem(i);
1210 osal_kfree(g_bind_send[i].send_bind_src);
1211 g_bind_send[i].send_bind_src = HI_NULL;
1212 }
1213 }
1214 }
1215