1
2 #if !defined(MSOS_TYPE_LINUX_KERNEL)
3 #include <stdio.h>
4 #include <string.h>
5 #else
6 #include <linux/kernel.h>
7 #include <linux/string.h>
8 #include <linux/slab.h>
9 #endif
10
11 #include "utopia_private.h"
12 #include "utopia.h"
13 #include "utopia_dapi.h"
14 #include "MsOS.h"
15 #include "drvMMIO.h"
16 #include "utopia_driver_id.h"
17
18 UTOPIA_PRIVATE* psUtopiaPrivate;
19
20 char moduleNames[][40] = {
21 #define PREFIX(MODULE) "MODULE_"#MODULE,
22 INCLUDED_MODULE
23 #undef PREFIX
24 };
25
26 char rpoolNames[][40] = {
27 #define PREFIX(MODULE) "RPOOL_"#MODULE,
28 INCLUDED_MODULE
29 #undef PREFIX
30 };
31
32 char ResourceNames[][40] = {
33 #define PREFIX(MODULE) "RESOURCE_"#MODULE,
34 INCLUDED_MODULE
35 #undef PREFIX
36 };
37
38 #define PREFIX(MODULE) MS_U32 MODULE_##MODULE##_OPEN = MODULE_##MODULE;
39 INCLUDED_MODULE
40 #undef PREFIX
41
42 #define PREFIX(MODULE) \
43 extern __attribute__((weak)) MS_U32 MODULE##RegisterToUtopia(FUtopiaOpen ModuleType);
44 INCLUDED_MODULE
45 #undef PREFIX
46
47 #if defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER_64BIT) || defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER_32BIT)
48
49 typedef MS_U32 (*FUResgisterModuleList)(FUtopiaOpen ModuleType);
50
emptyRegisterToUtopia(FUtopiaOpen ModuleType)51 MS_U32 emptyRegisterToUtopia(FUtopiaOpen ModuleType)
52 {
53 //printu("[utopia info] emptyRegisterToUtopia\n" );
54 return 0;
55 }
56
57 //FUResgisterModuleList AAResgisterModule = emptyRegisterToUtopia;
58
59
60 #define PREFIX(MODULE) \
61 FUResgisterModuleList MODULE##ResgisterModule = emptyRegisterToUtopia;
62 INCLUDED_MODULE
63 #undef PREFIX
64
65
66
67
autoRegisterModule(void)68 MS_U32 autoRegisterModule(void)
69 {
70
71 #define PREFIX(MODULE) \
72 if (MODULE##RegisterToUtopia != NULL && MODULE_TYPE_##MODULE##_FULL) \
73 { \
74 MODULE##ResgisterModule = MODULE##RegisterToUtopia; \
75 }
76 INCLUDED_MODULE
77 #undef PREFIX
78
79
80
81 return 0;
82 }
83
84
85 #endif
86
87
UtopiaInit()88 MS_U32 UtopiaInit()
89 {
90 MS_U32 u32Ret = 0;
91
92 printu("[utopia info] utopia init\n" );
93 psUtopiaPrivate = (UTOPIA_PRIVATE*)malloc(sizeof(UTOPIA_PRIVATE));
94 memset(psUtopiaPrivate, 0, sizeof(UTOPIA_PRIVATE));
95 psUtopiaPrivate->u32MutexID = MsOS_CreateMutex(E_MSOS_FIFO
96 , "UtopiaPrivateMutex", MSOS_PROCESS_SHARED);
97
98 MsOS_ObtainMutex(psUtopiaPrivate->u32MutexID, MSOS_WAIT_FOREVER);
99 #if defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER_64BIT) || defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER_32BIT)
100 u32Ret=autoRegisterModule();
101
102 #define PREFIX(MODULE) \
103 u32Ret |=(*(MODULE##ResgisterModule))((FUtopiaOpen)MODULE_TYPE_##MODULE##_FULL);
104 INCLUDED_MODULE
105 #undef PREFIX
106
107
108
109 #else
110
111 #define PREFIX(MODULE) \
112 if (MODULE##RegisterToUtopia != NULL && MODULE_TYPE_##MODULE##_FULL) \
113 { \
114 u32Ret |= MODULE##RegisterToUtopia((FUtopiaOpen)MODULE_TYPE_##MODULE##_FULL); \
115 }
116 INCLUDED_MODULE
117 #undef PREFIX
118
119 #endif //CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER_64BIT
120 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
121 UtopiaCreateMdbNode();
122 #endif
123 MsOS_ReleaseMutex(psUtopiaPrivate->u32MutexID);
124
125 return u32Ret;
126 }
127
UtopiaOpen(MS_U32 u32ModuleID,void ** ppInstanceTmp,MS_U32 u32ModuleVersion,const void * const pAttribute)128 MS_U32 UtopiaOpen(MS_U32 u32ModuleID, void** ppInstanceTmp
129 , MS_U32 u32ModuleVersion, const void* const pAttribute)
130 {
131 UTOPIA_MODULE* psUtopiaModule = psUtopiaPrivate->psModuleHead;
132 UTOPIA_INSTANCE** ppInstance = (UTOPIA_INSTANCE**)ppInstanceTmp;
133
134
135 while(psUtopiaModule != NULL)
136 {
137 if(psUtopiaModule->u32ModuleID == (u32ModuleID & (~KERNEL_MODE)))
138 {
139 int ret = psUtopiaModule->fpOpen((void**)ppInstance, pAttribute);
140
141 if(MSOS_BRANCH_PREDICTION_UNLIKELY(ret))
142 {
143 printu("[utopia open error] fail to create instance\n");
144 RET_OR_BLOCK(ret);
145 }
146
147 (*ppInstance)->psModule = psUtopiaModule;
148 (*ppInstance)->u32AppRequireModuleVersion = u32ModuleVersion;
149 return ret; /* depend on fpOpen, may not be UTOPIA_STATUS_SUCCESS */
150 }
151 psUtopiaModule = psUtopiaModule->psNext;
152 }
153 return UTOPIA_STATUS_FAIL;
154 }
155 EXPORT_SYMBOL(UtopiaOpen);
156
UtopiaIoctl(void * pInstanceTmp,MS_U32 u32Cmd,void * const pArgs)157 MS_U32 UtopiaIoctl(void* pInstanceTmp, MS_U32 u32Cmd, void* const pArgs)
158 {
159 UTOPIA_INSTANCE* pInstance = (UTOPIA_INSTANCE*)pInstanceTmp;
160 /* check param. */
161 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pInstance == NULL))
162 {
163 printu("[utopia param error] instance pointer should not be null\n");
164 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
165 }
166
167 return TO_INSTANCE_PTR(pInstance)->psModule->fpIoctl(pInstance,
168 u32Cmd, pArgs);
169 }
170 EXPORT_SYMBOL(UtopiaIoctl);
171
UtopiaClose(void * pInstantTmp)172 MS_U32 UtopiaClose(void* pInstantTmp)
173 {
174 UTOPIA_INSTANCE* pInstant = (UTOPIA_INSTANCE*)pInstantTmp;
175
176 UTOPIA_MODULE* psUtopiaModule = psUtopiaPrivate->psModuleHead;
177 while(psUtopiaModule != NULL)
178 {
179 if(psUtopiaModule->u32ModuleID == pInstant->psModule->u32ModuleID)
180 {
181 return psUtopiaModule->fpClose(pInstant);
182 }
183 psUtopiaModule = psUtopiaModule->psNext;
184 }
185 return 0;
186 }
187 EXPORT_SYMBOL(UtopiaClose);
188