1 #ifdef MSOS_TYPE_LINUX_KERNEL
2 #include <linux/module.h>
3 #include <linux/kernel.h>
4 #include <linux/string.h>
5 #else
6 #include <stdio.h>
7 #include <string.h>
8 #endif
9 #include "utopia.h"
10 #include "utopia_dapi.h"
11 #include "utopia_driver_id.h"
12
13 #include "MsDevice.h"
14 //#include "drvTVEncoder.h"
15
16 #include "MsOS.h"
17 #include "tvencoder_private.h"
18 #include "tvencoder.h"
19 #include "utopia_api_database.h"
20 #include "ve_hwreg_utility2.h"
21
22 #define IOCTL_SUCCESS 0
23 #define atoi(str) simple_strtoul(((str != NULL) ? str : ""), NULL, 0)
24 // ========== Global definition ==========
25 void* pUtopiaTVEncoder=NULL;
26 #ifdef MSOS_TYPE_LINUX_KERNEL
27
VEStr(MS_U32 u32PowerState,void * pModule)28 MS_U32 VEStr(MS_U32 u32PowerState, void* pModule)
29 {
30 MS_U32 u32Return=UTOPIA_STATUS_FAIL;
31
32 switch(u32PowerState)
33 {
34 case E_POWER_SUSPEND:
35 _MDrv_TVE_SetPowerState(u32PowerState);
36 u32Return=UTOPIA_STATUS_SUCCESS;
37 break;
38 case E_POWER_RESUME:
39 _MDrv_TVE_SetPowerState(u32PowerState);
40 u32Return=UTOPIA_STATUS_SUCCESS;
41 break;
42 default:
43 printf("[%s][%d] PowerState:%lx not Implement now!!!\n",__FUNCTION__,__LINE__,u32PowerState);
44 break;
45 }
46 return u32Return;
47 }
48 #endif
49
50 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
51
TVENCODERMdb_Cat(MDBCMD_CMDLINE_PARAMETER * paraCmdInfo)52 void TVENCODERMdb_Cat(MDBCMD_CMDLINE_PARAMETER *paraCmdInfo)
53 {
54 VE_DrvStatus* pDrvStatus;
55 if(MDrv_VE_GetStatus(pDrvStatus) == E_VE_OK)
56 {
57 MdbPrint(paraCmdInfo->u64ReqHdl,"---------------- Mstar VE Info -----------------\n");
58 MdbPrint(paraCmdInfo->u64ReqHdl,"VE H capture start : %d\n", pDrvStatus->u16H_CapStart);
59 MdbPrint(paraCmdInfo->u64ReqHdl,"VE H capture end : %d\n", pDrvStatus->u16H_CapStart + pDrvStatus->u16H_CapSize);
60 MdbPrint(paraCmdInfo->u64ReqHdl,"VE H input size : %d\n", pDrvStatus->u16H_CapSize);
61 MdbPrint(paraCmdInfo->u64ReqHdl,"VE H output size : %d\n", pDrvStatus->u16H_CapSize* R2BYTE(0x103B0CUL));
62 MdbPrint(paraCmdInfo->u64ReqHdl,"VE H scaling ratio : 0x%x\n", R2BYTE(0x103B0CUL));
63 MdbPrint(paraCmdInfo->u64ReqHdl,"VE V capture start : %d\n", pDrvStatus->u16V_CapStart);
64 MdbPrint(paraCmdInfo->u64ReqHdl,"VE V capture end : %d\n", pDrvStatus->u16V_CapStart + pDrvStatus->u16V_CapSize);
65 MdbPrint(paraCmdInfo->u64ReqHdl,"VE V output size : %d\n", pDrvStatus->u16H_CapSize* R2BYTE(0x103B0EUL));
66 MdbPrint(paraCmdInfo->u64ReqHdl,"VE V scaling ratio : 0x%x\n", R2BYTE(0x103B0EUL));
67 if(R2BYTEMSK(0x103B0EUL, 0x80) == 0x80)
68 {
69 MdbPrint(paraCmdInfo->u64ReqHdl,"VE mode : DE mode\n");
70 }
71 else
72 {
73 MdbPrint(paraCmdInfo->u64ReqHdl,"VE mode : HV mode\n");
74 }
75 }
76 }
77
TVENCODERMdb_TestPattern(MS_U8 u8pattern,MS_BOOL bEnable)78 void TVENCODERMdb_TestPattern(MS_U8 u8pattern, MS_BOOL bEnable)
79 {
80 if(u8pattern == 1)
81 {
82 if(bEnable == TRUE)
83 {
84 W2BYTEMSK(0x103E06UL,BIT(4),BIT(4));
85 }
86 else if(bEnable == FALSE)
87 {
88 W2BYTEMSK(0x103E06UL,0,BIT(4));
89 }
90 }
91 else if(u8pattern == 0)
92 {
93 static MS_BOOL bLastStatus = FALSE;
94 static MS_U16 u16Hscaling, u16Vscaling, u16HscalingRatio, u16VscalingRatio;
95 if(bEnable == TRUE)
96 {
97 if(bLastStatus == FALSE)
98 {
99 u16Hscaling = R2BYTEMSK(0x103B00UL,BIT(8));
100 u16Vscaling = R2BYTEMSK(0x103B00UL,BIT(9));
101 u16HscalingRatio = R2BYTE(0x103B2CUL);
102 u16VscalingRatio = R2BYTE(0x103B2EUL);
103 }
104 W2BYTEMSK(0x103B00UL,BIT(10),BIT(10));
105 W2BYTEMSK(0x103B00UL,BIT(11),BIT(11));
106 W2BYTEMSK(0x103B00UL,BIT(8),BIT(8));
107 W2BYTEMSK(0x103B00UL,BIT(9),BIT(9));
108 W2BYTE(0x103B2CUL,0x0400);
109 W2BYTE(0x103B2EUL,0x0400);
110 bLastStatus = TRUE;
111 }
112 else if(bEnable == FALSE)
113 {
114 W2BYTEMSK(0x103B00UL,0,BIT(10));
115 W2BYTEMSK(0x103B00UL,0,BIT(11));
116 W2BYTEMSK(0x103B00UL,u16Hscaling,BIT(8));
117 W2BYTEMSK(0x103B00UL,u16Vscaling,BIT(9));
118 W2BYTE(0x103B2CUL,u16HscalingRatio);
119 W2BYTE(0x103B2EUL,u16VscalingRatio);
120 bLastStatus = FALSE;
121 }
122 }
123 }
124
TVENCODERMdb_EchoCmd(MS_U64 * u64ReqHdl,char * pcCmdLine)125 void TVENCODERMdb_EchoCmd(MS_U64* u64ReqHdl, char* pcCmdLine)
126 {
127 char pch[] = " =,";
128 char* psep;
129 psep = strsep(&pcCmdLine,pch);
130 MS_U8 u8pattern;
131 MS_BOOL bEnable = FALSE;
132
133 if(strcmp(psep, "pattern") == 0)
134 {
135 psep = strsep(&pcCmdLine,pch); //for num
136 psep = strsep(&pcCmdLine,pch);
137 if(psep != NULL)
138 {
139 u8pattern = (MS_U8)atoi(psep);
140 }
141 psep = strsep(&pcCmdLine,pch);
142 if(psep != NULL)
143 {
144 bEnable = (MS_BOOL)atoi(psep);
145 }
146 TVENCODERMdb_TestPattern(u8pattern, bEnable);
147 }
148 }
149
TVENCODERMdbIoctl(MS_U32 cmd,const void * const pArgs)150 MS_U32 TVENCODERMdbIoctl(MS_U32 cmd, const void* const pArgs)
151 {
152 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
153 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
154 switch(cmd)
155 {
156 case MDBCMD_CMDLINE:
157 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
158 /*MdbPrint(paraCmdLine->u64ReqHdl,"LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
159 MdbPrint(paraCmdLine->u64ReqHdl,"u32CmdSize: %d\n", paraCmdLine->u32CmdSize);
160 MdbPrint(paraCmdLine->u64ReqHdl,"pcCmdLine: %s\n", paraCmdLine->pcCmdLine);*/
161 TVENCODERMdb_EchoCmd(paraCmdLine->u64ReqHdl, paraCmdLine->pcCmdLine);
162 paraCmdLine->result = MDBRESULT_SUCCESS_FIN;
163 break;
164
165 case MDBCMD_GETINFO:
166 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
167 //MdbPrint(paraGetInfo->u64ReqHdl,"LINE:%d, MDBCMD_GETINFO\n", __LINE__);
168 TVENCODERMdb_Cat(paraGetInfo);
169 paraGetInfo->result = MDBRESULT_SUCCESS_FIN;
170 break;
171 default:
172 MdbPrint(paraGetInfo->u64ReqHdl,"unknown cmd\n", __LINE__);
173 break;
174 }
175 return 0;
176 }
177 #endif
178
179 // this func will be call to init by utopia20 framework
TVENCODERRegisterToUtopia(FUtopiaOpen ModuleType)180 void TVENCODERRegisterToUtopia(FUtopiaOpen ModuleType)
181 {
182 TVENCODER_RESOURCE_PRIVATE * pResPri = NULL;
183
184 // 1. deal with module
185 //void* pUtopiaTVEncoder=NULL;
186 UtopiaModuleCreate(MODULE_TVENCODER, 8, &pUtopiaTVEncoder);
187 UtopiaModuleRegister(pUtopiaTVEncoder);
188 // register func for module, after register here,then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
189 UtopiaModuleSetupFunctionPtr(pUtopiaTVEncoder, (FUtopiaOpen)TVENCODEROpen, (FUtopiaClose)TVENCODERClose, (FUtopiaIOctl)TVENCODERIoctl);
190
191 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
192 UtopiaModuleRegisterMdbNode("ve", (FUtopiaMdbIoctl)TVENCODERMdbIoctl);
193 #endif
194
195 // 2. deal with resource
196 void* psResource = NULL;
197 #if defined(MSOS_TYPE_LINUX_KERNEL)
198 UtopiaModuleSetupSTRFunctionPtr(pUtopiaTVEncoder, (FUtopiaSTR)VEStr);
199 UtopiaModuleSetSTRPrivate(pUtopiaTVEncoder, sizeof(VE_REGS_SAVE_AREA));
200 #endif
201 // start func to add res, call once will create 2 access in resource. Also can declare VE for another
202 UtopiaModuleAddResourceStart(pUtopiaTVEncoder, E_TVENCODER_POOL_ID_VE0);
203 // resource can alloc private for internal use, ex, VE_RESOURCE_PROVATE
204 UtopiaResourceCreate("tvencoder0",sizeof(TVENCODER_RESOURCE_PRIVATE),&psResource);
205 // func to reg res
206 UtopiaResourceRegister(pUtopiaTVEncoder, psResource, E_TVENCODER_POOL_ID_VE0);
207 // end function to add res
208 UtopiaModuleAddResourceEnd(pUtopiaTVEncoder, E_TVENCODER_POOL_ID_VE0);
209
210 if(UtopiaResourceObtain(pUtopiaTVEncoder, E_TVENCODER_POOL_ID_VE0, &psResource) != UTOPIA_STATUS_SUCCESS)
211 {
212 printf("UtopiaResourceObtain fail,%s,%d\n",__FUNCTION__,__LINE__);
213 return;
214 }
215
216 UtopiaResourceGetPrivate(psResource, (void**)&pResPri);
217
218 if(pResPri->u32Magic != MAGIC_NUM)
219 {
220 // not register
221 pResPri->u32Magic = MAGIC_NUM;
222 pResPri->bInited_Drv = FALSE;
223 pResPri->u32MIUAddress = 0x00;
224 }
225
226 UtopiaResourceRelease(psResource);
227
228 }
229
TVENCODEROpen(void ** ppInstance,const void * const pAttribute)230 MS_U32 TVENCODEROpen(void** ppInstance, const void* const pAttribute)
231 {
232 //TVENCODER_INSTANT_PRIVATE *pVEpir = NULL;
233 TVENCODER_INSTANT_PRIVATE *pstInstPri = NULL;
234 printf("[VE info] VE open\n");
235 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d",__FUNCTION__,__LINE__);
236 // instance is allocated here, also can allocate private for internal use, ex
237 UtopiaInstanceCreate(sizeof(TVENCODER_INSTANT_PRIVATE),ppInstance);
238 // setup func in private and assign the calling func in func ptr in instance private
239
240 //UtopiaInstanceGetPrivate(*ppInstance,(void**)&pVEpir);
241 UtopiaInstanceGetPrivate(*ppInstance,(void**)&pstInstPri);
242 //pVEpir->fpTVESetInputSRC = (IOCTL_TVENCODER_SETINPUTSRC)MDrv_VE_SetInputSource;
243
244 #ifdef CONFIG_UTOPIA_SIZE_CUSTOMER
245 #define URELATION(a,b,c) pstInstPri->_URELATION_ASSIGN(a,b,c)
246 _MODULE_VE_U1_U2_RELATION
247 #undef URELEATION
248 #else
249 pstInstPri->fpVE_GetInfo =_MDrv_VE_GetInfo;
250 pstInstPri->fpVE_GetStatus =_MDrv_VE_GetStatus;
251 pstInstPri->fpVE_SetDbgLevel =_MDrv_VE_SetDbgLevel;
252 pstInstPri->fpVE_SwitchInputSource =_MDrv_VE_SwitchInputSource;
253 pstInstPri->fpVE_SetInputSource =_MDrv_VE_SetInputSource;
254 pstInstPri->fpVE_SwitchOuputDest =_MDrv_VE_SwitchOuputDest;
255 pstInstPri->fpVE_SetOutputCtrl =_MDrv_VE_SetOutputCtrl;
256 pstInstPri->fpVE_SetOutputVideoStd =_MDrv_VE_SetOutputVideoStd;
257 pstInstPri->fpVE_SetMemoryBaseAddr =_MDrv_VE_SetMemoryBaseAddr;
258 pstInstPri->fpVE_Init = _MDrv_VE_Init;
259 pstInstPri->fpVE_Exit =_MDrv_VE_Exit;
260 pstInstPri->fpVE_SetWSSData =_MDrv_VE_SetWSSData;
261 pstInstPri->fpVE_GetWSSData =_MDrv_VE_GetWSSData;
262 pstInstPri->fpVE_SetMode =_MDrv_VE_SetMode;
263 pstInstPri->fpVE_SetBlackScreen =_MDrv_VE_SetBlackScreen;
264 pstInstPri->fpVE_IsBlackScreenEnabled =_MDrv_VE_IsBlackScreenEnabled;
265 pstInstPri->fpVE_SetTtxBuffer =_MDrv_VE_SetTtxBuffer;
266 pstInstPri->fpVE_GetTtxReadDoneStatus =_MDrv_VE_GetTtxReadDoneStatus;
267 pstInstPri->fpVE_EnableCcSw =_MDrv_VE_EnableCcSw;
268 pstInstPri->fpVE_SetCcRange =_MDrv_VE_SetCcRange;
269 pstInstPri->fpVE_SendCcData =_MDrv_VE_SendCcData;
270 pstInstPri->fpVE_set_display_window =_MDrv_VE_set_display_window;
271 pstInstPri->fpVE_SetOSD =_MDrv_VE_SetOSD;
272 pstInstPri->fpVE_SetRGBIn =_MDrv_VE_SetRGBIn;
273 pstInstPri->fpVE_Get_Output_Video_Std =_MDrv_VE_Get_Output_Video_Std;
274 pstInstPri->fpVE_SetCaptureMode =_MDrv_VE_SetCaptureMode;
275 pstInstPri->fpVE_GetDstInfo = _MApi_VE_GetDstInfo;
276 pstInstPri->fpVE_Set_TestPattern =_MDrv_VE_Set_TestPattern;
277 pstInstPri->fpVE_DisableRegWrite =_MDrv_VE_DisableRegWrite;
278 pstInstPri->fpVE_AdjustPositionBase =_MDrv_VE_AdjustPositionBase;
279 pstInstPri->fpVE_Set_Customer_Scaling =_MDrv_VE_Set_Customer_Scaling;
280 pstInstPri->fpVE_InitVECapture = _MDrv_VE_InitVECapture;
281 pstInstPri->fpVE_EnaVECapture = _MDrv_VE_EnaVECapture;
282 pstInstPri->fpVE_Adjust_FrameStart =_MDrv_VE_Adjust_FrameStart;
283 pstInstPri->fpTVE_SetPowerState =_MDrv_TVE_SetPowerState;
284 pstInstPri->fpVE_SetCusTable =_MDrv_VE_SetCusTable;
285 pstInstPri->fpVE_EnableCusTable =_MDrv_VE_EnableCusTable;
286 pstInstPri->fpVE_SetFrameColor =_MDrv_VE_SetFrameColor;
287 pstInstPri->fpVE_Set_OSDLayer =_MDrv_VE_Set_OSDLayer;
288 pstInstPri->fpVE_Get_OSDLayer =_MDrv_VE_Get_OSDLayer;
289 pstInstPri->fpVE_Set_VideoAlpha =_MDrv_VE_Set_VideoAlpha;
290 pstInstPri->fpVE_Get_VideoAlpha =_MDrv_VE_Get_VideoAlpha;
291 pstInstPri->fpVE_DCS_SetType =_MDrv_VE_DCS_SetType;
292 pstInstPri->fpVE_DCS_SetActivationKey =_MDrv_VE_DCS_SetActivationKey;
293 pstInstPri->fpVE_ReloadSetting =_MDrv_VE_ReloadSetting;
294 pstInstPri->fpVE_GetConfig =_MDrv_VE_GetConfig;
295 #endif
296
297 return UTOPIA_STATUS_SUCCESS;
298
299
300
301 }
302
TVENCODERIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)303 MS_U32 TVENCODERIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
304 {
305 //UTOPIA_INSTANT* pInstant = (UTOPIA_INSTANT*)*pInstantTmp;
306 //UTOPIA_RESOURCE* pstRes = NULL;
307
308 //void* pModule = NULL;
309 //UtopiaInstanceGetModule(pInstance, &pModule);
310 //void* pResource = NULL;
311
312 void* pstRes = NULL;
313 TVENCODER_RESOURCE_PRIVATE * pstResPri = NULL;
314 MS_U32 u32Ret =UTOPIA_STATUS_FAIL;
315 ///TVENCODER_RESOURCE_PRIVATE *pstResPri = NULL;
316 TVENCODER_INSTANT_PRIVATE *pstInstPri = NULL;
317 UtopiaInstanceGetPrivate(pInstance, (void**)&pstInstPri);
318
319 // Assert
320
321 if(UtopiaResourceObtain(pUtopiaTVEncoder, E_TVENCODER_POOL_ID_VE0, &pstRes) != UTOPIA_STATUS_SUCCESS)
322 {
323 printf("UtopiaResourceObtain fail,%s,%d\n",__FUNCTION__,__LINE__);
324 return UTOPIA_STATUS_ERR_RESOURCE;
325 }
326
327 UtopiaResourceGetPrivate(pstRes, (void**)&pstResPri);
328
329 // E_MDRV_CMD_TVE_DisableRegWrite and E_MDRV_CMD_TVE_SetDbgLevel
330 // might be invoked before VE Init
331 if ((u32Cmd != E_MDRV_CMD_TVE_DisableRegWrite)
332 && (u32Cmd != E_MDRV_CMD_TVE_Adjust_FrameStart)
333 && (u32Cmd != E_MDRV_CMD_TVE_SetDbgLevel)
334 && (u32Cmd != E_MDRV_CMD_TVE_AdjustPositionBase))
335 {
336 // to check init first
337 if((FALSE == pstResPri->bInited_Drv) &&
338 (u32Cmd != E_MDRV_CMD_TVE_Init))
339 {
340 UtopiaResourceRelease(pstRes);
341 return UTOPIA_STATUS_FAIL;
342 }
343 }
344 //TVENCODER_SetInputSRC pSetinputSRCParam = NULL;
345
346 switch(u32Cmd)
347 {
348 case E_MDRV_CMD_TVE_GetInfo:
349 {
350 PTVE_GETINFO pGetInfo = (PTVE_GETINFO)pArgs;
351 pGetInfo->eRet = E_TVENCODER_OK;
352 memcpy(pGetInfo->pVE_DrvInfo,pstInstPri->fpVE_GetInfo(),sizeof(VE_DrvInfo));
353 u32Ret = UTOPIA_STATUS_SUCCESS;
354 break;
355 //pstInstPri->fpVE_GetInfo(pInstance,pGetInfo->pVE_DrvInfo);
356 }
357
358 case E_MDRV_CMD_TVE_GetStatues:
359 {
360 PTVE_GETSTATUS pGetStatus = (PTVE_GETSTATUS)pArgs;
361 if(E_VE_OK == pstInstPri->fpVE_GetStatus(pGetStatus->pStaus))
362 {
363 pGetStatus->eRet = E_TVENCODER_OK;
364 }
365 else
366 {
367 pGetStatus->eRet = E_TVENCODER_FAIL;
368 }
369 u32Ret = UTOPIA_STATUS_SUCCESS;
370 break;
371 }
372
373 case E_MDRV_CMD_TVE_SetDbgLevel:
374 {
375 PTVE_SETDBGLEVEL pDbgLevel = (PTVE_SETDBGLEVEL)pArgs;
376 pstInstPri->fpVE_SetDbgLevel(pDbgLevel->u16Level);
377 pDbgLevel->eRet = E_TVENCODER_OK;
378 u32Ret = UTOPIA_STATUS_SUCCESS;
379 break;
380 }
381
382 case E_MDRV_CMD_TVE_SwitchInputSRC:
383 {
384 PTVE_SWITCH_SRC_INFO pSwitchSrc_info = (PTVE_SWITCH_SRC_INFO)pArgs;
385 pstInstPri->fpVE_SwitchInputSource(pSwitchSrc_info->pSwithcSrc_info);
386 pSwitchSrc_info->eRet = E_TVENCODER_OK;
387 u32Ret = UTOPIA_STATUS_SUCCESS;
388 break;
389 }
390
391 case E_MDRV_CMD_TVE_SetInputSRC:
392 {
393 PTVE_SETINPUTSRC pSetInputSrc = (PTVE_SETINPUTSRC)pArgs;
394 if(MS_VE_SWITCH_SRC_SUCCESS == pstInstPri->fpVE_SetInputSource(pSetInputSrc->pInputSrcInfo))
395 {
396 pSetInputSrc->eRet = E_TVENCODER_OK;
397 }
398 else
399 {
400 pSetInputSrc->eRet = E_TVENCODER_FAIL;
401 }
402 u32Ret = UTOPIA_STATUS_SUCCESS;
403 break;
404 }
405
406 case E_MDRV_CMD_TVE_SwitchOutputDest:
407 {
408 PTVE_SWITCHOUTPUTDEST pSwitchOutputDest = (PTVE_SWITCHOUTPUTDEST)pArgs;
409 pstInstPri->fpVE_SwitchOuputDest(pSwitchOutputDest->pSwitchInfo);
410 pSwitchOutputDest->eRet = E_TVENCODER_OK;
411 u32Ret = UTOPIA_STATUS_SUCCESS;
412 break;
413 }
414
415 case E_MDRV_CMD_TVE_SetOutputCtrl:
416 {
417 PTVE_SETOUTPUTCTRL pSetOutputCtrl = (PTVE_SETOUTPUTCTRL)pArgs;
418 pstInstPri->fpVE_SetOutputCtrl(pSetOutputCtrl->pOutputCtrl);
419 pSetOutputCtrl->eRet = E_TVENCODER_OK;
420 u32Ret = UTOPIA_STATUS_SUCCESS;
421 break;
422 }
423
424 case E_MDRV_CMD_TVE_SetOutputVideoStd:
425 {
426 PTVE_SETOUTPUTVIDEOSTD pSetOutputVideoStd = (PTVE_SETOUTPUTVIDEOSTD)pArgs;
427 if(TRUE == pstInstPri->fpVE_SetOutputVideoStd(pSetOutputVideoStd->VideoSystem))
428 {
429 pSetOutputVideoStd->eRet = E_TVENCODER_OK;
430 }
431 else
432 {
433 pSetOutputVideoStd->eRet = E_TVENCODER_FAIL;
434 }
435 u32Ret = UTOPIA_STATUS_SUCCESS;
436 break;
437 }
438
439 case E_MDRV_CMD_TVE_SetMemoryBaseAddr:
440 {
441 PTVE_SETMEMORYBASEADDR pSetMemoryBaseAddr = (PTVE_SETMEMORYBASEADDR)pArgs;
442 pstInstPri->fpVE_SetMemoryBaseAddr(pSetMemoryBaseAddr->phyMIUAddress,pSetMemoryBaseAddr->u32MIUSize);
443 u32Ret = UTOPIA_STATUS_SUCCESS;
444 break;
445 }
446
447 case E_MDRV_CMD_TVE_Init:
448 {
449 if(pstResPri->bInited_Drv == FALSE)
450 {
451 PTVE_INIT pInit = (PTVE_INIT)pArgs;
452 if(pInit->u32MIUAddress == NULL)
453 {
454 // coverity[loop_top]
455 while(!pstResPri->bInited_Drv); // wait initialize in other process
456 pInit->eRet = E_TVENCODER_OK;
457 u32Ret = UTOPIA_STATUS_SUCCESS;
458
459 }
460 else
461 {
462 pstInstPri->fpVE_Init(pInit->u32MIUAddress);
463 pInit->eRet = E_TVENCODER_OK;
464 u32Ret = UTOPIA_STATUS_SUCCESS;
465 pstResPri->bInited_Drv = TRUE;
466 pstResPri->u32MIUAddress = pInit->u32MIUAddress;
467 }
468 }
469 break;
470 }
471
472 case E_MDRV_CMD_TVE_Exit:
473 {
474 PTVE_EXIT pExit = (PTVE_EXIT)pArgs;
475 if(TRUE == pstInstPri->fpVE_Exit())
476 {
477 pExit->eRet = E_TVENCODER_OK;
478 }
479 else
480 {
481 pExit->eRet = E_TVENCODER_FAIL;
482 }
483 u32Ret = UTOPIA_STATUS_SUCCESS;
484 break;
485 }
486
487 case E_MDRV_CMD_TVE_SetWSSData:
488 {
489 PTVE_SETWSSDATA pSetWSSdata = (PTVE_SETWSSDATA) pArgs;
490 pstInstPri->fpVE_SetWSSData(pSetWSSdata->bEn,pSetWSSdata->u16WSSData);
491 pSetWSSdata->eRet = E_TVENCODER_OK;
492 u32Ret = UTOPIA_STATUS_SUCCESS;
493 break;
494 }
495
496 case E_MDRV_CMD_TVE_GetWSSData:
497 {
498 PTVE_GETWSSDATA pGetWSSData = (PTVE_GETWSSDATA) pArgs;
499 pGetWSSData->u16WSSData = pstInstPri->fpVE_GetWSSData();
500 u32Ret = UTOPIA_STATUS_SUCCESS;
501 break;
502 }
503
504 case E_MDRV_CMD_TVE_SetMode:
505 {
506 PTVE_SETMODE pSetMode = (PTVE_SETMODE)pArgs;
507 pstInstPri->fpVE_SetMode(pSetMode-> pVESetMode);
508 pSetMode->eRet = E_TVENCODER_OK;
509 u32Ret = UTOPIA_STATUS_SUCCESS;
510 break;
511 }
512
513 case E_MDRV_CMD_TVE_SetBlackSceen:
514 {
515 PTVE_SETBLACKSCREEN pSetBlackScreen = (PTVE_SETBLACKSCREEN)pArgs;
516 pstInstPri->fpVE_SetBlackScreen(pSetBlackScreen->bEnable);
517 u32Ret = UTOPIA_STATUS_SUCCESS;
518 break;
519 }
520
521 case E_MDRV_CMD_TVE_IsBlackScreenEnabled:
522 {
523 PTVE_ISBLACKSCREENENABLE pBlackScreenEnable = (PTVE_ISBLACKSCREENENABLE)pArgs;
524 pBlackScreenEnable->bEnable = pstInstPri->fpVE_IsBlackScreenEnabled();
525 u32Ret = UTOPIA_STATUS_SUCCESS;
526 break;
527 }
528
529 case E_MDRV_CMD_TVE_SetTtxBuffer:
530 {
531 PTVE_SETTTXBUFFER pSetTtxBuffer = (PTVE_SETTTXBUFFER)pArgs;
532 pstInstPri->fpVE_SetTtxBuffer(pSetTtxBuffer->u32StartAddr,pSetTtxBuffer->u32Size);
533 u32Ret = UTOPIA_STATUS_SUCCESS;
534 break;
535 }
536
537 case E_MDRV_CMD_TVE_VE_GetTtxReadDoneStatus:
538 {
539 PTVE_GETTTXREADDONE pGetTtxReadDoneStatus = (PTVE_GETTTXREADDONE)pArgs;
540 pGetTtxReadDoneStatus->bDone = pstInstPri->fpVE_GetTtxReadDoneStatus();
541 u32Ret = UTOPIA_STATUS_SUCCESS;
542 break;
543 }
544
545 case E_MDRV_CMD_TVE_EnableCcSw:
546 {
547 PTVE_ENABLECCSW pEnableCcSw = (PTVE_ENABLECCSW)pArgs;
548 pstInstPri->fpVE_EnableCcSw(pEnableCcSw->bEnable);
549 u32Ret = UTOPIA_STATUS_SUCCESS;
550 break;
551 }
552
553 case E_MDRV_CMD_TVE_SetCcRange:
554 {
555 PTVE_SETCCRANGE pSetCcRange = (PTVE_SETCCRANGE)pArgs;
556 pstInstPri->fpVE_SetCcRange(pSetCcRange->u16odd_start,pSetCcRange->u16odd_end,
557 pSetCcRange->u16even_start,pSetCcRange->u16even_end);
558 u32Ret = UTOPIA_STATUS_SUCCESS;
559 break;
560 }
561
562 case E_MDRV_CMD_TVE_SendCcData:
563 {
564 PTVE_SENDCCDATA pSendCcData = (PTVE_SENDCCDATA) pArgs;
565 pstInstPri->fpVE_SendCcData(pSendCcData->bIsOdd,pSendCcData->u16data);
566 u32Ret = UTOPIA_STATUS_SUCCESS;
567 break;
568 }
569
570 case E_MDRV_CMD_TVE_set_display_window:
571 {
572 PTVE_SETDISPLAYWIN pSetDisplayWin = (PTVE_SETDISPLAYWIN)pArgs;
573 pstInstPri->fpVE_set_display_window(pSetDisplayWin->stDispWin);
574 u32Ret = UTOPIA_STATUS_SUCCESS;
575 break;
576 }
577
578 case E_MDRV_CMD_TVE_SetOSD:
579 {
580 PTVE_SETOSD pSetOsd = (PTVE_SETOSD)pArgs;
581 pstInstPri->fpVE_SetOSD(pSetOsd->bEnable);
582 u32Ret = UTOPIA_STATUS_SUCCESS;
583 break;
584 }
585
586 case E_MDRV_CMD_TVE_SetRGBIn:
587 {
588 PTVE_SETRGBIN pSetRGBIn = (PTVE_SETRGBIN)pArgs;
589 pstInstPri->fpVE_SetRGBIn(pSetRGBIn->bEnable);
590 u32Ret = UTOPIA_STATUS_SUCCESS;
591 break;
592 }
593
594 case E_MDRV_CMD_TVE_Get_Output_Video_Std:
595 {
596 PTVE_GETOUTPUTVIDEOSTD pOutputVideoSTD = (PTVE_GETOUTPUTVIDEOSTD)pArgs;
597 pOutputVideoSTD->stVideoSys = pstInstPri->fpVE_Get_Output_Video_Std();
598 u32Ret = UTOPIA_STATUS_SUCCESS;
599 break;
600 }
601
602 case E_MDRV_CMD_TVE_SetCaptureMode:
603 {
604 PTVE_SETCAPMODE pSetCaptureMode = (PTVE_SETCAPMODE)pArgs;
605 pstInstPri->fpVE_SetCaptureMode(pSetCaptureMode->bEnable);
606 u32Ret = UTOPIA_STATUS_SUCCESS;
607 break;
608 }
609
610 case E_MDRV_CMD_TVE_GetDstInfo:
611 {
612 PTVE_GETDSTINFO pGetDstInfo = (PTVE_GETDSTINFO)pArgs;
613 if(TRUE == pstInstPri->fpVE_GetDstInfo(pGetDstInfo->pDstInfo,pGetDstInfo->u32SizeofDstInfo))
614 {
615 pGetDstInfo->eRet = E_TVENCODER_OK;
616 }
617 else
618 {
619 pGetDstInfo->eRet = E_TVENCODER_FAIL;
620 }
621 u32Ret = UTOPIA_STATUS_SUCCESS;
622 break;
623 }
624
625 case E_MDRV_CMD_TVE_Set_TestPattern:
626 {
627 PTVE_SETTESTPATTERN pSetTestPattern = (PTVE_SETTESTPATTERN)pArgs;
628 pstInstPri->fpVE_Set_TestPattern(pSetTestPattern->bEnable);
629 u32Ret = UTOPIA_STATUS_SUCCESS;
630 break;
631 }
632
633 case E_MDRV_CMD_TVE_DisableRegWrite:
634 {
635 PTVE_DISABLEREGWRITE pDiableRegWrite = (PTVE_DISABLEREGWRITE)pArgs;
636 if(E_VE_OK == pstInstPri->fpVE_DisableRegWrite(pDiableRegWrite->bFlag))
637 {
638 pDiableRegWrite->eRet = E_TVENCODER_OK;
639 }
640 else
641 {
642 pDiableRegWrite->eRet = E_TVENCODER_FAIL;
643 }
644 u32Ret = UTOPIA_STATUS_SUCCESS;
645 break;
646 }
647
648 case E_MDRV_CMD_TVE_AdjustPositionBase:
649 {
650 PTVE_ADJPOSITIONBASE pAdjPositionBase = (PTVE_ADJPOSITIONBASE)pArgs;
651 if(E_VE_OK == pstInstPri->fpVE_AdjustPositionBase(pAdjPositionBase->s32WAddrAdjustment,
652 pAdjPositionBase->s32RAddrAdjustment))
653 {
654 pAdjPositionBase->eRet = E_TVENCODER_OK;
655 }
656 else
657 {
658 pAdjPositionBase->eRet = E_TVENCODER_FAIL;
659 }
660 u32Ret = UTOPIA_STATUS_SUCCESS;
661 break;
662 }
663
664 case E_MDRV_CMD_TVE_Set_Customer_Scaling:
665 {
666 PTVE_SETCUSSCALING pSetCusScaling = (PTVE_SETCUSSCALING)pArgs;
667 if(E_VE_OK == pstInstPri->fpVE_Set_Customer_Scaling(pSetCusScaling->pstVECusScalingInfo))
668 {
669 pSetCusScaling->eRet = E_TVENCODER_OK;
670 }
671 else
672 {
673 pSetCusScaling->eRet = E_TVENCODER_FAIL;
674 }
675 u32Ret = UTOPIA_STATUS_SUCCESS;
676 break;
677 }
678
679 case E_MDRV_CMD_TVE_InitVECapture:
680 {
681 P_TVE_INITCAPTURE pInitCapture = (P_TVE_INITCAPTURE)pArgs;
682 pstInstPri->fpVE_InitVECapture(pInitCapture->pVECapture);
683 u32Ret = UTOPIA_STATUS_SUCCESS;
684 break;
685 }
686
687 case E_MDRV_CMD_TVE_EnaVECapture:
688 {
689 PTVE_ENACAPTURE pEnableCapture =(PTVE_ENACAPTURE)pArgs;
690 if(TRUE == pstInstPri->fpVE_EnaVECapture(pEnableCapture->pstVECapState))
691 {
692 pEnableCapture->eRet = E_TVENCODER_OK;
693 }
694 else
695 {
696 pEnableCapture->eRet = E_TVENCODER_FAIL;
697 }
698 u32Ret = UTOPIA_STATUS_SUCCESS;
699 break;
700 }
701
702 case E_MDRV_CMD_TVE_Adjust_FrameStart:
703 {
704 PTVE_ADJFRAMESTART pAdjustFrameStart = (PTVE_ADJFRAMESTART)pArgs;
705 if(E_VE_OK == pstInstPri->fpVE_Adjust_FrameStart(pAdjustFrameStart->stSrcWin,
706 pAdjustFrameStart->pixel_offset))
707 {
708 pAdjustFrameStart->eRet = E_TVENCODER_OK;
709 }
710 else
711 {
712 pAdjustFrameStart->eRet = E_TVENCODER_FAIL;
713 }
714 u32Ret = UTOPIA_STATUS_SUCCESS;
715 break;
716 }
717
718 case E_MDRV_CMD_TVE_SetPowerState:
719 {
720 PTVE_SETPOWERSTATE pSetPowerState = (PTVE_SETPOWERSTATE)pArgs;
721
722 if(TRUE == pstInstPri->fpTVE_SetPowerState(pSetPowerState->ePowerState))
723 {
724 pSetPowerState->eRet = E_TVENCODER_OK;
725 }
726 else
727 {
728 pSetPowerState->eRet = E_TVENCODER_FAIL;
729 }
730 u32Ret = UTOPIA_STATUS_SUCCESS;
731 break;
732 }
733
734 case E_MDRV_CMD_TVE_Set_CusTable:
735 {
736 PTVE_SETCUSTABLE pSetCusTable = (PTVE_SETCUSTABLE)pArgs;
737
738 if(TRUE == pstInstPri->fpVE_SetCusTable(pSetCusTable->VideoSystem,pSetCusTable->pTbl))
739 {
740 pSetCusTable->eRet = E_TVENCODER_OK;
741 }
742 else
743 {
744 pSetCusTable->eRet = E_TVENCODER_FAIL;
745 }
746 u32Ret = UTOPIA_STATUS_SUCCESS;
747 break;
748 }
749
750 case E_MDRV_CMD_TVE_EnableCusTable:
751 {
752 PTVE_ENABLECUSTABLE pSetEnableTable = (PTVE_ENABLECUSTABLE)pArgs;
753 pstInstPri->fpVE_EnableCusTable(pSetEnableTable->bEnable);
754 u32Ret = UTOPIA_STATUS_SUCCESS;
755 break;
756 }
757
758 case E_MDRV_CMD_TVE_Set_FrameColor:
759 {
760 PTVE_SETFRAMECOLOR pSetFrameColor = (PTVE_SETFRAMECOLOR)pArgs;
761 pSetFrameColor->eRet = pstInstPri->fpVE_SetFrameColor(pSetFrameColor->u32aRGB);
762 u32Ret = UTOPIA_STATUS_SUCCESS;
763 break;
764 }
765
766 case E_MDRV_CMD_TVE_Set_OSDLayer:
767 {
768 PTVE_SETOSDLAYER pSetOSDLayer = (PTVE_SETOSDLAYER)pArgs;
769 pSetOSDLayer->eRet = pstInstPri->fpVE_Set_OSDLayer(pSetOSDLayer->eVideoOSDLayer);
770 u32Ret = UTOPIA_STATUS_SUCCESS;
771 break;
772 }
773
774 case E_MDRV_CMD_TVE_Get_OSDLayer:
775 {
776 PTVE_GETOSDLAYER pGetOSDLayer = (PTVE_GETOSDLAYER)pArgs;
777 pGetOSDLayer->eRet = pstInstPri->fpVE_Get_OSDLayer();
778 u32Ret = UTOPIA_STATUS_SUCCESS;
779 break;
780 }
781
782 case E_MDRV_CMD_TVE_Set_VideoAlpha:
783 {
784 PTVE_SETVIDEOALPHA pSetVideoAlpha = (PTVE_SETVIDEOALPHA)pArgs;
785 pSetVideoAlpha->eRet = pstInstPri->fpVE_Set_VideoAlpha(pSetVideoAlpha->u8Val);
786 u32Ret = UTOPIA_STATUS_SUCCESS;
787 break;
788 }
789
790 case E_MDRV_CMD_TVE_Get_VideoAlpha:
791 {
792 PTVE_GETVIDEOALPHA pGetVideoAlpha = (PTVE_GETVIDEOALPHA)pArgs;
793 pGetVideoAlpha->eRet = pstInstPri->fpVE_Get_VideoAlpha(pGetVideoAlpha->pu8Val);
794 u32Ret = UTOPIA_STATUS_SUCCESS;
795 break;
796 }
797
798 case E_MDRV_CMD_TVE_DCS_SetType:
799 {
800 PTVE_DCSSETTYPE pDCSSetType= (PTVE_DCSSETTYPE)pArgs;
801
802 if(TRUE == pstInstPri->fpVE_DCS_SetType(pDCSSetType->bEnable,
803 pDCSSetType->eType))
804 {
805 pDCSSetType->eRet = E_TVENCODER_OK;
806 }
807 else
808 {
809 pDCSSetType->eRet = E_TVENCODER_FAIL;
810 }
811 u32Ret = UTOPIA_STATUS_SUCCESS;
812 break;
813 }
814 case E_MDRV_CMD_TVE_DCS_SetActivationKey:
815 {
816 PTVE_DCSSETACTIVATIONKEY pDCSSetActivationKey= (PTVE_DCSSETACTIVATIONKEY)pArgs;
817
818 if(TRUE == pstInstPri->fpVE_DCS_SetActivationKey(pDCSSetActivationKey->pu8ActivationKeyTbl,
819 pDCSSetActivationKey->u8ActivationKeyTblSize))
820 {
821 pDCSSetActivationKey->eRet = E_TVENCODER_OK;
822 }
823 else
824 {
825 pDCSSetActivationKey->eRet = E_TVENCODER_FAIL;
826 }
827 u32Ret = UTOPIA_STATUS_SUCCESS;
828 break;
829 }
830 case E_MDRV_CMD_TVE_ReloadSetting:
831 {
832 PTVE_RELOADSETTING pReloadSetting = (PTVE_RELOADSETTING)pArgs;
833 if(TRUE == pstInstPri->fpVE_ReloadSetting())
834 {
835 pReloadSetting->eRet = E_TVENCODER_OK;
836 }
837 else
838 {
839 pReloadSetting->eRet = E_TVENCODER_FAIL;
840 }
841 u32Ret = UTOPIA_STATUS_SUCCESS;
842 break;
843 }
844 case E_MDRV_CMD_TVE_GetConfig:
845 {
846 PTVE_GETCONFIG pGetConfig = (PTVE_GETCONFIG)pArgs;
847
848 UtopiaResourceRelease(pstRes);
849
850 if(TRUE == pstInstPri->fpVE_GetConfig(pInstance, pGetConfig->pMIUAddress))
851 {
852 pGetConfig->eRet = E_TVENCODER_OK;
853 }
854 else
855 {
856 pGetConfig->eRet = E_TVENCODER_FAIL;
857 }
858
859 u32Ret = UTOPIA_STATUS_SUCCESS;
860 return u32Ret;
861 break;
862 }
863
864 }
865 UtopiaResourceRelease(pstRes);
866 return u32Ret; // FIXME: error code
867 }
868
TVENCODERClose(void * pInstance)869 MS_U32 TVENCODERClose(void* pInstance)
870 {
871 //UTOPIA_INSTANT* pInstant = *pInstantTmp;
872 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__));
873 UtopiaInstanceDelete(pInstance);
874 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("leave %s %d\n",__FUNCTION__,__LINE__));
875 //utopia_free(pInstant);
876 return UTOPIA_STATUS_SUCCESS;
877 }
878