1
2 //************************Kernel Module Define********************************//
3 //Please Don't Change Code Order.
4 #include "MsTypes.h"
5 #include "utopia_driver_id.h"
6
7 #if 0
8 typedef enum{
9 #define PREFIX(MODULE) CONFIG_API_##MODULE##_MODULE=0,
10 INCLUDED_MODULE
11 #undef PREFIX
12 }eCONFIG_API_MODULE;
13
14 typedef enum{
15 #define PREFIX(MODULE) CONFIG_DRV_##MODULE##_MODULE=0,
16 INCLUDED_MODULE
17 #undef PREFIX
18 }eCONFIG_DRV_MODULE;
19 #endif
20
21 #ifdef CONFIG_ENABLE_MENUCONFIG
22 #include <autoconf.h>
23 #endif
24 //*************************************************************************//
25
26 #include "MsCommon.h"
27 #include "utopia_private.h"
28 #include "utopia.h"
29 #include "utopia_dapi.h"
30 #include "MsOS.h"
31 #include "drvMMIO.h"
32
33 #if defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER)
34 #include <sys/ioctl.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <fcntl.h>
38 #include <unistd.h>
39 #include <errno.h>
40 #endif
41
42 #if !defined(MSOS_TYPE_LINUX_KERNEL)
43 #include <stdio.h>
44 #include <string.h>
45 #else
46 #include <linux/string.h>
47 #include <linux/slab.h>
48 #endif
49
50 UTOPIA_PRIVATE* psUtopiaPrivate;
51
52 char moduleNames[][40] = {
53 #define PREFIX(MODULE) "MODULE_"#MODULE,
54 INCLUDED_MODULE
55 #undef PREFIX
56 };
57
58 char rpoolNames[][40] = {
59 #define PREFIX(MODULE) "RPOOL_"#MODULE,
60 INCLUDED_MODULE
61 #undef PREFIX
62 };
63
64 char ResourceNames[][40] = {
65 #define PREFIX(MODULE) "RESOURCE_"#MODULE,
66 INCLUDED_MODULE
67 #undef PREFIX
68 };
69
70 unsigned int moduleMode[] = {
71 #define PREFIX(MODULE) 0,
72 INCLUDED_MODULE
73 #undef PREFIX
74 };
75
76 #if 0//defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER)
77
78 #define PREFIX(MODULE) MS_U32 MODULE_##MODULE##_OPEN = MODULE_##MODULE | \
79 ((CONFIG_API_##MODULE##_MODULE | CONFIG_DRV_##MODULE##_MODULE) << 31);
80 INCLUDED_MODULE
81 #undef PREFIX
82
83 #endif
84
85 #define UTOPIA_VERSION "libutopia-v02.01-20170812"
86 MS_U32 UTOPIARegisterToUtopia(FUtopiaOpen ModuleType);
87 #define PREFIX(MODULE) \
88 extern MS_U32 MODULE##RegisterToUtopia(FUtopiaOpen ModuleType);
89 _INCLUDED_MODULE
90 #undef PREFIX
91
92 //#define CONFIG_UTOPIA_MODE_BY_BOOTARQ
93
94 #ifdef CONFIG_UTOPIA_MODE_BY_BOOTARQ
95
96 #define BOOTARG_SIZE 2048
UtopiaParserBootArg(char * source,char * pattern,unsigned int size)97 static unsigned int UtopiaParserBootArg(char* source,char* pattern,unsigned int size)
98 {
99 char sCmdline[BOOTARG_SIZE]={0};
100 FILE* fpProcCmdlineFile = NULL;
101 int u32ReadCount = 0;
102 char* pFindString = NULL;
103 char* sTemp = NULL;
104
105 unsigned int u32CmdlineLen = 0;
106
107
108 fpProcCmdlineFile = fopen("/proc/cmdline","r");
109
110 if(fpProcCmdlineFile==NULL)
111 {
112 printu("[utopia info]%d : can't open /proc/cmdline",__LINE__);
113 return 0;
114 }
115
116 u32ReadCount = fread(sCmdline,1,BOOTARG_SIZE,fpProcCmdlineFile);
117
118 if(u32ReadCount > BOOTARG_SIZE)
119 {
120 printu("[utopia info]%d warring : cmdline info more than buffer size\n",__LINE__);
121 }
122 u32CmdlineLen = strlen(sCmdline);
123
124 //printu("[utopia info]:cmdline = %s \n",sCmdline);
125 //printu("[utopia info]:string len = %d \n",u32CmdlineLen);
126
127 pFindString=strstr(sCmdline,pattern);
128
129 if(pFindString==NULL)
130 {
131 printu("[utopia info] can't serch %s in bootargs \n",pattern);
132 return 0;
133 }
134 sTemp = sCmdline;
135 while(strsep(&sTemp," ")); //covert space to "\0"
136
137 sTemp=strsep(&pFindString,"=");
138
139 u32ReadCount = strlen(pFindString);
140
141 if(u32ReadCount>size)
142 {
143 strncpy(source, pFindString, size);
144 u32ReadCount = size;
145 }else
146 {
147 strncpy(source, pFindString, u32ReadCount);
148 }
149
150 //printu("%s\n",pFindString);
151 //printu("lens = %d\n",strlen(pFindString));
152
153 return u32ReadCount;
154 }
155 #endif
156 #ifndef CONFIG_UTOPIA_MODE_DEFAULT_KERNEL
UtopiaConfigReadFile(char * filePath)157 static MS_U32 UtopiaConfigReadFile(char* filePath)
158 {
159 char sModule[40], sEqual[20];
160 unsigned int u32moduleMode = 0;
161 unsigned int u32Cnt =0;
162 char sConf[50], *tok=" \n", *pch;
163 int len = 0;
164
165 FILE* fpUtopiaModuleMode = NULL;
166
167 #ifdef CONFIG_UTOPIA_MODE_BY_BOOTARQ
168 char sFilePathFormBootArq[40] = {0};
169 unsigned int u32RetParserBootArg = 0;
170 u32RetParserBootArg = UtopiaParserBootArg(sFilePathFormBootArq,"utopia_mode",40);
171
172 if(u32RetParserBootArg == 0)
173 return 0;
174
175 //printu("utopia_conf path : %s \n",sFilePathFormBootArq);
176 printu("[utopia info] open: %s\n", sFilePathFormBootArq);
177 fpUtopiaModuleMode = fopen(sFilePathFormBootArq, "r");
178 #else
179 printu("[utopia info] open: %s\n", CONFIG_UTOPIAXP_CONF_PATH);
180 fpUtopiaModuleMode = fopen(CONFIG_UTOPIAXP_CONF_PATH, "r");
181 if(fpUtopiaModuleMode==NULL) //forward compatible ,remove later
182 {
183 fpUtopiaModuleMode = fopen("/data/utopia.conf", "r");
184 }
185 #endif
186 if(fpUtopiaModuleMode==NULL)
187 {
188 printu("[utopia info] don't have utopia.conf\n");
189 return 0;
190 }
191
192 // coverity[secure_coding]
193 while(fgets(sConf,sizeof(sConf),fpUtopiaModuleMode)!=NULL)
194 {
195 if(strncmp(sConf,"MODULE_",7)!=0)
196 {
197 continue;
198 }
199 memset(sModule,0,sizeof(sModule));
200 memset(sEqual,0,sizeof(sEqual));
201 pch = strtok(sConf, tok);
202 len = (strlen(pch)>sizeof(sModule))?sizeof(sModule):strlen(pch);
203 strncpy(sModule,pch,len);
204 pch = strtok(NULL, tok);
205 len = (strlen(pch)>sizeof(sEqual))?sizeof(sEqual):strlen(pch);
206 strncpy(sEqual,pch,len);
207 pch = strtok(NULL, tok);
208 u32moduleMode = atoi(pch);
209 //printf("11. %s %s %d\n", sModule, sEqual, u32moduleMode);
210
211 for(u32Cnt = 0;u32Cnt<eMODULE_END;u32Cnt++)
212 {
213 if (0== strcmp((const char*)sModule, (const char*)moduleNames[u32Cnt]))
214 {
215 if(u32moduleMode == 1)
216 {
217 moduleMode[u32Cnt] = KERNEL_MODE;
218 printu("%s = %d \n",moduleNames[u32Cnt],u32moduleMode);
219 }else
220 {
221 moduleMode[u32Cnt] = 0;
222 }
223 break;
224 }
225
226 }
227 u32moduleMode = 0 ; //init
228 }
229
230 fclose(fpUtopiaModuleMode);
231 return 0;
232 }
233 #endif
234
UtopiaInit()235 MS_U32 UtopiaInit()
236 {
237 MS_U32 u32Ret = 0;
238
239 printu("[utopia info] utopia init version: %s\n", UTOPIA_VERSION);
240 psUtopiaPrivate = (UTOPIA_PRIVATE*)malloc(sizeof(UTOPIA_PRIVATE));
241 memset(psUtopiaPrivate, 0, sizeof(UTOPIA_PRIVATE));
242 psUtopiaPrivate->u32MutexID = MsOS_CreateMutex(E_MSOS_FIFO
243 , "UtopiaPrivateMutex", MSOS_PROCESS_SHARED);
244
245 MsOS_ObtainMutex(psUtopiaPrivate->u32MutexID, MSOS_WAIT_FOREVER);
246 #ifdef CONFIG_UTOPIA_MODE_DEFAULT_KERNEL
247 #define MODULE_DEFAULT_KERNEL \
248 PREFIX(XC) \
249 PREFIX(DIP) \
250 PREFIX(PNL) \
251 PREFIX(ACE) \
252 PREFIX(DLC) \
253 PREFIX(PQ) \
254 PREFIX(TVENCODER) \
255 PREFIX(HDMIRX) \
256 PREFIX(BDMA) \
257 PREFIX(AESDMA) \
258 PREFIX(HWI2C) \
259 PREFIX(MIU) \
260 PREFIX(VIF) \
261 PREFIX(AVD) \
262 PREFIX(MVOP) \
263 PREFIX(GOP) \
264 PREFIX(GFX) \
265 PREFIX(GPD) \
266 PREFIX(DTMB) \
267 PREFIX(CEC) \
268 PREFIX(MHL) \
269 PREFIX(AUDIO) \
270 PREFIX(NJPEG_EX) \
271 PREFIX(VDEC_EX) \
272 PREFIX(DSCMB) \
273 PREFIX(DMX) \
274 PREFIX(VBI) \
275
276 #define PREFIX(MODULE) moduleMode[MODULE_##MODULE] = KERNEL_MODE;
277 MODULE_DEFAULT_KERNEL
278 #undef PREFIX
279 #else
280 UtopiaConfigReadFile(CONFIG_UTOPIAXP_CONF_PATH);
281 #endif
282 UTOPIARegisterToUtopia((FUtopiaOpen)MODULE_TYPE_UTOPIA_FULL);
283 #define PREFIX(MODULE) \
284 if (MODULE##RegisterToUtopia != NULL && MODULE_TYPE_##MODULE##_FULL) \
285 { \
286 u32Ret |= MODULE##RegisterToUtopia((FUtopiaOpen)MODULE_TYPE_##MODULE##_FULL); \
287 }
288 _INCLUDED_MODULE
289 #undef PREFIX
290 MsOS_ReleaseMutex(psUtopiaPrivate->u32MutexID);
291
292 return u32Ret;
293 }
294
UtopiaOpen(MS_U32 u32ModuleID,void ** ppInstanceTmp,MS_U32 u32ModuleVersion,const void * const pAttribute)295 MS_U32 UtopiaOpen(MS_U32 u32ModuleID, void** ppInstanceTmp
296 , MS_U32 u32ModuleVersion, const void* const pAttribute)
297 {
298 UTOPIA_MODULE* psUtopiaModule = psUtopiaPrivate->psModuleHead;
299 #if defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER)
300 //UTOPIA_USER_INSTANCE ** ppInstance= (UTOPIA_USER_INSTANCE**)ppInstanceTmp;
301 MS_S32 _s32UtopiaFd = -1;
302 UTOPIA_DDI_OPEN_ARG sOpenArg;
303 UTOPIA_USER_INSTANCE* pInstance = NULL;
304 while(psUtopiaModule != NULL)
305 {
306 if(psUtopiaModule->u32ModuleID == (u32ModuleID&~KERNEL_MODE))
307 {
308 MS_U32 u32ModuleIndex = u32ModuleID&~KERNEL_MODE;
309 pInstance= malloc(sizeof(UTOPIA_USER_INSTANCE));
310
311 if(pInstance == NULL)
312 {
313 printu("utopia.c : malloc fail %d \n",__LINE__);
314 return UTOPIA_STATUS_FAIL;
315 }else
316 {
317 // printu("utopia.c : malloc ok,Module= %s \n",moduleNames[u32ModuleIndex]);
318 }
319
320 //if(u32ModuleID & KERNEL_MODE)
321 if(moduleMode[u32ModuleIndex] & KERNEL_MODE)
322 {
323 if (0 > (_s32UtopiaFd = open("/proc/utopia", O_RDWR)))
324 {
325 printu("aa : 0x%x Open /proc/utopia fail aa\n", u32ModuleID);
326 free(pInstance);//coverity Resource leak
327 return UTOPIA_STATUS_FAIL;
328 }
329 // printu("Module : %s kernel mode\n",moduleNames[u32ModuleIndex]);
330 // printu("_s32UtopiaFd : %d \n",_s32UtopiaFd);
331 sOpenArg.u32ModuleID = psUtopiaModule->u32ModuleID;
332 sOpenArg.u32ModuleVersion = u32ModuleVersion;
333 sOpenArg.pAttribute = (void*)pAttribute;
334 if(ioctl(_s32UtopiaFd,UTOPIA_IOCTL_SetMODULE,&sOpenArg)!=UTOPIA_STATUS_SUCCESS)
335 {
336 printu("utopia.c : UtopiaOpen fail %d \n",__LINE__);
337 free(pInstance);
338 close(_s32UtopiaFd);
339 return UTOPIA_STATUS_FAIL;
340 }
341 //while(1);
342 pInstance->psUtopiaInstant = 0;
343 pInstance->s32Fd = _s32UtopiaFd;
344 pInstance->u32KernelSpaceIdentify =KERNEL_MODE;
345 pInstance->u32ModuleID = psUtopiaModule->u32ModuleID;
346 *ppInstanceTmp = pInstance;
347 return UTOPIA_STATUS_SUCCESS;
348 }else
349 {
350 // printu("Module : %s user mode\n",moduleNames[u32ModuleIndex]);
351 MS_U32 ret = psUtopiaModule->fpOpen(&(pInstance->psUtopiaInstant), pAttribute);
352
353 if(MSOS_BRANCH_PREDICTION_UNLIKELY(ret))
354 {
355 printu("[utopia open error] fail to create instance\n");
356 RET_OR_BLOCK(ret);
357 }
358 ((UTOPIA_INSTANCE*)(pInstance->psUtopiaInstant))->psModule =psUtopiaModule;
359 ((UTOPIA_INSTANCE*)(pInstance->psUtopiaInstant))->u32AppRequireModuleVersion = u32ModuleVersion;
360 //(*ppInstance)->psModule = psUtopiaModule;
361 //(*ppInstance)->u32AppRequireModuleVersion = u32ModuleVersion;
362 pInstance->u32KernelSpaceIdentify = 0;
363 pInstance->s32Fd = 0;
364
365 *ppInstanceTmp = pInstance;
366 return ret; /* depend on fpOpen, may not be UTOPIA_STATUS_SUCCESS */
367 }
368 }
369 psUtopiaModule = psUtopiaModule->psNext;
370 }
371 return UTOPIA_STATUS_FAIL;
372 #else
373 UTOPIA_INSTANCE** ppInstance = (UTOPIA_INSTANCE**)ppInstanceTmp;
374
375
376 while(psUtopiaModule != NULL)
377 {
378 if(psUtopiaModule->u32ModuleID == u32ModuleID)
379 {
380 MS_U32 ret = psUtopiaModule->fpOpen((void**)ppInstance, pAttribute);
381
382 if(MSOS_BRANCH_PREDICTION_UNLIKELY(ret))
383 {
384 printu("[utopia open error] fail to create instance\n");
385 RET_OR_BLOCK(ret);
386 }
387
388 (*ppInstance)->psModule = psUtopiaModule;
389 (*ppInstance)->u32AppRequireModuleVersion = u32ModuleVersion;
390 return ret; /* depend on fpOpen, may not be UTOPIA_STATUS_SUCCESS */
391 }
392 psUtopiaModule = psUtopiaModule->psNext;
393 }
394 return UTOPIA_STATUS_FAIL;
395 #endif
396 }
397
UtopiaIoctl(void * pInstanceTmp,MS_U32 u32Cmd,void * const pArgs)398 MS_U32 UtopiaIoctl(void* pInstanceTmp, MS_U32 u32Cmd, void* const pArgs)
399 {
400 #if defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER)
401 UTOPIA_DDI_IOCTL_ARG sIOCTLArg;
402 UTOPIA_USER_INSTANCE* pInstance = (UTOPIA_USER_INSTANCE*)pInstanceTmp;
403 MS_U32 ret = 0;
404
405 /* check param. */
406 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pInstance == NULL))
407 {
408 printu("[utopia param error] instance pointer should not be null\n");
409 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
410 }
411
412 if((pInstance->u32KernelSpaceIdentify) & KERNEL_MODE)
413 {
414 sIOCTLArg.u32Cmd = u32Cmd;
415 sIOCTLArg.pArg = pArgs;
416
417 ret = ioctl((pInstance->s32Fd),UTOPIA_IOCTL_IoctlMODULE,&sIOCTLArg);
418 if(ret != 0)
419 {
420
421 //printf("UtopiaIoctl error %d \n",ret);
422 //printf("Module: %s Cmd: %d \n",moduleNames[pInstance->u32ModuleID] , u32Cmd);
423 //print_trace();
424 //RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
425 }
426
427 //ioctl(((MS_S32)(pInstance->psUtopiaInstant)),u32Cmd,pArgs);
428 return ret;
429 }else
430 {
431 return TO_INSTANCE_PTR((pInstance->psUtopiaInstant))->psModule->fpIoctl((pInstance->psUtopiaInstant),
432 u32Cmd, pArgs);
433 }
434 #else
435 UTOPIA_INSTANCE* pInstance = (UTOPIA_INSTANCE*)pInstanceTmp;
436 /* check param. */
437 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pInstance == NULL))
438 {
439 printu("[utopia param error] instance pointer should not be null\n");
440 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
441 }
442
443 return TO_INSTANCE_PTR(pInstance)->psModule->fpIoctl(pInstance,
444 u32Cmd, pArgs);
445 #endif
446 }
447
UtopiaClose(void * pInstantTmp)448 MS_U32 UtopiaClose(void* pInstantTmp)
449 {
450 #if defined(CONFIG_UTOPIA_FRAMEWORK_KERNEL_DRIVER)
451 UTOPIA_USER_INSTANCE* pInstance = (UTOPIA_USER_INSTANCE*)pInstantTmp;
452 //UTOPIA_INSTANCE* pInstant = (UTOPIA_INSTANCE*)pInstantTmp;
453
454 UTOPIA_MODULE* psUtopiaModule = psUtopiaPrivate->psModuleHead;
455 MS_U32 u32Ret = UTOPIA_STATUS_FAIL;
456
457 if((pInstance->u32KernelSpaceIdentify) & KERNEL_MODE)
458 {
459 close((int)(pInstance->s32Fd));
460 free(pInstance);
461 return 0;//fix me
462 }else
463 {
464 while(psUtopiaModule != NULL)
465 {
466 if(psUtopiaModule->u32ModuleID == (TO_INSTANCE_PTR(pInstance->psUtopiaInstant))->psModule->u32ModuleID)
467 {
468 u32Ret = psUtopiaModule->fpClose(pInstance->psUtopiaInstant);
469 if(u32Ret==UTOPIA_STATUS_SUCCESS)
470 {
471 //printf("utopia.c : UtopiaClose ok,Module= %s \n",moduleNames[psUtopiaModule->u32ModuleID]);
472 free(pInstantTmp);
473 }
474 else
475 printf("UtopiaClose fail : Module = %s \n",moduleNames[psUtopiaModule->u32ModuleID]);
476
477
478 return u32Ret;
479 }
480 psUtopiaModule = psUtopiaModule->psNext;
481 }
482 return 0;
483 }
484 #else
485 UTOPIA_INSTANCE* pInstance = (UTOPIA_INSTANCE*)pInstantTmp;
486
487 /* check param. */
488 if (MSOS_BRANCH_PREDICTION_UNLIKELY(pInstance == NULL))
489 {
490 printu("[utopia param error] instance pointer should not be null\n");
491 RET_OR_BLOCK(UTOPIA_STATUS_FAIL);
492 }
493
494 UTOPIA_MODULE* psUtopiaModule = psUtopiaPrivate->psModuleHead;
495 while(psUtopiaModule != NULL)
496 {
497 if(psUtopiaModule->u32ModuleID == pInstance->psModule->u32ModuleID)
498 {
499 return psUtopiaModule->fpClose(pInstance);
500 }
501 psUtopiaModule = psUtopiaModule->psNext;
502 }
503 return 0;
504 #endif
505 }
506
507