1 #include "MsTypes.h"
2 #ifndef MSOS_TYPE_LINUX_KERNEL
3 #include <stdio.h>
4 #include <string.h>
5 #endif
6 #include "utopia.h"
7 #include "utopia_dapi.h"
8 #include "MsCommon.h"
9 #include "mhal_xc_chip_config.h"
10 #include "apiXC_DWIN_v2.h"
11 #include "XC_DWIN_private.h"
12 #include "mvideo_context.h"
13 #include "drv_sc_DIP_scaling.h"
14 #include "xc_hwreg_utility2.h"
15
16 #if (defined ANDROID) && (defined TV_OS)
17 #include <cutils/log.h>
18 #define printf LOGD
19 #ifndef LOGD // android 4.1 rename LOGx to ALOGx
20 #define LOGD ALOGD
21 #endif
22 #endif
23
24 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
DIPMdbIoctl(MS_U32 u32Cmd,const void * const pArgs)25 MS_U32 DIPMdbIoctl(MS_U32 u32Cmd, const void* const pArgs)
26 {
27 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
28 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
29 switch(u32Cmd)
30 {
31 case MDBCMD_CMDLINE:
32 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
33 MdbPrint(paraCmdLine->u64ReqHdl,"=====Echo DIP=====\n");
34 MDrv_XC_DIP_Mdb_Cmdline(paraCmdLine->u64ReqHdl,paraCmdLine->u32CmdSize,paraCmdLine->pcCmdLine);
35 paraCmdLine->result = MDBRESULT_SUCCESS_FIN;
36 break;
37 case MDBCMD_GETINFO:
38 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
39 MdbPrint(paraGetInfo->u64ReqHdl,"=====Read all DIP Information Start=====\n");
40 MDrv_XC_DIP_Mdb_GetInfo(paraGetInfo->u64ReqHdl);
41 paraCmdLine->result = MDBRESULT_SUCCESS_FIN;
42 MdbPrint(paraGetInfo->u64ReqHdl,"=====Read all DIP Information End=====\n");
43 break;
44 default:
45 break;
46 }
47 return 0;
48 }
49 #endif
50
DIPRegisterToUtopia(FUtopiaOpen ModuleType)51 void DIPRegisterToUtopia(FUtopiaOpen ModuleType)
52 {
53 SCALER_DIP_WIN i;
54 char name[8] = "\0";
55 void* psResource = NULL;
56 // 1. deal with module
57 void* pUtopiaModule = NULL;
58 UtopiaModuleCreate(MODULE_DIP, 8, &pUtopiaModule);
59 UtopiaModuleRegister(pUtopiaModule);
60 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)DIPOpen, (FUtopiaClose)DIPClose, (FUtopiaIOctl)DIPIoctl);
61 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
62 UtopiaModuleRegisterMdbNode("dip", (FUtopiaMdbIoctl)DIPMdbIoctl);
63 #endif
64
65 // 2. deal with resource
66 for(i=DIP_WINDOW ;i<MAX_DIP_WINDOW;i++)
67 {
68 snprintf(name,sizeof(name),"DIP%d",i);
69 UtopiaModuleAddResourceStart(pUtopiaModule,i);
70 UtopiaResourceCreate(name, sizeof(DIP_RESOURCE_PRIVATE), &psResource);
71 UtopiaResourceRegister(pUtopiaModule, psResource, i);
72 UtopiaModuleAddResourceEnd(pUtopiaModule, i);
73 }
74 UtopiaModuleAddResourceStart(pUtopiaModule,MAX_DIP_WINDOW);
75 UtopiaResourceCreate("DIPR", sizeof(DIP_SHARE_RESOURCE_PRIVATE), &psResource);
76 UtopiaResourceRegister(pUtopiaModule, psResource, MAX_DIP_WINDOW);
77 UtopiaModuleAddResourceEnd(pUtopiaModule,MAX_DIP_WINDOW);
78 }
79
DIPOpen(void ** ppInstance,const void * const pAttribute)80 MS_U32 DIPOpen(void** ppInstance, const void* const pAttribute)
81 {
82 XC_INFO("\n[DIP INFO] dip open");
83 DIP_INSTANCE_PRIVATE *pDipPri = NULL;
84 UtopiaInstanceCreate(sizeof(DIP_INSTANCE_PRIVATE), ppInstance);
85 UtopiaInstanceGetPrivate(*ppInstance, (void**)&pDipPri);
86
87 pDipPri->bInit = FALSE;
88 pDipPri->u8DbgLevel = E_XC_DIP_Debug_Level_LOW;
89 pDipPri->eWindow = MAX_DIP_WINDOW;
90 pDipPri->pResource = NULL;
91 pDipPri->pShareResource = NULL;
92 return UTOPIA_STATUS_SUCCESS;
93 }
94
DIPIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)95 MS_U32 DIPIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
96 {
97 //printf("\n[DIP INFO] dip ioctl cmd = %ld\n",u32Cmd);
98 DIP_RESOURCE* pDipResource = NULL;
99 DIP_INPUT_SOURCE* pInputSource = NULL;
100 DIP_SET_WINDOW* pSetWindow = NULL;
101 DIP_SET_WIN_PROPERTY* pSetWinProperty = NULL;
102 DIP_SET_PROPERTY* pSetProperty = NULL;
103 DIP_BUF_INFO* pBufInfo = NULL;
104 DIP_INTER_STUS* pIntrStus = NULL;
105 DIP_INTER_CB* pIntrCb = NULL;
106 DIP_TRIGGER_MODE* pTrigMode = NULL;
107 DIP_SET_DIPR_PROPERTY_EX* pSetDIPRProperty_ex = NULL;
108 DIP_CMDQ_SET_ACTION* pDipCmdq = NULL;
109 DIP_CMDQ_SET_OPERATIONS* pDipCmdqOps = NULL;
110 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
111 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
112 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
113 DIP_CONFIG_PIPE* pDIP_Config_Pipe = NULL;
114
115 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
116
117 void* pModule = NULL;
118 UtopiaInstanceGetModule(pInstance, &pModule);
119 //Keep share memory point
120 if(pDipPri->pShareResource == NULL)
121 {
122 if(UtopiaResourceObtain(pModule,MAX_DIP_WINDOW, &(pDipPri->pShareResource)) != 0)
123 {
124 XC_ERR("UtopiaResourceObtainToInstant fail\n");
125 return UTOPIA_STATUS_FAIL;
126 }
127 UtopiaResourceRelease(pDipPri->pShareResource);
128 }
129 switch(u32Cmd)
130 {
131 case MDrv_CMD_DIP_INIT:
132 pDipResource = (DIP_RESOURCE*)pArgs;
133 MDrv_XC_DIP_Init(pInstance,pDipResource->eWindow);
134 break;
135 case MDrv_CMD_DIP_GET_RESOURCE:
136 pDipResource = (DIP_RESOURCE*)pArgs;
137 //XC_INFO("MDrv_CMD_DIP_GET_RESOURCE[%d] start\n",pDipResource->eWindow);
138
139 //take to use mutex lock
140 if(UtopiaResourceObtain(pModule,MAX_DIP_WINDOW, &(pDipPri->pShareResource)) != 0)
141 {
142 XC_ERR("UtopiaResourceObtainToInstant fail\n");
143 return UTOPIA_STATUS_FAIL;
144 }
145 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
146
147 //obtain check
148 if(pDipPri->pResource != NULL)
149 {
150 XC_ERR("MDrv_CMD_DIP_GET_RESOURCE[%d] have already obtained\n",pDipResource->eWindow);
151 //take to use mutex unlock
152 UtopiaResourceRelease(pDipPri->pShareResource);
153 return UTOPIA_STATUS_FAIL;
154 }
155 if(UtopiaResourceObtain(pModule, pDipResource->eWindow, &(pDipPri->pResource)) != 0)
156 {
157 XC_ERR("UtopiaResourceObtainToInstant fail\n");
158 //take to use mutex unlock
159 UtopiaResourceRelease(pDipPri->pShareResource);
160 return UTOPIA_STATUS_FAIL;
161 }
162 pDipResPri->bLock[pDipResource->eWindow] = 1;
163
164 //take to use mutex unlock
165 UtopiaResourceRelease(pDipPri->pShareResource);
166 //XC_INFO("MDrv_CMD_DIP_GET_RESOURCE[%d] end\n",pDipResource->eWindow);
167 break;
168 case MDrv_CMD_DIP_RELEASE_RESOURCE:
169 pDipResource = (DIP_RESOURCE*)pArgs;
170 //XC_INFO("MDrv_CMD_DIP_RELEASE_RESOURCE[%d] start\n",pDipResource->eWindow);
171
172 //take to use mutex lock
173 if(UtopiaResourceObtain(pModule,MAX_DIP_WINDOW, &(pDipPri->pShareResource)) != 0)
174 {
175 XC_ERR("UtopiaResourceObtainToInstant fail\n");
176 return UTOPIA_STATUS_FAIL;
177 }
178 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
179
180 //release check
181 if(pDipPri->pResource == NULL)
182 {
183 XC_ERR("MDrv_CMD_DIP_RELEASE_RESOURCE[%d] have already released\n",pDipResource->eWindow);
184 //take to use mutex unlock
185 UtopiaResourceRelease(pDipPri->pShareResource);
186 return UTOPIA_STATUS_FAIL;
187 }
188 UtopiaResourceRelease(pDipPri->pResource);
189 pDipPri->pResource = NULL;
190 pDipResPri->bLock[pDipResource->eWindow] = 0;
191
192 //take to use mutex unlock
193 UtopiaResourceRelease(pDipPri->pShareResource);
194 //XC_INFO("MDrv_CMD_DIP_RELEASE_RESOURCE[%d] end\n",pDipResource->eWindow);
195 break;
196 case MDrv_CMD_DIP_QUERY_RESOURCE:
197 pDipResource = (DIP_RESOURCE*)pArgs;
198
199 //take to use mutex lock
200 if(UtopiaResourceObtain(pModule,MAX_DIP_WINDOW, &(pDipPri->pShareResource)) != 0)
201 {
202 XC_ERR("UtopiaResourceObtainToInstant fail\n");
203 return UTOPIA_STATUS_FAIL;
204 }
205 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
206
207 if(pDipResPri->bLock[pDipResource->eWindow] == 1)
208 {
209 u32Ret = UTOPIA_STATUS_NO_RESOURCE;
210 }
211
212 //take to use mutex unlock
213 UtopiaResourceRelease(pDipPri->pShareResource);
214 break;
215
216 case MDrv_CMD_DIP_CMDQ_SETACTION:
217 pDipCmdq = (DIP_CMDQ_SET_ACTION*)pArgs;
218 MDrv_XC_DIP_CMDQ_SetAction(pInstance, pDipCmdq->eAction, pDipCmdq->eWindow);
219 break;
220 case MDrv_CMD_DIP_CMDQ_SETOPERATIONS:
221 pDipCmdqOps = (DIP_CMDQ_SET_OPERATIONS*)pArgs;
222 MDrv_XC_DIP_CMDQ_SetOperations(pInstance, pDipCmdqOps->pOps, pDipCmdqOps->bEnable, pDipCmdqOps->eWindow);
223 break;
224
225 case MDrv_CMD_DIP_SET_INPUTSOURCE:
226 pInputSource = (DIP_INPUT_SOURCE*)pArgs;
227
228 break;
229 case MDrv_CMD_DIP_SET_WINDOW:
230 pSetWindow = (DIP_SET_WINDOW*)pArgs;
231 //_XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR)
232 MDrv_XC_DIP_SetWindow(pInstance,&(pSetWindow->WinInfo), pSetWindow->u32DataLen, pSetWindow->eWindow);
233 //_XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
234 break;
235 case MDrv_CMD_DIP_SET_WINPROPERTY:
236 pSetWinProperty = (DIP_SET_WIN_PROPERTY*)pArgs;
237 MDrv_XC_DIP_SetWinProperty(pInstance,&(pSetWinProperty->WinProperty),pSetWinProperty->eWindow);
238 break;
239 case MDrv_CMD_DIP_GET_BUFINFO:
240 pBufInfo = (DIP_BUF_INFO*)pArgs;
241 pBufInfo->BufInfo = MDrv_XC_DIP_GetBufferInfo(pInstance,pBufInfo->eWindow);
242 break;
243 case MDrv_CMD_DIP_INTERRUPT:
244 pIntrStus = (DIP_INTER_STUS*)pArgs;
245 if(pIntrStus->eFlag == DIP_INTR_ENABLE)
246 MDrv_XC_DIP_EnableIntr(pInstance,pIntrStus->IntrStautus,TRUE,pIntrStus->eWindow);
247 else if(pIntrStus->eFlag == DIP_INTR_GET)
248 pIntrStus->IntrStautus = MDrv_XC_DIP_GetIntrStatus(pInstance,pIntrStus->eWindow);
249 else if(pIntrStus->eFlag == DIP_INTR_CLEAR)
250 MDrv_XC_DIP_ClearIntr(pInstance,pIntrStus->IntrStautus,pIntrStus->eWindow);
251 else
252 MDrv_XC_DIP_EnableIntr(pInstance,pIntrStus->IntrStautus,FALSE,pIntrStus->eWindow);
253 break;
254 case MDrv_CMD_DIP_INTERRUPT_CB:
255 pIntrCb = (DIP_INTER_CB*)pArgs;
256 if(pIntrCb->eFlag == DIP_INTR_ATTACH)
257 MDrv_XC_DIP_InterruptAttach(pInstance,pIntrCb->pIntCb,pIntrCb->eWindow);
258 else if(pIntrCb->eFlag == DIP_INTR_DETACH)
259 MDrv_XC_DIP_InterruptDetach(pInstance,pIntrCb->eWindow);
260 break;
261 case MDrv_CMD_DIP_TRIGGER:
262 pTrigMode = (DIP_TRIGGER_MODE*)pArgs;
263 if(pTrigMode->eTrigMode == DIP_TRIG_ON)
264 {
265 //_XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR)
266 MDrv_XC_DIP_EnableCaptureStream(pInstance,TRUE,pTrigMode->eWindow);
267 //_XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
268 }
269 else if(pTrigMode->eTrigMode == DIP_TRIG_ONESHOT)
270 MDrv_XC_DIP_CaptureOneFrame(pInstance,pTrigMode->eWindow);
271 else if(pTrigMode->eTrigMode == DIP_TRIG_ONESHOTFAST)
272 MDrv_XC_DIP_CaptureOneFrame2(pInstance,pTrigMode->eWindow);
273 else if(pTrigMode->eTrigMode == DIP_TRIG_RESET)
274 MDrv_XC_DIP_SWReset(pInstance,pTrigMode->eWindow);
275 else
276 {
277 //_XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR)
278 MDrv_XC_DIP_EnableCaptureStream(pInstance,FALSE,pTrigMode->eWindow);
279 //_XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
280 }
281 break;
282 case MDrv_CMD_DIP_SET_DIPR_PROPERTY:
283 pSetDIPRProperty_ex = (DIP_SET_DIPR_PROPERTY_EX*)pArgs;
284 if(pSetDIPRProperty_ex->enDIPRFlag==E_DIP_SET_DIPR_NORMAL)
285 {
286 MDrv_XC_DIP_SetDIPRProperty(pInstance,&(pSetDIPRProperty_ex->stDIPRProperty_ex.stDIPRProperty),pSetDIPRProperty_ex->eWindow);
287 }
288 else if(pSetDIPRProperty_ex->enDIPRFlag==E_DIP_SET_DIPR_EX)
289 {
290 MDrv_XC_DIP_SetDIPRProperty_EX(pInstance,&(pSetDIPRProperty_ex->stDIPRProperty_ex),pSetDIPRProperty_ex->eWindow);
291 }
292 break;
293 case MDrv_CMD_DIP_SET_PROPERTY:
294 pSetProperty = (DIP_SET_PROPERTY*)pArgs;
295
296 if (pSetProperty->eFlag& DIP_PRO_SCANMODE)
297 MDrv_XC_DIP_SelectSourceScanType(pInstance,(EN_XC_DWIN_SCAN_TYPE)pSetProperty->Property.eScanMode,pSetProperty->eWindow);
298 if (pSetProperty->eFlag & DIP_PRO_DATAFMT)
299 MDrv_XC_DIP_SetDataFmt(pInstance,(EN_DRV_XC_DWIN_DATA_FMT)pSetProperty->Property.eDataFmt,pSetProperty->eWindow);
300 if (pSetProperty->eFlag & DIP_PRO_R2Y)
301 MDrv_XC_DWIN_EnableR2YCSC(pInstance,pSetProperty->Property.bR2Y,pSetProperty->eWindow);
302 if (pSetProperty->eFlag & DIP_PRO_Y2R)
303 MDrv_XC_DIP_SetY2R(pInstance,pSetProperty->Property.bY2R,pSetProperty->eWindow);
304 if (pSetProperty->eFlag & DIP_PRO_SWAPUV)
305 MDrv_XC_DIP_SetUVSwap(pInstance,pSetProperty->Property.bSwapUV,pSetProperty->eWindow);
306 if (pSetProperty->eFlag & DIP_PRO_SWAPYC)
307 MDrv_XC_DIP_SetYCSwap(pInstance,pSetProperty->Property.bSwapYC,pSetProperty->eWindow);
308 if (pSetProperty->eFlag & DIP_PRO_SWAPRGB)
309 MDrv_XC_DIP_SetRGBSwap(pInstance,pSetProperty->Property.stSwapRGB.bSwap,pSetProperty->eWindow);
310 if (pSetProperty->eFlag & DIP_PRO_INTERLACE_W)
311 MDrv_XC_DIP_SetInterlaceWrite(pInstance,pSetProperty->Property.bInterlaceW,pSetProperty->eWindow);
312 if (pSetProperty->eFlag & DIP_PRO_ALPHA)
313 MDrv_XC_DIP_SetAlphaValue(pInstance,pSetProperty->Property.u8Alpha,pSetProperty->eWindow);
314 if (pSetProperty->eFlag & DIP_PRO_FRC)
315 MDrv_XC_DIP_SetFRC(pInstance,pSetProperty->Property.stFrameRateControl.bFrameRateCtrl,pSetProperty->Property.stFrameRateControl.u16In,pSetProperty->Property.stFrameRateControl.u16Out,pSetProperty->eWindow);
316 if (pSetProperty->eFlag & DIP_PRO_OP_CAPTURE)
317 MDrv_XC_DIP_SetOutputCapture(pInstance,pSetProperty->Property.stOpCapture.bOpCapture,pSetProperty->Property.stOpCapture.eOpCapture,pSetProperty->eWindow);
318 if (pSetProperty->eFlag & DIP_PRO_MIRROR)
319 MDrv_XC_DIP_SetMirror(pInstance,pSetProperty->Property.stMirror.bHMirror,pSetProperty->Property.stMirror.bVMirror,pSetProperty->eWindow);
320 if (pSetProperty->eFlag & DIP_PRO_PINPON)
321 MDrv_XC_DIP_SetPinpon(pInstance,pSetProperty->Property.stPinpon.bPinpon,pSetProperty->Property.stPinpon.u32PinponAddr,pSetProperty->eWindow);
322 if (pSetProperty->eFlag & DIP_PRO_ROTATION)
323 MDrv_XC_DIP_SetRotation(pInstance,pSetProperty->Property.stRotation.bRotation,pSetProperty->Property.stRotation.eRoDirection,pSetProperty->eWindow);
324 if (pSetProperty->eFlag & DIP_PRO_HVSP)
325 {
326 if( MDrv_XC_DIP_SetHVSP(pInstance,pSetProperty->Property.bHVSP,pSetProperty->eWindow) == FALSE)
327 return UTOPIA_STATUS_NO_RESOURCE;
328 }
329 if (pSetProperty->eFlag & DIP_PRO_TILEBLOCK)
330 {
331 if( MDrv_XC_DIP_Set420TileBlock(pInstance,pSetProperty->Property.eTileBlock,pSetProperty->eWindow) == FALSE)
332 return UTOPIA_STATUS_NOT_SUPPORTED;
333 }
334 break;
335 case MDrv_CMD_DIP_SET_DBG_LEVEL:
336 pDipPri->u8DbgLevel = *(MS_U8 *)(pArgs);
337 MDrv_XC_DIP_SetBdgLevel(*(MS_U8 *)(pArgs));
338 break;
339
340 case MDrv_CMD_DIP_CONFIG_PIPE:
341 pDIP_Config_Pipe = (DIP_CONFIG_PIPE*)pArgs;
342 MDrv_XC_DIP_ConfigPipe_U2(pInstance, pDIP_Config_Pipe->u32PipeID, pDIP_Config_Pipe->u32SecureDMA, pDIP_Config_Pipe->u32OperationMode);
343 break;
344 }
345 return u32Ret; // FIXME: error code
346 }
347
DIPClose(void * pInstance)348 MS_U32 DIPClose(void* pInstance)
349 {
350 XC_INFO("\n[DIP INFO] dip close");
351 UtopiaInstanceDelete(pInstance);
352 return UTOPIA_STATUS_SUCCESS;
353 }
354