1 /*
2 * Copyright (C) 2022 Huawei Technologies Co., Ltd.
3 * Licensed under the Mulan PSL v2.
4 * You can use this software according to the terms and conditions of the Mulan PSL v2.
5 * You may obtain a copy of Mulan PSL v2 at:
6 * http://license.coscl.org.cn/MulanPSL2
7 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
8 * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
9 * PURPOSE.
10 * See the Mulan PSL v2 for more details.
11 */
12 #include "base_drv_node.h"
13 #include <libdrv_frame.h>
14 #include "drv_dispatch.h"
15 #include "drv_process_mgr.h"
16 #include "ta_framework.h"
17 #include "target_type.h"
18 #include "tee_config.h"
19 #include "tee_log.h"
20 #include <securec.h>
21
22 const struct base_driver_node g_product_base_drv[] = {
23 #ifdef CRYPTO_MGR_SERVER_ENABLE
24 { CRYPTOMGR,
25 { CRYPTOMGR, TEE_CRYPTO_DRIVER_NAME, 10, true, DEFAULT_STACK_SIZE * 10, DEFAULT_HEAP_SIZE * 50, 0 },
26 { 1, false, true, 2}
27 },
28 #endif
29 #ifdef CONFIG_TEE_MISC_DRIVER
30 { TEE_MISC_DRIVER, { TEE_MISC_DRIVER, TEE_MISC_DRIVER_NAME, TEE_MISC_DRV_SIZE, true, DEFAULT_STACK_SIZE,
31 DEFAULT_HEAP_SIZE * 50, 0 }, { 1, false, false, 2} },
32 #endif
33 };
34
35 static const uint32_t g_product_base_drv_num =
36 sizeof(g_product_base_drv) / sizeof(g_product_base_drv[0]);
37
get_base_drv_flag(const char * drv_name,uint32_t drv_name_size)38 bool get_base_drv_flag(const char *drv_name, uint32_t drv_name_size)
39 {
40 if (drv_name == NULL)
41 return false;
42
43 for (uint32_t i = 0; i < g_product_base_drv_num; i++) {
44 if (strncmp(drv_name, g_product_base_drv[i].mani.service_name, drv_name_size + 1) == 0)
45 return true;
46 }
47
48 return false;
49 }
50
set_tlv_node(struct drv_tlv * tlv,const struct base_driver_node * drv_service_property)51 static int32_t set_tlv_node(struct drv_tlv *tlv, const struct base_driver_node *drv_service_property)
52 {
53 errno_t ret;
54 ret = memcpy_s(&tlv->uuid, sizeof(tlv->uuid), &drv_service_property->uuid, sizeof(drv_service_property->uuid));
55 if (ret != EOK) {
56 tloge("copy uuid failed\n");
57 return -1;
58 }
59
60 ret = memcpy_s(&tlv->drv_conf.mani, sizeof(tlv->drv_conf.mani),
61 &drv_service_property->mani, sizeof(drv_service_property->mani));
62 if (ret != EOK) {
63 tloge("copy mani failed\n");
64 return -1;
65 }
66
67 ret = memcpy_s(&tlv->drv_conf.drv_basic_info, sizeof(tlv->drv_conf.drv_basic_info),
68 &(drv_service_property->drv_basic_info), sizeof(drv_service_property->drv_basic_info));
69 if (ret != EOK) {
70 tloge("copy drv basic info failed\n");
71 return -1;
72 }
73
74 return 0;
75 }
76
init_base_drv_node(const struct base_driver_node * drv_service_property)77 static void init_base_drv_node(const struct base_driver_node *drv_service_property)
78 {
79 struct drv_tlv *tlv = malloc(sizeof(struct drv_tlv));
80 if (tlv == NULL) {
81 tloge("malloc tlv node failed\n");
82 return;
83 }
84
85 errno_t rc = memset_s(tlv, sizeof(*tlv), 0, sizeof(*tlv));
86 if (rc != EOK) {
87 tloge("memset failed\n");
88 free(tlv);
89 return;
90 }
91
92 int32_t ret = set_tlv_node(tlv, drv_service_property);
93 if (ret != 0) {
94 tloge("set tlv node value failed\n");
95 free(tlv);
96 return;
97 }
98
99 struct task_node *node = alloc_and_init_drv_node(tlv);
100 if (node == NULL) {
101 tloge("alloc node failed\n");
102 free(tlv);
103 return;
104 }
105
106 if (receive_task_conf(node) != 0) {
107 tloge("task conf node get failed\n");
108 free(tlv);
109 free_task_node(node);
110 return;
111 }
112
113 free(tlv);
114 return;
115 }
116
register_base_drv_node(void)117 int32_t register_base_drv_node(void)
118 {
119 uint32_t drv_property_num = g_product_base_drv_num;
120 const struct base_driver_node *drv_service_property = g_product_base_drv;
121 if (drv_service_property == NULL)
122 return 0;
123
124 for (uint32_t i = 0; i < drv_property_num; i++)
125 init_base_drv_node(&drv_service_property[i]);
126
127 return 0;
128 }
129