1 //-------------------------------------------------------------------------------------------------
2 // Include Files
3 //-------------------------------------------------------------------------------------------------
4 #ifndef MSOS_TYPE_LINUX_KERNEL
5 #include <stdio.h>
6 #include <string.h>
7 #include <sys/types.h>
8 #include <signal.h>
9 #include <errno.h>
10 #else
11 #include <linux/slab.h>
12 #endif
13 #include "utopia.h"
14 #include "utopia_dapi.h"
15 #include "util_symbol.h"
16 #include "MsTypes.h"
17 #include "MsOS.h"
18 #include "MsCommon.h"
19 #include "MsVersion.h"
20 #include "apiGOP.h"
21 #include "apiGOP_priv.h"
22 #include "drvGOP.h"
23 #include "drvGFLIP.h"
24 #include "drvGOP_priv.h"
25 #include "halGOP.h"
26 #include "halCHIP.h"
27
28 enum
29 {
30 GOP_POOL_ID_GOP0=0
31 } eGOPPoolID;
32 //-------------------------------------------------------------------------------------------------
33 // Local Compiler Options
34 //-------------------------------------------------------------------------------------------------
35 #define DUMP_INFO 0
36
37 #define FPGA_TEST 0UL
38
39 //-------------------------------------------------------------------------------------------------
40 // Local Defines
41 //-------------------------------------------------------------------------------------------------
42 #ifdef MSOS_TYPE_LINUX_KERNEL
43 #define atoi(str) simple_strtoul(((str != NULL) ? str : ""), NULL, 0)
44 #endif
45
46 #define GetMaxActiveGwinFalse 4UL
47 #define GetMaxActiveGwinFalse_op 5UL
48 #define GetMaxActiveGwinFalse_opened 6UL
49 #define GWIN_SDRAM_NULL 0x30UL
50 #define msWarning(c) do {} while (0)
51 #define XC_MAIN_WINDOW 0UL
52
53
54 // Define return values of check align
55 #define CHECKALIGN_SUCCESS 1UL
56 #define CHECKALIGN_FORMAT_FAIL 2UL
57 #define CHECKALIGN_PARA_FAIL 3UL
58
59 //#define GWIN_SDRAM_PG_UNIT 0x00000010 // 16-byte page-unit for gwin_sdram
60 #define GWIN_SDRAM_PG_ALIGN(_x) ALIGN_32(_x)
61 #define IS_GWIN_SDRAM_ALIGN(_x) ((_x)== GWIN_SDRAM_PG_ALIGN(_x))
62
63 static MS_BOOL bInitFWR = FALSE;
64 static MS_BOOL bInitBkFWR[SHARED_GOP_MAX_COUNT]={[0 ... (SHARED_GOP_MAX_COUNT-1)] = FALSE};
65
66 static MS_BOOL bFirstInit = FALSE;
67
68 #ifdef INSTANT_PRIVATE
69 #define g_pGOPCtxLocal psGOPInstPri->g_pGOPCtxLocal
70 #else
71 MS_GOP_CTX_LOCAL *g_pGOPCtxLocal = NULL;
72 #endif
73 static GOP_TYPE_DEF GOPTYPE;
74
75 #ifdef MSOS_TYPE_LINUX_KERNEL
76 static MS_U8 _devGFLIPCnt =0;
77 #endif
78
79 #include "ULog.h"
80 MS_U32 u32GOPDbgLevel_mapi;
81
82 // Debug Logs, level form low(INFO) to high(FATAL, always show)
83 // Function information, ex function entry
84 #define GOP_M_INFO(x, args...) if(u32GOPDbgLevel_mapi >= E_GOP_Debug_Level_HIGH) { ULOGI("GOP mAPI", x, ##args); }
85 // Warning, illegal paramter but can be self fixed in functions
86 #define GOP_M_WARN(x, args...) if(u32GOPDbgLevel_mapi >= E_GOP_Debug_Level_HIGH) { ULOGW("GOP mAPI", x, ##args); }
87 // Need debug, illegal paramter.
88 #define GOP_M_DBUG(x, args...) if(u32GOPDbgLevel_mapi >= E_GOP_Debug_Level_MED) { ULOGD("GOP mAPI", x, ##args); }
89 // Error, function will be terminated but system not crash
90 #define GOP_M_ERR(x, args...) if(u32GOPDbgLevel_mapi >= E_GOP_Debug_Level_LOW) { ULOGE("GOP mAPI", x, ##args); }
91 // Critical, system crash. (ex. assert)
92 #define GOP_M_FATAL(x, args...) if(u32GOPDbgLevel_mapi >= E_GOP_Debug_Level_LOW) { ULOGF("GOP mAPI", x, ##args); }
93
94 #define APIGOP_RetFailPri(FailType) \
95 do {\
96 switch ((E_GOP_API_Result)FailType)\
97 {\
98 case GOP_API_FAIL:\
99 GOP_M_DBUG("\nGOP_FAIL");\
100 break;\
101 case GOP_API_NON_ALIGN_ADDRESS:\
102 GOP_M_DBUG("\nGOP_NON_ALIGN_ADDRESS");\
103 break;\
104 case GOP_API_NON_ALIGN_PITCH:\
105 GOP_M_DBUG("\nGOP_NON_ALIGN_PITCH");\
106 break;\
107 case GOP_API_DEPEND_NOAVAIL:\
108 GOP_M_DBUG("\nGOP_DEPEND_NOAVAIL");\
109 break;\
110 case GOP_API_MUTEX_OBTAIN_FAIL:\
111 GOP_M_DBUG("\nGOP_MUTEX_OBTAIN_FAIL");\
112 break;\
113 case GOP_API_MUTEX_OBTAINED:\
114 GOP_M_DBUG("\nGOP_MUTEX_OBTAINED");\
115 break;\
116 case GOP_API_INVALID_BUFF_INFO:\
117 GOP_M_DBUG("\nGOP_INVALID_BUFF_INFO");\
118 break;\
119 case GOP_API_INVALID_PARAMETERS:\
120 GOP_M_DBUG("\nGOP_INVALID_PARAMETERS");\
121 break;\
122 case GOP_API_FUN_NOT_SUPPORTED:\
123 GOP_M_DBUG("\nGOP_FUN_NOT_SUPPORTED");\
124 break;\
125 case GOP_API_ENUM_NOT_SUPPORTED:\
126 GOP_M_DBUG("\nGOP_ENUM_NOT_SUPPORTED");\
127 break;\
128 case GOP_API_CRT_GWIN_FAIL:\
129 GOP_M_DBUG("\nGOP_CRT_GWIN_FAIL");\
130 break;\
131 case GOP_API_CRT_GWIN_NOAVAIL:\
132 GOP_M_DBUG("\nGOP_CRT_GWIN_NOAVAIL");\
133 break;\
134 case GOP_API_SUCCESS:\
135 break;\
136 default:\
137 break;\
138 }\
139 }while(0)
140
141
142 #define APIGOP_CHECK_INIT() \
143 { \
144 if(g_pGOPCtxLocal ==NULL) \
145 { \
146 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nshould call MApi_GOP_Init first\n")); \
147 return GOP_API_FAIL;\
148 } \
149 }
150
151 //-------------------------------------------------------------------------------------------------
152 // Local Structures
153 //-------------------------------------------------------------------------------------------------
154 /// GOP HVMirror GWIN position option define
155 typedef enum
156 {
157 E_Set_HPos,
158 E_Set_VPos,
159 E_Set_X,
160 E_Set_Y,
161 }HMirror_Opt;
162
163 static MS_U32 (*fpSetFBFmt)(MS_U16 ,MS_PHY , MS_U16 ) = NULL;
164 MS_BOOL (*_fpXCIsInterlace)(void) = NULL;
165 MS_U16 (*_fpXCGetCapHStart)(void) = NULL;
166 static void (*fpXCReduceBWForOSD)(MS_U8 , MS_BOOL) = NULL;
167 static void (*fpEventNotify)(MS_U32 , void* ) = NULL;
168 static MS_BOOL (*fpXCSetDwinInfo)(MS_U16 cmd,MS_U32 *arg,MS_U16 size) = NULL;
169
170
171
_GOP_IsFbIdValid(void * pInstance,MS_U32 u32FbId)172 static MS_BOOL _GOP_IsFbIdValid(void* pInstance,MS_U32 u32FbId)
173 {
174 if (u32FbId > DRV_MAX_GWIN_FB_SUPPORT)
175 return FALSE;
176 else
177 return TRUE;
178 }
179
180
_GetWinFB(void * pInstance,MS_U32 FbId)181 static GOP_WinFB_INFO* _GetWinFB(void* pInstance,MS_U32 FbId)
182 {
183 #ifdef INSTANT_PRIVATE
184 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
185 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
186 #endif
187
188 if (!_GOP_IsFbIdValid(pInstance,FbId))
189 {
190 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)FbId);
191 return NULL;
192 }
193 #if WINFB_INSHARED
194 //memcpy(pWinFB,&(g_pGOPCtxLocal->pGOPCtxShared->winFB[FbId]),sizeof(GOP_WinFB_INFO));
195 return &(g_pGOPCtxLocal->pGOPCtxShared->winFB[FbId]);
196 #else
197 //memcpy(pWinFB,g_pGOPCtxLocal->winFB[FbId],sizeof(GOP_WinFB_INFO));
198 return &g_pGOPCtxLocal->winFB[FbId];
199 #endif
200
201 }
202
_GOP_MAP_FBID_AFBCCmd(void * pInstance,MS_U32 u32fbId,EN_DRV_GOP_AFBC_CNTL * AFBC_Cmd,MS_BOOL * AFBC_Enable)203 static void _GOP_MAP_FBID_AFBCCmd(void* pInstance,MS_U32 u32fbId,EN_DRV_GOP_AFBC_CNTL* AFBC_Cmd, MS_BOOL* AFBC_Enable)
204 {
205 #ifdef INSTANT_PRIVATE
206 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
207 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
208 #endif
209 GOP_WinFB_INFO* pwinFB;
210
211 pwinFB = _GetWinFB(pInstance,u32fbId);
212 if(pwinFB == NULL)
213 {
214 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
215 return;
216 }
217
218 switch(pwinFB->FBString)
219 {
220 case E_DRV_GOP_FB_AFBC_SPLT_YUVTRNSFER_ARGB8888:
221 *AFBC_Enable = TRUE;
222 *AFBC_Cmd = E_DRV_GOP_AFBC_SPILT|E_DRV_GOP_AFBC_YUV_TRANSFER|E_DRV_GOP_AFBC_ARGB8888;
223 break;
224 case E_DRV_GOP_FB_AFBC_NONSPLT_YUVTRS_ARGB8888:
225 *AFBC_Enable = TRUE;
226 *AFBC_Cmd = E_DRV_GOP_AFBC_YUV_TRANSFER|E_DRV_GOP_AFBC_ARGB8888;
227 break;
228 case E_DRV_GOP_FB_AFBC_SPLT_NONYUVTRS_ARGB8888:
229 *AFBC_Enable = TRUE;
230 *AFBC_Cmd = E_DRV_GOP_AFBC_SPILT|E_DRV_GOP_AFBC_ARGB8888;
231 break;
232 case E_DRV_GOP_FB_AFBC_NONSPLT_NONYUVTRS_ARGB8888:
233 *AFBC_Enable = TRUE;
234 *AFBC_Cmd = E_DRV_GOP_AFBC_ARGB8888;
235 break;
236 default:
237 *AFBC_Enable = FALSE;
238 *AFBC_Cmd = E_DRV_GOP_FB_NULL;
239 break;
240 }
241 }
242
243 //-------------------------------------------------------------------------------------------------
244 // Debug Functions
245 //-------------------------------------------------------------------------------------------------
246
_GOP_GetMaxGOPNum(void * pInstance)247 static MS_U8 _GOP_GetMaxGOPNum(void* pInstance)
248 {
249 #ifdef INSTANT_PRIVATE
250 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
251 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
252 #endif
253
254 return MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal);
255 }
256
257
_GOP_IsGopNumValid(void * pInstance,MS_U32 gop)258 static MS_BOOL _GOP_IsGopNumValid(void* pInstance,MS_U32 gop)
259 {
260 if (gop>=_GOP_GetMaxGOPNum(pInstance))
261 return FALSE;
262 else
263 return TRUE;
264 }
_GOP_IsGwinIdValid(void * pInstance,MS_U8 u8GwinID)265 static MS_BOOL _GOP_IsGwinIdValid(void* pInstance,MS_U8 u8GwinID)
266 {
267 #ifdef INSTANT_PRIVATE
268 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
269 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
270 #endif
271
272 if(u8GwinID>=SHARED_GWIN_MAX_COUNT)
273 return FALSE;
274 else if (u8GwinID>=g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum)
275 return FALSE;
276 else
277 return TRUE;
278 }
279
280
_GOP_GetGop0WinInfo(void * pInstance,MS_U8 u8win,GOP_GwinInfo * pinfo)281 static void _GOP_GetGop0WinInfo(void* pInstance,MS_U8 u8win, GOP_GwinInfo* pinfo)
282 {
283 DRV_GOP_GWIN_INFO sGetInfo;
284 DRV_GOPDstType Gop0Dst =E_DRV_GOP_DST_INVALID;
285 GOP_WinFB_INFO* pwinFB;
286
287 #ifdef INSTANT_PRIVATE
288 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
289 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
290 #endif
291
292 if (!_GOP_IsGwinIdValid(pInstance,u8win))
293 {
294 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
295 return;
296 }
297
298
299 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8win].u32CurFBId);
300
301 if(pwinFB == NULL)
302 {
303 GOP_M_ERR("[%s][%d]GetWinFB Fail : gwinMap[%d].u32CurFBId=%td\n",__FUNCTION__,__LINE__,u8win,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8win].u32CurFBId);
304 return;
305 }
306
307 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, 0, &Gop0Dst);
308 if (Gop0Dst ==E_DRV_GOP_DST_INVALID)
309 {
310 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n Get GOP destination fail!\n"));
311 return;
312 }
313 memset(&sGetInfo, 0, sizeof(DRV_GOP_GWIN_INFO));
314 MDrv_GOP_GWIN_GetGwinInfo(g_pGOPCtxLocal, u8win, &sGetInfo);
315 pinfo->u16RBlkHPixSize = sGetInfo.u16RBlkHPixSize;
316 pinfo->u16RBlkVPixSize = sGetInfo.u16RBlkVPixSize;
317 //2009.03.14 Fix the TTX,CC position error
318 sGetInfo.u16WinX = pwinFB->s_x;
319 sGetInfo.u16WinY = pwinFB->s_y;
320
321 pinfo->clrType = (EN_GOP_COLOR_TYPE)sGetInfo.clrType;
322
323 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_VMirror_VPos, u8win))
324 {
325 pinfo->u16DispVPixelStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVStr;
326 pinfo->u16DispVPixelEnd= g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVEnd;
327
328 if (g_pGOPCtxLocal->Gwin_V_Dup)
329 pinfo->u16DispVPixelEnd = (pinfo->u16DispVPixelEnd + pinfo->u16DispVPixelStart) >> 1; // pix
330 }
331 else
332 {
333 pinfo->u16DispVPixelStart = sGetInfo.u16DispVPixelStart; // pix
334 if (g_pGOPCtxLocal->Gwin_V_Dup)
335 {
336 MS_BOOL bInterlace = FALSE;
337
338 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
339 if( ((Gop0Dst == E_DRV_GOP_DST_IP0) || (Gop0Dst == E_DRV_GOP_DST_IP1)) && bInterlace)
340 pinfo->u16DispVPixelEnd = (((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart) >> 1;
341 else if((Gop0Dst == E_DRV_GOP_DST_VE) || (Gop0Dst == E_DRV_GOP_DST_OP1))
342 pinfo->u16DispVPixelEnd = (((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart) >> 1;
343 else
344 pinfo->u16DispVPixelEnd = (sGetInfo.u16DispVPixelEnd + pinfo->u16DispVPixelStart) >> 1; // pix
345 }
346 else
347 {
348 MS_BOOL bInterlace = FALSE;
349
350 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
351 if( ((Gop0Dst == E_DRV_GOP_DST_IP0) || (Gop0Dst == E_DRV_GOP_DST_IP1)) && bInterlace)
352 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
353 else if((Gop0Dst == E_DRV_GOP_DST_VE) || (Gop0Dst == E_DRV_GOP_DST_OP1))
354 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
355 else if (((Gop0Dst == E_DRV_GOP_DST_OP0) || (Gop0Dst == E_DRV_GOP_DST_FRC) || (Gop0Dst == E_DRV_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,0))
356 {
357 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
358 }
359 else
360 pinfo->u16DispVPixelEnd = sGetInfo.u16DispVPixelEnd; // pix
361 }
362 }
363
364 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_HMirror_HPos, u8win))
365 {
366 pinfo->u16DispHPixelStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHStr;
367 pinfo->u16DispHPixelEnd= g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHEnd;
368
369 if (g_pGOPCtxLocal->Gwin_H_Dup)
370 pinfo->u16DispHPixelEnd = (pinfo->u16DispHPixelEnd + pinfo->u16DispHPixelStart) >> 1; // pix
371 }
372 else
373 {
374 pinfo->u16DispHPixelStart = sGetInfo.u16DispHPixelStart; // pix
375 pinfo->u16DispHPixelEnd = sGetInfo.u16DispHPixelEnd; // pix
376
377 if (g_pGOPCtxLocal->Gwin_H_Dup)
378 pinfo->u16DispHPixelEnd = (pinfo->u16DispHPixelEnd + pinfo->u16DispHPixelStart) >> 1; // pix
379 }
380
381 pinfo->u16RBlkHRblkSize = sGetInfo.u16RBlkHRblkSize; //3
382 pinfo->u32DRAMRBlkStart = sGetInfo.u64DRAMRBlkStart;
383 pinfo->u16WinY = sGetInfo.u16WinY; //Original Y pix of FB
384 pinfo->u16WinX= sGetInfo.u16WinX; //Original X pix of FB
385 }
386
_GOP_GetGop1WinInfo(void * pInstance,MS_U8 u8win,GOP_GwinInfo * pinfo)387 static void _GOP_GetGop1WinInfo(void* pInstance,MS_U8 u8win, GOP_GwinInfo* pinfo)
388 {
389 DRV_GOP_GWIN_INFO sGetInfo;
390 DRV_GOPDstType Gop1Dst =E_DRV_GOP_DST_INVALID;
391
392 #ifdef INSTANT_PRIVATE
393 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
394 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
395 #endif
396
397 if (!_GOP_IsGwinIdValid(pInstance,u8win))
398 {
399 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
400 return;
401 }
402
403
404 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, 1, &Gop1Dst);
405 if (Gop1Dst ==E_DRV_GOP_DST_INVALID)
406 {
407 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n Get GOP destination fail!\n"));
408 return;
409 }
410
411 memset(&sGetInfo, 0, sizeof(DRV_GOP_GWIN_INFO));
412 MDrv_GOP_GWIN_GetGwinInfo(g_pGOPCtxLocal, u8win, &sGetInfo);
413 pinfo->u16RBlkHPixSize = sGetInfo.u16RBlkHPixSize;
414 pinfo->u16RBlkVPixSize = sGetInfo.u16RBlkVPixSize;
415 pinfo->clrType = (EN_GOP_COLOR_TYPE)sGetInfo.clrType;
416
417 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_VMirror_VPos, u8win))
418 {
419 pinfo->u16DispVPixelStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVStr;
420 pinfo->u16DispVPixelEnd = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVEnd;
421
422 if (g_pGOPCtxLocal->Gwin_V_Dup)
423 pinfo->u16DispVPixelEnd = (pinfo->u16DispVPixelEnd + pinfo->u16DispVPixelStart) >> 1; // pix
424 }
425 else
426 {
427 pinfo->u16DispVPixelStart = sGetInfo.u16DispVPixelStart; // pix
428
429 if (g_pGOPCtxLocal->Gwin_V_Dup)
430 {
431 MS_BOOL bInterlace = FALSE;
432
433 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
434 if( ((Gop1Dst == E_DRV_GOP_DST_IP0) || (Gop1Dst == E_DRV_GOP_DST_IP1)) && bInterlace)
435 pinfo->u16DispVPixelEnd = (((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart) >> 1;
436 else if((Gop1Dst == E_DRV_GOP_DST_VE) || (Gop1Dst == E_DRV_GOP_DST_OP1))
437 pinfo->u16DispVPixelEnd = (((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart) >> 1;
438 else
439 pinfo->u16DispVPixelEnd = (sGetInfo.u16DispVPixelEnd + pinfo->u16DispVPixelStart) >> 1; // pix
440 }
441 else
442 {
443 MS_BOOL bInterlace = FALSE;
444
445 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
446 if( ((Gop1Dst == E_DRV_GOP_DST_IP0) || (Gop1Dst == E_DRV_GOP_DST_IP1)) && bInterlace)
447 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
448 else if((Gop1Dst == E_DRV_GOP_DST_VE) || (Gop1Dst == E_DRV_GOP_DST_OP1))
449 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
450 else if (((Gop1Dst == E_DRV_GOP_DST_OP0) || (Gop1Dst == E_DRV_GOP_DST_FRC) || (Gop1Dst == E_DRV_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,1))
451 {
452 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
453 }
454 else
455 pinfo->u16DispVPixelEnd = sGetInfo.u16DispVPixelEnd; // pix
456 }
457 }
458
459 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_HMirror_HPos, u8win))
460 {
461 pinfo->u16DispHPixelStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHStr;
462 pinfo->u16DispHPixelEnd = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHEnd;
463
464 if (g_pGOPCtxLocal->Gwin_H_Dup)
465 pinfo->u16DispHPixelEnd = (pinfo->u16DispHPixelEnd + pinfo->u16DispHPixelStart) >> 1; // pix
466 }
467 else
468 {
469 pinfo->u16DispHPixelStart = sGetInfo.u16DispHPixelStart; // pix
470
471 if (g_pGOPCtxLocal->Gwin_H_Dup)
472 pinfo->u16DispHPixelEnd = (sGetInfo.u16DispHPixelEnd + pinfo->u16DispHPixelStart) >> 1; // pix
473 else
474 pinfo->u16DispHPixelEnd = sGetInfo.u16DispHPixelEnd; // pix
475 }
476
477 pinfo->u16RBlkHRblkSize = sGetInfo.u16RBlkHRblkSize;
478 pinfo->u32DRAMRBlkStart = sGetInfo.u64DRAMRBlkStart;
479
480 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr, u8win) ||
481 HAS_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, u8win))
482 {
483 pinfo->u32DRAMRBlkStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u64NonMirrorFBAdr;
484 }
485 }
486
_GOP_GetGop23WinInfo(void * pInstance,MS_U8 u8win,GOP_GwinInfo * pinfo)487 static void _GOP_GetGop23WinInfo(void* pInstance,MS_U8 u8win, GOP_GwinInfo* pinfo)
488 {
489 DRV_GOP_GWIN_INFO sGetInfo;
490 DRV_GOPDstType Gop23Dst =E_DRV_GOP_DST_INVALID;
491
492 #ifdef INSTANT_PRIVATE
493 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
494 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
495 #endif
496
497 if (!_GOP_IsGwinIdValid(pInstance,u8win))
498 {
499 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
500 return;
501 }
502
503
504 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8win), &Gop23Dst);
505 if (Gop23Dst ==E_DRV_GOP_DST_INVALID)
506 {
507 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n Get GOP destination fail!\n"));
508 return;
509 }
510
511 memset(&sGetInfo, 0, sizeof(DRV_GOP_GWIN_INFO));
512 MDrv_GOP_GWIN_GetGwinInfo(g_pGOPCtxLocal, u8win, &sGetInfo);
513 pinfo->u16RBlkHPixSize = sGetInfo.u16RBlkHPixSize;
514 pinfo->u16RBlkVPixSize = sGetInfo.u16RBlkVPixSize;
515 pinfo->clrType = (EN_GOP_COLOR_TYPE)sGetInfo.clrType;
516
517 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_VMirror_VPos, u8win))
518 {
519 pinfo->u16DispVPixelStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVStr;
520 pinfo->u16DispVPixelEnd = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVEnd;
521
522 if (g_pGOPCtxLocal->Gwin_V_Dup)
523 pinfo->u16DispVPixelEnd = (pinfo->u16DispVPixelEnd + pinfo->u16DispVPixelStart) >> 1; // pix
524 }
525 else
526 {
527 pinfo->u16DispVPixelStart = sGetInfo.u16DispVPixelStart; // pix
528
529 if (g_pGOPCtxLocal->Gwin_V_Dup)
530 {
531 MS_BOOL bInterlace = FALSE;
532
533 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
534 if( ((Gop23Dst == E_DRV_GOP_DST_IP0) || (Gop23Dst == E_DRV_GOP_DST_IP1)) && bInterlace)
535 pinfo->u16DispVPixelEnd = (((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart) >> 1;
536 else if((Gop23Dst == E_DRV_GOP_DST_VE) || (Gop23Dst == E_DRV_GOP_DST_OP1))
537 pinfo->u16DispVPixelEnd = (((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart) >> 1;
538 else
539 pinfo->u16DispVPixelEnd = (sGetInfo.u16DispVPixelEnd + pinfo->u16DispVPixelStart) >> 1; // pix
540 }
541 else
542 {
543 MS_BOOL bInterlace = FALSE;
544
545 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
546 if( ((Gop23Dst == E_DRV_GOP_DST_IP0) || (Gop23Dst == E_DRV_GOP_DST_IP1)) && bInterlace)
547 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
548 else if((Gop23Dst == E_DRV_GOP_DST_VE) || (Gop23Dst == E_DRV_GOP_DST_OP1))
549 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
550 else if (((Gop23Dst == E_DRV_GOP_DST_OP0) || (Gop23Dst == E_DRV_GOP_DST_FRC) || (Gop23Dst == E_DRV_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal, MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8win)))
551 {
552 pinfo->u16DispVPixelEnd = ((sGetInfo.u16DispVPixelEnd - pinfo->u16DispVPixelStart) << 1) + pinfo->u16DispVPixelStart;
553 }
554 else
555 pinfo->u16DispVPixelEnd = sGetInfo.u16DispVPixelEnd; // pix
556 }
557 }
558
559 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_HMirror_HPos, u8win))
560 {
561 pinfo->u16DispHPixelStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHStr;
562 pinfo->u16DispHPixelEnd = g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHEnd;
563
564 if (g_pGOPCtxLocal->Gwin_H_Dup)
565 pinfo->u16DispHPixelEnd = (pinfo->u16DispHPixelEnd + pinfo->u16DispHPixelStart) >> 1; // pix
566 }
567 else
568 {
569 pinfo->u16DispHPixelStart = sGetInfo.u16DispHPixelStart; // pix
570
571 if (g_pGOPCtxLocal->Gwin_H_Dup)
572 pinfo->u16DispHPixelEnd = (sGetInfo.u16DispHPixelEnd + pinfo->u16DispHPixelStart) >> 1; // pix
573 else
574 pinfo->u16DispHPixelEnd = sGetInfo.u16DispHPixelEnd; // pix
575 }
576
577 pinfo->u16RBlkHRblkSize = sGetInfo.u16RBlkHRblkSize;
578 pinfo->u32DRAMRBlkStart = sGetInfo.u64DRAMRBlkStart;
579
580 if (HAS_BIT(g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr, u8win) ||
581 HAS_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, u8win))
582 {
583 pinfo->u32DRAMRBlkStart = g_pGOPCtxLocal->sMirrorInfo[u8win].u64NonMirrorFBAdr;
584 }
585 }
586
587
588
589
_GOP_SelGwinId2(void * pInstance,MS_U32 u32GOP,MS_U32 u8GwinIdx)590 MS_U8 _GOP_SelGwinId2(void* pInstance,MS_U32 u32GOP, MS_U32 u8GwinIdx)
591 {
592 MS_U8 tmp;
593
594 #ifdef INSTANT_PRIVATE
595 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
596 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
597 #endif
598
599 if (!_GOP_IsGopNumValid(pInstance,u32GOP))
600 {
601 GOP_M_ERR("[%s][%d]GOP %td is out of range\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32GOP);
602 return GWIN_NO_AVAILABLE;
603 }
604 tmp = MDrv_GOP_SelGwinIdByGOP(g_pGOPCtxLocal, u32GOP, u8GwinIdx);
605
606 return tmp;
607
608 }
609
_GOP_MAP_MUX_Enum(void * pInstance,EN_Gop_MuxSel GOPMux,Gop_MuxSel * pGOPMux)610 static E_GOP_API_Result _GOP_MAP_MUX_Enum(void* pInstance,EN_Gop_MuxSel GOPMux, Gop_MuxSel *pGOPMux)
611 {
612 E_GOP_API_Result ret = GOP_API_FAIL;
613
614 switch (GOPMux)
615 {
616 case EN_GOP_MUX0:
617 *pGOPMux = E_GOP_MUX0;
618 ret = GOP_API_SUCCESS;
619 break;
620 case EN_GOP_MUX1:
621 *pGOPMux = E_GOP_MUX1;
622 ret = GOP_API_SUCCESS;
623 break;
624 case EN_GOP_MUX2:
625 *pGOPMux = E_GOP_MUX2;
626 ret = GOP_API_SUCCESS;
627 break;
628 case EN_GOP_MUX3:
629 *pGOPMux = E_GOP_MUX3;
630 ret = GOP_API_SUCCESS;
631 break;
632 case EN_GOP_MUX4:
633 *pGOPMux = E_GOP_MUX4;
634 ret = GOP_API_SUCCESS;
635 break;
636 case EN_GOP_IP0_MUX:
637 *pGOPMux = E_GOP_IP0_MUX;
638 ret = GOP_API_SUCCESS;
639 break;
640 case EN_GOP_IP1_MUX:
641 *pGOPMux = E_GOP_IP1_MUX;
642 ret = GOP_API_SUCCESS;
643 break;
644 case EN_GOP_VOP0_MUX:
645 *pGOPMux = E_GOP_VOP0_MUX;
646 ret = GOP_API_SUCCESS;
647 break;
648 case EN_GOP_VOP1_MUX:
649 *pGOPMux = E_GOP_VOP1_MUX;
650 ret = GOP_API_SUCCESS;
651 break;
652 case EN_GOP_FRC_MUX0:
653 *pGOPMux = E_GOP_FRC_MUX0;
654 ret = GOP_API_SUCCESS;
655 break;
656 case EN_GOP_FRC_MUX1:
657 *pGOPMux = E_GOP_FRC_MUX1;
658 ret = GOP_API_SUCCESS;
659 break;
660 case EN_GOP_FRC_MUX2:
661 *pGOPMux = E_GOP_FRC_MUX2;
662 ret = GOP_API_SUCCESS;
663 break;
664 case EN_GOP_FRC_MUX3:
665 *pGOPMux = E_GOP_FRC_MUX3;
666 ret = GOP_API_SUCCESS;
667 break;
668 case EN_GOP_BYPASS_MUX0:
669 *pGOPMux = E_GOP_BYPASS_MUX0;
670 ret = GOP_API_SUCCESS;
671 break;
672 case EN_GOP_IP0_SUB_MUX:
673 *pGOPMux = E_GOP_IP0_SUB_MUX;
674 ret = GOP_API_SUCCESS;
675 break;
676 case EN_GOP_VOP0_SUB_MUX:
677 *pGOPMux = E_GOP_VOP0_SUB_MUX;
678 ret = GOP_API_SUCCESS;
679 break;
680 case EN_GOP_OP1_MUX:
681 *pGOPMux = E_GOP_OP1_MUX;
682 ret = GOP_API_SUCCESS;
683 break;
684 case EN_GOP_DIP_MUX:
685 *pGOPMux = E_GOP_DIP_MUX;
686 ret = GOP_API_SUCCESS;
687 break;
688 case EN_GOP_GS_MUX:
689 *pGOPMux = E_GOP_GS_MUX;
690 ret = GOP_API_SUCCESS;
691 break;
692 default:
693 *pGOPMux = E_GOP_MUX_INVAILD;
694 GOP_M_ERR("\n MAP GOP Mux error!! \n");
695 ret = GOP_API_FAIL;
696 break;
697 }
698 return ret;
699 }
_GOP_Map_APIDst2DRV_Enum(void * pInstance,EN_GOP_DST_TYPE GopDst,DRV_GOPDstType * pGopDst)700 static MS_U32 _GOP_Map_APIDst2DRV_Enum(void* pInstance,EN_GOP_DST_TYPE GopDst, DRV_GOPDstType *pGopDst)
701 {
702 MS_U32 ret = GOP_API_FAIL;
703
704 switch (GopDst)
705 {
706 case E_GOP_DST_IP0:
707 *pGopDst = E_DRV_GOP_DST_IP0;
708 ret = (MS_U32)GOP_API_SUCCESS;
709 break;
710 case E_GOP_DST_MIXER2VE:
711 *pGopDst = E_DRV_GOP_DST_MIXER2VE;
712 ret = (MS_U32)GOP_API_SUCCESS;
713 break;
714 case E_GOP_DST_OP0:
715 *pGopDst = E_DRV_GOP_DST_OP0;
716 ret = (MS_U32)GOP_API_SUCCESS;
717 break;
718 case E_GOP_DST_VOP:
719 *pGopDst = E_DRV_GOP_DST_VOP;
720 ret = (MS_U32)GOP_API_SUCCESS;
721 break;
722 case E_GOP_DST_IP1:
723 *pGopDst = E_DRV_GOP_DST_IP1;
724 ret = (MS_U32)GOP_API_SUCCESS;
725 break;
726 case E_GOP_DST_IP_MAIN:
727 *pGopDst = E_DRV_GOP_DST_IP0; //For compatible temporaily
728 GOP_M_ERR("\n %s, E_GOP_DST_IP_MAIN is going to be removed, please choose E_GOP_DST_IP0!! \n", __FUNCTION__);
729 ret = (MS_U32)GOP_API_SUCCESS;
730 break;
731 case E_GOP_DST_IP_SUB: //For compatible temporaily
732 *pGopDst = E_DRV_GOP_DST_IP0_SUB;
733 ret = (MS_U32)GOP_API_SUCCESS;
734 break;
735 case E_GOP_DST_MIXER2OP:
736 *pGopDst = E_DRV_GOP_DST_MIXER2OP;
737 ret = (MS_U32)GOP_API_SUCCESS;
738 break;
739 case E_GOP_DST_VOP_SUB:
740 *pGopDst = E_DRV_GOP_DST_VOP_SUB;
741 ret = (MS_U32)GOP_API_SUCCESS;
742 break;
743 case E_GOP_DST_FRC:
744 *pGopDst = E_DRV_GOP_DST_FRC;
745 ret = (MS_U32)GOP_API_SUCCESS;
746 break;
747 case E_GOP_DST_VE:
748 *pGopDst = E_DRV_GOP_DST_VE;
749 ret = (MS_U32)GOP_API_SUCCESS;
750 break;
751 case E_GOP_DST_BYPASS:
752 *pGopDst = E_DRV_GOP_DST_BYPASS;
753 ret = (MS_U32)GOP_API_SUCCESS;
754 break;
755 case E_GOP_DST_OP1:
756 *pGopDst = E_DRV_GOP_DST_OP1;
757 ret = (MS_U32)GOP_API_SUCCESS;
758 break;
759 case E_GOP_DST_MIXER2OP1:
760 *pGopDst = E_DRV_GOP_DST_MIXER2OP1;
761 ret = (MS_U32)GOP_API_SUCCESS;
762 break;
763 case E_GOP_DST_DIP:
764 *pGopDst = E_DRV_GOP_DST_DIP;
765 ret = (MS_U32)GOP_API_SUCCESS;
766 break;
767 case E_GOP_DST_GOPScaling:
768 *pGopDst = E_DRV_GOP_DST_GOPScaling;
769 ret = (MS_U32)GOP_API_SUCCESS;
770 break;
771 case E_GOP_DST_OP_DUAL_RATE:
772 *pGopDst = E_DRV_GOP_DST_OP_DUAL_RATE;
773 ret = (MS_U32)GOP_API_SUCCESS;
774 break;
775 default:
776 *pGopDst = E_DRV_GOP_DST_INVALID;
777 GOP_M_ERR("\n MAP GOP Dst plane error!! \n");
778 ret = (MS_U32)GOP_API_FAIL;
779 break;
780 }
781 return ret;
782 }
783
_GOP_Map_DRVDst2API_Enum_(void * pInstance,EN_GOP_DST_TYPE * pGopDst,DRV_GOPDstType GopDst)784 static MS_U32 _GOP_Map_DRVDst2API_Enum_(void* pInstance,EN_GOP_DST_TYPE *pGopDst, DRV_GOPDstType GopDst)
785 {
786 MS_U32 ret = 0;
787
788 switch (GopDst)
789 {
790 case E_DRV_GOP_DST_IP0:
791 *pGopDst = E_GOP_DST_IP0;
792 ret = (MS_U32)GOP_API_SUCCESS;
793 break;
794 case E_DRV_GOP_DST_MIXER2VE:
795 *pGopDst = E_GOP_DST_MIXER2VE;
796 ret = (MS_U32)GOP_API_SUCCESS;
797 break;
798 case E_DRV_GOP_DST_OP0:
799 *pGopDst = E_GOP_DST_OP0;
800 ret = (MS_U32)GOP_API_SUCCESS;
801 break;
802 case E_DRV_GOP_DST_VOP:
803 *pGopDst = E_GOP_DST_VOP;
804 ret = (MS_U32)GOP_API_SUCCESS;
805 break;
806 case E_DRV_GOP_DST_IP1:
807 *pGopDst = E_GOP_DST_IP1;
808 ret = (MS_U32)GOP_API_SUCCESS;
809 break;
810 case E_DRV_GOP_DST_IP0_SUB: //For compatible temporaily
811 *pGopDst = E_GOP_DST_IP_SUB;
812 ret = (MS_U32)GOP_API_SUCCESS;
813 break;
814 case E_DRV_GOP_DST_MIXER2OP:
815 *pGopDst = E_GOP_DST_MIXER2OP;
816 ret = (MS_U32)GOP_API_SUCCESS;
817 break;
818 case E_DRV_GOP_DST_VOP_SUB:
819 *pGopDst = E_GOP_DST_VOP_SUB;
820 ret = (MS_U32)GOP_API_SUCCESS;
821 break;
822 case E_DRV_GOP_DST_FRC:
823 *pGopDst = E_GOP_DST_FRC;
824 ret = (MS_U32)GOP_API_SUCCESS;
825 break;
826 case E_DRV_GOP_DST_VE:
827 *pGopDst = E_GOP_DST_VE;
828 ret = (MS_U32)GOP_API_SUCCESS;
829 break;
830 case E_DRV_GOP_DST_BYPASS:
831 *pGopDst = E_GOP_DST_BYPASS;
832 ret = (MS_U32)GOP_API_SUCCESS;
833 break;
834 case E_DRV_GOP_DST_OP1:
835 *pGopDst = E_GOP_DST_OP1;
836 ret = (MS_U32)GOP_API_SUCCESS;
837 break;
838 case E_DRV_GOP_DST_MIXER2OP1:
839 *pGopDst = E_GOP_DST_MIXER2OP1;
840 ret = (MS_U32)GOP_API_SUCCESS;
841 break;
842 case E_DRV_GOP_DST_DIP:
843 *pGopDst = E_GOP_DST_DIP;
844 ret = (MS_U32)GOP_API_SUCCESS;
845 break;
846 case E_DRV_GOP_DST_GOPScaling:
847 *pGopDst = E_GOP_DST_GOPScaling;
848 ret = (MS_U32)GOP_API_SUCCESS;
849 break;
850 case E_DRV_GOP_DST_OP_DUAL_RATE :
851 *pGopDst = E_GOP_DST_OP_DUAL_RATE;
852 ret = (MS_U32)GOP_API_SUCCESS;
853 break;
854 default:
855 *pGopDst = (EN_GOP_DST_TYPE)0xff;
856 GOP_M_ERR("\n MAP GOP Dst plane error!! \n");
857 ret = (MS_U32)GOP_API_FAIL;
858 break;
859 }
860 return ret;
861 }
862
_GOP_CalcPitch(void * pInstance,MS_U8 fbFmt,MS_U16 width)863 static MS_U32 _GOP_CalcPitch(void* pInstance,MS_U8 fbFmt, MS_U16 width)
864 {
865 MS_U16 pitch=0;
866
867 switch ( fbFmt )
868 {
869 case E_MS_FMT_I1 :
870 pitch = (width) >> 3;
871 break;
872 case E_MS_FMT_I2 :
873 pitch = (width<<1) >> 3;
874 break;
875 case E_MS_FMT_I4 :
876 pitch = (width<<2) >> 3;
877 break;
878 case E_MS_FMT_I8 :
879 pitch = width;
880 break;
881 case E_MS_FMT_RGB565 :
882 case E_MS_FMT_BGR565 :
883 case E_MS_FMT_ARGB1555 :
884 case E_MS_FMT_ABGR1555 :
885 case E_MS_FMT_BGRA5551 :
886 case E_MS_FMT_RGBA5551 :
887 case E_MS_FMT_ARGB4444 :
888 case E_MS_FMT_RGBA4444 :
889 case E_MS_FMT_ABGR4444 :
890 case E_MS_FMT_BGRA4444 :
891 case E_MS_FMT_1ABFgBg12355:
892 case E_MS_FMT_FaBaFgBg2266:
893 case E_MS_FMT_YUV422:
894 case E_MS_FMT_ARGB1555_DST :
895 pitch = width << 1;
896 break;
897 case E_MS_FMT_AYUV8888 :
898 case E_MS_FMT_ARGB8888 :
899 case E_MS_FMT_RGBA8888 :
900 case E_MS_FMT_BGRA8888:
901 case E_MS_FMT_ABGR8888 :
902 pitch = width << 2;
903 break;
904 default :
905 //print err
906 pitch = 0;
907 break;
908 }
909 return pitch;
910 }
911
_GOP_GetBPP(void * pInstance,EN_GOP_COLOR_TYPE fbFmt)912 static MS_U16 _GOP_GetBPP(void* pInstance,EN_GOP_COLOR_TYPE fbFmt)
913 {
914 MS_U16 bpp=0;
915
916 switch ( fbFmt )
917 {
918 case E_GOP_COLOR_RGB555_BLINK :
919 case E_GOP_COLOR_RGB565 :
920 case E_GOP_COLOR_BGR565 :
921 case E_GOP_COLOR_ARGB1555:
922 case E_GOP_COLOR_ABGR1555:
923 case E_GOP_COLOR_ARGB4444 :
924 case E_GOP_COLOR_RGBA4444 :
925 case E_GOP_COLOR_ABGR4444 :
926 case E_GOP_COLOR_BGRA4444 :
927 case E_GOP_COLOR_RGB555YUV422:
928 case E_GOP_COLOR_YUV422:
929 case E_GOP_COLOR_2266:
930 case E_GOP_COLOR_RGBA5551:
931 case E_GOP_COLOR_BGRA5551:
932 bpp = 16;
933 break;
934 case E_GOP_COLOR_AYUV8888 :
935 case E_GOP_COLOR_ARGB8888 :
936 case E_GOP_COLOR_ABGR8888 :
937 case E_GOP_COLOR_RGBA8888 :
938 case E_GOP_COLOR_BGRA8888 :
939 bpp = 32;
940 break;
941
942 case E_GOP_COLOR_I8 :
943 bpp = 8;
944 break;
945 default :
946 //print err
947 //__ASSERT(0);
948 bpp = 0xFFFF;
949 break;
950 }
951 return bpp;
952
953 }
954
_GOP_GWIN_IsGwinCreated(void * pInstance,MS_U8 gId)955 static MS_U8 _GOP_GWIN_IsGwinCreated(void* pInstance,MS_U8 gId)
956 {
957 #ifdef INSTANT_PRIVATE
958 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
959 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
960 #endif
961
962 if (!_GOP_IsGwinIdValid(pInstance,gId))
963 {
964 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,gId);
965 return FALSE;
966 }
967
968 if((gId< g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum)
969 && (GWIN_ID_INVALID ==g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId))
970 {
971 return FALSE;
972 }
973
974 GOP_M_INFO("IsGwinCreated Debug: gId=%d\n", gId);
975 return TRUE;
976 }
977
978
bCursorSupport(void * pInstance,MS_U8 u8GOP)979 static MS_BOOL bCursorSupport(void* pInstance,MS_U8 u8GOP)
980 {
981 #if CURSOR_SUPPORT
982 //if cursor GOP, dont need to do adjust
983 if(u8GOP == 3)
984 return TRUE;
985 else
986 return FALSE;
987 #else
988 return FALSE;
989 #endif
990 }
991
992 // Alignment stretch window value
_GOP_GWIN_Align_StretchWin(void * pInstance,MS_U8 u8GOP,EN_GOP_DST_TYPE eDstType,MS_U16 * pu16x,MS_U16 * pu16y,MS_U16 * pu16Width,MS_U16 * pu16height,MS_U16 BPP)993 static void _GOP_GWIN_Align_StretchWin(void* pInstance, MS_U8 u8GOP, EN_GOP_DST_TYPE eDstType, MS_U16 *pu16x, MS_U16 *pu16y, MS_U16 *pu16Width, MS_U16 *pu16height, MS_U16 BPP)
994 {
995 MS_U16 u16align_offset;
996 MS_U16 u16GOP_Unit;
997
998 #ifdef INSTANT_PRIVATE
999 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1000 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1001 #endif
1002
1003 u16GOP_Unit = MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8GOP);
1004
1005 if((eDstType == E_GOP_DST_IP0) || (eDstType == E_GOP_DST_IP1))
1006 {
1007 MS_BOOL bInterlace = FALSE;
1008
1009 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1010 if( bInterlace )
1011 {
1012 *pu16height /=2;
1013 *pu16y = *pu16y/2;
1014 }
1015 }
1016 else if(eDstType == E_GOP_DST_VE)
1017 {
1018 *pu16height /=2;
1019 *pu16y = *pu16y/2 + g_pGOPCtxLocal->pGopChipProperty->GOP_VE_V_Offset;
1020 }
1021 else if(eDstType == E_GOP_DST_OP1)
1022 {
1023 *pu16height /=2;
1024 *pu16y = *pu16y/2;
1025 }
1026 else if (((eDstType == E_GOP_DST_OP0) || (eDstType == E_GOP_DST_FRC) || (eDstType == E_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,u8GOP))
1027 {
1028 *pu16height /=2;
1029 *pu16y = *pu16y/2;
1030 }
1031
1032
1033 if(u16GOP_Unit ==1)
1034 {
1035 *pu16Width =((*pu16Width + 1)>> 1) << 1; //do 2 pixel align
1036 }
1037 else
1038 {
1039 u16align_offset = (u16GOP_Unit * 8 /BPP -1);
1040 *pu16Width = (*pu16Width + u16align_offset)&(~u16align_offset) ; //do 8-byte align
1041 }
1042 }
1043
1044 //Adjust stretch window for GOP 3D
_GOP_GWIN_Adjust_3DStretchWin(void * pInstance,MS_U8 u8Gop,MS_U16 * pu16x,MS_U16 * pu16y,MS_U16 * pu16Width,MS_U16 * pu16Height)1045 static void _GOP_GWIN_Adjust_3DStretchWin(void* pInstance,MS_U8 u8Gop, MS_U16 *pu16x, MS_U16 *pu16y, MS_U16 *pu16Width, MS_U16 *pu16Height)
1046 {
1047 #ifdef INSTANT_PRIVATE
1048 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1049 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1050 #endif
1051
1052 if(g_pGOPCtxLocal->pGopChipProperty->enGOP3DType == E_DRV_3D_DUP_HALF)
1053 {
1054 if((g_pGOPCtxLocal->pGOPCtxShared->GOP_StereoMode[u8Gop] == E_DRV_GOP_3D_LINE_ALTERNATIVE) ||
1055 (g_pGOPCtxLocal->pGOPCtxShared->GOP_StereoMode[u8Gop] == E_DRV_GOP_3D_TOP_BOTTOM)
1056 )
1057 {
1058 *pu16Height = *pu16Height <<1;
1059 //Line by line, do not need middle
1060 if(g_pGOPCtxLocal->pGOPCtxShared->GOP_StereoMode[u8Gop] == E_DRV_GOP_3D_TOP_BOTTOM)
1061 {
1062 *pu16Height +=g_pGOPCtxLocal->u16GOPGWinMiddle[u8Gop]; //Stretch win includes middle
1063 }
1064 }
1065 else if(g_pGOPCtxLocal->pGOPCtxShared->GOP_StereoMode[u8Gop] == E_DRV_GOP_3D_LINE_FRAMEPACKING)
1066 {
1067 //Frame packing, no middle, always full screen
1068 //Adjust Gap only
1069 *pu16Height = (*pu16Height << 1) + g_pGOPCtxLocal->GOP_FramePacking_Gap;
1070 }
1071 else if(g_pGOPCtxLocal->pGOPCtxShared->GOP_StereoMode[u8Gop] == E_DRV_GOP_3D_SIDE_BY_SYDE)
1072 {
1073 *pu16Width = *pu16Width <<1;
1074 *pu16Width +=g_pGOPCtxLocal->u16GOPGWinMiddle[u8Gop]; //Stretch win includes middle
1075 }
1076 }
1077 }
1078
_GOP_GWIN_SetHVMirrorWinPos(void * pInstance,MS_U8 u8GwinID,HMirror_Opt opt,GOP_GwinInfo * pGWINInfo)1079 static void _GOP_GWIN_SetHVMirrorWinPos(void* pInstance,MS_U8 u8GwinID, HMirror_Opt opt, GOP_GwinInfo* pGWINInfo)
1080 {
1081 MS_U16 u16GWINWidth=0, u16GWINHeight=0;
1082 MS_S16 s16MirrorHStr=-1, s16MirrorVStr=-1;
1083 MS_U8 u8Gop=INVALID_GOP_NUM;
1084
1085 #ifdef INSTANT_PRIVATE
1086 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1087 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1088 #endif
1089
1090 if (!_GOP_IsGwinIdValid(pInstance,u8GwinID))
1091 {
1092 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8GwinID);
1093 return;
1094 }
1095 u8Gop = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8GwinID);
1096 u16GWINWidth = pGWINInfo->u16DispHPixelEnd - pGWINInfo->u16DispHPixelStart;
1097 u16GWINHeight = pGWINInfo->u16DispVPixelEnd - pGWINInfo->u16DispVPixelStart;
1098
1099 switch (opt)
1100 {
1101 case E_Set_HPos:
1102 {
1103 pGWINInfo->u16DispHPixelEnd = g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchWidth[u8Gop] - pGWINInfo->u16DispHPixelStart;
1104 s16MirrorHStr = pGWINInfo->u16DispHPixelEnd - u16GWINWidth;
1105 if (s16MirrorHStr<0)
1106 {
1107 pGWINInfo->u16DispHPixelStart = 0;
1108 pGWINInfo->u16DispHPixelEnd = u16GWINWidth;
1109 }
1110 else
1111 {
1112 pGWINInfo->u16DispHPixelStart = s16MirrorHStr;
1113 }
1114 SET_BIT(g_pGOPCtxLocal->u16GOP_HMirror_HPos, u8GwinID);
1115 break;
1116 }
1117 case E_Set_VPos:
1118 {
1119 pGWINInfo->u16DispVPixelEnd = g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchHeight[u8Gop] - pGWINInfo->u16DispVPixelStart;
1120 s16MirrorVStr = pGWINInfo->u16DispVPixelEnd - u16GWINHeight;
1121 if (s16MirrorVStr<0)
1122 {
1123 pGWINInfo->u16DispVPixelStart = 0;
1124 pGWINInfo->u16DispVPixelEnd = u16GWINHeight;
1125 }
1126 else
1127 {
1128 pGWINInfo->u16DispVPixelStart = s16MirrorVStr;
1129 }
1130 SET_BIT(g_pGOPCtxLocal->u16GOP_VMirror_VPos, u8GwinID);
1131 break;
1132 }
1133 case E_Set_X:
1134 {
1135 if(u8Gop == GOPTYPE.GOP0)
1136 {
1137 #if ENABLE_GOP0_RBLK_MIRROR
1138 MS_U16 bpp=MDrv_GOP_GetBPP(g_pGOPCtxLocal, (DRV_GOPColorType)pGWINInfo->clrType);
1139 MS_U16 u16HPixelSize;
1140 if((bpp != 0) && (bpp != 0xFFFF))
1141 {
1142 u16HPixelSize = pGWINInfo->u16RBlkHRblkSize / (bpp>>3);
1143 }
1144 else
1145 {
1146 u16HPixelSize = pGWINInfo->u16RBlkHPixSize;
1147 }
1148 if((u16HPixelSize != 0))
1149 {
1150 pGWINInfo->u16WinX = u16HPixelSize - ((pGWINInfo->u16WinX + pGWINInfo->u16DispHPixelEnd- pGWINInfo->u16DispHPixelStart) % u16HPixelSize);
1151 pGWINInfo->u16WinX %= u16HPixelSize;
1152 }
1153 else
1154 #endif //ENABLE_GOP0_RBLK_MIRROR
1155 {
1156 pGWINInfo->u16WinX = 0 ;
1157 }
1158 }
1159 break;
1160 }
1161 case E_Set_Y:
1162 {
1163 if(u8Gop == GOPTYPE.GOP0)
1164 {
1165 #if ENABLE_GOP0_RBLK_MIRROR
1166 if(pGWINInfo->u16RBlkVPixSize != 0)
1167 {
1168 pGWINInfo->u16WinY = (pGWINInfo->u16WinY + (pGWINInfo->u16DispVPixelEnd-pGWINInfo->u16DispVPixelStart-1)) % pGWINInfo->u16RBlkVPixSize;
1169 }
1170 else
1171 #endif//ENABLE_GOP0_RBLK_MIRROR
1172 {
1173 pGWINInfo->u16WinY = (pGWINInfo->u16DispVPixelEnd-pGWINInfo->u16DispVPixelStart-1);
1174 }
1175 }
1176 break;
1177 }
1178 default:
1179 {
1180 //ASSERT(0);
1181 break;
1182 }
1183 }
1184 }
1185
1186
_GOP_GWIN_IsGwinExistInClient(void * pInstance,MS_U8 gId)1187 static MS_U8 _GOP_GWIN_IsGwinExistInClient(void* pInstance,MS_U8 gId)
1188 {
1189 MS_BOOL result0, result1, result2, result3, result4;
1190 MS_U32 MaxGwinSupport;
1191
1192 GOP_WinFB_INFO* pwinFB;
1193
1194 #ifdef INSTANT_PRIVATE
1195 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1196 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1197 #endif
1198
1199 if (!_GOP_IsGwinIdValid(pInstance,gId))
1200 {
1201 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,gId);
1202 return FALSE;
1203 }
1204
1205 MaxGwinSupport = g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum;
1206
1207 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId);
1208
1209 if(pwinFB == NULL)
1210 {
1211 GOP_M_ERR("[%s][%d]GetWinFB Fail : gwinMap[%d].u32CurFBId=%td\n",__FUNCTION__,__LINE__,gId,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId);
1212 return FALSE;
1213 }
1214
1215 result0 = (MaxGwinSupport<=gId);
1216 result1 = (FALSE == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].bIsShared);
1217 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
1218 MS_U32 pid = (GETPIDTYPE)getpid();
1219 result2 = (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32GOPClientId != pid);
1220 #else
1221 result2 = (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32GOPClientId != g_pGOPCtxLocal->u32GOPClientId);
1222 #endif
1223 result3 = (DRV_MAX_GWIN_FB_SUPPORT <= g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId);
1224 result4 = (0 == pwinFB->in_use);
1225
1226 if ( result0 || (result1 && (result2 || result3 || result4) ) )
1227 {
1228 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
1229 GOP_M_INFO("result0 = %d,result1 = %d,result2 = %d,result3 = %d,result4 = %d\n",result0,result1,result2,result3,result4);
1230 GOP_M_INFO("[%s][%d]GWIN %d is not exist\n",__FUNCTION__,__LINE__,gId);
1231 #else
1232 GOP_M_INFO("IsGwinExistInClient Debug: gId =%d, \n" , gId);
1233 GOP_M_INFO("gwinMap[gId].u32GOPClientId: gId =%d, \n" , (ptrdiff_t)(g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32GOPClientId) );
1234 GOP_M_INFO("_pGOPCtxLocal->u32GOPClientId =%d, \n" , (ptrdiff_t)(g_pGOPCtxLocal->u32GOPClientId) );
1235 GOP_M_INFO("gwinMap[gId].u32CurFBId =%d, \n" , (ptrdiff_t)(g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId));
1236 GOP_M_INFO("gwinMap[gId].u32CurFBId].in_use =%d, \n" , pwinFB->in_use);
1237 #endif
1238 return FALSE;
1239 }
1240 return TRUE;
1241
1242 }
1243
1244
1245
_GOP_GWIN_IsEnableMirror(void * pInstance,DRV_GOPDstType eGopDst,MS_BOOL * pbHMirror,MS_BOOL * pbVMirror)1246 static void _GOP_GWIN_IsEnableMirror(void* pInstance,DRV_GOPDstType eGopDst, MS_BOOL *pbHMirror, MS_BOOL *pbVMirror)
1247 {
1248
1249 #ifdef INSTANT_PRIVATE
1250 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1251 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1252 #endif
1253
1254 if((pbHMirror == NULL) || (pbVMirror == NULL))
1255 {
1256 return;
1257 }
1258
1259 if( (eGopDst == E_DRV_GOP_DST_OP0)
1260 ||(eGopDst == E_DRV_GOP_DST_OP_DUAL_RATE)
1261 ||(eGopDst == E_DRV_GOP_DST_BYPASS)
1262 ||(eGopDst == E_DRV_GOP_DST_FRC)
1263 ||( ((eGopDst == E_DRV_GOP_DST_IP0) || (eGopDst == E_DRV_GOP_DST_IP0_SUB))
1264 &&(E_GOP_VIDEOTIMING_MIRROR_BYMVOP == Mdrv_GOP_GetVideoTimingMirrorType(g_pGOPCtxLocal, TRUE)))
1265 )
1266 {
1267 *pbHMirror = g_pGOPCtxLocal->pGOPCtxShared->bHMirror;
1268 *pbVMirror = g_pGOPCtxLocal->pGOPCtxShared->bVMirror;
1269 }
1270 else
1271 {
1272 #if (FPGA_TEST) //FPGA use VOP path to verify mirror.
1273 *pbHMirror = g_pGOPCtxLocal->pGOPCtxShared->bHMirror;
1274 *pbVMirror = g_pGOPCtxLocal->pGOPCtxShared->bVMirror;
1275 #else
1276 *pbHMirror = FALSE;
1277 *pbVMirror = FALSE;
1278 #endif
1279 }
1280 }
1281
_GetGOPEnum(void * pInstance)1282 static MS_BOOL _GetGOPEnum(void* pInstance)
1283 {
1284 #ifdef INSTANT_PRIVATE
1285 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1286 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1287 #endif
1288
1289 memset(&GOPTYPE, 0xff, sizeof(GOP_TYPE_DEF));
1290 return MDrv_GOP_GetGOPEnum(g_pGOPCtxLocal, &GOPTYPE);
1291 }
1292
1293
_GOP_Init_Ctx(void * pInstance,MS_BOOL * pbFirstDrvInstant)1294 static MS_BOOL _GOP_Init_Ctx(void* pInstance,MS_BOOL *pbFirstDrvInstant)
1295 {
1296 MS_BOOL bNeedInitShared =FALSE;
1297 MS_U16 u16LoopTime = 0x0;
1298
1299 #ifdef INSTANT_PRIVATE
1300 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1301 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1302 #endif
1303
1304 _GetGOPEnum(pInstance);
1305
1306 if(g_pGOPCtxLocal)
1307 {
1308 if(bFirstInit)
1309 {
1310 *pbFirstDrvInstant = TRUE;
1311 }
1312 else
1313 {
1314 *pbFirstDrvInstant = FALSE;
1315 }
1316
1317 return TRUE;
1318 }
1319 g_pGOPCtxLocal = Drv_GOP_Init_Context(pInstance,&bNeedInitShared);
1320 if(NULL == g_pGOPCtxLocal)
1321 {
1322 GOP_M_ERR("Error : g_pGOPCtxLocal = NULL\n");
1323 return FALSE;
1324 }
1325 g_pGOPCtxLocal->pGOPCtxShared->bInitShared = bNeedInitShared;
1326
1327 if(pbFirstDrvInstant)
1328 *pbFirstDrvInstant = bNeedInitShared;
1329
1330
1331 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
1332 g_pGOPCtxLocal->u32GOPClientId = (GETPIDTYPE)getpid();
1333 #else
1334 g_pGOPCtxLocal->u32GOPClientId = ++g_pGOPCtxLocal->pGOPCtxShared->u32ClientIdAllocator;
1335 if(0 == g_pGOPCtxLocal->u32GOPClientId)
1336 g_pGOPCtxLocal->u32GOPClientId = ++g_pGOPCtxLocal->pGOPCtxShared->u32ClientIdAllocator;
1337 #endif
1338
1339 g_pGOPCtxLocal->sMirrorInfo = NULL;
1340 u16LoopTime = 0;
1341 while (u16LoopTime<0xFF)
1342 {
1343 #ifdef MSOS_TYPE_LINUX_KERNEL
1344 if(g_pGOPCtxLocal->sMirrorInfo ==NULL)
1345 g_pGOPCtxLocal->sMirrorInfo = kmalloc(g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum * sizeof(GOP_GwinMirror_Info), GFP_KERNEL);
1346 #else
1347 if(g_pGOPCtxLocal->sMirrorInfo ==NULL)
1348 g_pGOPCtxLocal->sMirrorInfo = malloc(g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum * sizeof(GOP_GwinMirror_Info));
1349 #endif
1350
1351 if (g_pGOPCtxLocal->sMirrorInfo!=NULL)
1352 {
1353 break;
1354 }
1355 u16LoopTime++;
1356
1357 }
1358
1359 if (g_pGOPCtxLocal->sMirrorInfo==NULL)
1360 {
1361 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nallocate memory for gwin mirror info fail!!!"));
1362 }
1363 else
1364 {
1365 memset(g_pGOPCtxLocal->sMirrorInfo, 0, g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum * sizeof(GOP_GwinMirror_Info));
1366 }
1367
1368 memset(&g_pGOPCtxLocal->sGOPConfig, 0, sizeof(GOP_Config));
1369
1370 memset(g_pGOPCtxLocal->MS_MuxGop, 0, MAX_GOP_MUX_SUPPORT*sizeof(MS_U8));
1371 g_pGOPCtxLocal->IsChgMux= FALSE;
1372 g_pGOPCtxLocal->IsClkClosed= FALSE;
1373 g_pGOPCtxLocal->u8ChgIpMuxGop = 0xFF;
1374 #if GOP_LOCK_SUPPORT
1375 char GOP_MUTEX[] = "GOP_Mutex";
1376
1377 g_pGOPCtxLocal->s32GOPMutexCnt = 0;
1378 g_pGOPCtxLocal->s32GOPMutex = MsOS_CreateMutex(E_MSOS_FIFO, (char *)GOP_MUTEX, MSOS_PROCESS_SHARED);
1379 if (0 > g_pGOPCtxLocal->s32GOPMutex)
1380 {
1381 GOP_M_ERR("%screate gop mutex fail\n", __FUNCTION__);
1382 return FALSE;
1383 }
1384 g_pGOPCtxLocal->s32GOPLock = -1;
1385 #endif
1386
1387 #if GOP_XC_LOCK_SUPPORT
1388 char XC_MUTEX[] = "_XC_Mutex";
1389
1390 g_pGOPCtxLocal->s32GOPXC_MutexCnt = 0;
1391 g_pGOPCtxLocal->s32GOPXC_Mutex = MsOS_CreateMutex(E_MSOS_FIFO, (char *)XC_MUTEX, MSOS_PROCESS_SHARED);
1392 if (0 > g_pGOPCtxLocal->s32GOPXC_Mutex)
1393 {
1394 GOP_M_ERR("[%s][%06d] create XC mutex fail _GOPXC_Mutex=0x%x\n", __FUNCTION__, __LINE__, g_pGOPCtxLocal->s32GOPXC_Mutex);
1395 }
1396 g_pGOPCtxLocal->s32GOPXC_Lock = -1;
1397 #endif
1398 return TRUE;
1399 }
1400
1401
1402
1403
1404
_GOP_TestPattern(void * pInstance,DRV_GOP_TSTPATTERN * TstPattern)1405 static void _GOP_TestPattern(void* pInstance,DRV_GOP_TSTPATTERN *TstPattern)
1406 {
1407 #ifdef INSTANT_PRIVATE
1408 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1409 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1410 #endif
1411
1412 MDrv_GOP_TestPattern_SetHVDuplicate(g_pGOPCtxLocal, TstPattern->u8TSTClr_Hdup, TstPattern->u8TSTClr_Vdup);
1413 MDrv_GOP_TestPattern_SetStartClr(g_pGOPCtxLocal,TstPattern->u8R_stc, TstPattern->u8G_stc, TstPattern->u8B_stc);
1414
1415 MDrv_GOP_TestPattern_SetHInitColor(g_pGOPCtxLocal, TstPattern->u8HR_inc, TstPattern->u8HG_inc, TstPattern->u8HB_inc);
1416 MDrv_GOP_TestPattern_SetHIncremental_Signz(g_pGOPCtxLocal,TstPattern->u8HR_inc_signz, TstPattern->u8HG_inc_signz, TstPattern->u8HB_inc_signz);
1417 MDrv_GOP_TestPattern_SetHStep(g_pGOPCtxLocal, TstPattern->u8HR_step, TstPattern->u8HG_step, TstPattern->u8HB_step);
1418
1419 MDrv_GOP_TestPattern_SetVInitColor(g_pGOPCtxLocal, TstPattern->u8VR_inc, TstPattern->u8VG_inc, TstPattern->u8VB_inc);
1420 MDrv_GOP_TestPattern_SetVIncremental_Signz(g_pGOPCtxLocal, TstPattern->u8VR_inc_signz, TstPattern->u8VG_inc_signz, TstPattern->u8VB_inc_signz);
1421 MDrv_GOP_TestPattern_SetVStep(g_pGOPCtxLocal, TstPattern->u8VR_step, TstPattern->u8VG_step, TstPattern->u8VB_step);
1422
1423 MDrv_GOP_TestPattern(g_pGOPCtxLocal, TstPattern->bTSTClr_En, TstPattern->u8TSTClr_Alpha);
1424
1425 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal, 0x0); //only gop0 has test pattern
1426 }
1427
1428
1429
1430
1431
1432
_GOP_GWIN_SetHVMirrorDRAMAddr(void * pInstance,MS_U8 u8win,MS_BOOL bHMirror,MS_BOOL bVMirror,GOP_GwinInfo * pinfo)1433 static void _GOP_GWIN_SetHVMirrorDRAMAddr(void* pInstance,MS_U8 u8win, MS_BOOL bHMirror, MS_BOOL bVMirror, GOP_GwinInfo* pinfo)
1434 {
1435 MS_PHY u64AddrTemp=0;
1436 MS_U8 u8Gop = 0;
1437 APIGOP_ASSERT(pinfo, GOP_M_FATAL("\npinfo is Null\n"));
1438
1439 #ifdef INSTANT_PRIVATE
1440 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1441 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1442 #endif
1443
1444 u8Gop = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8win);
1445 if (!_GOP_IsGwinIdValid(pInstance,u8win))
1446 {
1447 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
1448 return;
1449 }
1450
1451 if(u8Gop != GOPTYPE.GOP0)
1452 {
1453 if(bHMirror)
1454 {
1455 if(!g_pGOPCtxLocal->pGopChipProperty->bAutoAdjustMirrorHSize)
1456 {
1457 //if Vmirror is not enable, shift HRblkSize. Otherwise, Dram start will be re-calculated at v-mirror.
1458 if(!bVMirror)
1459 {
1460 pinfo->u32DRAMRBlkStart = pinfo->u32DRAMRBlkStart + (MS_U32)pinfo->u16RBlkHRblkSize;
1461 }
1462
1463 u64AddrTemp = pinfo->u32DRAMRBlkStart + (MS_U32)pinfo->u16RBlkHRblkSize;
1464
1465 if (u64AddrTemp >= MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8Gop) )
1466 {
1467 if(MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8Gop) != 1)
1468 {
1469 pinfo->u32DRAMRBlkStart = u64AddrTemp - MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8Gop);//Back to last MIU word of the line
1470 }
1471 else
1472 {
1473 pinfo->u32DRAMRBlkStart = u64AddrTemp;
1474 }
1475 }
1476 else
1477 {
1478 pinfo->u32DRAMRBlkStart = u64AddrTemp;
1479 }
1480
1481 if(pinfo->u16RBlkHRblkSize > (pinfo->u16DispHPixelEnd*_GOP_GetBPP(pInstance,pinfo->clrType)/8)) //Pitch and width not equal
1482 {
1483 pinfo->u32DRAMRBlkStart -=(pinfo->u16RBlkHRblkSize - (pinfo->u16DispHPixelEnd*_GOP_GetBPP(pInstance,pinfo->clrType)/8));
1484 }
1485 }
1486 else
1487 {
1488 if(pinfo->u16RBlkHRblkSize > ((pinfo->u16DispHPixelEnd - pinfo->u16DispHPixelStart)*_GOP_GetBPP(pInstance,pinfo->clrType)/8)) //Pitch and width not equal
1489 {
1490 pinfo->u32DRAMRBlkStart -= (pinfo->u16RBlkHRblkSize - ((pinfo->u16DispHPixelEnd - pinfo->u16DispHPixelStart)*_GOP_GetBPP(pInstance,pinfo->clrType)/8));
1491 }
1492 }
1493 SET_BIT(g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr, u8win);
1494 }
1495 if(bVMirror)
1496 {
1497 //reg_dram_rblk_str += reg_rblk_hsize * (reg_gwin_vend - reg_gwin_vstr)
1498 if(!g_pGOPCtxLocal->pGOPCtxShared->b32TileMode[u8Gop]) //if tile mode, we should not change dram address
1499 {
1500 //Warning message
1501 if( pinfo->u16RBlkVPixSize != (pinfo->u16DispVPixelEnd-pinfo->u16DispVPixelStart))
1502 {
1503 MS_DEBUG_MSG(GOP_M_WARN("[%s][%d]Please to Check GwinInfo: u16RBlkVPixSize:0x%x not match (u16DispVPixelEnd=0x%x- u16DispVPixelStart=0x%x)\n",
1504 __FUNCTION__,__LINE__,pinfo->u16RBlkVPixSize, pinfo->u16DispVPixelEnd, pinfo->u16DispVPixelStart));
1505 }
1506
1507 if(pinfo->u16RBlkVPixSize != 0)
1508 {
1509 pinfo->u32DRAMRBlkStart += (pinfo->u16RBlkHRblkSize*(pinfo->u16RBlkVPixSize-1));
1510 }
1511 else
1512 {
1513 pinfo->u32DRAMRBlkStart += (pinfo->u16RBlkHRblkSize*(pinfo->u16DispVPixelEnd-pinfo->u16DispVPixelStart-1));
1514 }
1515 SET_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, u8win);
1516 }
1517 }
1518 }
1519 }
1520
_GOP_GWIN_SetTLBHVMirrorDRAMAddr(void * pInstance,MS_U8 u8win,MS_BOOL bHMirror,MS_BOOL bVMirror,GOP_GwinInfo * pinfo)1521 static void _GOP_GWIN_SetTLBHVMirrorDRAMAddr(void* pInstance,MS_U8 u8win, MS_BOOL bHMirror, MS_BOOL bVMirror, GOP_GwinInfo* pinfo)
1522 {
1523 MS_PHY u64AddrTemp=0;
1524 MS_U8 u8Gop = 0;
1525 APIGOP_ASSERT(pinfo, GOP_M_FATAL("\npinfo is Null\n"));
1526
1527 #ifdef INSTANT_PRIVATE
1528 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1529 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1530 #endif
1531 u8Gop = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8win);
1532 if (!_GOP_IsGwinIdValid(pInstance,u8win))
1533 {
1534 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
1535 return;
1536 }
1537
1538 if(bHMirror)
1539 {
1540 //if Vmirror is not enable, shift HRblkSize. Otherwise, Dram start will be re-calculated at v-mirror.
1541 if(!bVMirror)
1542 {
1543 pinfo->u32DRAMRBlkStart = pinfo->u32DRAMRBlkStart + (MS_U32)pinfo->u16RBlkHRblkSize;
1544 }
1545
1546 u64AddrTemp = pinfo->u32DRAMRBlkStart + (MS_U32)pinfo->u16RBlkHRblkSize;
1547
1548 if (u64AddrTemp >= MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8Gop) )
1549 {
1550 if(MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8Gop) != 1)
1551 {
1552 pinfo->u32DRAMRBlkStart = u64AddrTemp - MDrv_GOP_GetWordUnit(g_pGOPCtxLocal, u8Gop);//Back to last MIU word of the line
1553 }
1554 else
1555 {
1556 pinfo->u32DRAMRBlkStart = u64AddrTemp;
1557 }
1558 }
1559 else
1560 {
1561 pinfo->u32DRAMRBlkStart = u64AddrTemp;
1562 }
1563
1564 if(pinfo->u16RBlkHRblkSize > (pinfo->u16DispHPixelEnd*_GOP_GetBPP(pInstance,pinfo->clrType)/8)) //Pitch and width not equal
1565 {
1566 pinfo->u32DRAMRBlkStart -=(pinfo->u16RBlkHRblkSize - (pinfo->u16DispHPixelEnd*_GOP_GetBPP(pInstance,pinfo->clrType)/8));
1567 }
1568
1569
1570 SET_BIT(g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr, u8win);
1571 }
1572
1573 if(bVMirror)
1574 {
1575 //Warning message
1576 if( pinfo->u16RBlkVPixSize != (pinfo->u16DispVPixelEnd-pinfo->u16DispVPixelStart))
1577 {
1578 MS_DEBUG_MSG(GOP_M_WARN("[%s][%d]Please to Check GwinInfo: u16RBlkVPixSize:0x%x not match (u16DispVPixelEnd=0x%x- u16DispVPixelStart=0x%x)\n",
1579 __FUNCTION__,__LINE__,pinfo->u16RBlkVPixSize, pinfo->u16DispVPixelEnd, pinfo->u16DispVPixelStart));
1580 }
1581 if(pinfo->u16RBlkVPixSize != 0)
1582 {
1583 pinfo->u32DRAMRBlkStart += (pinfo->u16RBlkHRblkSize*(pinfo->u16RBlkVPixSize-1));
1584 }
1585 else
1586 {
1587 pinfo->u32DRAMRBlkStart += (pinfo->u16RBlkHRblkSize*(pinfo->u16DispVPixelEnd-pinfo->u16DispVPixelStart-1));
1588 }
1589 SET_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, u8win);
1590 }
1591 }
1592
GOP_GetWinInfo(void * pInstance,MS_U32 u32win,GOP_GwinInfo * pinfo)1593 MS_BOOL GOP_GetWinInfo(void* pInstance,MS_U32 u32win, GOP_GwinInfo* pinfo)
1594 {
1595 MS_U8 u8GOP;
1596 #ifdef INSTANT_PRIVATE
1597 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1598 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1599 #endif
1600
1601 if (!_GOP_IsGwinIdValid(pInstance, u32win))
1602 {
1603 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32win);
1604 return FALSE;
1605 }
1606 memset(pinfo, 0, sizeof(GOP_GwinInfo));
1607 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u32win);
1608
1609 if(u8GOP == GOPTYPE.GOP0)
1610 {
1611 _GOP_GetGop0WinInfo(pInstance,u32win, pinfo);
1612 }
1613 else if (u8GOP == GOPTYPE.GOP1)
1614 {
1615 _GOP_GetGop1WinInfo(pInstance,u32win, pinfo);
1616 }
1617 else
1618 {
1619 _GOP_GetGop23WinInfo(pInstance,u32win, pinfo);
1620 }
1621
1622 return TRUE;
1623 }
1624
_SetGop0WinInfo(void * pInstance,MS_U8 u8win,GOP_GwinInfo * pinfo)1625 static void _SetGop0WinInfo(void* pInstance,MS_U8 u8win, GOP_GwinInfo* pinfo)
1626 {
1627 DRV_GOPDstType Gop0Dst =E_DRV_GOP_DST_INVALID;
1628 GOP_OupputColor gopOut;
1629 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
1630 MS_BOOL bRIUHMirror = FALSE, bRIUVMirror = FALSE;
1631 MS_PHY TLBMainAddr=0;
1632 #ifdef INSTANT_PRIVATE
1633 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1634 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1635 #endif
1636 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, E_GOP0, &Gop0Dst);
1637
1638 if (Gop0Dst ==E_DRV_GOP_DST_INVALID)
1639 {
1640 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n Get GOP destination fail!\n"));
1641 return;
1642 }
1643
1644 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[E_GOP0])
1645 {
1646 if(u8win != 0)
1647 {
1648 GOP_M_DBUG("\n[%s] not support TLB mode, gwin id:%d ", __FUNCTION__, u8win);
1649 }
1650 }
1651
1652 _GOP_GWIN_IsEnableMirror(pInstance,Gop0Dst, &bHMirror, &bVMirror);
1653
1654 if(( Gop0Dst == E_DRV_GOP_DST_OP0) ||( Gop0Dst == E_DRV_GOP_DST_FRC) || ( Gop0Dst == E_DRV_GOP_DST_BYPASS) || ( Gop0Dst == E_DRV_GOP_DST_OP_DUAL_RATE))//GOP destination is OP
1655 {
1656
1657 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP0])
1658 {
1659 gopOut = DRV_GOPOUT_RGB;
1660 }
1661 else
1662 {
1663 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP0];
1664 }
1665
1666 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP0, gopOut);
1667
1668 if ((g_pGOPCtxLocal->pGopChipProperty->bOpInterlace == TRUE) && ( Gop0Dst == E_DRV_GOP_DST_OP0))
1669 {
1670 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, FALSE);
1671 }
1672 else
1673 {
1674 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, TRUE);
1675 }
1676
1677 }
1678 else if( Gop0Dst == E_DRV_GOP_DST_IP0 || Gop0Dst == E_DRV_GOP_DST_IP0_SUB || Gop0Dst == E_DRV_GOP_DST_IP1 || Gop0Dst == E_DRV_GOP_DST_VOP || Gop0Dst == E_DRV_GOP_DST_VOP_SUB)//GOP destination is IP
1679 {
1680 MS_BOOL bInterlace = FALSE;
1681
1682 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1683 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP0])
1684 {
1685 gopOut = DRV_GOPOUT_YUV;
1686 }
1687 else
1688 {
1689 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP0];
1690 }
1691
1692 if( bInterlace ) //interlace mode
1693 {
1694 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP0, gopOut);
1695 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, FALSE);
1696 }
1697 else //Progressive mode
1698 {
1699 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP0, gopOut);
1700 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, TRUE);
1701 }
1702 }
1703 else // GOP destination is VE,MVOP
1704 {
1705 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP0])
1706 {
1707 gopOut = DRV_GOPOUT_YUV;
1708 }
1709 else
1710 {
1711 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP0];
1712 }
1713
1714 #if (FPGA_TEST)
1715 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, TRUE); //progressive output in FPGA environement.
1716 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP0, DRV_GOPOUT_RGB);
1717 #else
1718 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP0, gopOut);
1719 if(( Gop0Dst == E_DRV_GOP_DST_MIXER2VE) || ( Gop0Dst == E_DRV_GOP_DST_MIXER2OP) || ( Gop0Dst == E_DRV_GOP_DST_DIP))
1720 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, TRUE);
1721 else
1722 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP0, FALSE);
1723 #endif
1724 }
1725
1726 if (g_pGOPCtxLocal->pGOPCtxShared->bHMirror || g_pGOPCtxLocal->pGOPCtxShared->bVMirror)
1727 {
1728 g_pGOPCtxLocal->sMirrorInfo[u8win].u64NonMirrorFBAdr = pinfo->u32DRAMRBlkStart;
1729 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[E_GOP0])
1730 {
1731 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,u8win, bHMirror, bVMirror, pinfo);
1732 }
1733 }
1734 MDrv_GOP_IsGOPMirrorEnable(g_pGOPCtxLocal ,E_GOP0, &bRIUHMirror , &bRIUVMirror);
1735
1736 if(bHMirror)
1737 {
1738 /*save gwin postion before h mirror setting*/
1739 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHStr = pinfo->u16DispHPixelStart;
1740 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHEnd = pinfo->u16DispHPixelEnd;
1741 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorGOP0WinX = pinfo->u16WinX;
1742
1743 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, E_GOP0, TRUE);
1744 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_HPos, pinfo);
1745 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_X, pinfo);
1746 }
1747 else
1748 {
1749 //System is mirror, but bHMirror=FALSE, so need GOP mirror off
1750 if (g_pGOPCtxLocal->pGOPCtxShared->bHMirror || (bRIUHMirror==TRUE) )
1751 {
1752 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, E_GOP0, FALSE);
1753 }
1754 }
1755 if (!(g_pGOPCtxLocal->pGOPCtxShared->bHMirror && ((Gop0Dst == E_DRV_GOP_DST_OP0)||( Gop0Dst == E_DRV_GOP_DST_FRC) ||(Gop0Dst == E_DRV_GOP_DST_BYPASS))))
1756 {
1757 if (g_pGOPCtxLocal->Gwin_H_Dup)
1758 pinfo->u16DispHPixelEnd = (pinfo->u16DispHPixelEnd<< 1) - pinfo->u16DispHPixelStart;
1759 }
1760
1761 if(bVMirror)
1762 {
1763 /*save gwin postion before V mirror setting*/
1764 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVStr = pinfo->u16DispVPixelStart;
1765 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVEnd = pinfo->u16DispVPixelEnd;
1766 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorGOP0WinY = pinfo->u16WinY;
1767
1768 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, E_GOP0, TRUE);
1769 //SET_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, u8win);
1770 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_VPos, pinfo);
1771 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_Y, pinfo);
1772 }
1773 else
1774 {
1775 if(g_pGOPCtxLocal->pGOPCtxShared->bVMirror || (bRIUVMirror==TRUE) )//System is mirror, but bHMirror=FALSE, so need GOP mirror off
1776 {
1777 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, E_GOP0, FALSE);
1778 }
1779 }
1780
1781 //if (!(g_pGOPCtxLocal->pGOPCtxShared->bVMirror))
1782 {
1783 if (g_pGOPCtxLocal->Gwin_V_Dup)
1784 {
1785 MS_BOOL bInterlace = FALSE;
1786
1787 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1788 if( ((Gop0Dst == E_DRV_GOP_DST_IP0) || (Gop0Dst == E_DRV_GOP_DST_IP1) || (Gop0Dst == E_DRV_GOP_DST_IP0_SUB) || (Gop0Dst == E_DRV_GOP_DST_VOP) || (Gop0Dst == E_DRV_GOP_DST_VOP_SUB)) && bInterlace )
1789 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (((pinfo->u16DispVPixelEnd<<1) - pinfo->u16DispVPixelStart) / 2);
1790 else if((Gop0Dst == E_DRV_GOP_DST_VE) || (Gop0Dst == E_DRV_GOP_DST_OP1))
1791 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (((pinfo->u16DispVPixelEnd<<1) - pinfo->u16DispVPixelStart) / 2);
1792 else
1793 pinfo->u16DispVPixelEnd = (pinfo->u16DispVPixelEnd << 1) - pinfo->u16DispVPixelStart;
1794 }
1795 else
1796 {
1797 MS_BOOL bInterlace = FALSE;
1798
1799 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1800 if( ((Gop0Dst == E_DRV_GOP_DST_IP0) || (Gop0Dst == E_DRV_GOP_DST_IP1) || (Gop0Dst == E_DRV_GOP_DST_IP0_SUB) || (Gop0Dst == E_DRV_GOP_DST_VOP) || (Gop0Dst == E_DRV_GOP_DST_VOP_SUB)) && bInterlace )
1801 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
1802 else if((Gop0Dst == E_DRV_GOP_DST_VE) || (Gop0Dst == E_DRV_GOP_DST_OP1))
1803 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
1804 else if (((Gop0Dst == E_DRV_GOP_DST_OP0) || (Gop0Dst == E_DRV_GOP_DST_FRC) || (Gop0Dst == E_DRV_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,0))
1805 {
1806 pinfo->u16DispVPixelStart = pinfo->u16DispVPixelStart/2;
1807 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelEnd/2;;
1808 }
1809 }
1810 }
1811
1812 MDrv_GOP_GWIN_SetWinFmt(g_pGOPCtxLocal, u8win, (DRV_GOPColorType)pinfo->clrType);
1813 //MDrv_GOP_GWIN_UpdateRegOnce(g_pGOPCtxLocal, FALSE);
1814 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[E_GOP0])
1815 {
1816 TLBMainAddr = (pinfo->u32DRAMRBlkStart/PAGE_SIZE)*TLB_PER_ENTRY_SIZE + g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[E_GOP0];
1817 MDrv_GOP_SetTLBAddr(g_pGOPCtxLocal,E_GOP0,TLBMainAddr,g_pGOPCtxLocal->pGOPCtxShared->bHMirror,g_pGOPCtxLocal->pGOPCtxShared->bVMirror,(DRV_GOP_GWIN_INFO*)pinfo);
1818 pinfo->u32DRAMRBlkStart= g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[E_GOP0] % (PAGE_SIZE*PER_MIU_TLB_ENTRY_COUNT);
1819 MDrv_GOP_GWIN_SetGwinInfo(g_pGOPCtxLocal, u8win, (DRV_GOP_GWIN_INFO*)pinfo);
1820 }
1821 else
1822 {
1823 MDrv_GOP_GWIN_SetGwinInfo(g_pGOPCtxLocal, u8win, (DRV_GOP_GWIN_INFO*)pinfo);
1824 }
1825 GOP_M_INFO("GWIN_SetWin(%d): [adr(B), RBsz, offset] = [%td, %d, %d]\n", \
1826 u8win,\
1827 (ptrdiff_t)pinfo->u32DRAMRBlkStart,\
1828 pinfo->u16RBlkHPixSize * pinfo->u16RBlkVPixSize / (64/_GOP_GetBPP(pInstance,pinfo->clrType)),\
1829 (pinfo->u16WinY * pinfo->u16RBlkHPixSize + pinfo->u16WinX)/(64/_GOP_GetBPP(pInstance,pinfo->clrType)) );
1830 GOP_M_INFO("\t[Vst, Vend, Hst, Hend, GwinHsz] = [%d, %d, %d, %d, %d]\n",\
1831 pinfo->u16DispVPixelStart, \
1832 pinfo->u16DispVPixelEnd, \
1833 pinfo->u16DispHPixelStart/(64/_GOP_GetBPP(pInstance,pinfo->clrType)), \
1834 pinfo->u16DispHPixelEnd/(64/_GOP_GetBPP(pInstance,pinfo->clrType)),\
1835 pinfo->u16RBlkHPixSize/(64/_GOP_GetBPP(pInstance,pinfo->clrType)) );
1836 }
1837
_SetGop1WinInfo(void * pInstance,MS_U8 u8win,GOP_GwinInfo * pinfo)1838 static void _SetGop1WinInfo(void* pInstance,MS_U8 u8win, GOP_GwinInfo* pinfo)
1839 {
1840 DRV_GOPDstType Gop1Dst =E_DRV_GOP_DST_INVALID;
1841 GOP_OupputColor gopOut;
1842 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
1843 MS_BOOL bRIUHMirror = FALSE, bRIUVMirror = FALSE;
1844 #ifdef INSTANT_PRIVATE
1845 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
1846 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
1847 #endif
1848 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, E_GOP1, &Gop1Dst);
1849 if (Gop1Dst ==E_DRV_GOP_DST_INVALID)
1850 {
1851 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n Get GOP destination fail!\n"));
1852 return;
1853 }
1854 _GOP_GWIN_IsEnableMirror(pInstance,Gop1Dst, &bHMirror, &bVMirror);
1855 if(( Gop1Dst == E_DRV_GOP_DST_OP0 )||( Gop1Dst == E_DRV_GOP_DST_FRC) || ( Gop1Dst == E_DRV_GOP_DST_BYPASS) || (Gop1Dst == E_DRV_GOP_DST_OP_DUAL_RATE)) //GOP destination is OP
1856 {
1857 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP1])
1858 {
1859 gopOut = DRV_GOPOUT_RGB;
1860 }
1861 else
1862 {
1863 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP1];
1864 }
1865
1866 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP1, gopOut);
1867
1868 if ((g_pGOPCtxLocal->pGopChipProperty->bOpInterlace == TRUE) && ( Gop1Dst == E_DRV_GOP_DST_OP0))
1869 {
1870 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, FALSE);
1871 }
1872 else
1873 {
1874 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, TRUE);
1875 }
1876 }
1877 else if(Gop1Dst == E_DRV_GOP_DST_IP0 || Gop1Dst == E_DRV_GOP_DST_IP0_SUB || Gop1Dst == E_DRV_GOP_DST_IP1 || Gop1Dst == E_DRV_GOP_DST_VOP || Gop1Dst == E_DRV_GOP_DST_VOP_SUB)// GOP destination is IP
1878 {
1879 MS_BOOL bInterlace = FALSE;
1880
1881 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1882 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP1])
1883 {
1884 gopOut = DRV_GOPOUT_YUV;
1885 }
1886 else
1887 {
1888 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP1];
1889 }
1890
1891 if( bInterlace ) //interlace mode
1892 {
1893 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP1, gopOut);
1894 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, FALSE);
1895 }
1896 else //Progressive mode
1897 {
1898 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP1, gopOut);
1899 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, TRUE);
1900 }
1901 }
1902 else // GOP destination is VE,MVOP
1903 {
1904 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[E_GOP1])
1905 {
1906 gopOut = DRV_GOPOUT_YUV;
1907 }
1908 else
1909 {
1910 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[1];
1911 }
1912
1913 #if(FPGA_TEST)
1914 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, TRUE); //progressive output in FPGA environement.
1915 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP1, DRV_GOPOUT_RGB);
1916 #else
1917 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,E_GOP1, DRV_GOPOUT_YUV);
1918 if(( Gop1Dst == E_DRV_GOP_DST_MIXER2VE) || ( Gop1Dst == E_DRV_GOP_DST_MIXER2OP) || ( Gop1Dst == E_DRV_GOP_DST_DIP))
1919 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, TRUE);
1920 else
1921 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, E_GOP1, FALSE);
1922 #endif
1923
1924 }
1925
1926 if (g_pGOPCtxLocal->pGOPCtxShared->bHMirror || g_pGOPCtxLocal->pGOPCtxShared->bVMirror)
1927 {
1928 g_pGOPCtxLocal->sMirrorInfo[u8win].u64NonMirrorFBAdr = pinfo->u32DRAMRBlkStart;
1929 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,u8win, bHMirror, bVMirror, pinfo);
1930 }
1931
1932 MDrv_GOP_IsGOPMirrorEnable(g_pGOPCtxLocal ,E_GOP1, &bRIUHMirror , &bRIUVMirror);
1933
1934 if(bHMirror)
1935 {
1936 /*save gwin postion before h mirror setting*/
1937 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHStr = pinfo->u16DispHPixelStart;
1938 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHEnd = pinfo->u16DispHPixelEnd;
1939
1940 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, E_GOP1, TRUE);
1941 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_HPos, pinfo);
1942 }
1943 else
1944 {
1945 if((g_pGOPCtxLocal->pGOPCtxShared->bHMirror || (bRIUHMirror==TRUE)) )//System is mirror, but bHMirror=FALSE, so need GOP mirror off
1946 {
1947 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, E_GOP1, FALSE);
1948 }
1949 }
1950
1951 if(bVMirror)
1952 {
1953 /*save gwin postion before V mirror setting*/
1954 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVStr = pinfo->u16DispVPixelStart;
1955 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVEnd = pinfo->u16DispVPixelEnd;
1956
1957 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, E_GOP1, TRUE);
1958 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_VPos, pinfo);
1959 }
1960 else
1961 {
1962 if((g_pGOPCtxLocal->pGOPCtxShared->bVMirror || (bRIUVMirror==TRUE)))//System is mirror, but bHMirror=FALSE, so need GOP mirror off
1963 {
1964 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, E_GOP1, FALSE);
1965 }
1966 }
1967
1968 //if (!g_pGOPCtxLocal->pGOPCtxShared->bVMirror)
1969 {
1970 if (g_pGOPCtxLocal->Gwin_V_Dup)
1971 {
1972 MS_BOOL bInterlace = FALSE;
1973
1974 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1975 if( ((Gop1Dst == E_DRV_GOP_DST_IP0) || (Gop1Dst == E_DRV_GOP_DST_IP1) || (Gop1Dst == E_DRV_GOP_DST_IP0_SUB) || (Gop1Dst == E_DRV_GOP_DST_VOP) || (Gop1Dst == E_DRV_GOP_DST_VOP_SUB)) && bInterlace )
1976 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (((pinfo->u16DispVPixelEnd<<1) - pinfo->u16DispVPixelStart) / 2);
1977 else if((Gop1Dst == E_DRV_GOP_DST_VE) || (Gop1Dst == E_DRV_GOP_DST_OP1))
1978 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (((pinfo->u16DispVPixelEnd<<1) - pinfo->u16DispVPixelStart) / 2);
1979 else
1980 pinfo->u16DispVPixelEnd = (pinfo->u16DispVPixelEnd << 1) - pinfo->u16DispVPixelStart;
1981 }
1982 else
1983 {
1984 MS_BOOL bInterlace = FALSE;
1985
1986 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
1987 if( ((Gop1Dst == E_DRV_GOP_DST_IP0) || (Gop1Dst == E_DRV_GOP_DST_IP1) || (Gop1Dst == E_DRV_GOP_DST_IP0_SUB) || (Gop1Dst == E_DRV_GOP_DST_VOP) || (Gop1Dst == E_DRV_GOP_DST_VOP_SUB)) && bInterlace )
1988 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
1989 else if((Gop1Dst == E_DRV_GOP_DST_VE) || (Gop1Dst == E_DRV_GOP_DST_OP1))
1990 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
1991 else if (((Gop1Dst == E_DRV_GOP_DST_OP0) || (Gop1Dst == E_DRV_GOP_DST_FRC) || (Gop1Dst == E_DRV_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,1))
1992 {
1993 pinfo->u16DispVPixelStart = pinfo->u16DispVPixelStart/2;
1994 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelEnd/2;
1995 }
1996 }
1997 }
1998
1999 MDrv_GOP_GWIN_SetWinFmt(g_pGOPCtxLocal, u8win, (DRV_GOPColorType)pinfo->clrType);
2000 MDrv_GOP_GWIN_SetGwinInfo(g_pGOPCtxLocal, u8win, (DRV_GOP_GWIN_INFO*)pinfo);
2001 }
2002
_SetGop23WinInfo(void * pInstance,MS_U8 u8win,GOP_GwinInfo * pinfo)2003 static void _SetGop23WinInfo(void* pInstance,MS_U8 u8win, GOP_GwinInfo* pinfo)
2004 {
2005 DRV_GOPDstType Gop23Dst =E_DRV_GOP_DST_INVALID;
2006 GOP_OupputColor gopOut;
2007 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
2008 MS_BOOL bRIUHMirror = FALSE, bRIUVMirror = FALSE;
2009 MS_PHY TLBMainAddr=0;
2010 MS_U8 u8GOP=0;
2011 MS_U8 u8GWinBase=0;
2012 MS_U8 i;
2013 #ifdef INSTANT_PRIVATE
2014 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2015 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2016 #endif
2017 if( !MDrv_GOP_HasGop1GPalette(g_pGOPCtxLocal) && (pinfo->clrType==E_GOP_COLOR_I8 || pinfo->clrType==E_GOP_COLOR_2266\
2018 ||pinfo->clrType==E_GOP_COLOR_RGB555_BLINK))
2019 {
2020 GOP_M_ERR("\n[%s] not support gwin id:%d index mode", __FUNCTION__, u8win);
2021 return;
2022 }
2023
2024 u8GOP=MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8win);
2025 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOP, &Gop23Dst);
2026 if (Gop23Dst ==E_DRV_GOP_DST_INVALID)
2027 {
2028 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n Get GOP destination fail!\n"));
2029 return;
2030 }
2031
2032 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP])
2033 {
2034 u8GWinBase=0;
2035 for(i=0;i<u8GOP;i++)
2036 {
2037 u8GWinBase += MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, i);
2038 }
2039 if(u8win != u8GWinBase)
2040 {
2041 GOP_M_DBUG("\n[%s] not support TLB mode, gwin id:%d ", __FUNCTION__, u8win);
2042 }
2043 }
2044 _GOP_GWIN_IsEnableMirror(pInstance,Gop23Dst, &bHMirror, &bVMirror);
2045 if(( Gop23Dst == E_DRV_GOP_DST_OP0)||( Gop23Dst == E_DRV_GOP_DST_FRC)|| ( Gop23Dst == E_DRV_GOP_DST_BYPASS) || ( Gop23Dst == E_DRV_GOP_DST_OP_DUAL_RATE)) //GOP destination is OP
2046 {
2047 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP])
2048 {
2049 gopOut = DRV_GOPOUT_RGB;
2050 }
2051 else
2052 {
2053 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP];
2054 }
2055
2056 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, gopOut);
2057
2058 if ((g_pGOPCtxLocal->pGopChipProperty->bOpInterlace == TRUE) && ( Gop23Dst == E_DRV_GOP_DST_OP0))
2059 {
2060 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
2061 }
2062 else
2063 {
2064 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
2065 }
2066 }
2067 else if (Gop23Dst == E_DRV_GOP_DST_IP0 || Gop23Dst==E_DRV_GOP_DST_IP0_SUB || Gop23Dst == E_DRV_GOP_DST_IP1 || Gop23Dst == E_DRV_GOP_DST_VOP || Gop23Dst == E_DRV_GOP_DST_VOP_SUB) // GOP destination is IP
2068 {
2069 MS_BOOL bInterlace = FALSE;
2070
2071 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
2072 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP])
2073 {
2074 gopOut = DRV_GOPOUT_YUV;
2075 }
2076 else
2077 {
2078 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP];
2079 }
2080
2081 if(bInterlace) //interlace mode
2082 {
2083 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, gopOut);
2084 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
2085 }
2086 else //Progressive mode
2087 {
2088 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, gopOut);
2089 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
2090 }
2091 }
2092 else // GOP destination is VE,MVOP
2093 {
2094 if((-1)==g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP])
2095 {
2096 gopOut = DRV_GOPOUT_YUV;
2097 }
2098 else
2099 {
2100 gopOut = (GOP_OupputColor)g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP];
2101 }
2102
2103 #if(FPGA_TEST)
2104 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE); //progressive output in FPGA environement.
2105 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, DRV_GOPOUT_RGB);
2106 #else
2107 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, DRV_GOPOUT_YUV);
2108 if(( Gop23Dst == E_DRV_GOP_DST_MIXER2VE) || ( Gop23Dst == E_DRV_GOP_DST_MIXER2OP) || ( Gop23Dst == E_DRV_GOP_DST_DIP))
2109 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
2110 else
2111 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
2112 #endif
2113
2114 }
2115
2116 if (g_pGOPCtxLocal->pGOPCtxShared->bHMirror || g_pGOPCtxLocal->pGOPCtxShared->bVMirror)
2117 {
2118 g_pGOPCtxLocal->sMirrorInfo[u8win].u64NonMirrorFBAdr = pinfo->u32DRAMRBlkStart;
2119 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP])
2120 {
2121 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,u8win, bHMirror, bVMirror, pinfo);
2122 }
2123 else
2124 {
2125 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,u8win, bHMirror, bVMirror, pinfo);
2126 }
2127 }
2128
2129 MDrv_GOP_IsGOPMirrorEnable(g_pGOPCtxLocal ,u8GOP, &bRIUHMirror , &bRIUVMirror);
2130
2131 if(bHMirror)
2132 {
2133 /*save gwin postion before h mirror setting*/
2134 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHStr = pinfo->u16DispHPixelStart;
2135 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorHEnd = pinfo->u16DispHPixelEnd;
2136
2137 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, u8GOP, TRUE);
2138
2139 if(!bCursorSupport(pInstance,u8GOP))
2140 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_HPos, pinfo);
2141 }
2142 else
2143 {
2144 if((g_pGOPCtxLocal->pGOPCtxShared->bHMirror || (bRIUHMirror==TRUE)))//System is mirror, but bHMirror=FALSE, so need GOP mirror off
2145 {
2146 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, u8GOP, FALSE);
2147 }
2148 }
2149
2150 if(bVMirror)
2151 {
2152 /*save gwin postion before V mirror setting*/
2153 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVStr = pinfo->u16DispVPixelStart;
2154 g_pGOPCtxLocal->sMirrorInfo[u8win].u16NonMirrorVEnd = pinfo->u16DispVPixelEnd;
2155
2156 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, u8GOP, TRUE);
2157
2158 if(!bCursorSupport(pInstance,u8GOP))
2159 _GOP_GWIN_SetHVMirrorWinPos(pInstance,u8win, E_Set_VPos, pinfo);
2160 }
2161 else
2162 {
2163 if((g_pGOPCtxLocal->pGOPCtxShared->bVMirror || (bRIUVMirror==TRUE)))//System is mirror, but bHMirror=FALSE, so need GOP mirror off
2164 {
2165 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, u8GOP, FALSE);
2166 }
2167 }
2168
2169 //if (!g_pGOPCtxLocal->pGOPCtxShared->bVMirror)
2170 {
2171 if (g_pGOPCtxLocal->Gwin_V_Dup)
2172 {
2173 MS_BOOL bInterlace = FALSE;
2174
2175 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
2176 if( ((Gop23Dst == E_DRV_GOP_DST_IP0) || (Gop23Dst == E_DRV_GOP_DST_IP1) || (Gop23Dst == E_DRV_GOP_DST_IP0_SUB) || (Gop23Dst == E_DRV_GOP_DST_VOP) || (Gop23Dst == E_DRV_GOP_DST_VOP_SUB)) && bInterlace )
2177 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (((pinfo->u16DispVPixelEnd<<1) - pinfo->u16DispVPixelStart) / 2);
2178 else if((Gop23Dst == E_DRV_GOP_DST_VE) || (Gop23Dst == E_DRV_GOP_DST_OP1))
2179 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (((pinfo->u16DispVPixelEnd<<1) - pinfo->u16DispVPixelStart) / 2);
2180 else
2181 pinfo->u16DispVPixelEnd = (pinfo->u16DispVPixelEnd << 1) - pinfo->u16DispVPixelStart;
2182 }
2183 else
2184 {
2185 MS_BOOL bInterlace = FALSE;
2186
2187 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
2188 if( ((Gop23Dst == E_DRV_GOP_DST_IP0) || (Gop23Dst == E_DRV_GOP_DST_IP1) || (Gop23Dst == E_DRV_GOP_DST_IP0_SUB) || (Gop23Dst == E_DRV_GOP_DST_VOP) || (Gop23Dst == E_DRV_GOP_DST_VOP_SUB)) && bInterlace )
2189 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
2190 else if((Gop23Dst == E_DRV_GOP_DST_VE) || (Gop23Dst == E_DRV_GOP_DST_OP1))
2191 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
2192 else if (((Gop23Dst == E_DRV_GOP_DST_OP0) || (Gop23Dst == E_DRV_GOP_DST_FRC) || (Gop23Dst == E_DRV_GOP_DST_BYPASS)) && !MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,u8GOP))
2193 {
2194 pinfo->u16DispVPixelStart = pinfo->u16DispVPixelStart/2;
2195 pinfo->u16DispVPixelEnd = pinfo->u16DispVPixelEnd/2;
2196 }
2197 }
2198 }
2199
2200 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP])
2201 {
2202 TLBMainAddr = (pinfo->u32DRAMRBlkStart/PAGE_SIZE)*TLB_PER_ENTRY_SIZE + g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[u8GOP];
2203 MDrv_GOP_SetTLBAddr(g_pGOPCtxLocal,u8GOP,TLBMainAddr,g_pGOPCtxLocal->pGOPCtxShared->bHMirror,g_pGOPCtxLocal->pGOPCtxShared->bVMirror,(DRV_GOP_GWIN_INFO*)pinfo);
2204 pinfo->u32DRAMRBlkStart= g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[u8GOP] % (PAGE_SIZE*PER_MIU_TLB_ENTRY_COUNT);
2205 MDrv_GOP_GWIN_SetGwinInfo(g_pGOPCtxLocal, u8win, (DRV_GOP_GWIN_INFO*)pinfo);
2206 }
2207 else
2208 {
2209 MDrv_GOP_GWIN_SetGwinInfo(g_pGOPCtxLocal, u8win, (DRV_GOP_GWIN_INFO*)pinfo);
2210 }
2211 MDrv_GOP_GWIN_SetWinFmt(g_pGOPCtxLocal, u8win, (DRV_GOPColorType)pinfo->clrType);
2212 }
2213
_GOP_ArrangePoolMem(void * pInstance,GOP_FB_POOL * pFBPool)2214 static void _GOP_ArrangePoolMem(void* pInstance,GOP_FB_POOL *pFBPool)
2215 {
2216 MS_PHY lastAddr, curStartAdr;
2217 MS_U64 size2move, moveSize, gapSize, count;
2218 GOP_GwinInfo gWin;
2219 MS_PHY *src_PA,*dst_PA;
2220 GOP_WinFB_INFO* pwinFB;
2221 MS_U8 u8GOP;
2222 MS_U8 u8WinID;
2223
2224 #ifdef INSTANT_PRIVATE
2225 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2226 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2227 #endif
2228
2229 MS_U32 u32NextFBId = pFBPool->u32FirstFBIdInPool;
2230
2231 memset(&gWin, 0, sizeof(GOP_GwinInfo));
2232
2233 if(0 == pFBPool->u32GWinFB_Pool_MemLen)
2234 return;
2235 GOP_M_INFO("Arrange GOP pool %d\n", pFBPool->poolId);
2236 lastAddr = pFBPool->GWinFB_Pool_BaseAddr;
2237
2238
2239 if(fpEventNotify != NULL)
2240 fpEventNotify(E_GOP_EVENT_BUF_ARRANGE_BEGIN, NULL);
2241 else
2242 {
2243 //APIGOP_ASSERT(TRUE, printf("\nfpEvenNotifyBegin is Null"));
2244 GOP_M_INFO("%s: fpEvenNotifyBegin is not hooked. Bypass switch...\n", __FUNCTION__);
2245 }
2246
2247 while(INVALID_POOL_NEXT_FBID != u32NextFBId)
2248 {
2249 pwinFB = _GetWinFB(pInstance,u32NextFBId);
2250
2251 if(pwinFB == NULL)
2252 {
2253 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32NextFBId);
2254 return;
2255 }
2256
2257 APIGOP_ASSERT(DRV_MAX_GWIN_FB_SUPPORT>u32NextFBId, GOP_M_FATAL("\nInvalid next fbid %td", (ptrdiff_t)u32NextFBId));
2258 APIGOP_ASSERT(pwinFB->in_use && pwinFB->poolId==pFBPool->poolId
2259 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at fbid %td", (ptrdiff_t)u32NextFBId));
2260 APIGOP_ASSERT(pwinFB->addr >= lastAddr
2261 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at fbid %td", (ptrdiff_t)u32NextFBId));
2262 APIGOP_ASSERT(pwinFB->addr>= pFBPool->GWinFB_Pool_BaseAddr &&
2263 (pwinFB->addr+pwinFB->size)<= (pFBPool->GWinFB_Pool_BaseAddr+pFBPool->u32GWinFB_Pool_MemLen)
2264 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at fbid %td", (ptrdiff_t)u32NextFBId));
2265
2266 APIGOP_ASSERT(IS_GWIN_SDRAM_ALIGN(pwinFB->addr)
2267 , GOP_M_FATAL("\nInvalid alignment for addr 0x%tx", (ptrdiff_t)pwinFB->addr));
2268 if(pwinFB->addr == lastAddr)
2269 {
2270 lastAddr += GWIN_SDRAM_PG_ALIGN(pwinFB->size);
2271 u32NextFBId = pwinFB->nextFBIdInPool;
2272 continue;
2273 }
2274
2275 curStartAdr = pwinFB->addr;
2276 gapSize = curStartAdr - lastAddr;
2277 moveSize = count = 0;
2278 size2move = pwinFB->size;
2279
2280 while (moveSize < size2move)
2281 {
2282 count = (moveSize + gapSize > size2move) ? (size2move - moveSize) : gapSize;
2283 src_PA = (MS_PHY *)MS_PA2KSEG1(curStartAdr + moveSize);
2284 dst_PA = (MS_PHY *)MS_PA2KSEG1(lastAddr + moveSize);
2285 memcpy(dst_PA,src_PA, count);
2286 moveSize += count;
2287 }
2288
2289 pwinFB->addr = lastAddr;
2290
2291 for (u8WinID = 0; (MS_U8)u8WinID < (MS_U8)g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum; u8WinID++)
2292 {
2293 if ((g_pGOPCtxLocal->pGOPCtxShared->gwinMap[(MS_U8)u8WinID].u32CurFBId ==u32NextFBId)
2294 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
2295 && (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[(MS_U8)u8WinID].u32GOPClientId == (GETPIDTYPE)getpid())
2296 #else
2297 && (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[(MS_U8)u8WinID].u32GOPClientId ==g_pGOPCtxLocal->u32GOPClientId)
2298 #endif
2299 )
2300 {
2301 if(GOP_GetWinInfo(pInstance,(MS_U8)u8WinID, &gWin))
2302 {
2303 gWin.u32DRAMRBlkStart = lastAddr;
2304 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8WinID);
2305
2306 if(u8GOP == GOPTYPE.GOP0)
2307 {
2308 _SetGop0WinInfo(pInstance,(MS_U8)u8WinID, &gWin);
2309 }
2310 else if(u8GOP == GOPTYPE.GOP1)
2311 {
2312 _SetGop1WinInfo(pInstance,(MS_U8)u8WinID, &gWin);
2313 }
2314 else
2315 {
2316 _SetGop23WinInfo(pInstance,(MS_U8)u8WinID, &gWin);
2317 }
2318 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
2319 }
2320 else
2321 {
2322 APIGOP_ASSERT(FALSE, GOP_M_FATAL("!!!Alert!!! Serious error in arrange pool memory\n"));
2323 }
2324 }
2325 }
2326
2327 lastAddr = GWIN_SDRAM_PG_ALIGN(pwinFB->addr + pwinFB->size);
2328 u32NextFBId = pwinFB->nextFBIdInPool;
2329
2330 }
2331
2332 if(fpEventNotify != NULL)
2333 fpEventNotify(E_GOP_EVENT_BUF_ARRANGE_END, NULL);
2334 else
2335 {
2336 APIGOP_ASSERT(TRUE, GOP_M_FATAL("\nfpEvenNotifyEnd is Null"));
2337 GOP_M_INFO("%s: fpEvenNotifyEnd is not hooked. Bypass switch...\n", __FUNCTION__);
2338 }
2339 }
2340
_GOP_FreePoolMem(void * pInstance,GOP_FB_POOL * pFBPool,MS_U32 u32fbId)2341 static void _GOP_FreePoolMem(void* pInstance,GOP_FB_POOL *pFBPool, MS_U32 u32fbId)
2342 {
2343 MS_U32 u32CurFBId, u32PreFBId;
2344 MS_PHY lastAddr;
2345 GOP_WinFB_INFO* pwinFB;
2346 GOP_WinFB_INFO* pPrewinFB;
2347
2348 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
2349 {
2350 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
2351 return;
2352 }
2353
2354 u32CurFBId = pFBPool->u32FirstFBIdInPool;
2355 u32PreFBId = INVALID_POOL_NEXT_FBID;
2356 lastAddr = pFBPool->GWinFB_Pool_BaseAddr;
2357
2358 while(INVALID_POOL_NEXT_FBID != u32CurFBId)
2359 {
2360 pwinFB = _GetWinFB(pInstance,u32CurFBId);
2361
2362 if(pwinFB == NULL)
2363 {
2364 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32CurFBId);
2365 return;
2366 }
2367
2368 APIGOP_ASSERT(DRV_MAX_GWIN_FB_SUPPORT>u32CurFBId, GOP_M_FATAL("\nInvalid next fbid %td", (ptrdiff_t)u32CurFBId));
2369 APIGOP_ASSERT(pwinFB->in_use && pwinFB->poolId==pFBPool->poolId
2370 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at fbid %td", (ptrdiff_t)u32CurFBId));
2371 APIGOP_ASSERT(pwinFB->addr >= lastAddr
2372 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at fbid %td", (ptrdiff_t)u32CurFBId));
2373 APIGOP_ASSERT(pwinFB->addr>= pFBPool->GWinFB_Pool_BaseAddr &&
2374 (pwinFB->addr+pwinFB->size)<= (pFBPool->GWinFB_Pool_BaseAddr+pFBPool->u32GWinFB_Pool_MemLen)
2375 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at fbid %td", (ptrdiff_t)u32CurFBId));
2376 if(u32CurFBId == u32fbId)
2377 break;
2378 lastAddr = pwinFB->addr+pwinFB->size;
2379 u32PreFBId = u32CurFBId;
2380 u32CurFBId = pwinFB->nextFBIdInPool;
2381 }
2382 APIGOP_ASSERT(INVALID_POOL_NEXT_FBID!=u32CurFBId, GOP_M_FATAL("\n Inconsistent pool list for %td", (ptrdiff_t)u32CurFBId));
2383
2384 pwinFB = _GetWinFB(pInstance,u32CurFBId);
2385
2386 if(pwinFB == NULL)
2387 {
2388 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32CurFBId);
2389 return;
2390 }
2391
2392 if(INVALID_POOL_NEXT_FBID == u32PreFBId)
2393 pFBPool->u32FirstFBIdInPool = pwinFB->nextFBIdInPool;
2394 else
2395 {
2396 pPrewinFB = _GetWinFB(pInstance,u32PreFBId);
2397
2398 if(pPrewinFB == NULL)
2399 {
2400 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32PreFBId);
2401 return;
2402 }
2403
2404 pPrewinFB->nextFBIdInPool = pwinFB->nextFBIdInPool;
2405 }
2406 pwinFB->nextFBIdInPool = INVALID_POOL_NEXT_FBID;
2407
2408 }
2409
_GOP_GWIN_CreatePoolFB(void * pInstance,MS_U32 u32fbId,MS_U16 dispX,MS_U16 dispY,MS_U16 width,MS_U16 height,MS_U16 fbFmt,EN_GOP_FRAMEBUFFER_STRING FBString)2410 static MS_U8 _GOP_GWIN_CreatePoolFB(void* pInstance,MS_U32 u32fbId, MS_U16 dispX, MS_U16 dispY, MS_U16 width, MS_U16 height, MS_U16 fbFmt, EN_GOP_FRAMEBUFFER_STRING FBString)
2411 {
2412 GOP_FB_POOL *pFBPool;
2413 MS_U32 u32CurFBId, u32PreFBId;
2414 MS_PHY lastAddr;
2415 MS_U32 size;
2416 MS_BOOL bPoolArranged = FALSE;
2417 GOP_WinFB_INFO* pwinFB;
2418 GOP_WinFB_INFO* pCurwinFB;
2419 GOP_WinFB_INFO* pPrewinFB;
2420
2421 #ifdef INSTANT_PRIVATE
2422 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2423 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2424 #endif
2425
2426 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
2427 {
2428 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
2429 return GWIN_NO_AVAILABLE;
2430 }
2431
2432 pwinFB = _GetWinFB(pInstance,u32fbId);
2433
2434 if(pwinFB == NULL)
2435 {
2436 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
2437 return GWIN_NO_AVAILABLE;
2438 }
2439
2440 if(pwinFB->in_use)
2441 {
2442 msWarning(ERR_FB_ID_ALREADY_ALLOCATED);
2443 GOP_M_ERR("[%s][%d]FbId %td is already exist\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
2444 return GWIN_NO_AVAILABLE;
2445
2446 }
2447
2448 switch(g_pGOPCtxLocal->pGOPCtxShared->fb_currentPoolId)
2449 {
2450 case GOP_WINFB_POOL1:
2451 pFBPool = &g_pGOPCtxLocal->pGOPCtxShared->fbPool1;
2452 break;
2453 case GOP_WINFB_POOL2:
2454 pFBPool = &g_pGOPCtxLocal->pGOPCtxShared->fbPool2;
2455 break;
2456 default:
2457 msWarning(ERR_FB_OUT_OF_MEMORY);
2458 return GWIN_NO_AVAILABLE;
2459 }
2460
2461 TRY_AGAIN:
2462
2463 u32CurFBId = pFBPool->u32FirstFBIdInPool;
2464 u32PreFBId = INVALID_POOL_NEXT_FBID;
2465 lastAddr = pFBPool->GWinFB_Pool_BaseAddr;
2466
2467 while(INVALID_POOL_NEXT_FBID != u32CurFBId)
2468 {
2469 pCurwinFB = _GetWinFB(pInstance,u32CurFBId);
2470
2471 if(pCurwinFB == NULL)
2472 {
2473 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32CurFBId);
2474 return GWIN_NO_AVAILABLE;
2475 }
2476
2477 APIGOP_ASSERT(DRV_MAX_GWIN_FB_SUPPORT>u32CurFBId, GOP_M_FATAL("\nInvalid next u32fbId %td", (ptrdiff_t)u32CurFBId));
2478 APIGOP_ASSERT(pCurwinFB->in_use && pCurwinFB->poolId==pFBPool->poolId
2479 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at u32fbId %td", (ptrdiff_t)u32CurFBId));
2480 APIGOP_ASSERT(pCurwinFB->addr >= lastAddr
2481 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at u32fbId %td", (ptrdiff_t)u32CurFBId));
2482 APIGOP_ASSERT(pCurwinFB->addr>= pFBPool->GWinFB_Pool_BaseAddr &&
2483 (pCurwinFB->addr+pCurwinFB->size)<= (pFBPool->GWinFB_Pool_BaseAddr+pFBPool->u32GWinFB_Pool_MemLen)
2484 , GOP_M_FATAL("\nSerious error, inconsistant Pool list at u32fbId %td", (ptrdiff_t)u32CurFBId));
2485 lastAddr = GWIN_SDRAM_PG_ALIGN(pCurwinFB->addr+pCurwinFB->size);
2486 u32PreFBId = u32CurFBId;
2487 u32CurFBId = pCurwinFB->nextFBIdInPool;
2488
2489 }
2490
2491 size = _GOP_CalcPitch(pInstance,fbFmt, width)*height;
2492
2493 if((pFBPool->u32GWinFB_Pool_MemLen-(lastAddr-pFBPool->GWinFB_Pool_BaseAddr)) < size)
2494 {
2495 if(bPoolArranged)
2496 {
2497 msWarning(ERR_FB_OUT_OF_MEMORY);
2498 return GWIN_NO_AVAILABLE;
2499 }
2500 _GOP_ArrangePoolMem(pInstance,pFBPool);
2501 bPoolArranged = TRUE;
2502 goto TRY_AGAIN;
2503 }
2504
2505 pwinFB->enable = FALSE;
2506 pwinFB->in_use = 1;
2507 pwinFB->obtain = 1;
2508 //g_pGOPCtxLocal->winFB[u32fbId].gWinId = gId; // set by calling functions
2509 pwinFB->x0 = dispX;
2510 pwinFB->y0 = dispY;
2511 pwinFB->width = width;
2512 pwinFB->height= height;
2513 pwinFB->x1 = pwinFB->x0 + pwinFB->width;
2514 pwinFB->y1 = pwinFB->y0 + pwinFB->height;
2515 // g_pGOPCtxLocal->winFB[u32fbId].pitch = width & 0xFFFC;//width; //(width & 0xFFF8); // pitch must be 4-pix alignment
2516 pwinFB->addr = lastAddr;
2517 pwinFB->size = size;
2518
2519 pwinFB->s_x = dispX;
2520 pwinFB->s_y = dispY;
2521 pwinFB->dispWidth = width ;
2522 pwinFB->dispHeight = height;
2523 pwinFB->poolId = pFBPool->poolId;
2524 pwinFB->pitch = _GOP_CalcPitch(pInstance,fbFmt, width);
2525
2526
2527 pCurwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GWIN_OSD_DEFAULT].u32CurFBId);
2528
2529 if(pCurwinFB == NULL)
2530 {
2531 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GWIN_OSD_DEFAULT].u32CurFBId);
2532 return GWIN_NO_AVAILABLE;
2533 }
2534
2535 // FB format
2536 pwinFB->fbFmt = (fbFmt != FB_FMT_AS_DEFAULT) ? fbFmt : pCurwinFB->fbFmt;
2537
2538
2539 pwinFB->string = FBString;
2540 pwinFB->u32GOPClientId = (GETPIDTYPE)getpid();
2541 pwinFB->nextFBIdInPool = INVALID_POOL_NEXT_FBID;
2542 if(INVALID_POOL_NEXT_FBID == u32PreFBId)
2543 pFBPool->u32FirstFBIdInPool = u32fbId;
2544 else
2545 {
2546 pPrewinFB = _GetWinFB(pInstance,u32PreFBId);
2547
2548 if(pPrewinFB == NULL)
2549 {
2550 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32PreFBId);
2551 return GWIN_NO_AVAILABLE;
2552 }
2553
2554 pPrewinFB->nextFBIdInPool = u32fbId;
2555 }
2556 return GWIN_OK;
2557 }
2558
_GOP_GetPDByDst(void * pInstance,MS_U8 u8GOP_num,DRV_GOPDstType GopDst,MS_U16 * u16StrwinStr)2559 static void _GOP_GetPDByDst(void* pInstance,MS_U8 u8GOP_num, DRV_GOPDstType GopDst,MS_U16 *u16StrwinStr)
2560 {
2561 #ifdef INSTANT_PRIVATE
2562 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2563 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2564 #endif
2565 MS_BOOL bHDREnable=FALSE;
2566
2567 switch(GopDst)
2568 {
2569 case E_DRV_GOP_DST_IP0:
2570 if(g_pGOPCtxLocal->pGopChipProperty->bIgnoreIPHPD)
2571 *u16StrwinStr = 0;
2572 else
2573 {
2574 MS_U32 u32Hstart = 0;
2575
2576 MDrv_GOP_GetIPCaptureHStart(g_pGOPCtxLocal,&u32Hstart,E_DRV_GOP_MAIN_WINDOW);
2577 *u16StrwinStr = u32Hstart + g_pGOPCtxLocal->pGopChipProperty->GOP_IP_PD;
2578 }
2579 break;
2580 case E_DRV_GOP_DST_IP1:
2581 if(g_pGOPCtxLocal->pGopChipProperty->bIgnoreIP1HPD)
2582 *u16StrwinStr = 0;
2583 break;
2584 case E_DRV_GOP_DST_OP1:
2585 *u16StrwinStr = g_pGOPCtxLocal->pGopChipProperty->GOP_OP1_PD;
2586 break;
2587 case E_DRV_GOP_DST_OP0:
2588 case E_DRV_GOP_DST_GOPScaling:
2589 MDrv_GOP_IsHDREnabled(g_pGOPCtxLocal, &bHDREnable);
2590 if(bHDREnable==FALSE)
2591 {
2592 *u16StrwinStr = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOP_num] + g_pGOPCtxLocal->pGopChipProperty->GOP_PD;
2593 }
2594 else
2595 {
2596 *u16StrwinStr = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOP_num] + g_pGOPCtxLocal->pGopChipProperty->GOP_HDR_OP_PD;
2597 }
2598 break;
2599 case E_DRV_GOP_DST_FRC:
2600 case E_DRV_GOP_DST_DIP:
2601 *u16StrwinStr =0;
2602 break;
2603 case E_DRV_GOP_DST_BYPASS:
2604 *u16StrwinStr =g_pGOPCtxLocal->pGopChipProperty->GOP_Mux_FRC_offset;
2605 break;
2606 case E_DRV_GOP_DST_VOP:
2607 *u16StrwinStr = g_pGOPCtxLocal->pGopChipProperty->GOP_MVOP_PD;
2608 break;
2609 case E_DRV_GOP_DST_MIXER2VE:
2610 case E_DRV_GOP_DST_MIXER2OP:
2611 *u16StrwinStr = g_pGOPCtxLocal->pGopChipProperty->GOP_MIXER_PD;
2612 break;
2613 case E_DRV_GOP_DST_VE:
2614 *u16StrwinStr = g_pGOPCtxLocal->pGopChipProperty->GOP_VE_PD;
2615 break;
2616 case E_DRV_GOP_DST_OP_DUAL_RATE:
2617 *u16StrwinStr = g_pGOPCtxLocal->pGopChipProperty->GOP_DUAL_OP_PD;
2618 break;
2619 default:
2620 *u16StrwinStr = g_pGOPCtxLocal->pGopChipProperty->GOP_PD;
2621 break;
2622 }
2623
2624 }
2625
_GOP_AdjustHSPD(void * pInstance,MS_U8 u8GOP_num,MS_U16 u16StrwinStr,DRV_GOPDstType GopDst)2626 static void _GOP_AdjustHSPD(void* pInstance,MS_U8 u8GOP_num, MS_U16 u16StrwinStr, DRV_GOPDstType GopDst)
2627 {
2628 MS_U8 u8Offset;
2629 #ifdef INSTANT_PRIVATE
2630 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2631 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2632 #endif
2633
2634 if (!_GOP_IsGopNumValid(pInstance,u8GOP_num))
2635 {
2636 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP_num);
2637 return;
2638 }
2639
2640 switch(GopDst)
2641 {
2642 case E_DRV_GOP_DST_IP0:
2643 case E_DRV_GOP_DST_DIP:
2644 case E_DRV_GOP_DST_IP1:
2645 u8Offset = 0;
2646 break;
2647 case E_DRV_GOP_DST_MIXER2VE:
2648 case E_DRV_GOP_DST_MIXER2OP:
2649 case E_DRV_GOP_DST_VE:
2650 case E_DRV_GOP_DST_FRC:
2651 if(g_pGOPCtxLocal->pGopChipProperty->bIgnoreVEHPD)
2652 u8Offset = 0;
2653 else
2654 u8Offset = MDrv_GOP_GetHPipeOfst(g_pGOPCtxLocal,u8GOP_num, GopDst);
2655 break;
2656 case E_DRV_GOP_DST_OP0:
2657 case E_DRV_GOP_DST_VOP:
2658 case E_DRV_GOP_DST_BYPASS:
2659 case E_DRV_GOP_DST_OP_DUAL_RATE:
2660 default:
2661 u8Offset = MDrv_GOP_GetHPipeOfst(g_pGOPCtxLocal,u8GOP_num, GopDst);
2662 break;
2663 }
2664
2665 MDrv_GOP_GWIN_SetHSPipe(g_pGOPCtxLocal, u8GOP_num, u8Offset+u16StrwinStr);
2666 }
2667
_GOP_InitHSPDByGOP(void * pInstance,MS_U8 u8GOP_num)2668 static void _GOP_InitHSPDByGOP(void* pInstance,MS_U8 u8GOP_num)
2669 {
2670 MS_U16 u16StrwinStr=0;
2671 DRV_GOPDstType GopDst = E_DRV_GOP_DST_OP0;
2672
2673 #ifdef INSTANT_PRIVATE
2674 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2675 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2676 #endif
2677
2678 if (!_GOP_IsGopNumValid(pInstance,u8GOP_num))
2679 {
2680 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP_num);
2681 return;
2682 }
2683
2684 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOP_num, &GopDst);
2685 _GOP_GetPDByDst(pInstance,u8GOP_num, GopDst,&u16StrwinStr);
2686 _GOP_AdjustHSPD(pInstance,u8GOP_num, u16StrwinStr, GopDst);
2687 }
2688
2689
2690
_IsGopInMux0(void * pInstance,MS_U8 u8GopNum)2691 static MS_BOOL _IsGopInMux0(void* pInstance,MS_U8 u8GopNum)
2692 {
2693 MS_U8 GetGopNum=0;
2694 #ifdef INSTANT_PRIVATE
2695 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2696 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2697 #endif
2698
2699 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, E_GOP_MUX0);
2700
2701 if (u8GopNum == GetGopNum)
2702 {
2703 return TRUE;
2704 }
2705 else
2706 {
2707 return FALSE;
2708 }
2709 }
_IsGopInMux1(void * pInstance,MS_U8 u8GopNum)2710 static MS_BOOL _IsGopInMux1(void* pInstance,MS_U8 u8GopNum)
2711 {
2712 MS_U8 GetGopNum=0;
2713 #ifdef INSTANT_PRIVATE
2714 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2715 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2716 #endif
2717
2718 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, E_GOP_MUX1);
2719 if (u8GopNum==GetGopNum)
2720 {
2721 return TRUE;
2722 }
2723 return FALSE;
2724 }
_IsGopInMux2(void * pInstance,MS_U8 u8GopNum)2725 static MS_BOOL _IsGopInMux2(void* pInstance,MS_U8 u8GopNum)
2726 {
2727 MS_U8 GetGopNum=0;
2728 #ifdef INSTANT_PRIVATE
2729 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2730 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2731 #endif
2732
2733 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, E_GOP_MUX2);
2734
2735 if (u8GopNum == GetGopNum)
2736 {
2737 return TRUE;
2738 }
2739 return FALSE;
2740 }
_IsGopInMux3(void * pInstance,MS_U8 u8GopNum)2741 static MS_BOOL _IsGopInMux3(void* pInstance,MS_U8 u8GopNum)
2742 {
2743 MS_U8 GetGopNum=0;
2744 #ifdef INSTANT_PRIVATE
2745 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2746 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2747 #endif
2748
2749 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, E_GOP_MUX3);
2750 if (u8GopNum==GetGopNum)
2751 {
2752 return TRUE;
2753 }
2754 return FALSE;
2755 }
2756
_IsGopInMux0To2(void * pInstance,MS_U8 u8GopNum)2757 static MS_BOOL _IsGopInMux0To2(void* pInstance,MS_U8 u8GopNum)
2758 {
2759 if (_IsGopInMux0(pInstance,u8GopNum) || _IsGopInMux1(pInstance,u8GopNum) || _IsGopInMux2(pInstance,u8GopNum))
2760 {
2761 return TRUE;
2762 }
2763 return FALSE;
2764 }
2765
_IsGopInMux0To3(void * pInstance,MS_U8 u8GopNum)2766 static MS_BOOL _IsGopInMux0To3(void* pInstance,MS_U8 u8GopNum)
2767 {
2768 if (_IsGopInMux0(pInstance,u8GopNum) || _IsGopInMux1(pInstance,u8GopNum) || _IsGopInMux2(pInstance,u8GopNum) || _IsGopInMux3(pInstance,u8GopNum))
2769 {
2770 return TRUE;
2771 }
2772 return FALSE;
2773 }
2774
_GetNonUseOPMux(void * pInstance)2775 static Gop_MuxSel _GetNonUseOPMux(void* pInstance)
2776 {
2777 MS_S8 i;
2778 MS_U8 GetGopNum = 0;
2779 #ifdef INSTANT_PRIVATE
2780 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2781 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2782 #endif
2783 for (i=MAX_GOP_MUX_OPNum-1; i>=0; i--)
2784 {
2785 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, (Gop_MuxSel)i);
2786 if (GetGopNum == 0x7)
2787 return (Gop_MuxSel)i;
2788 }
2789 return MAX_GOP_MUX_SUPPORT;
2790 }
2791
_GetNonUseDualOPMux(void * pInstance)2792 static Gop_MuxSel _GetNonUseDualOPMux(void* pInstance)
2793 {
2794 MS_S8 i;
2795 MS_U8 GetGopNum = 0;
2796 #ifdef INSTANT_PRIVATE
2797 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2798 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2799 #endif
2800 for (i=E_GOP_DUALRATE_OP_MUX0; i<=E_GOP_DUALRATE_OP_MUX2; i++)
2801 {
2802 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, (Gop_MuxSel)i);
2803 if (GetGopNum == MAX_GOP_DualMUX_Num)
2804 return (Gop_MuxSel)i;
2805 }
2806 return MAX_GOP_MUX_SUPPORT;
2807 }
2808
_GOP_Get_StretchWin(void * pInstance,MS_U8 gop,MS_U16 * x,MS_U16 * y,MS_U16 * w,MS_U16 * h)2809 static void _GOP_Get_StretchWin(void* pInstance,MS_U8 gop,MS_U16 *x,MS_U16 *y,MS_U16 *w,MS_U16 *h)
2810 {
2811 DRV_GOPDstType eDstType = E_DRV_GOP_DST_INVALID;
2812
2813 #ifdef INSTANT_PRIVATE
2814 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2815 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2816 #endif
2817 MDrv_GOP_GWIN_Get_StretchWin(g_pGOPCtxLocal, gop, x, y, w, h);
2818 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal,gop, &eDstType);
2819
2820 if((eDstType == E_DRV_GOP_DST_IP0) || (eDstType == E_DRV_GOP_DST_IP1))
2821 {
2822 MS_BOOL bInterlace = FALSE;
2823
2824 MDrv_GOP_GetIPInterlace(g_pGOPCtxLocal,&bInterlace,E_DRV_GOP_MAIN_WINDOW);
2825 if( bInterlace )
2826 {
2827 (*h) *=2;
2828 (*y) = (*y)*2;
2829 }
2830 }
2831 else if(eDstType == E_DRV_GOP_DST_VE)
2832 {
2833 (*h) *=2;
2834 (*y) = ((*y)*2) - g_pGOPCtxLocal->pGopChipProperty->GOP_VE_V_Offset;
2835 }
2836 else if(eDstType == E_DRV_GOP_DST_OP1)
2837 {
2838 (*h) *=2;
2839 (*y) = ((*y)*2);
2840 }
2841 if((eDstType == E_DRV_GOP_DST_OP0) || (eDstType == E_DRV_GOP_DST_FRC) || (eDstType == E_DRV_GOP_DST_BYPASS))
2842 {
2843 if (!MDrv_GOP_GWIN_IsProgressive(g_pGOPCtxLocal,gop))
2844 {
2845 (*h) *=2;
2846 (*y) = (*y)*2;
2847 }
2848 }
2849 }
2850
_GOP_SetOCCapability(void * pInstance,MS_U8 u8GOP,DRV_GOPDstType GopDst)2851 static void _GOP_SetOCCapability(void* pInstance,MS_U8 u8GOP, DRV_GOPDstType GopDst)
2852 {
2853 #ifdef INSTANT_PRIVATE
2854 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2855 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2856 #endif
2857
2858 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
2859 {
2860 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
2861 return;
2862 }
2863
2864 switch(GopDst)
2865 {
2866 case E_DRV_GOP_DST_IP0:
2867 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, FALSE);
2868 MDrv_GOP_OC_SetOCEn(g_pGOPCtxLocal, u8GOP, FALSE);
2869 break;
2870
2871 case E_DRV_GOP_DST_VOP:
2872 MDrv_GOP_OC_SetOCEn(g_pGOPCtxLocal, u8GOP, FALSE);
2873 break;
2874
2875 case E_DRV_GOP_DST_OP0:
2876 case E_DRV_GOP_DST_BYPASS:
2877 case E_DRV_GOP_DST_GOPScaling:
2878 case E_DRV_GOP_DST_OP_DUAL_RATE:
2879 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, TRUE);
2880 MDrv_GOP_OC_SetOCEn(g_pGOPCtxLocal, u8GOP, FALSE);
2881 break;
2882
2883 case E_DRV_GOP_DST_FRC:
2884 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, TRUE);
2885 MDrv_GOP_OC_SetOCEn(g_pGOPCtxLocal, u8GOP, TRUE);
2886 break;
2887
2888 default:
2889 break;
2890 }
2891
2892 }
2893
2894 #if (DUMP_INFO)
2895 static void _GOP_GWIN_UpdateAllInfo(void* pInstance,)
2896 {
2897 MS_U8 u8Index = 0,u16Index = 0;
2898 GOP_WinFB_INFO* pwinFB;
2899
2900 #ifdef INSTANT_PRIVATE
2901 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2902 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2903 #endif
2904 GOP_M_INFO("GwinNo. CurFBId IsShared SharedCnt ClientId\n");
2905 GOP_M_INFO("========================================================================\n");
2906 for (u8Index=0; u8Index<(MS_U8)g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum; u8Index++)
2907 {
2908 GOP_M_INFO("%02d\t\t%04ld\t\t%02d\t\t%04d\t\t%04ld\n",u8Index,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8Index].u32CurFBId,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8Index].bIsShared ,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8Index].u16SharedCnt,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8Index].u32GOPClientId);
2909 }
2910 GOP_M_INFO("========================================================================\n");
2911 GOP_M_INFO("FbNo. in_use addr size widthxheight pitch fmt ClientId\n");
2912 GOP_M_INFO("===========================================================================\n");
2913 for (u16Index=0; u16Index<DRV_MAX_GWIN_FB_SUPPORT; u16Index++)
2914 {
2915 pwinFB = _GetWinFB(pInstance,u16Index);
2916 if(pwinFB)
2917 {
2918 GOP_M_INFO("[%02d]\t%02d\t%08lx\t%08lx\t%04d x %04d\t%04d\t%02d\t%04ld\n",u16Index,pwinFB->in_use,pwinFB->addr,pwinFB->size,pwinFB->width,pwinFB->height,pwinFB->pitch,pwinFB->fbFmt,pwinFB->u32GOPClientId);
2919 }
2920 }
2921 GOP_M_INFO("===========================================================================\n");
2922 }
2923 #endif
2924
GOP_FB_Destroy(void * pInstance,MS_U32 u32fbId)2925 static MS_U32 GOP_FB_Destroy(void* pInstance,MS_U32 u32fbId)
2926 {
2927 GOP_WinFB_INFO* pwinFB;
2928 #ifdef INSTANT_PRIVATE
2929 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2930 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2931 #endif
2932
2933 pwinFB = _GetWinFB(pInstance,u32fbId);
2934
2935
2936 switch(pwinFB->poolId)
2937 {
2938 case GOP_WINFB_POOL1:
2939 _GOP_FreePoolMem(pInstance,&g_pGOPCtxLocal->pGOPCtxShared->fbPool1, u32fbId);
2940 break;
2941 case GOP_WINFB_POOL2:
2942 _GOP_FreePoolMem(pInstance,&g_pGOPCtxLocal->pGOPCtxShared->fbPool1, u32fbId);
2943 break;
2944 default:
2945 break;
2946 }
2947
2948 pwinFB->poolId = GOP_WINFB_POOL_NULL;
2949 pwinFB->enable = FALSE;
2950 pwinFB->in_use = 0;
2951 pwinFB->obtain = 0;
2952 pwinFB->x0 = 0;
2953 pwinFB->y0 = 0;
2954 pwinFB->x1 = 0;
2955 pwinFB->y1 = 0;
2956
2957 pwinFB->gWinId = GWIN_ID_INVALID;
2958 pwinFB->width = 0;
2959 pwinFB->height= 0;
2960 pwinFB->pitch = 0;
2961 pwinFB->fbFmt =0;
2962 pwinFB->addr = 0;
2963 pwinFB->size = 0;
2964 pwinFB->dispHeight = 0;
2965 pwinFB->dispWidth = 0;
2966 pwinFB->s_x = 0;
2967 pwinFB->s_y = 0;
2968 pwinFB->string = E_GOP_FB_NULL;
2969 pwinFB->u32GOPClientId = INVALID_CLIENT_PID;
2970
2971 return GWIN_OK;
2972 }
2973
GOP_SetWinInfo(void * pInstance,MS_U32 u32Gwin,GOP_GwinInfo * pinfo)2974 static MS_U32 GOP_SetWinInfo(void* pInstance,MS_U32 u32Gwin, GOP_GwinInfo* pinfo)
2975 {
2976 MS_U8 u8GOP;
2977
2978 #ifdef INSTANT_PRIVATE
2979 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
2980 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
2981 #endif
2982
2983 if (!_GOP_IsGwinIdValid(pInstance,u32Gwin))
2984 {
2985 GOP_M_ERR("\n[%s] not support gwin id:%td in this chip version", __FUNCTION__, (ptrdiff_t)u32Gwin);
2986 return GOP_API_FAIL;
2987 }
2988 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u32Gwin);
2989
2990
2991 switch(u8GOP)
2992 {
2993 case E_GOP0:
2994 _SetGop0WinInfo(pInstance,u32Gwin, pinfo);
2995 break;
2996 case E_GOP1:
2997 _SetGop1WinInfo(pInstance,u32Gwin, pinfo);
2998 break;
2999 case E_GOP2:
3000 case E_GOP3:
3001 case E_GOP4:
3002 case E_GOP5:
3003 _SetGop23WinInfo(pInstance,u32Gwin, pinfo);
3004 break;
3005 default:
3006 break;
3007 }
3008
3009 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
3010
3011 return GOP_API_SUCCESS;
3012 }
3013
GOP_Win_Destroy(void * pInstance,MS_U32 gId)3014 static MS_U32 GOP_Win_Destroy(void* pInstance,MS_U32 gId)
3015 {
3016 MS_U32 u32fbId;
3017 GOP_GwinInfo gWin;
3018 GOP_WinFB_INFO* pwinFB;
3019 MS_U8 u8GOP,u8MIU;
3020
3021 #ifdef INSTANT_PRIVATE
3022 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3023 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3024 #endif
3025
3026 GOP_M_INFO("\33[0;36m %s:%d gId = %td \33[m \n",__FUNCTION__,__LINE__,(ptrdiff_t)gId);
3027
3028 if (!_GOP_IsGwinIdValid(pInstance,gId))
3029 {
3030 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gId);
3031 return GOP_API_FAIL;
3032 }
3033 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,gId))
3034 {
3035 GOP_M_ERR("[%s][%d]GWIN %td is not exist\n",__FUNCTION__,__LINE__,(ptrdiff_t)gId);
3036 return GOP_API_FAIL;
3037 }
3038
3039 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, gId, FALSE);
3040 u32fbId = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId;
3041
3042 pwinFB = _GetWinFB(pInstance,u32fbId);
3043 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
3044 {
3045 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
3046 return GOP_API_FAIL;
3047 }
3048
3049 if ((GOP_WINFB_POOL_NULL!=pwinFB->poolId) && (GOP_FB_Destroy(pInstance,u32fbId) != GWIN_OK))
3050 {
3051 MS_DEBUG_MSG( GOP_M_ERR( "[%s][%d], failed to delete FB %td\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId ) );
3052
3053 }
3054
3055 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId= GWIN_ID_INVALID;
3056 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32GOPClientId = 0;
3057 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].bIsShared = FALSE;
3058 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u16SharedCnt = 0;
3059
3060 memset(&gWin, 0, sizeof(GOP_GwinInfo));
3061 gWin.clrType = E_GOP_COLOR_ARGB8888;
3062 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,(gId));
3063 u8MIU = MDrv_GOP_Get_MIU_Sel(g_pGOPCtxLocal,u8GOP);
3064 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP] != TRUE)
3065 {
3066 _miu_offset_to_phy(u8MIU,gWin.u32DRAMRBlkStart,gWin.u32DRAMRBlkStart);
3067 }
3068 GOP_SetWinInfo(pInstance,gId,&gWin);
3069
3070 RESET_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, gId);
3071 RESET_BIT(g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr, gId);
3072 RESET_BIT(g_pGOPCtxLocal->u16GOP_HMirror_HPos, gId);
3073 RESET_BIT(g_pGOPCtxLocal->u16GOP_VMirror_VPos, gId);
3074
3075 MDrv_GOP_GWIN_ClearFlipQueue(g_pGOPCtxLocal,gId);
3076 return GOP_API_SUCCESS;
3077 }
3078
3079 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
GOP_AtExit(void * pInstance)3080 static void GOP_AtExit(void* pInstance)
3081 {
3082 MS_U32 u32TempID=0, u32GWinFBID=DRV_MAX_GWIN_FB_SUPPORT;
3083 MS_U32 u32CurPID = (GETPIDTYPE)getpid();
3084 E_GOP_API_Result enRet = GOP_API_FAIL;
3085 GOP_WinFB_INFO* pwinFB;
3086 #ifdef INSTANT_PRIVATE
3087 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3088 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3089 #endif
3090
3091 if(g_pGOPCtxLocal ==NULL)
3092 {
3093 return;
3094 }
3095
3096 #if GOP_LOCK_SUPPORT
3097 GOP_M_INFO("---%s %d: PID[%tu], TID[%td] exited, MutexCnt=%d\n", __FUNCTION__, __LINE__, (ptrdiff_t)u32CurPID, (ptrdiff_t)MsOS_GetOSThreadID(), g_pGOPCtxLocal->s32GOPMutexCnt);
3098 #else
3099 GOP_M_INFO("---%s %d: PID[%tu], TID[%td] exited\n", __FUNCTION__, __LINE__, (ptrdiff_t)u32CurPID, (ptrdiff_t)MsOS_GetOSThreadID());
3100 #endif
3101 for(u32TempID=0; u32TempID < g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum; u32TempID++)
3102 {
3103 //Check and release APP's GWIN resource
3104 if(((FALSE == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32TempID].bIsShared)
3105 && (DRV_MAX_GWIN_FB_SUPPORT>g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32TempID].u32CurFBId)
3106 && (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32TempID].u32GOPClientId==u32CurPID))
3107 || ((TRUE == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32TempID].bIsShared)
3108 && (0x0 == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32TempID].u16SharedCnt)))
3109
3110 {
3111 u32GWinFBID = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32TempID].u32CurFBId;
3112 enRet = (E_GOP_API_Result)GOP_Win_Destroy(pInstance,u32TempID);
3113 GOP_M_INFO("\n---%s %d: Try DestroyWIN[%tu], return[%u]\n", __FUNCTION__, __LINE__, (ptrdiff_t)u32TempID, (MS_U8)enRet);
3114 enRet = (E_GOP_API_Result)GOP_FB_Destroy(pInstance,u32GWinFBID);
3115 GOP_M_INFO("\n---%s %d: Try DestroyWIN's FB[%tu], return[%u]\n", __FUNCTION__, __LINE__, (ptrdiff_t)u32GWinFBID, (MS_U8)enRet);
3116 }
3117 }
3118
3119
3120 for(u32TempID=0; u32TempID < DRV_MAX_GWIN_FB_SUPPORT; u32TempID++)
3121 {
3122 pwinFB = _GetWinFB(pInstance,u32TempID);
3123 // Check and release APP1's un-maped FB resource
3124 // Note: If this APP1's FB is currently mapped to GWIN, means this FB is used by APP2
3125 if( (pwinFB->u32GOPClientId == u32CurPID)
3126 &&(pwinFB->gWinId == GWIN_ID_INVALID))
3127 {
3128 enRet = (E_GOP_API_Result)GOP_Win_Destroy(pInstance,u32TempID);
3129 GOP_M_INFO("\n---%s %d: Try DestroyFB[%tu], return[%u]\n", __FUNCTION__, __LINE__,(ptrdiff_t)u32TempID, (MS_U8)enRet);
3130 }
3131 }
3132
3133 #if GOP_LOCK_SUPPORT
3134
3135 if(g_pGOPCtxLocal->s32GOPMutexCnt > 0)
3136 {
3137 g_pGOPCtxLocal->s32GOPMutexCnt = 0;
3138 MsOS_ReleaseMutex(g_pGOPCtxLocal->s32GOPMutex);
3139 }
3140 #endif
3141
3142 #if GOP_XC_LOCK_SUPPORT
3143 if(g_pGOPCtxLocal->s32GOPXC_MutexCnt > 0)
3144 {
3145 g_pGOPCtxLocal->s32GOPXC_MutexCnt = 0;
3146 MsOS_ReleaseMutex(g_pGOPCtxLocal->s32GOPXC_Mutex);
3147 }
3148 #endif
3149 }
3150 #endif
3151
GOP_PreInit_Ctx(void * pInstance,MS_BOOL * pbFirstDrvInstant)3152 static MS_BOOL GOP_PreInit_Ctx(void* pInstance,MS_BOOL *pbFirstDrvInstant)
3153 {
3154 MS_BOOL bNeedInitShared =FALSE;
3155 MS_U16 u16LoopTime = 0x0;
3156 #ifdef INSTANT_PRIVATE
3157 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3158 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3159 #endif
3160
3161 _GetGOPEnum(pInstance);
3162
3163 if(g_pGOPCtxLocal)
3164 {
3165 if(bFirstInit)
3166 {
3167 *pbFirstDrvInstant = TRUE;
3168 }
3169 else
3170 {
3171 *pbFirstDrvInstant = FALSE;
3172 }
3173
3174 return TRUE;
3175 }
3176 g_pGOPCtxLocal = Drv_GOP_Init_Context(pInstance,&bNeedInitShared);
3177 if(NULL == g_pGOPCtxLocal)
3178 return FALSE;
3179 if(pbFirstDrvInstant)
3180 *pbFirstDrvInstant = bNeedInitShared;
3181
3182 g_pGOPCtxLocal->pGOPCtxShared->bDummyInit = bNeedInitShared;
3183
3184 #if 0
3185 if(bNeedInitShared)
3186 {
3187 MS_U32 gId;
3188
3189 u16LoopTime = 0;
3190 g_pGOPCtxLocal->pGOPCtxShared->gwinMap = NULL;
3191 while (u16LoopTime<0xFF)
3192 {
3193 g_pGOPCtxLocal->pGOPCtxShared->gwinMap = malloc(MDrv_GOP_GetTotalGwinNum(g_pGOPCtxLocal)*sizeof(GWIN_MAP));
3194 if (g_pGOPCtxLocal->pGOPCtxShared->gwinMap!=NULL)
3195 {
3196 break;
3197 }
3198 u16LoopTime++;
3199 }
3200 if (g_pGOPCtxLocal->pGOPCtxShared->gwinMap!=NULL)
3201 {
3202 for( gId=0; gId<MApi_GOP_GWIN_GetTotalGwinNum(); gId++)
3203 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId= GWIN_ID_INVALID;
3204 }
3205 else
3206 {
3207 printf("\n[%s]allocate memory for gwinMap info fail!!!!!!!", __FUNCTION__);
3208 }
3209
3210 u16LoopTime = 0;
3211 g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType = NULL;
3212 while (u16LoopTime<0xFF)
3213 {
3214 g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType = malloc(MApi_GOP_GWIN_GetMaxGOPNum()*sizeof(MS_S32));
3215 if (g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType!=NULL)
3216 {
3217 break;
3218 }
3219 u16LoopTime++;
3220 }
3221 if (g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType!=NULL)
3222 {
3223 for( gId=0; gId<MApi_GOP_GWIN_GetMaxGOPNum(); gId++)
3224 g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[gId] = -1;
3225 }
3226 else
3227 {
3228 printf("\n[%s]allocate memory for s32OutputColorType info fail!!!!!!!", __FUNCTION__);
3229 }
3230 }
3231 #endif
3232
3233 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
3234 g_pGOPCtxLocal->u32GOPClientId = (GETPIDTYPE)getpid();
3235 #else
3236 g_pGOPCtxLocal->u32GOPClientId = ++g_pGOPCtxLocal->pGOPCtxShared->u32ClientIdAllocator;
3237 if(0 == g_pGOPCtxLocal->u32GOPClientId)
3238 g_pGOPCtxLocal->u32GOPClientId = ++g_pGOPCtxLocal->pGOPCtxShared->u32ClientIdAllocator;
3239 #endif
3240
3241 g_pGOPCtxLocal->sMirrorInfo = NULL;
3242 u16LoopTime = 0;
3243 while (u16LoopTime<0xFF)
3244 {
3245 #ifdef MSOS_TYPE_LINUX_KERNEL
3246 if(g_pGOPCtxLocal->sMirrorInfo ==NULL)
3247 g_pGOPCtxLocal->sMirrorInfo = kmalloc(g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum * sizeof(GOP_GwinMirror_Info), GFP_KERNEL);
3248 #else
3249 if(g_pGOPCtxLocal->sMirrorInfo ==NULL)
3250 g_pGOPCtxLocal->sMirrorInfo = malloc(g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum * sizeof(GOP_GwinMirror_Info));
3251 #endif
3252
3253 if (g_pGOPCtxLocal->sMirrorInfo!=NULL)
3254 {
3255 break;
3256 }
3257 u16LoopTime++;
3258
3259 }
3260
3261 if (g_pGOPCtxLocal->sMirrorInfo==NULL)
3262 {
3263 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n [%s][%d]allocate memory for gwin mirror info fail!!!",__FUNCTION__,__LINE__));
3264 }
3265 else
3266 {
3267 memset(g_pGOPCtxLocal->sMirrorInfo, 0, g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum * sizeof(GOP_GwinMirror_Info));
3268 }
3269
3270 memset(&g_pGOPCtxLocal->sGOPConfig, 0, sizeof(GOP_Config));
3271
3272 memset(g_pGOPCtxLocal->MS_MuxGop, 0, MAX_GOP_MUX_SUPPORT*sizeof(MS_U8));
3273 g_pGOPCtxLocal->IsChgMux= FALSE;
3274 g_pGOPCtxLocal->IsClkClosed= FALSE;
3275 g_pGOPCtxLocal->u8ChgIpMuxGop = 0xFF;
3276 #if GOP_LOCK_SUPPORT
3277 char GOP_MUTEX[] = "GOP_Mutex";
3278
3279 g_pGOPCtxLocal->s32GOPMutexCnt = 0;
3280 g_pGOPCtxLocal->s32GOPMutex = MsOS_CreateMutex(E_MSOS_FIFO, (char *)GOP_MUTEX, MSOS_PROCESS_SHARED);
3281 if (0 > g_pGOPCtxLocal->s32GOPMutex)
3282 {
3283 GOP_M_ERR("%s %d create gop mutex fail\n", __FUNCTION__,__LINE__);
3284 return FALSE;
3285 }
3286 g_pGOPCtxLocal->s32GOPLock = -1;
3287 #endif
3288
3289 #if GOP_XC_LOCK_SUPPORT
3290 char XC_MUTEX[] = "_XC_Mutex";
3291
3292 g_pGOPCtxLocal->s32GOPXC_MutexCnt = 0;
3293 g_pGOPCtxLocal->s32GOPXC_Mutex = MsOS_CreateMutex(E_MSOS_FIFO, (char *)XC_MUTEX, MSOS_PROCESS_SHARED);
3294 if (0 > g_pGOPCtxLocal->s32GOPXC_Mutex)
3295 {
3296 GOP_M_INFO("[%s][%06d] create XC mutex fail _GOPXC_Mutex=0x%lx\n", __FUNCTION__, __LINE__, g_pGOPCtxLocal->s32GOPXC_Mutex);
3297 }
3298 g_pGOPCtxLocal->s32GOPXC_Lock = -1;
3299 #endif
3300
3301 return TRUE;
3302 }
3303
3304
GOP_MapFB2Win(void * pInstance,MS_U32 u32fbId,MS_U32 GwinId)3305 MS_U32 GOP_MapFB2Win(void* pInstance,MS_U32 u32fbId, MS_U32 GwinId)
3306 {
3307 GOP_GwinInfo gWin;
3308 MS_U32 u32Temp;
3309 GOP_WinFB_INFO* pwinFB;
3310 GOP_WinFB_INFO* pwinFB2;
3311
3312 MS_BOOL bAFBC_Enable=FALSE;
3313 MS_U8 u8GOP=0;
3314 DRV_GOP_AFBC_Info sAFBCWinProperty;
3315 EN_DRV_GOP_AFBC_CNTL eAFBC_cmd=E_DRV_GOP_AFBC_MAX;
3316 memset(&sAFBCWinProperty, 0, sizeof(DRV_GOP_AFBC_Info));
3317 #ifdef INSTANT_PRIVATE
3318 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3319 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3320 #endif
3321
3322 if (u32fbId >= DRV_MAX_GWIN_FB_SUPPORT)
3323 {
3324 msWarning(ERR_FB_ID_OUT_OF_RANGE);
3325 GOP_M_ERR("[%s][%d]: fbId max already reached! FBId: %td, winId: %td\n",__FUNCTION__, __LINE__, (ptrdiff_t)u32fbId, (ptrdiff_t)GwinId);
3326 return (GOP_API_FAIL);
3327 }
3328
3329 if (!_GOP_IsGwinIdValid(pInstance,GwinId))
3330 {
3331 GOP_M_ERR("\n[%s][%d] not support gwin id:%td in this chip version",__FUNCTION__, __LINE__, (ptrdiff_t)GwinId);
3332 return (GOP_API_FAIL);
3333 }
3334 memset(&gWin, 0, sizeof(GOP_GwinInfo));
3335 pwinFB = _GetWinFB(pInstance,u32fbId);
3336
3337 if(pwinFB == NULL)
3338 {
3339 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
3340 return (GOP_API_FAIL);
3341 }
3342 //Add support to Map a Non-Created Gwin with a dedicated FB:
3343 if(!_GOP_GWIN_IsGwinCreated(pInstance,GwinId))
3344 {
3345 //Create GWin for The client:
3346 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GwinId].u32CurFBId = u32fbId;
3347
3348 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
3349 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GwinId].u32GOPClientId= (GETPIDTYPE)getpid();
3350 #else
3351 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GwinId].u32GOPClientId= g_pGOPCtxLocal->u32GOPClientId;
3352 #endif
3353
3354 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, GwinId, FALSE);
3355
3356 pwinFB->enable = TRUE;
3357 }
3358 u32Temp = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GwinId].u32CurFBId;
3359 if (DRV_MAX_GWIN_FB_SUPPORT > u32Temp)
3360 {
3361 pwinFB2 = _GetWinFB(pInstance,u32Temp);
3362
3363 if(pwinFB2 == NULL)
3364 {
3365 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32Temp);
3366 return (GOP_API_FAIL);
3367 }
3368
3369 msWarning(ERR_GWIN_ID_ALREADY_MAPPED);
3370 GOP_M_INFO("Warning: [%s][%d]: u8gwinId already assigned to fbId2(%td), fbId(%td)\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32Temp, (ptrdiff_t)u32fbId);
3371 pwinFB2->gWinId = GWIN_ID_INVALID;
3372 }
3373
3374 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GwinId].u32CurFBId= u32fbId;
3375
3376 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,GwinId ))
3377 {
3378 msWarning(ERR_GWIN_ID_OUT_OF_RANGE);
3379 GOP_M_ERR("[%s][%d]: winId=%td is not in existence\n",__FUNCTION__,__LINE__,(ptrdiff_t)GwinId);
3380 return (GOP_API_FAIL);
3381 }
3382
3383 pwinFB->gWinId = GwinId;
3384
3385 gWin.u16DispHPixelStart = pwinFB->x0;
3386 gWin.u16DispVPixelStart = pwinFB->y0;
3387 gWin.u16RBlkHPixSize = pwinFB->width;
3388 gWin.u16RBlkVPixSize = pwinFB->height;
3389 u32Temp = _GOP_CalcPitch(pInstance,pwinFB->fbFmt, pwinFB->width);
3390 if(pwinFB->pitch < u32Temp)
3391 {
3392 gWin.u16RBlkHRblkSize = (MS_U16)u32Temp;//FB's pitch is invalid
3393 }
3394 else
3395 {
3396 gWin.u16RBlkHRblkSize = pwinFB->pitch;//FB's pitch is ok
3397 }
3398 gWin.u16DispHPixelEnd = pwinFB->x1;
3399 gWin.u16DispVPixelEnd = pwinFB->y1;
3400 gWin.u32DRAMRBlkStart = pwinFB->addr;
3401 gWin.u16WinX = gWin.u16WinY = 0;
3402 gWin.clrType = (EN_GOP_COLOR_TYPE)pwinFB->fbFmt;
3403
3404 GOP_SetWinInfo(pInstance,GwinId,&gWin);
3405
3406 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,GwinId);
3407 if(g_pGOPCtxLocal->pGopChipProperty->bAFBC_Support[u8GOP]==TRUE)
3408 {
3409 _GOP_MAP_FBID_AFBCCmd(pInstance,u32fbId,&eAFBC_cmd,&bAFBC_Enable);
3410
3411 sAFBCWinProperty.u16HPixelStart = gWin.u16DispHPixelStart;
3412 sAFBCWinProperty.u16HPixelEnd = gWin.u16DispHPixelEnd;
3413 sAFBCWinProperty.u16Pitch = gWin.u16RBlkHRblkSize;
3414 sAFBCWinProperty.u16VPixelStart = gWin.u16DispVPixelStart;
3415 sAFBCWinProperty.u16VPixelEnd= gWin.u16DispVPixelEnd;
3416 sAFBCWinProperty.u64DRAMAddr = gWin.u32DRAMRBlkStart;
3417 sAFBCWinProperty.u8Fmt = (MS_U8)eAFBC_cmd;
3418 MDrv_GOP_GWIN_AFBCSetWindow(g_pGOPCtxLocal, u8GOP, &sAFBCWinProperty, TRUE);
3419
3420 MDrv_GOP_GWIN_AFBCMode(g_pGOPCtxLocal, u8GOP, bAFBC_Enable,eAFBC_cmd);
3421 }
3422 return GOP_API_SUCCESS;
3423 }
3424
3425
GOP_Set_Hscale(void * pInstance,MS_U8 u8GOP,MS_BOOL bEnable,MS_U16 src,MS_U16 dst)3426 MS_U32 GOP_Set_Hscale(void* pInstance,MS_U8 u8GOP,MS_BOOL bEnable, MS_U16 src, MS_U16 dst)
3427 {
3428
3429 #ifdef INSTANT_PRIVATE
3430 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3431 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3432 #endif
3433
3434 if(!g_pGOPCtxLocal->pGopChipProperty->bPixelModeSupport)
3435 {
3436 if (src > dst)
3437 {
3438 GOP_M_ERR("[%s][%d]GOP can not scaling down\n",__FUNCTION__,__LINE__);
3439 return GOP_API_FAIL;
3440 }
3441 }
3442
3443 if (bEnable)
3444 {
3445 g_pGOPCtxLocal->pGOPCtxShared->u16HScaleDst[u8GOP] = dst;
3446 }
3447 else
3448 {
3449 g_pGOPCtxLocal->pGOPCtxShared->u16HScaleDst[u8GOP] = 0;
3450 }
3451 MDrv_GOP_GWIN_Set_HSCALE(g_pGOPCtxLocal,u8GOP, bEnable, src, dst);
3452 MDrv_GOP_Set3DOSD_Middle(g_pGOPCtxLocal, u8GOP);
3453 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
3454 return GOP_API_SUCCESS;
3455 }
3456
GOP_Get_Hscale(void * pInstance,MS_U32 u32GopId)3457 MS_U16 GOP_Get_Hscale(void* pInstance,MS_U32 u32GopId)
3458 {
3459 MS_U16 HScaleRatio = SCALING_MULITPLIER;
3460 MS_U16 VScaleRatio = SCALING_MULITPLIER;
3461
3462 #ifdef INSTANT_PRIVATE
3463 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3464 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3465 #endif
3466
3467 MDrv_GOP_GWIN_Get_HVScaleRatio(g_pGOPCtxLocal, (MS_U8)u32GopId, &HScaleRatio, &VScaleRatio);
3468 return HScaleRatio;
3469 }
3470
GOP_Get_Vscale(void * pInstance,MS_U32 u32GopId)3471 MS_U16 GOP_Get_Vscale(void* pInstance,MS_U32 u32GopId)
3472 {
3473 MS_U16 HScaleRatio = SCALING_MULITPLIER;
3474 MS_U16 VScaleRatio = SCALING_MULITPLIER;
3475
3476 #ifdef INSTANT_PRIVATE
3477 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3478 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3479 #endif
3480
3481 MDrv_GOP_GWIN_Get_HVScaleRatio(g_pGOPCtxLocal, (MS_U8)u32GopId, &HScaleRatio, &VScaleRatio);
3482 return VScaleRatio;
3483 }
3484
GOP_Set_Vscale(void * pInstance,MS_U8 u8GOP,MS_BOOL bEnable,MS_U16 src,MS_U16 dst)3485 MS_U32 GOP_Set_Vscale(void* pInstance,MS_U8 u8GOP,MS_BOOL bEnable, MS_U16 src, MS_U16 dst)
3486 {
3487
3488 #ifdef INSTANT_PRIVATE
3489 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3490 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3491 #endif
3492
3493 if(!g_pGOPCtxLocal->pGopChipProperty->bPixelModeSupport)
3494 {
3495 if (src > dst)
3496 {
3497 GOP_M_ERR("[%s][%d]GOP can not scaling down\n",__FUNCTION__,__LINE__);
3498 return GOP_API_FAIL;
3499 }
3500 }
3501
3502 if (bEnable)
3503 {
3504 g_pGOPCtxLocal->pGOPCtxShared->u16VScaleDst[u8GOP] = dst;
3505 }
3506 else
3507 {
3508 g_pGOPCtxLocal->pGOPCtxShared->u16VScaleDst[u8GOP] = 0;
3509 }
3510 MDrv_GOP_GWIN_Set_VSCALE(g_pGOPCtxLocal, u8GOP,bEnable, src, dst);
3511 MDrv_GOP_Set3DOSD_Middle(g_pGOPCtxLocal, u8GOP);
3512 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
3513 return GOP_API_SUCCESS;
3514
3515 }
3516
GOP_SetStretchWin(void * pInstance,MS_U8 u8GOP_num,EN_GOP_DST_TYPE eDstType,MS_U16 x,MS_U16 y,MS_U16 width,MS_U16 height)3517 MS_U32 GOP_SetStretchWin(void* pInstance,MS_U8 u8GOP_num, EN_GOP_DST_TYPE eDstType,MS_U16 x, MS_U16 y, MS_U16 width, MS_U16 height)
3518 {
3519 MS_U16 u16OrgWidth, u16Temp;
3520
3521 #ifdef INSTANT_PRIVATE
3522 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3523 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3524 #endif
3525
3526 if (!_GOP_IsGopNumValid(pInstance,u8GOP_num))
3527 {
3528 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP_num);
3529 return GOP_API_FAIL;
3530 }
3531
3532 //Get real original hw Stretch win width
3533 _GOP_Get_StretchWin(pInstance,u8GOP_num, &u16Temp, &u16Temp, &u16OrgWidth, &u16Temp);
3534 _GOP_GWIN_Align_StretchWin(pInstance, u8GOP_num, eDstType, &x, &y, &width, &height, 16);
3535 //Store API use stretch window
3536 g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchWidth[u8GOP_num] = width;
3537 g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchHeight[u8GOP_num]= height;
3538
3539 _GOP_GWIN_Adjust_3DStretchWin(pInstance,u8GOP_num, &x, &y, &width, &height);
3540 if (u16OrgWidth <= width)//Set a large one, set htt first
3541 {
3542 MDrv_GOP_GWIN_SetHTotal(g_pGOPCtxLocal,u8GOP_num ,width);
3543 }
3544 MDrv_GOP_GWIN_SetStretchWin(g_pGOPCtxLocal, u8GOP_num, x, y, width, height);
3545 _GOP_InitHSPDByGOP(pInstance,u8GOP_num);
3546 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP_num);
3547
3548 if (u16OrgWidth > width)//Set a small one, set htt after Gwin regsiter updated
3549 {
3550 MDrv_GOP_GWIN_SetHTotal(g_pGOPCtxLocal,u8GOP_num ,width);
3551 }
3552
3553 return GOP_API_SUCCESS;
3554 }
3555
GOP_SetStretchWinPosition(void * pInstance,MS_U8 u8GOPNum,MS_U16 u16DispX,MS_U16 u16DispY)3556 MS_U32 GOP_SetStretchWinPosition(void* pInstance,MS_U8 u8GOPNum, MS_U16 u16DispX, MS_U16 u16DispY)
3557 {
3558 #ifdef INSTANT_PRIVATE
3559 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3560 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3561 #endif
3562
3563 MS_U16 u16SrcWidth;
3564 MS_U16 u16SrcHeight;
3565 MS_U16 u16StrenthWidth = g_pGOPCtxLocal->pGOPCtxShared->u16HScaleDst[u8GOPNum];
3566 MS_U16 u16StrenthHeight = g_pGOPCtxLocal->pGOPCtxShared->u16VScaleDst[u8GOPNum];
3567 MS_U16 u16PnlWidth = g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8GOPNum];
3568 MS_U16 u16PnlHeight = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8GOPNum];
3569 MS_U16 u16HStart = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOPNum];
3570 EN_GOP_DST_TYPE GopDst = MAX_GOP_DST_SUPPORT;
3571 DRV_GOPDstType enDst = E_DRV_GOP_DST_INVALID;
3572 MS_U16 u16Tmp = 0;
3573
3574 (MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOPNum, &enDst));
3575 //Fix me : tmp only for OP
3576 if(enDst != E_DRV_GOP_DST_OP0)
3577 {
3578 return GOP_API_SUCCESS;
3579 }
3580
3581 MDrv_GOP_GWIN_Get_StretchWin(g_pGOPCtxLocal, u8GOPNum, &u16Tmp, &u16Tmp, &u16SrcWidth, &u16SrcHeight);
3582
3583 if ((0 == u16StrenthWidth) || (0 == u16StrenthHeight))
3584 {
3585 MS_U16 u16HRatio = SCALING_MULITPLIER;
3586 MS_U16 u16VRatio = SCALING_MULITPLIER;
3587 MDrv_GOP_GWIN_Get_HVScaleRatio(g_pGOPCtxLocal, u8GOPNum, &u16HRatio, &u16VRatio);
3588 //get u16StrenthWidth or u16StrenthHeight from current ratio
3589
3590 if (g_pGOPCtxLocal->pGOPCtxShared->bHMirror && (0 != u16DispX))
3591 {
3592 // if x!=0 bHMirror = 1, up alignment the u16StrenthWidth, to make sure there is space lefted in the left of mirror panel
3593 u16StrenthWidth = (MS_U16)(((u16SrcWidth * SCALING_MULITPLIER) + u16HRatio) / u16HRatio);
3594 }
3595 else //None mirror or mirror+x=0
3596 {
3597 // if x=0 bHMirror = 1, down alignment the u16StrenthWidth, to make sure there is no space lefted in the left of mirror panel
3598 u16StrenthWidth = (MS_U16)((u16SrcWidth * SCALING_MULITPLIER) / u16HRatio);
3599 }
3600 if (g_pGOPCtxLocal->pGOPCtxShared->bVMirror && (0 != u16DispY))
3601 {
3602 // if y!=0 bVMirror = 1, up alignment the u16StrenthHeight, to make sure there is space lefted in the top of mirror panel
3603 u16StrenthHeight = (MS_U16)(((u16SrcHeight * SCALING_MULITPLIER) + u16VRatio) / u16VRatio);
3604 }
3605 else
3606 {
3607 // if y=0 bVMirror = 1, down alignment the u16StrenthHeight, to make sure there is no space lefted in the top of mirror panel
3608 u16StrenthHeight = (MS_U16)((u16SrcHeight * SCALING_MULITPLIER) / u16VRatio);
3609 }
3610 }
3611
3612 if(g_pGOPCtxLocal->pGopChipProperty->enGOP3DType == E_DRV_3D_DUP_FULL)
3613 {
3614 switch (g_pGOPCtxLocal->pGOPCtxShared->GOP_StereoMode[u8GOPNum])
3615 {
3616 case E_DRV_GOP_3D_LINE_ALTERNATIVE:
3617 case E_DRV_GOP_3D_TOP_BOTTOM:
3618 u16StrenthHeight = u16StrenthHeight <<1;
3619 break;
3620 case E_DRV_GOP_3D_LINE_FRAMEPACKING:
3621 u16StrenthHeight = u16StrenthHeight <<1;
3622 u16StrenthHeight += g_pGOPCtxLocal->u16GOPGWinMiddle[u8GOPNum];
3623 break;
3624 case E_DRV_GOP_3D_SIDE_BY_SYDE:
3625 u16StrenthWidth = u16StrenthWidth <<1;
3626 break;
3627 default:
3628 break;
3629 }
3630 }
3631 //error protect: width < panel width
3632 if (u16PnlWidth < u16StrenthWidth)
3633 {
3634 u16DispX = 0;
3635 u16StrenthWidth = u16PnlWidth;
3636 }
3637 else
3638 {
3639 //error protect: x+width < panel width +Hstart
3640 if (u16PnlWidth + u16HStart < u16DispX + u16StrenthWidth)
3641 {
3642 // allow strench win out of panel limited by HTT with OP dst
3643 u16DispX = 0;
3644 }
3645 }
3646 if (g_pGOPCtxLocal->pGOPCtxShared->bHMirror)
3647 {
3648 MS_U16 u16RightEnd = u16DispX + u16StrenthWidth;
3649 // adjust x axis for mirror
3650 if (u16PnlWidth > u16RightEnd)
3651 {
3652 u16DispX = u16PnlWidth - u16RightEnd;
3653 }
3654 else
3655 {
3656 u16DispX = 0;
3657 }
3658 }
3659
3660 //error protect: height < panel height
3661 if (u16PnlHeight < u16StrenthHeight)
3662 {
3663 u16DispY = 0;
3664 u16StrenthHeight = u16PnlHeight;
3665 }
3666 //error protect: y+height < panel height
3667 else if (u16PnlHeight < u16DispY + u16StrenthHeight)
3668 {
3669 u16DispY = 0;
3670 }
3671 if (g_pGOPCtxLocal->pGOPCtxShared->bVMirror)
3672 {
3673 // adjust y axis for mirror
3674 u16DispY = u16PnlHeight - u16DispY - u16StrenthHeight;
3675 }
3676
3677 _GOP_Map_DRVDst2API_Enum_(pInstance,&GopDst, enDst);
3678 _GOP_GWIN_Align_StretchWin(pInstance, u8GOPNum, GopDst, &u16DispX, &u16DispY, &u16Tmp, &u16Tmp, 16);
3679
3680 MDrv_GOP_GWIN_SetStretchWinPosition(g_pGOPCtxLocal, u8GOPNum, u16DispX, u16DispY);
3681 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOPNum);
3682
3683 return GOP_API_SUCCESS;
3684 }
3685
GOP_MultiSwitchByAddr(void * pInstance,PGOP_GWIN_FLIP_MULTI_WIN_INFO pMultiflip)3686 MS_BOOL GOP_MultiSwitchByAddr(void* pInstance,PGOP_GWIN_FLIP_MULTI_WIN_INFO pMultiflip)
3687 {
3688 MS_U8 u8GwinGOP,i = 0;
3689 MS_U32 u32GwinIdx = 0;
3690 GOP_WinFB_INFO* pwinFB;
3691 MS_GFLIP_MULTIINFO Multiinfo;
3692 MS_TLB_GFLIP_MULTIINFO TLBMultiinfo;
3693 MS_U8 u8MiuSel=0xFF;
3694 MS_U8 u8GWinBase=0;
3695 MS_BOOL bTLBenable=FALSE;
3696 #ifdef INSTANT_PRIVATE
3697 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3698 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3699 #endif
3700
3701 Multiinfo.u8GopInfoCnt = pMultiflip->u8InfoCnt;
3702 for(i = 0;i < (pMultiflip->u8InfoCnt);i++)
3703 {
3704 if (!_GOP_IsGwinIdValid(pInstance,pMultiflip->FlipInfo[i].GwinId))
3705 {
3706 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)pMultiflip->FlipInfo[i].GwinId);
3707 return FALSE;
3708 }
3709
3710 u8GwinGOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,pMultiflip->FlipInfo[i].GwinId);
3711 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGOP])
3712 {
3713 u8GWinBase=0;
3714 for(i=0;i<u8GwinGOP;i++)
3715 {
3716 u8GWinBase += MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, i);
3717 }
3718 if(pMultiflip->FlipInfo[i].GwinId != u8GWinBase)
3719 {
3720 GOP_M_INFO("\n[%s] not support TLB mode, gwin id:0x%tx ", __FUNCTION__, (ptrdiff_t)pMultiflip->FlipInfo[i].GwinId);
3721 }
3722 }
3723 switch(u8GwinGOP)
3724 {
3725 case E_GOP0:
3726 u32GwinIdx=pMultiflip->FlipInfo[i].GwinId;
3727 break;
3728 case E_GOP1:
3729 u32GwinIdx=pMultiflip->FlipInfo[i].GwinId-MAX_GOP0_GWIN;
3730 break;
3731 case E_GOP2:
3732 u32GwinIdx=pMultiflip->FlipInfo[i].GwinId-GOP2_Gwin0Id;
3733 break;
3734 case E_GOP3:
3735 u32GwinIdx=pMultiflip->FlipInfo[i].GwinId-GOP3_Gwin0Id;
3736 break;
3737 case E_GOP4:
3738 u32GwinIdx=pMultiflip->FlipInfo[i].GwinId-GOP4_Gwin0Id;
3739 break;
3740 case E_GOP5:
3741 u32GwinIdx=pMultiflip->FlipInfo[i].GwinId-GOP5_Gwin0Id;
3742 break;
3743 default:
3744 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GwinGOP);
3745 break;
3746 }
3747
3748 Multiinfo.astGopInfo[i].u32GopIdx = (MS_U32)u8GwinGOP;
3749 Multiinfo.astGopInfo[i].u32GwinIdx = u32GwinIdx;
3750 Multiinfo.astGopInfo[i].u64MainAddr = pMultiflip->FlipInfo[i].FlipAddr;
3751 Multiinfo.astGopInfo[i].u64SubAddr = pMultiflip->FlipInfo[i].SubFlipAddr;
3752 Multiinfo.astGopInfo[i].u32TagId = pMultiflip->FlipInfo[i].WaitTagID;
3753 Multiinfo.astGopInfo[i].u32QEntry = *(pMultiflip->FlipInfo[i].pQueueCnt);
3754 Multiinfo.astGopInfo[i].u32Result = TRUE;
3755
3756 if(g_pGOPCtxLocal->pGOPCtxShared->bGOP3DLRSwitch[u8GwinGOP])
3757 {
3758 //Do L/R switch
3759 MS_PHY u64Temp = Multiinfo.astGopInfo[i].u64MainAddr;
3760 Multiinfo.astGopInfo[i].u64MainAddr = Multiinfo.astGopInfo[i].u64SubAddr;
3761 Multiinfo.astGopInfo[i].u64SubAddr = u64Temp;
3762 }
3763
3764 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGOP])
3765 {
3766 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
3767 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
3768 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GwinGOP, &GopDst);
3769 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
3770 if(bHMirror || bVMirror)
3771 {
3772 GOP_GwinInfo stGwinInfo;
3773 GOP_GetWinInfo(pInstance,pMultiflip->FlipInfo[i].GwinId, &stGwinInfo);
3774 stGwinInfo.u32DRAMRBlkStart = Multiinfo.astGopInfo[i].u64MainAddr;
3775 g_pGOPCtxLocal->sMirrorInfo[u32GwinIdx].u64NonMirrorFBAdr = stGwinInfo.u32DRAMRBlkStart;
3776 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,pMultiflip->FlipInfo[i].GwinId, bHMirror, bVMirror, &stGwinInfo);
3777 Multiinfo.astGopInfo[i].u64MainAddr = stGwinInfo.u32DRAMRBlkStart;
3778
3779 stGwinInfo.u32DRAMRBlkStart = Multiinfo.astGopInfo[i].u64SubAddr;
3780 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,pMultiflip->FlipInfo[i].GwinId, bHMirror, bVMirror, &stGwinInfo);
3781 Multiinfo.astGopInfo[i].u64SubAddr = stGwinInfo.u32DRAMRBlkStart;
3782 }
3783 }
3784 else
3785 {
3786 if(u8GwinGOP > GOPTYPE.GOP0)
3787 {
3788 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
3789 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
3790 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GwinGOP, &GopDst);
3791 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
3792 if(bHMirror || bVMirror)
3793 {
3794 GOP_GwinInfo stGwinInfo;
3795 GOP_GetWinInfo(pInstance,pMultiflip->FlipInfo[i].GwinId, &stGwinInfo);
3796 stGwinInfo.u32DRAMRBlkStart = Multiinfo.astGopInfo[i].u64MainAddr;
3797 g_pGOPCtxLocal->sMirrorInfo[u32GwinIdx].u64NonMirrorFBAdr = stGwinInfo.u32DRAMRBlkStart;
3798 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,pMultiflip->FlipInfo[i].GwinId, bHMirror, bVMirror, &stGwinInfo);
3799 Multiinfo.astGopInfo[i].u64MainAddr = stGwinInfo.u32DRAMRBlkStart;
3800
3801 stGwinInfo.u32DRAMRBlkStart = Multiinfo.astGopInfo[i].u64SubAddr;
3802 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,pMultiflip->FlipInfo[i].GwinId, bHMirror, bVMirror, &stGwinInfo);
3803 Multiinfo.astGopInfo[i].u64SubAddr = stGwinInfo.u32DRAMRBlkStart;
3804
3805 }
3806 }
3807 }
3808 //GOP HW just read the relative offset of each MIU
3809 _phy_to_miu_offset(u8MiuSel, Multiinfo.astGopInfo[i].u64MainAddr, Multiinfo.astGopInfo[i].u64MainAddr);
3810
3811 //GOP HW just read the relative offset of each MIU
3812 _phy_to_miu_offset(u8MiuSel, Multiinfo.astGopInfo[i].u64SubAddr, Multiinfo.astGopInfo[i].u64SubAddr);
3813
3814 TLBMultiinfo.astTLBGopInfo[i].u32GopIdx = Multiinfo.astGopInfo[i].u32GopIdx;
3815 TLBMultiinfo.astTLBGopInfo[i].u32GwinIdx = Multiinfo.astGopInfo[i].u32GwinIdx;
3816 TLBMultiinfo.astTLBGopInfo[i].u64MainAddr = Multiinfo.astGopInfo[i].u64MainAddr;
3817 TLBMultiinfo.astTLBGopInfo[i].u32TagId = Multiinfo.astGopInfo[i].u32TagId;
3818 TLBMultiinfo.astTLBGopInfo[i].u32QEntry = Multiinfo.astGopInfo[i].u32QEntry;
3819 TLBMultiinfo.astTLBGopInfo[i].u32Result = Multiinfo.astGopInfo[i].u32Result;
3820 TLBMultiinfo.astTLBGopInfo[i].u64SubAddr = Multiinfo.astGopInfo[i].u64SubAddr;
3821 TLBMultiinfo.astTLBGopInfo[i].bTLBEnable = g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGOP];
3822 TLBMultiinfo.astTLBGopInfo[i].u64TLBAddr = g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[u8GwinGOP];
3823
3824 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGOP])
3825 {
3826 bTLBenable=TRUE;
3827 }
3828 }
3829 TLBMultiinfo.u8GopInfoCnt=Multiinfo.u8GopInfoCnt;
3830
3831 if(bTLBenable == TRUE)
3832 {
3833 if(MDrv_GFLIP_SetTLBMultiFlipInfo(g_pGOPCtxLocal,&TLBMultiinfo))
3834 {
3835 for(i = 0;i < (pMultiflip->u8InfoCnt);i++)
3836 {
3837 if(g_pGOPCtxLocal->pGOPCtxShared->gwinMap[pMultiflip->FlipInfo[i].GwinId].u32CurFBId<DRV_MAX_GWIN_FB_SUPPORT)
3838 {
3839 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[pMultiflip->FlipInfo[i].GwinId].u32CurFBId);
3840 pwinFB->gWinId = GWIN_ID_INVALID;
3841 }
3842 *(pMultiflip->FlipInfo[i].pQueueCnt) = Multiinfo.astGopInfo[i].u32QEntry;
3843 }
3844 return TRUE;
3845 }
3846 }
3847 else
3848 {
3849 if(MDrv_GFLIP_SetMultiFlipInfo(g_pGOPCtxLocal,&Multiinfo))
3850 {
3851 for(i = 0;i < (pMultiflip->u8InfoCnt);i++)
3852 {
3853 if(g_pGOPCtxLocal->pGOPCtxShared->gwinMap[pMultiflip->FlipInfo[i].GwinId].u32CurFBId<DRV_MAX_GWIN_FB_SUPPORT)
3854 {
3855 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[pMultiflip->FlipInfo[i].GwinId].u32CurFBId);
3856 pwinFB->gWinId = GWIN_ID_INVALID;
3857 }
3858 *(pMultiflip->FlipInfo[i].pQueueCnt) = Multiinfo.astGopInfo[i].u32QEntry;
3859 }
3860 return TRUE;
3861 }
3862 }
3863 return FALSE;
3864 }
3865
GOP_SwitchByAddr(void * pInstance,MS_U32 gWinId,MS_PHY u64MainFlipAddr,MS_PHY u64SubFlipAddr,MS_U16 u32WaitTagID,MS_U32 * pU32QueueCnt,MS_BOOL b3DEn)3866 MS_BOOL GOP_SwitchByAddr(void* pInstance,MS_U32 gWinId, MS_PHY u64MainFlipAddr, MS_PHY u64SubFlipAddr, MS_U16 u32WaitTagID, MS_U32 *pU32QueueCnt, MS_BOOL b3DEn)
3867 {
3868 MS_U8 u8GwinGOP;
3869 MS_U32 u32QueueCnt=0;
3870 GOP_WinFB_INFO* pwinFB;
3871 MS_U8 u8GWinBase=0;
3872 MS_U8 i;
3873
3874 #ifdef INSTANT_PRIVATE
3875 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3876 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3877 #endif
3878
3879 if (!_GOP_IsGwinIdValid(pInstance,gWinId))
3880 {
3881 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gWinId);
3882 return FALSE;
3883 }
3884
3885 u8GwinGOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,gWinId);
3886 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGOP])
3887 {
3888 u8GWinBase=0;
3889 for(i=0;i<u8GwinGOP;i++)
3890 {
3891 u8GWinBase += MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, i);
3892 }
3893 if(gWinId != u8GWinBase)
3894 {
3895 GOP_M_INFO("\n[%s] not support TLB mode, gwin id:0x%tx ", __FUNCTION__, (ptrdiff_t)gWinId);
3896 }
3897 }
3898
3899 if(g_pGOPCtxLocal->pGOPCtxShared->bGOP3DLRSwitch[u8GwinGOP])
3900 {
3901 //Do L/R switch
3902 MS_PHY u64Temp = u64MainFlipAddr;
3903 u64MainFlipAddr = u64SubFlipAddr;
3904 u64SubFlipAddr = u64Temp;
3905 }
3906
3907 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGOP])
3908 {
3909 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
3910 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
3911 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GwinGOP, &GopDst);
3912 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
3913 if(bHMirror || bVMirror)
3914 {
3915 GOP_GwinInfo stGwinInfo;
3916 GOP_GetWinInfo(pInstance,gWinId, &stGwinInfo);
3917 stGwinInfo.u32DRAMRBlkStart = u64MainFlipAddr;
3918 g_pGOPCtxLocal->sMirrorInfo[gWinId].u64NonMirrorFBAdr = u64MainFlipAddr;
3919 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,gWinId, bHMirror, bVMirror, &stGwinInfo);
3920 u64MainFlipAddr = stGwinInfo.u32DRAMRBlkStart;
3921
3922 stGwinInfo.u32DRAMRBlkStart = u64SubFlipAddr;
3923 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,gWinId, bHMirror, bVMirror, &stGwinInfo);
3924 u64SubFlipAddr = stGwinInfo.u32DRAMRBlkStart;
3925 }
3926 }
3927 else
3928 {
3929 if(u8GwinGOP > GOPTYPE.GOP0)
3930 {
3931 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
3932 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
3933 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GwinGOP, &GopDst);
3934 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
3935 if(bHMirror || bVMirror)
3936 {
3937 GOP_GwinInfo stGwinInfo;
3938 GOP_GetWinInfo(pInstance,gWinId, &stGwinInfo);
3939 stGwinInfo.u32DRAMRBlkStart = u64MainFlipAddr;
3940 g_pGOPCtxLocal->sMirrorInfo[gWinId].u64NonMirrorFBAdr = u64MainFlipAddr;
3941 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,gWinId, bHMirror, bVMirror, &stGwinInfo);
3942 u64MainFlipAddr = stGwinInfo.u32DRAMRBlkStart;
3943
3944 stGwinInfo.u32DRAMRBlkStart = u64SubFlipAddr;
3945 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,gWinId, bHMirror, bVMirror, &stGwinInfo);
3946 u64SubFlipAddr = stGwinInfo.u32DRAMRBlkStart;
3947
3948 }
3949 }
3950 }
3951 u32QueueCnt = *pU32QueueCnt;
3952
3953 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gWinId].u32CurFBId);
3954
3955 if(b3DEn == 0)
3956 {
3957 u64SubFlipAddr = 0;
3958 }
3959
3960 if(MDrv_GOP_SwitchGWIN2Addr(g_pGOPCtxLocal, gWinId, u64MainFlipAddr, u64SubFlipAddr, u32WaitTagID, &u32QueueCnt))
3961 {
3962 if( g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gWinId].u32CurFBId<DRV_MAX_GWIN_FB_SUPPORT)
3963 pwinFB->gWinId = GWIN_ID_INVALID;
3964
3965 *pU32QueueCnt = (MS_U16)u32QueueCnt;
3966 return TRUE;
3967 }
3968
3969 return FALSE;
3970 }
3971
GOP_SwitchByFBID(void * pInstance,MS_U32 gWinId,MS_U32 u32fbId,MS_U32 u32WaitTagID,MS_U32 * pU32QueueCnt)3972 MS_BOOL GOP_SwitchByFBID(void* pInstance,MS_U32 gWinId, MS_U32 u32fbId, MS_U32 u32WaitTagID, MS_U32* pU32QueueCnt)
3973 {
3974 MS_U8 u8GwinGop;
3975 MS_PHY u64FlipAddr;
3976 GOP_WinFB_INFO* pwinFB;
3977 MS_U8 u8GWinBase=0;
3978 MS_U8 i;
3979
3980 #ifdef INSTANT_PRIVATE
3981 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
3982 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
3983 #endif
3984
3985 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
3986 {
3987 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
3988 return FALSE;
3989 }
3990 if (!_GOP_IsGwinIdValid(pInstance,gWinId))
3991 {
3992 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gWinId);
3993 return FALSE;
3994 }
3995 if(!_GOP_GWIN_IsGwinExistInClient(pInstance,gWinId))
3996 {
3997 msWarning(ERR_FB_ID_OUT_OF_RANGE);
3998 GOP_M_ERR("[%s][%d]GWIN %td is not exist\n",__FUNCTION__,__LINE__,(ptrdiff_t)gWinId);
3999 return FALSE;
4000 }
4001
4002 pwinFB = _GetWinFB(pInstance,u32fbId);
4003
4004 if(pwinFB == NULL)
4005 {
4006 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
4007 return FALSE;
4008 }
4009
4010 if(pwinFB->in_use == 0)
4011 {
4012 msWarning(ERR_FB_ID_NOT_ALLOCATED);
4013 GOP_M_ERR("%s: fbId=%td is not in existence\n",__FUNCTION__,(ptrdiff_t)u32fbId);
4014 return FALSE;
4015 }
4016
4017 u8GwinGop = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,gWinId);
4018 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGop])
4019 {
4020 u8GWinBase=0;
4021 for(i=0;i<u8GwinGop;i++)
4022 {
4023 u8GWinBase += MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, i);
4024 }
4025 if(gWinId != u8GWinBase)
4026 {
4027 GOP_M_INFO("\n[%s] not support TLB mode, gwin id:0x%tx ", __FUNCTION__, (ptrdiff_t)gWinId);
4028 }
4029 }
4030 u64FlipAddr = pwinFB->addr;
4031
4032 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GwinGop])
4033 {
4034 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
4035 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
4036 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GwinGop, &GopDst);
4037 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
4038 if(bHMirror || bVMirror)
4039 {
4040 GOP_GwinInfo stGwinInfo;
4041 GOP_GetWinInfo(pInstance,gWinId, &stGwinInfo);
4042 stGwinInfo.u32DRAMRBlkStart = u64FlipAddr;
4043 g_pGOPCtxLocal->sMirrorInfo[gWinId].u64NonMirrorFBAdr = u64FlipAddr;
4044 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,gWinId, bHMirror, bVMirror, &stGwinInfo);
4045 u64FlipAddr = stGwinInfo.u32DRAMRBlkStart;
4046 }
4047 }
4048 else
4049 {
4050 if(u8GwinGop > GOPTYPE.GOP0)
4051 {
4052 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
4053 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
4054 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GwinGop, &GopDst);
4055 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
4056 if(bHMirror || bVMirror)
4057 {
4058 GOP_GwinInfo stGwinInfo;
4059 GOP_GetWinInfo(pInstance,gWinId, &stGwinInfo);
4060 stGwinInfo.u32DRAMRBlkStart = u64FlipAddr;
4061 g_pGOPCtxLocal->sMirrorInfo[gWinId].u64NonMirrorFBAdr = u64FlipAddr;
4062 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,gWinId, bHMirror, bVMirror, &stGwinInfo);
4063 u64FlipAddr = stGwinInfo.u32DRAMRBlkStart;
4064 }
4065 }
4066 }
4067 if(MDrv_GOP_SwitchGWIN2Addr(g_pGOPCtxLocal, gWinId, u64FlipAddr, (MS_U32)0, u32WaitTagID, pU32QueueCnt))
4068 {
4069 GOP_WinFB_INFO* pCurwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gWinId].u32CurFBId);
4070
4071 if(pCurwinFB == NULL)
4072 {
4073 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gWinId].u32CurFBId);
4074 return FALSE;
4075 }
4076
4077 if( g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gWinId].u32CurFBId<DRV_MAX_GWIN_FB_SUPPORT)
4078 pCurwinFB->gWinId = GWIN_ID_INVALID;
4079
4080 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gWinId].u32CurFBId = u32fbId;
4081 return TRUE;
4082 }
4083
4084 return FALSE;
4085 }
4086
4087
GOP_MIUSel(void * pInstance,MS_U8 u8GOP,EN_GOP_SEL_TYPE MiuSel)4088 MS_U32 GOP_MIUSel(void* pInstance,MS_U8 u8GOP, EN_GOP_SEL_TYPE MiuSel )
4089 {
4090 #ifdef INSTANT_PRIVATE
4091 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4092 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4093 #endif
4094
4095 MDrv_GOP_MIU_Sel(g_pGOPCtxLocal,u8GOP,(E_DRV_GOP_SEL_TYPE)MiuSel);
4096
4097 return GOP_API_SUCCESS;
4098 }
4099
GOP_GetMIUSel(void * pInstance,MS_U8 u8GOP)4100 MS_U8 GOP_GetMIUSel(void* pInstance,MS_U8 u8GOP)
4101 {
4102 #ifdef INSTANT_PRIVATE
4103 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4104 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4105 #endif
4106
4107 return MDrv_GOP_Get_MIU_Sel(g_pGOPCtxLocal,u8GOP);
4108
4109 }
4110
GOP_SetAlphaInverse(void * pInstance,MS_U32 gop,MS_BOOL bEn)4111 MS_U32 GOP_SetAlphaInverse(void* pInstance,MS_U32 gop, MS_BOOL bEn)
4112 {
4113 #ifdef INSTANT_PRIVATE
4114 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4115 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4116 #endif
4117
4118 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, gop, bEn);
4119 return GOP_API_SUCCESS;
4120 }
GOP_GetAlphaInverse(void * pInstance,MS_U32 gop)4121 MS_BOOL GOP_GetAlphaInverse(void* pInstance,MS_U32 gop)
4122 {
4123 MS_BOOL bEn;
4124 #ifdef INSTANT_PRIVATE
4125 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4126 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4127 #endif
4128 MDrv_GOP_GWIN_GetAlphaInverse(g_pGOPCtxLocal,gop, &bEn);
4129 return GOP_API_SUCCESS;
4130 }
4131
GOP_SetContrast(void * pInstance,MS_U8 u8GOP,MS_U16 u16YContrast,MS_U16 u16UContrast,MS_U16 u16VContrast)4132 MS_U32 GOP_SetContrast(void* pInstance,MS_U8 u8GOP, MS_U16 u16YContrast, MS_U16 u16UContrast, MS_U16 u16VContrast )
4133 {
4134 E_GOP_API_Result enRet = GOP_API_FAIL;
4135
4136 #ifdef INSTANT_PRIVATE
4137 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4138 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4139 #endif
4140
4141 enRet = (E_GOP_API_Result)MDrv_GOP_SetGOPContrast( g_pGOPCtxLocal, u8GOP, u16YContrast, u16UContrast, u16VContrast );
4142
4143 return enRet;
4144 }
4145
GOP_GetContrast(void * pInstance,MS_U8 u8GOP,MS_U32 * YContrast,MS_U32 * UContrast,MS_U32 * VContrast)4146 MS_U32 GOP_GetContrast(void* pInstance,MS_U8 u8GOP, MS_U32* YContrast, MS_U32* UContrast, MS_U32* VContrast )
4147 {
4148 E_GOP_API_Result enRet= GOP_API_FAIL;
4149
4150 #ifdef INSTANT_PRIVATE
4151 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4152 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4153 #endif
4154
4155 enRet = (E_GOP_API_Result)MDrv_GOP_GetGOPContrast( g_pGOPCtxLocal, u8GOP, YContrast, UContrast, VContrast );
4156 return enRet;
4157 }
4158
4159
4160
GOP_SetBrightness(void * pInstance,MS_U8 u8GOP,MS_U16 u16BriVal,MS_BOOL bMSB)4161 MS_U32 GOP_SetBrightness(void* pInstance,MS_U8 u8GOP,MS_U16 u16BriVal,MS_BOOL bMSB)
4162 {
4163 E_GOP_API_Result enRet=GOP_API_FAIL;
4164
4165 #ifdef INSTANT_PRIVATE
4166 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4167 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4168 #endif
4169
4170 enRet = (E_GOP_API_Result)MDrv_GOP_SetGOPBrightness(g_pGOPCtxLocal, u8GOP, u16BriVal,bMSB);
4171
4172 return enRet;
4173 }
4174
GOP_GetBrightness(void * pInstance,MS_U8 u8GOP,MS_U16 * u16BriVal,MS_BOOL * bMSB)4175 MS_U32 GOP_GetBrightness(void* pInstance,MS_U8 u8GOP,MS_U16* u16BriVal,MS_BOOL* bMSB)
4176 {
4177 E_GOP_API_Result enRet=GOP_API_FAIL;
4178
4179 #ifdef INSTANT_PRIVATE
4180 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4181 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4182 #endif
4183
4184 enRet =(E_GOP_API_Result)MDrv_GOP_GetGOPBrightness(g_pGOPCtxLocal,u8GOP,u16BriVal,bMSB);
4185
4186 return enRet;
4187 }
4188
4189
GOP_SetOutputColor(void * pInstance,MS_U8 u8GOP,EN_GOP_OUTPUT_COLOR type)4190 MS_U32 GOP_SetOutputColor(void* pInstance,MS_U8 u8GOP, EN_GOP_OUTPUT_COLOR type)
4191 {
4192
4193 #ifdef INSTANT_PRIVATE
4194 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4195 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4196 #endif
4197
4198 g_pGOPCtxLocal->pGOPCtxShared->s32OutputColorType[u8GOP] = (MS_S32)type;
4199 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, (GOP_OupputColor)type);
4200
4201 return GOP_API_SUCCESS;
4202 }
4203
GOP_SetUVSwap(void * pInstance,MS_U8 u8GOP,MS_BOOL bEn)4204 MS_U32 GOP_SetUVSwap(void* pInstance,MS_U8 u8GOP, MS_BOOL bEn)
4205 {
4206
4207 #ifdef INSTANT_PRIVATE
4208 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4209 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4210 #endif
4211
4212 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4213 {
4214 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4215 return GOP_API_FAIL;
4216 }
4217
4218 MDrv_GOP_SetUVSwap(g_pGOPCtxLocal, u8GOP, bEn);
4219 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
4220
4221 return GOP_API_SUCCESS;
4222
4223 }
4224
4225
GOP_SetYCSwap(void * pInstance,MS_U8 u8GOP,MS_BOOL bEn)4226 MS_U32 GOP_SetYCSwap(void* pInstance,MS_U8 u8GOP, MS_BOOL bEn)
4227 {
4228
4229 #ifdef INSTANT_PRIVATE
4230 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4231 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4232 #endif
4233
4234 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4235 {
4236 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4237 return GOP_API_FAIL;
4238 }
4239
4240
4241 MDrv_GOP_SetYCSwap(g_pGOPCtxLocal, u8GOP, bEn);
4242 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
4243
4244 return GOP_API_SUCCESS;
4245
4246 }
4247
GOP_SetProgressive(void * pInstance,MS_U8 gop,MS_BOOL bEn)4248 MS_U32 GOP_SetProgressive(void* pInstance,MS_U8 gop,MS_BOOL bEn)
4249 {
4250 MS_U8 u8WinIdx = 0x0;
4251 MS_U8 u8GopIdx = 0x0;
4252 MS_U8 u8StartWin = 0x0;
4253 MS_U8 u8EndWin = 0x0;
4254 MS_U8 i = 0x0;
4255 MS_U8 u8GOPGwinMaxCount = 0x0;
4256 MS_U16 u16StretchX = 0x0;
4257 MS_U16 u16StretchY = 0x0;
4258 MS_U16 u16StretchW = 0x0;
4259 MS_U16 u16StretchH = 0x0;
4260 GOP_WinFB_INFO* pwinFB;
4261 DRV_GOPDstType enDst = E_DRV_GOP_DST_INVALID;
4262 EN_GOP_DST_TYPE GopDst = E_GOP_DST_OP0;
4263 #ifdef INSTANT_PRIVATE
4264 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4265 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4266 #endif
4267
4268 for (i=0; i < MAX_GOP_SUPPORT; i++)
4269 {
4270 if(u8GOPGwinMaxCount<MDrv_GOP_GetGwinNum(pInstance, i))
4271 u8GOPGwinMaxCount=MDrv_GOP_GetGwinNum(pInstance, i);
4272 }
4273 GOP_GwinInfo winInfo[u8GOPGwinMaxCount];
4274 MS_BOOL bGwinFBInit[u8GOPGwinMaxCount];
4275 memset(winInfo,0,sizeof(GOP_GwinInfo)*u8GOPGwinMaxCount);
4276 memset(bGwinFBInit,0,sizeof(MS_BOOL)*u8GOPGwinMaxCount);
4277
4278 for (u8GopIdx = 0; u8GopIdx < gop; u8GopIdx++)
4279 {
4280 u8StartWin += MDrv_GOP_GetGwinNum(pInstance, u8GopIdx);
4281 }
4282 u8EndWin = u8StartWin + MDrv_GOP_GetGwinNum(pInstance, gop);
4283
4284 if((u8EndWin-u8StartWin)>u8GOPGwinMaxCount)
4285 {
4286 printf("[%s][%d]GWINCount %d is out of range\n",__FUNCTION__,__LINE__,u8EndWin-u8StartWin);
4287 return GOP_API_FAIL;
4288 }
4289
4290 for (i=0,u8WinIdx=u8StartWin; u8WinIdx<u8EndWin; u8WinIdx++,i++)
4291 {
4292 if (!_GOP_IsFbIdValid(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8WinIdx].u32CurFBId))
4293 {
4294 continue;
4295 }
4296 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u8WinIdx].u32CurFBId);
4297 if(pwinFB == NULL)
4298 bGwinFBInit[i]=FALSE;
4299 else
4300 bGwinFBInit[i]=TRUE;
4301 }
4302
4303 for (i=0,u8WinIdx=u8StartWin; u8WinIdx<u8EndWin; u8WinIdx++,i++)
4304 {
4305 if(bGwinFBInit[i])
4306 GOP_GetWinInfo(pInstance, u8WinIdx, &winInfo[i]);
4307 }
4308 _GOP_Get_StretchWin(pInstance, gop, &u16StretchX, &u16StretchY, &u16StretchW, &u16StretchH);
4309
4310 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, gop, bEn);
4311
4312 for (i=0,u8WinIdx=u8StartWin; u8WinIdx<u8EndWin; u8WinIdx++,i++)
4313 {
4314 if(bGwinFBInit[i])
4315 GOP_SetWinInfo(pInstance, u8WinIdx, &winInfo[i]);
4316 }
4317
4318 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, gop, &enDst);
4319 _GOP_Map_DRVDst2API_Enum_(pInstance,&GopDst, enDst);
4320 GOP_SetStretchWin(pInstance, gop, GopDst, u16StretchX, u16StretchY, u16StretchW, u16StretchH);
4321 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,gop);
4322 return GOP_API_SUCCESS;
4323 }
4324
GOP_SetHStart(void * pInstance,MS_U8 u8GOP,MS_U16 u16PanelHStr)4325 MS_U32 GOP_SetHStart(void* pInstance,MS_U8 u8GOP,MS_U16 u16PanelHStr)
4326 {
4327
4328 #ifdef INSTANT_PRIVATE
4329 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4330 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4331 #endif
4332
4333 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4334 {
4335 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4336 return GOP_API_FAIL;
4337 }
4338
4339 g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOP] = u16PanelHStr;
4340 _GOP_InitHSPDByGOP(pInstance,u8GOP);
4341 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal, u8GOP);
4342 return GOP_API_SUCCESS;
4343
4344 }
4345
GOP_SetPanelTiming(void * pInstance,MS_U8 u8GOP,PST_GOP_TIMING_INFO pstInfo)4346 MS_U32 GOP_SetPanelTiming(void* pInstance,MS_U8 u8GOP,PST_GOP_TIMING_INFO pstInfo)
4347 {
4348 #ifdef INSTANT_PRIVATE
4349 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4350 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4351 #endif
4352
4353 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4354 {
4355 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4356 return GOP_API_FAIL;
4357 }
4358
4359 g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOP] = pstInfo->u16DEHStart;
4360 g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8GOP] = pstInfo->u16DEHSize;
4361 g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8GOP] = pstInfo->u16DEVSize;
4362 _GOP_InitHSPDByGOP(pInstance,u8GOP);
4363 return GOP_API_SUCCESS;
4364 }
4365
GOP_GetPanelTiming(void * pInstance,MS_U8 u8GOP,PST_GOP_TIMING_INFO pstInfo)4366 MS_U32 GOP_GetPanelTiming(void* pInstance,MS_U8 u8GOP,PST_GOP_TIMING_INFO pstInfo)
4367 {
4368 #ifdef INSTANT_PRIVATE
4369 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4370 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4371 #endif
4372
4373 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4374 {
4375 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4376 return GOP_API_FAIL;
4377 }
4378
4379 pstInfo->u16DEHStart = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOP];
4380 pstInfo->u16DEHSize = g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8GOP];
4381 pstInfo->u16DEVSize = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8GOP];
4382 return GOP_API_SUCCESS;
4383 }
4384
GOP_CreateBuffer(void * pInstance,PGOP_BUFFER_INFO pBuff,MS_U32 fbid)4385 MS_U32 GOP_CreateBuffer(void* pInstance,PGOP_BUFFER_INFO pBuff,MS_U32 fbid)
4386 {
4387 _GOP_GWIN_CreatePoolFB(pInstance,fbid,pBuff->disp_rect.x,pBuff->disp_rect.y,pBuff->disp_rect.w,pBuff->disp_rect.h,pBuff->fbFmt,pBuff->FBString);
4388 return GOP_API_SUCCESS;
4389 }
GOP_CreateBufferByAddr(void * pInstance,PGOP_BUFFER_INFO pBuff,MS_U32 u32fbId)4390 MS_U32 GOP_CreateBufferByAddr(void* pInstance,PGOP_BUFFER_INFO pBuff,MS_U32 u32fbId)
4391 {
4392 MS_U32 size;
4393 GOP_WinFB_INFO* pwinFB;
4394 MS_U32 width;
4395 MS_U32 height;
4396 MS_U32 pitch;
4397 MS_U32 fbFmt;
4398 MS_U32 u32FbAddr;
4399 MS_U32 dispX,dispY;
4400 EN_GOP_FRAMEBUFFER_STRING FBString;
4401
4402
4403 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
4404 {
4405 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
4406 return GWIN_NO_AVAILABLE;
4407 }
4408
4409 pwinFB = _GetWinFB(pInstance,u32fbId);
4410
4411 if(pwinFB == NULL)
4412 {
4413 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
4414 return GWIN_NO_AVAILABLE;
4415 }
4416
4417 if(pwinFB->in_use)
4418 {
4419 msWarning(ERR_FB_ID_ALREADY_ALLOCATED);
4420 GOP_M_ERR("[%s][%d]FbId %td is already allocated\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
4421 return GWIN_NO_AVAILABLE;
4422
4423 }
4424
4425 GOP_M_INFO("[%s][%d]: new gwinFBId = %td \n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId);
4426
4427
4428 width = pBuff->width;
4429 height = pBuff->height;
4430 pitch = pBuff->pitch;
4431 fbFmt = pBuff->fbFmt;
4432 dispX = pBuff->disp_rect.x;
4433 dispY = pBuff->disp_rect.y;
4434 u32FbAddr = pBuff->addr;
4435 FBString = pBuff->FBString;
4436
4437 size = _GOP_CalcPitch(pInstance,fbFmt, width) *height;
4438
4439 pwinFB->enable = FALSE;
4440 pwinFB->in_use = 1;
4441 pwinFB->obtain = 1;
4442 pwinFB->x0 = dispX;
4443 pwinFB->y0 = dispY;
4444 pwinFB->width = width;
4445 pwinFB->height= height;
4446 pwinFB->x1 = pwinFB->x0 + width;
4447 pwinFB->y1 = pwinFB->y0 +height;
4448 pwinFB->addr = u32FbAddr; //addr;
4449 pwinFB->size = size;
4450 pwinFB->FBString = (EN_DRV_FRAMEBUFFER_STRING)FBString;
4451
4452 // FB format
4453 pwinFB->fbFmt = (fbFmt != FB_FMT_AS_DEFAULT) ? fbFmt : E_MS_FMT_ARGB1555;//g_pGOPCtxLocal->winFB[g_pGOPCtxLocal->pGOPCtxShared->gwinMap[GWIN_OSD_DEFAULT]].fbFmt;
4454 if(pitch ==0)
4455 {
4456 pwinFB->pitch = _GOP_CalcPitch(pInstance,fbFmt, width);
4457 }
4458 else
4459 {
4460 pwinFB->pitch = pitch;
4461 }
4462 // update ptrs
4463 pwinFB->poolId = GOP_WINFB_POOL_NULL;
4464 pwinFB->nextFBIdInPool = INVALID_POOL_NEXT_FBID;
4465 pwinFB->string = E_GOP_FB_NULL;
4466 pwinFB->u32GOPClientId = (GETPIDTYPE)getpid();
4467 GOP_M_INFO("\33[0;36m %s:%d FBId = %td \33[m \n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId);
4468
4469 return GOP_API_SUCCESS;
4470 }
4471
4472
GOP_Win_Destroy_Abnormal(void * pInstance,MS_U32 gId)4473 MS_U32 GOP_Win_Destroy_Abnormal(void* pInstance,MS_U32 gId)
4474 {
4475 MS_U32 u32fbId;
4476 GOP_GwinInfo gWin;
4477 GOP_WinFB_INFO* pwinFB;
4478 MS_U8 u8GOP,u8MIU;
4479
4480 #ifdef INSTANT_PRIVATE
4481 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4482 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4483 #endif
4484
4485 GOP_M_INFO("\33[0;36m %s:%d gId = %td \33[m \n",__FUNCTION__,__LINE__,(ptrdiff_t)gId);
4486
4487 if (!_GOP_IsGwinIdValid(pInstance,gId))
4488 {
4489 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gId);
4490 return GOP_API_FAIL;
4491 }
4492
4493 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, gId, FALSE);
4494 u32fbId = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId;
4495
4496 pwinFB = _GetWinFB(pInstance,u32fbId);
4497 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
4498 {
4499 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
4500 return GOP_API_FAIL;
4501 }
4502
4503 if ((GOP_WINFB_POOL_NULL!=pwinFB->poolId) && (GOP_FB_Destroy(pInstance,u32fbId) != GWIN_OK))
4504 {
4505 MS_DEBUG_MSG( GOP_M_INFO( "[%s][%d], failed to delete FB %td\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId ) );
4506
4507 }
4508
4509 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32CurFBId= GWIN_ID_INVALID;
4510 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u32GOPClientId = 0;
4511 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].bIsShared = FALSE;
4512 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gId].u16SharedCnt = 0;
4513
4514 memset(&gWin, 0, sizeof(GOP_GwinInfo));
4515 gWin.clrType = E_GOP_COLOR_ARGB8888;
4516 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,(gId));
4517 u8MIU = MDrv_GOP_Get_MIU_Sel(g_pGOPCtxLocal,u8GOP);
4518 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP] != TRUE)
4519 {
4520 _miu_offset_to_phy(u8MIU,gWin.u32DRAMRBlkStart,gWin.u32DRAMRBlkStart);
4521 }
4522 GOP_SetWinInfo(pInstance,gId,&gWin);
4523
4524 RESET_BIT(g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr, gId);
4525 RESET_BIT(g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr, gId);
4526 RESET_BIT(g_pGOPCtxLocal->u16GOP_HMirror_HPos, gId);
4527 RESET_BIT(g_pGOPCtxLocal->u16GOP_VMirror_VPos, gId);
4528
4529 MDrv_GOP_GWIN_ClearFlipQueue(g_pGOPCtxLocal,gId);
4530 return GOP_API_SUCCESS;
4531
4532 }
4533
4534
GOP_ResetGOP(void * pInstance,MS_U8 u8GOP)4535 void GOP_ResetGOP(void* pInstance,MS_U8 u8GOP)
4536 {
4537 MS_U32 i = 0,j = 0;
4538 MS_U8 u8GwinId;
4539 GOP_WinFB_INFO* pwinFB;
4540 E_GOP_API_Result enRet = GOP_API_FAIL;
4541
4542 #ifdef INSTANT_PRIVATE
4543 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4544 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4545 #endif
4546
4547 if(g_pGOPCtxLocal ==NULL)
4548 {
4549 MS_BOOL bFirstInstance;
4550 GOP_PreInit_Ctx(pInstance, &bFirstInstance);
4551 if (MDrv_GOP_SetIOMapBase(g_pGOPCtxLocal) != TRUE)
4552 {
4553 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nget IO base fail"));
4554 return ;
4555 }
4556 }
4557
4558 u8GwinId = _GOP_SelGwinId2(pInstance,u8GOP, 0);
4559 for(i = u8GwinId; i < u8GwinId + MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,u8GOP); i++)
4560 {
4561 //Check and release APP's GWIN resource
4562 if(((FALSE == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].bIsShared)
4563 && (DRV_MAX_GWIN_FB_SUPPORT>g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].u32CurFBId))
4564 || ((TRUE == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].bIsShared)
4565 && (0x0 == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].u16SharedCnt)))
4566
4567 {
4568 for(j=0; j < DRV_MAX_GWIN_FB_SUPPORT; j++)
4569 {
4570 pwinFB = _GetWinFB(pInstance,j);
4571 if(pwinFB != NULL)
4572 {
4573 if ((pwinFB->u32GOPClientId == g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].u32GOPClientId)
4574 && (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].u32CurFBId != j))
4575 {
4576 enRet = (E_GOP_API_Result)GOP_FB_Destroy(pInstance,j);
4577 GOP_M_INFO("\n---%s %d: Try DestroyWIN's FB[%tu], return[%u]\n", __FUNCTION__, __LINE__, (ptrdiff_t)j, (MS_U8)enRet);
4578 }
4579 }
4580 }
4581 if (g_pGOPCtxLocal->pGOPCtxShared->gwinMap[i].u32GOPClientId != 0)
4582 {
4583 enRet = (E_GOP_API_Result)GOP_Win_Destroy_Abnormal(pInstance,i);
4584 GOP_M_INFO("\n---%s %d: Try DestroyWIN[%tu], return[%u]\n", __FUNCTION__, __LINE__,(ptrdiff_t) i, (MS_U8)enRet);
4585 }
4586 }
4587 }
4588 }
4589
GOP_GWIN_InitByGOP(void * pInstance,MS_BOOL bFirstIntance,MS_U8 u8GOP)4590 static void GOP_GWIN_InitByGOP(void* pInstance,MS_BOOL bFirstIntance, MS_U8 u8GOP)
4591 {
4592 MS_U8 i;
4593 MS_U8 bytePerPix = 2;
4594 MS_U16 width=0, height=0, pitch=0, fbFmt=0;
4595 MS_U32 addr=0;
4596 MS_U32 u32index;
4597 GOP_GwinInfo gWin;
4598 GOP_WinFB_INFO* pwinFB;
4599 MS_U32 MaxGwinSupport;
4600 MS_U8 u8MIU;
4601
4602 #ifdef INSTANT_PRIVATE
4603 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4604 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4605 #endif
4606
4607 //GE_BufInfo buffinfo;
4608 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4609 {
4610 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4611 return;
4612 }
4613 GOP_M_INFO("MDrv_GOP_GWIN_Init\n");
4614 memset(&gWin, 0, sizeof(GOP_GwinInfo));
4615 if(g_pGOPCtxLocal->pGOPCtxShared->bInitShared)
4616 {
4617 g_pGOPCtxLocal->pGOPCtxShared->bInitShared = FALSE;
4618 //First init of whole GOP Driver
4619 for (u32index = 0; u32index <DRV_MAX_GWIN_FB_SUPPORT; u32index++)
4620 {
4621 pwinFB = _GetWinFB(pInstance,u32index);
4622
4623 if(pwinFB == NULL)
4624 {
4625 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32index);
4626 return;
4627 }
4628
4629 pwinFB->enable = FALSE;
4630 pwinFB->in_use = 0;
4631 pwinFB->obtain = 0;
4632 pwinFB->gWinId = GWIN_ID_INVALID; // orig GWIN_OSD_DEFAULT;
4633 pwinFB->x0 = gWin.u16DispHPixelStart = 0;
4634 pwinFB->y0 = gWin.u16DispVPixelStart = 0;
4635 pwinFB->width = gWin.u16RBlkHPixSize = 0;
4636 pwinFB->height= gWin.u16RBlkVPixSize = 0;
4637 pwinFB->x1 = gWin.u16DispHPixelEnd = 0;
4638 pwinFB->y1 = gWin.u16DispVPixelEnd = 0;
4639 pwinFB->pitch = 0;
4640 pwinFB->addr = gWin.u32DRAMRBlkStart = 0;
4641 pwinFB->size = 0;
4642 gWin.u16WinX = gWin.u16WinY = 0;
4643 // FB format
4644 pwinFB->fbFmt = FB_FMT_AS_DEFAULT;
4645 // update ptrs
4646 pwinFB->poolId = GOP_WINFB_POOL_NULL;
4647 pwinFB->nextFBIdInPool = INVALID_POOL_NEXT_FBID;
4648 pwinFB->string = E_GOP_FB_NULL;
4649 pwinFB->u32GOPClientId = INVALID_CLIENT_PID;
4650 }
4651 }
4652 if(FALSE ==g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[u8GOP])
4653 {
4654 memset(&gWin, 0, sizeof(GOP_GwinInfo));
4655 MS_BOOL bGwinEnable = FALSE;
4656 for (i = 0; i<MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,u8GOP); i++)
4657 {
4658 u8MIU = MDrv_GOP_Get_MIU_Sel(g_pGOPCtxLocal,u8GOP);
4659 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP] != TRUE)
4660 {
4661 _miu_offset_to_phy(u8MIU,gWin.u32DRAMRBlkStart,gWin.u32DRAMRBlkStart);
4662 }
4663 u32index = _GOP_SelGwinId2(pInstance,u8GOP, i);
4664 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[u32index].u32CurFBId= GWIN_ID_INVALID;
4665 gWin.clrType = (EN_GOP_COLOR_TYPE)E_GOP_COLOR_ARGB1555;
4666 //Disable all Gwin when GOP first init
4667 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_GWIN))
4668 {
4669 MDrv_GOP_GWIN_IsGWINEnabled(g_pGOPCtxLocal, u32index, &bGwinEnable);
4670 if (bGwinEnable == TRUE)
4671 {
4672 //GWIN must be turn off in Vsync to avoid garbage
4673 MDrv_GOP_GWIN_ForceWrite_Update(g_pGOPCtxLocal, u8GOP, FALSE);
4674 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, u32index, FALSE);
4675 MDrv_GOP_GWIN_ForceWrite_Update(g_pGOPCtxLocal, u8GOP, TRUE);
4676 }
4677 GOP_SetWinInfo(pInstance,u32index, &gWin);
4678 MDrv_GOP_GWIN_SetBlending(g_pGOPCtxLocal, u32index, FALSE, 0x0);
4679 }
4680 }
4681 }
4682 /*
4683 width = MDrv_Read2Byte(GE_REG_STBB_S_W+GE_REG_BASE)+1;
4684 height = MDrv_Read2Byte(GE_REG_STBB_S_H+GE_REG_BASE)+1;
4685 pitch = MDrv_Read2Byte(GE_REG_DB_PIT+GE_REG_BASE);
4686 fbFmt = MDrv_Read2Byte(GE_REG_B_FM+GE_REG_BASE);
4687 addr = MDrv_Read4Byte(GE_REG_DB_BASE0+GE_REG_BASE);
4688 MDrv_GE_GetFrameBufferInfo(&width, &height, &pitch, &fbFmt, &addr);
4689 */
4690 //MDrv_GE_GetBufferInfo(&buffinfo);
4691 pwinFB = _GetWinFB(pInstance,DRV_MAX_GWIN_FB_SUPPORT);
4692 MaxGwinSupport = g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum;
4693
4694 if(pwinFB == NULL)
4695 {
4696 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%ld\n",__FUNCTION__,__LINE__,DRV_MAX_GWIN_FB_SUPPORT);
4697 return;
4698 }
4699
4700 pwinFB->enable = TRUE;
4701 pwinFB->in_use = 1;
4702 pwinFB->obtain = 1;
4703 pwinFB->gWinId = MaxGwinSupport;
4704 pwinFB->x0 = 0;
4705 pwinFB->y0 = 0;
4706 pwinFB->width = width;
4707 pwinFB->height = height;
4708 pwinFB->x1 = pwinFB->x0 + pwinFB->width;
4709 pwinFB->y1 = pwinFB->y0 + pwinFB->height;
4710 pwinFB->pitch = (pitch & 0xFFF8); // pitch must be 4-pix alignment;
4711 pwinFB->addr = addr;
4712 pwinFB->size = ((MS_U32)width) * ((MS_U32)height) * ((MS_U32)bytePerPix);
4713 // FB format
4714 pwinFB->fbFmt = fbFmt;
4715 // update ptrs
4716 pwinFB->poolId = GOP_WINFB_POOL_NULL;
4717 pwinFB->nextFBIdInPool = INVALID_POOL_NEXT_FBID;
4718 pwinFB->string = E_GOP_FB_NULL;
4719 pwinFB->u32GOPClientId = INVALID_CLIENT_PID;
4720
4721 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[MaxGwinSupport].u32CurFBId= DRV_MAX_GWIN_FB_SUPPORT;
4722
4723 }
4724
4725
GOP_GWIN_OutputLayerSwitch(void * pInstance,MS_U8 u8GOP)4726 MS_U32 GOP_GWIN_OutputLayerSwitch(void* pInstance,MS_U8 u8GOP)
4727 {
4728 E_GOP_API_Result GOPRet;
4729
4730
4731 //#ifndef MSOS_TYPE_LINUX
4732 MS_U8 i;
4733
4734 #ifdef INSTANT_PRIVATE
4735 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4736 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4737 #endif
4738
4739 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
4740 {
4741 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
4742 return GOP_API_FAIL;
4743 }
4744
4745 GOPRet = (E_GOP_API_Result)MDrv_GOP_SetGOPHighPri(g_pGOPCtxLocal, u8GOP);
4746 for (i=0; i<_GOP_GetMaxGOPNum(pInstance); i++)
4747 {
4748 _GOP_InitHSPDByGOP(pInstance,i);
4749 }
4750
4751 return GOPRet;
4752 }
GOP_GetCurrentGOP(void * pInstance)4753 MS_U32 GOP_GetCurrentGOP(void* pInstance)
4754 {
4755 #ifdef INSTANT_PRIVATE
4756 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4757 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4758 #endif
4759
4760 return MDrv_GOP_Get(g_pGOPCtxLocal);
4761 }
4762
GOP_GetCurrentGWin(void * pInstance)4763 MS_U32 GOP_GetCurrentGWin(void* pInstance)
4764 {
4765 #ifdef INSTANT_PRIVATE
4766 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4767 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4768 #endif
4769
4770 return g_pGOPCtxLocal->current_winId;
4771 }
4772
GOP_GetCurrentFBID(void * pInstance)4773 MS_U32 GOP_GetCurrentFBID(void* pInstance)
4774 {
4775 GOP_WinFB_INFO* pwinFB;
4776
4777 #ifdef INSTANT_PRIVATE
4778 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4779 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4780 #endif
4781
4782 MS_U8 curWinId = GOP_GetCurrentGWin(pInstance);
4783 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,curWinId))
4784 {
4785 GOP_M_ERR("[%s][%d]GWIN %d is not exist\n",__FUNCTION__,__LINE__,curWinId);
4786 return GWIN_ID_INVALID;
4787 }
4788
4789 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[curWinId].u32CurFBId);
4790
4791 if(pwinFB == NULL)
4792 {
4793 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[curWinId].u32CurFBId);
4794 return GWIN_ID_INVALID;
4795 }
4796 if (!_GOP_IsFbIdValid(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[curWinId].u32CurFBId))
4797 {
4798 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[curWinId].u32CurFBId);
4799 return GWIN_ID_INVALID;
4800 }
4801
4802 if (0==pwinFB->in_use)
4803 {
4804 GOP_M_ERR("[%s][%d]FbId %td is not allocated\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[curWinId].u32CurFBId);
4805 return GWIN_ID_INVALID;
4806
4807 }
4808 return g_pGOPCtxLocal->pGOPCtxShared->gwinMap[curWinId].u32CurFBId;
4809
4810 }
4811
4812
GOP_GWIN_SetHMirror(void * pInstance,MS_BOOL bEnable)4813 MS_U32 GOP_GWIN_SetHMirror(void* pInstance,MS_BOOL bEnable)
4814 {
4815 MS_U8 u8GwinID=0, u8GWinBase=0, u8GOPWinNum=0, u8GOPIdx=0;
4816 MS_U16 u16GwinState = 0;
4817 GOP_GwinInfo sGWININfo;
4818 MS_BOOL bUpdateRegOnce = FALSE, bHMirror = FALSE, bVMirror = FALSE;
4819
4820 #ifdef INSTANT_PRIVATE
4821 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4822 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4823 #endif
4824
4825 bUpdateRegOnce = g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE];
4826 g_pGOPCtxLocal->pGOPCtxShared->bHMirror = bEnable;
4827
4828 for(u8GOPIdx=0; u8GOPIdx < MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal);u8GOPIdx++)
4829 {
4830 MDrv_GOP_IsGOPMirrorEnable(g_pGOPCtxLocal, u8GOPIdx, &bHMirror, &bVMirror);
4831 if(bHMirror == bEnable)
4832 {
4833 continue; //Duplicate mirror setting, skip it
4834 }
4835
4836 u8GOPWinNum = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, u8GOPIdx);
4837 if(u8GOPWinNum == 0xff)
4838 {
4839 continue; //NO Gwin, skip it
4840 }
4841
4842 u8GWinBase = _GOP_SelGwinId2(pInstance, u8GOPIdx, 0);
4843 u16GwinState = 0; //Clear GWIN on/off state
4844 //Turn off all on state GWIN
4845 for (u8GwinID=u8GWinBase; u8GwinID<u8GWinBase+u8GOPWinNum; u8GwinID++)
4846 {
4847 if (!_GOP_IsGwinIdValid(pInstance,u8GwinID))
4848 {
4849 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8GwinID);
4850 return GOP_API_FAIL;
4851 }
4852
4853 if (g_pGOPCtxLocal->pGOPCtxShared->bGWINEnable[u8GwinID] != TRUE)
4854 {
4855 continue;
4856 }
4857
4858 if(_GOP_GWIN_IsGwinExistInClient(pInstance,u8GwinID)== TRUE)
4859 {
4860 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, u8GwinID, FALSE);
4861 u16GwinState |= (1<<u8GwinID);
4862 }
4863 else
4864 {
4865 u16GwinState = 0xFFFF;
4866 break; //This GWIn does not exist in current client, skip gop mirror setting
4867 }
4868 }
4869
4870 if(u16GwinState == 0xFFFF)
4871 {
4872 continue;//This GWIn does not exist in current client, skip gop mirror setting
4873 }
4874
4875 //Enable mirror
4876 MDrv_GOP_GWIN_EnableHMirror(g_pGOPCtxLocal, u8GOPIdx, bEnable);
4877 //Reset ON state GWIN info after mirror enable
4878 if(u16GwinState !=0)
4879 {
4880 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = TRUE; //Update GWIN info and GWIN enable one time
4881 for (u8GwinID=u8GWinBase; u8GwinID<u8GWinBase+u8GOPWinNum; u8GwinID++)
4882 {
4883 if(u16GwinState & (1<<u8GwinID))
4884 {
4885 if(GOP_GetWinInfo(pInstance,u8GwinID, &sGWININfo) == TRUE)
4886 {
4887 GOP_SetWinInfo(pInstance,u8GwinID, &sGWININfo);
4888 }
4889 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, u8GwinID, TRUE);
4890 }
4891 }
4892 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = bUpdateRegOnce;
4893 }
4894 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal, u8GOPIdx);
4895 }
4896
4897 if (bEnable == FALSE)
4898 {
4899 g_pGOPCtxLocal->u16GOP_HMirror_HPos = 0;
4900 g_pGOPCtxLocal->u16GOP_HMirrorRBLK_Adr = 0;
4901 }
4902 return GOP_API_SUCCESS;
4903 }
4904
4905
GOP_GWIN_SetVMirror(void * pInstance,MS_BOOL bEnable)4906 MS_U32 GOP_GWIN_SetVMirror(void* pInstance,MS_BOOL bEnable)
4907 {
4908 MS_U8 u8GwinID=0, u8GWinBase=0, u8GOPWinNum=0, u8GOPIdx=0;
4909 MS_U16 u16GwinState = 0;
4910 GOP_GwinInfo sGWININfo;
4911 MS_BOOL bUpdateRegOnce = FALSE, bHMirror = FALSE, bVMirror = FALSE;
4912
4913 #ifdef INSTANT_PRIVATE
4914 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
4915 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
4916 #endif
4917
4918 bUpdateRegOnce = g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE];
4919 g_pGOPCtxLocal->pGOPCtxShared->bVMirror = bEnable;
4920
4921 for(u8GOPIdx=0; u8GOPIdx < MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal);u8GOPIdx++)
4922 {
4923 MDrv_GOP_IsGOPMirrorEnable(g_pGOPCtxLocal, u8GOPIdx, &bHMirror, &bVMirror);
4924 if(bVMirror == bEnable)
4925 {
4926 continue; //Duplicate mirror setting, skip it
4927 }
4928
4929 u8GOPWinNum = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, u8GOPIdx);
4930 if(u8GOPWinNum == 0xff)
4931 {
4932 continue; //NO Gwin, skip it
4933 }
4934
4935 u8GWinBase = _GOP_SelGwinId2(pInstance, u8GOPIdx, 0);
4936 u16GwinState = 0; //Clear GWIN on/off state
4937 //Turn off all on state GWIN
4938 for (u8GwinID=u8GWinBase; u8GwinID<u8GWinBase+u8GOPWinNum; u8GwinID++)
4939 {
4940 if (!_GOP_IsGwinIdValid(pInstance,u8GwinID))
4941 {
4942 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8GwinID);
4943 return GOP_API_FAIL;
4944 }
4945
4946 if (g_pGOPCtxLocal->pGOPCtxShared->bGWINEnable[u8GwinID] != TRUE)
4947 {
4948 continue;
4949 }
4950
4951 if(_GOP_GWIN_IsGwinExistInClient(pInstance,u8GwinID)== TRUE)
4952 {
4953 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, u8GwinID, FALSE);
4954 u16GwinState |= (1<<u8GwinID);
4955 }
4956 else
4957 {
4958 u16GwinState = 0xFFFF;
4959 break; //This GWIn does not exist in current client, skip gop mirror setting
4960 }
4961 }
4962
4963 if(u16GwinState == 0xFFFF)
4964 {
4965 continue; //There is GWIn does not exist in current client, skip gop mirror setting
4966 }
4967
4968 //Enable mirror
4969 MDrv_GOP_GWIN_EnableVMirror(g_pGOPCtxLocal, u8GOPIdx, bEnable);
4970 //Reset ON state GWIN info after mirror enable
4971 if(u16GwinState !=0)
4972 {
4973 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = TRUE; //Update GWIN info and GWIN enable one time
4974 for (u8GwinID=u8GWinBase; u8GwinID<u8GWinBase+u8GOPWinNum; u8GwinID++)
4975 {
4976 if(u16GwinState & (1<<u8GwinID))
4977 {
4978 if(GOP_GetWinInfo(pInstance,u8GwinID, &sGWININfo) == TRUE)
4979 {
4980 GOP_SetWinInfo(pInstance,u8GwinID, &sGWININfo);
4981 }
4982 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, u8GwinID, TRUE);
4983 }
4984 }
4985 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = bUpdateRegOnce;
4986 }
4987 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal, u8GOPIdx);
4988 }
4989
4990 if (bEnable == FALSE)
4991 {
4992 g_pGOPCtxLocal->u16GOP_VMirrorRBLK_Adr = 0;
4993 g_pGOPCtxLocal->u16GOP_VMirror_VPos = 0;
4994 }
4995
4996 return GOP_API_SUCCESS;
4997
4998 }
4999
GOP_GWIN_SetNewAlphaMode(void * pInstance,MS_U8 gwin,MS_BOOL bEn)5000 MS_U32 GOP_GWIN_SetNewAlphaMode(void* pInstance,MS_U8 gwin, MS_BOOL bEn)
5001 {
5002 #ifdef INSTANT_PRIVATE
5003 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5004 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5005 #endif
5006
5007 if (!_GOP_IsGwinIdValid(pInstance,gwin))
5008 {
5009 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,gwin);
5010 return GOP_API_FAIL;
5011 }
5012
5013 MDrv_GOP_GWIN_SetNewAlphaMode(g_pGOPCtxLocal, gwin, bEn);
5014
5015 return GOP_API_SUCCESS;
5016
5017 }
5018
GOP_GWIN_IsEnable(void * pInstance,MS_U8 winId)5019 MS_U32 GOP_GWIN_IsEnable(void* pInstance,MS_U8 winId)
5020 {
5021 MS_BOOL IsEnable =FALSE;
5022
5023 #ifdef INSTANT_PRIVATE
5024 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5025 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5026 #endif
5027
5028 if (!_GOP_IsGwinIdValid(pInstance,winId))
5029 {
5030 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,winId);
5031 return FALSE;
5032 }
5033 MDrv_GOP_GWIN_IsGWINEnabled(g_pGOPCtxLocal, winId, &IsEnable);
5034 return IsEnable;
5035 }
5036
GOP_GWIN_SetEnable(void * pInstance,MS_U8 winId,MS_BOOL bEnable)5037 MS_U32 GOP_GWIN_SetEnable(void* pInstance,MS_U8 winId, MS_BOOL bEnable)
5038 {
5039 MS_U16 regval2 =0,i;
5040 MS_U32 u32fbId;
5041 GOP_WinFB_INFO* pwinFB;
5042 #ifdef INSTANT_PRIVATE
5043 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5044 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5045 #endif
5046 if (!_GOP_IsGwinIdValid(pInstance,winId))
5047 {
5048 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,winId);
5049 return GOP_API_FAIL;
5050 }
5051
5052 //printf("GWINID=%d,Enable=%d\n",(MS_U8)winId,(MS_U8)bEnable);
5053 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,winId))
5054 {
5055 GOP_M_ERR("[%s][%d]GWIN %d is not exist\n",__FUNCTION__,__LINE__,winId);
5056 //__ASSERT(0);
5057 }
5058
5059 // printf(" u8win=%02bx, bEnable=%02bx\n",winId,bEnable);
5060 u32fbId = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[winId].u32CurFBId;
5061 pwinFB = _GetWinFB(pInstance,u32fbId);
5062
5063 if(pwinFB == NULL)
5064 {
5065 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%d\n",__FUNCTION__,__LINE__,(unsigned int)u32fbId);
5066 goto fail;
5067 }
5068
5069 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
5070 {
5071 GOP_M_ERR("[%s][%d]FbId %d is out of range\n",__FUNCTION__,__LINE__,(unsigned int)u32fbId);
5072 goto fail;
5073 }
5074
5075 if (0 == pwinFB->in_use)
5076 {
5077 msWarning(ERR_GWIN_ID_NOT_ALLOCATED);
5078 GOP_M_ERR("[%s][%d]GWIN %d not allocated\n",__FUNCTION__,__LINE__,winId);
5079 goto fail;
5080 }
5081 pwinFB->enable = bEnable;
5082
5083 //regval2 = MApi_GOP_GWIN_GetActiveGWIN();
5084
5085 for(i = 0; i < g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum ; i++)
5086 {
5087 if(GOP_GWIN_IsEnable(pInstance,i) == TRUE)
5088 {
5089 regval2 |= 1<<i;
5090 }
5091 }
5092
5093 if (bEnable == 0) // Turn off GOP
5094 {
5095 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, winId, FALSE);
5096 if ((regval2 & ~(1<<winId)) == 0)
5097 {
5098 if(fpXCReduceBWForOSD!=NULL)
5099 {
5100 fpXCReduceBWForOSD(XC_MAIN_WINDOW, FALSE);
5101 }
5102 }
5103 }
5104 else //turn on GOP
5105 {
5106 //printf("gop on, interlace=%bx\n", IsSrcInterlace());
5107 if(fpXCReduceBWForOSD!=NULL)
5108 {
5109 fpXCReduceBWForOSD(XC_MAIN_WINDOW, TRUE);
5110 }
5111 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, winId, TRUE);
5112 }
5113 return GOP_API_SUCCESS;
5114
5115 fail:
5116 if (bEnable == 0) // Turn off GOP
5117 {
5118 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, winId, FALSE);
5119 }
5120 return GOP_API_FAIL;
5121 }
5122
GOP_GWIN_SetBlending(void * pInstance,MS_U8 u8win,MS_BOOL bEnable,MS_U8 u8coef)5123 MS_U32 GOP_GWIN_SetBlending(void* pInstance,MS_U8 u8win, MS_BOOL bEnable, MS_U8 u8coef)
5124 {
5125 #ifdef INSTANT_PRIVATE
5126 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5127 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5128 #endif
5129
5130 if (!_GOP_IsGwinIdValid(pInstance,u8win))
5131 {
5132 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
5133 return GOP_API_FAIL;
5134 }
5135 MDrv_GOP_GWIN_SetBlending(g_pGOPCtxLocal, u8win,bEnable,u8coef);
5136 return GOP_API_SUCCESS;
5137
5138 }
5139
GOP_GWIN_SetBlink(void * pInstance,MS_U8 winId,MS_BOOL bEnable,MS_U8 u8rate)5140 MS_U32 GOP_GWIN_SetBlink(void* pInstance,MS_U8 winId,MS_BOOL bEnable, MS_U8 u8rate)
5141 {
5142 #ifdef INSTANT_PRIVATE
5143 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5144 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5145 #endif
5146
5147 MDrv_GOP_GWIN_SetBlink(g_pGOPCtxLocal,winId, bEnable, u8rate);
5148 return GOP_API_SUCCESS;
5149 }
GOP_GWIN_Set_VStretchMode(void * pInstance,MS_U8 u8GOP,EN_GOP_STRETCH_VMODE VStrchMode)5150 MS_U32 GOP_GWIN_Set_VStretchMode(void* pInstance,MS_U8 u8GOP,EN_GOP_STRETCH_VMODE VStrchMode)
5151 {
5152 #ifdef INSTANT_PRIVATE
5153 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5154 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5155 #endif
5156 switch(VStrchMode)
5157 {
5158 case E_GOP_VSTRCH_LINEAR:
5159 case E_GOP_VSTRCH_LINEAR_GAIN0:
5160 case E_GOP_VSTRCH_LINEAR_GAIN1:
5161 MDrv_GOP_GWIN_Set_VStretchMode(g_pGOPCtxLocal,u8GOP,E_DRV_GOP_VSTRCH_LINEAR);
5162 MDrv_GOP_GWIN_Load_VStretchModeTable(g_pGOPCtxLocal,u8GOP,(DRV_GOPStrchVMode)VStrchMode);
5163 break;
5164 case E_GOP_VSTRCH_DUPLICATE:
5165 case E_GOP_VSTRCH_NEAREST:
5166 case E_GOP_VSTRCH_LINEAR_GAIN2:
5167 case E_GOP_VSTRCH_4TAP:
5168 MDrv_GOP_GWIN_Set_VStretchMode(g_pGOPCtxLocal,u8GOP, (DRV_GOPStrchVMode)VStrchMode);
5169 break;
5170 default:
5171 return(GOP_API_ENUM_NOT_SUPPORTED);
5172 break;
5173 }
5174 return GOP_API_SUCCESS;
5175 }
GOP_GWIN_Set_HStretchMode(void * pInstance,MS_U8 u8GOP,EN_GOP_STRETCH_HMODE HStrchMode)5176 MS_U32 GOP_GWIN_Set_HStretchMode(void* pInstance,MS_U8 u8GOP,EN_GOP_STRETCH_HMODE HStrchMode)
5177 {
5178 #ifdef INSTANT_PRIVATE
5179 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5180 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5181 #endif
5182 switch(HStrchMode)
5183 {
5184 case E_GOP_HSTRCH_DUPLICATE:
5185 MDrv_GOP_GWIN_Set_HStretchMode(g_pGOPCtxLocal,u8GOP, (DRV_GOPStrchHMode)E_GOP_HSTRCH_DUPLICATE);
5186 break;
5187 case E_GOP_HSTRCH_6TAPE:
5188 case E_GOP_HSTRCH_6TAPE_LINEAR:
5189 case E_GOP_HSTRCH_6TAPE_NEAREST:
5190 case E_GOP_HSTRCH_6TAPE_GAIN0:
5191 case E_GOP_HSTRCH_6TAPE_GAIN1:
5192 case E_GOP_HSTRCH_6TAPE_GAIN2:
5193 case E_GOP_HSTRCH_6TAPE_GAIN3:
5194 case E_GOP_HSTRCH_6TAPE_GAIN4:
5195 case E_GOP_HSTRCH_6TAPE_GAIN5:
5196 case E_GOP_HSTRCH_2TAPE:
5197 MDrv_GOP_GWIN_Set_HStretchMode(g_pGOPCtxLocal,u8GOP, (DRV_GOPStrchHMode)E_GOP_HSTRCH_6TAPE);
5198 MDrv_GOP_GWIN_Load_HStretchModeTable(g_pGOPCtxLocal,u8GOP,(DRV_GOPStrchHMode)HStrchMode);
5199 break;
5200 case E_GOP_HSTRCH_4TAPE:
5201 MDrv_GOP_GWIN_Set_HStretchMode(g_pGOPCtxLocal,u8GOP, (DRV_GOPStrchHMode)E_GOP_HSTRCH_4TAPE);
5202 break;
5203 default:
5204 return(GOP_API_ENUM_NOT_SUPPORTED);
5205 break;
5206 }
5207
5208 return GOP_API_SUCCESS;
5209 }
GOP_GWIN_Set_TranspColorStretchMode(void * pInstance,MS_U8 u8GOP,EN_GOP_STRCH_TRANSPCOLORMODE TColorStrchMode)5210 MS_U32 GOP_GWIN_Set_TranspColorStretchMode(void* pInstance,MS_U8 u8GOP,EN_GOP_STRCH_TRANSPCOLORMODE TColorStrchMode)
5211 {
5212 E_GOP_API_Result enRet=GOP_API_FAIL;
5213 #ifdef INSTANT_PRIVATE
5214 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5215 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5216 #endif
5217 enRet = (E_GOP_API_Result)MDrv_GOP_GWIN_Set_TranspColorStretchMode(g_pGOPCtxLocal,u8GOP, (DRV_GOPSTRCH_TRANSPCOLORMODE)TColorStrchMode);
5218 return enRet;
5219 }
5220
GOP_DWIN_GetDWinIntInfoTimeout(void * pInstance,GOP_DWinIntInfo * pDWinIntInfo,MS_U32 u32Timeout)5221 MS_U32 GOP_DWIN_GetDWinIntInfoTimeout(void* pInstance,GOP_DWinIntInfo *pDWinIntInfo,MS_U32 u32Timeout)
5222 {
5223 E_GOP_API_Result enRet=GOP_API_FAIL;
5224 DRV_GOP_DWinIntInfo gopDWinIntInfo;
5225 #ifdef INSTANT_PRIVATE
5226 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5227 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5228 #endif
5229 enRet = (E_GOP_API_Result)MDrv_GOP_DWIN_GetDWinIntInfo(g_pGOPCtxLocal, &gopDWinIntInfo,u32Timeout);
5230 pDWinIntInfo->u8DWinIntInfo = gopDWinIntInfo.u8DWinIntInfo;
5231 return enRet;
5232 }
5233
GOP_GWIN_EnableT3DMode(void * pInstance,MS_BOOL bEnable)5234 MS_U32 GOP_GWIN_EnableT3DMode(void* pInstance,MS_BOOL bEnable)
5235 {
5236 #ifdef INSTANT_PRIVATE
5237 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5238 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5239 #endif
5240
5241 #ifdef ENABLE_GOP_T3DPATCH
5242 MS_U8 u8GOPNum = 0;
5243 DRV_GOPDstType enGopDst = E_DRV_GOP_DST_INVALID;
5244 MS_U16 u16StrwinStr;
5245
5246 if (bEnable)
5247 {
5248 g_pGOPCtxLocal->pGopChipProperty->GOP_PD = GOP_PD_T3D;
5249 }
5250 else
5251 {
5252 g_pGOPCtxLocal->pGopChipProperty->GOP_PD = GOP_PD_NORMAL;
5253 }
5254
5255 for (u8GOPNum = 0; u8GOPNum < MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal); u8GOPNum++)
5256 {
5257 if (!(g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[u8GOPNum]))
5258 {
5259 continue;
5260 }
5261
5262 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOPNum, &enGopDst);
5263 if (E_DRV_GOP_DST_OP0 == enGopDst)
5264 {
5265 _GOP_GetPDByDst(pInstance,u8GOPNum, enGopDst, &u16StrwinStr);
5266 _GOP_AdjustHSPD(pInstance,u8GOPNum, u16StrwinStr, enGopDst);
5267 }
5268 }
5269 MDrv_GOP_GWIN_UpdateRegWithSync(g_pGOPCtxLocal, u8GOPNum, TRUE);
5270 #endif
5271 return(GOP_API_SUCCESS);
5272 }
5273
GOP_PowerOn(void * pInstance)5274 MS_U32 GOP_PowerOn(void* pInstance)
5275 {
5276 #ifdef INSTANT_PRIVATE
5277 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5278 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5279 #endif
5280
5281 if (g_pGOPCtxLocal->IsClkClosed)
5282 {
5283 GOP_M_ERR("\n%s, The GOP has been powered on!!!\n",__FUNCTION__);
5284 MDrv_GOP_SetClock(g_pGOPCtxLocal,TRUE);
5285 g_pGOPCtxLocal->IsClkClosed = FALSE;
5286 return(GOP_API_SUCCESS);
5287 }
5288 else
5289 {
5290 GOP_M_ERR("\n%s,Warning!!! No need to power on again!\n",__FUNCTION__);
5291 return(GOP_API_FAIL);
5292 }
5293 }
GOP_PowerOff(void * pInstance)5294 MS_U32 GOP_PowerOff(void* pInstance)
5295 {
5296 #ifdef INSTANT_PRIVATE
5297 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5298 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5299 #endif
5300
5301 if (!g_pGOPCtxLocal->IsClkClosed)
5302 {
5303 GOP_M_ERR("\n%s,Warning!!! The GOP has been powered off, please turn on it if you want to use\n",__FUNCTION__);
5304 MDrv_GOP_SetClock(g_pGOPCtxLocal,FALSE);
5305 g_pGOPCtxLocal->IsClkClosed =TRUE;
5306 return(GOP_API_SUCCESS);
5307 }
5308 else
5309 {
5310 GOP_M_ERR("\n%s,Warning!!! No need to power off again!\n",__FUNCTION__);
5311 return(GOP_API_FAIL);
5312 }
5313 }
5314
GOP_GetRTStatus(void * pInstance,GOP_ApiStatus * pGopApiSts)5315 MS_U32 GOP_GetRTStatus(void* pInstance,GOP_ApiStatus *pGopApiSts)
5316 {
5317 MS_U8 i, j;
5318
5319 #ifdef INSTANT_PRIVATE
5320 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5321 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5322 #endif
5323
5324 for (i=0; i<MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal); i++)
5325 {
5326 pGopApiSts->eGOPNumDstType[i] = (EN_GOP_DST_TYPE)0xFF;
5327 pGopApiSts->u16GopNumStrWinHSize[i] = pGopApiSts->u16GopNumStrWinVSize[i] = 0xFF;
5328
5329 switch (i)
5330 {
5331 case 0: //gop0
5332 {
5333 MS_U8 u8GWinNum = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,i);
5334 for (j=0; j < u8GWinNum; j++)
5335 {
5336 pGopApiSts->Gop0GwinIsEnable[j] = FALSE;
5337 }
5338 }
5339 break;
5340 case 1: //gop1
5341 {
5342 MS_U8 u8GWinNum = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,i);
5343 for (j=0; j < u8GWinNum; j++)
5344 {
5345 pGopApiSts->Gop1GwinIsEnable[j] = FALSE;
5346 }
5347 }
5348 break;
5349 case 2: //gop2
5350 {
5351 pGopApiSts->Gop2GwinIsEnable = FALSE;
5352 }
5353 break;
5354 case 3: //gop3
5355 {
5356 pGopApiSts->Gop3GwinIsEnable = FALSE;
5357 }
5358 break;
5359 case 4: //gop4
5360 {
5361 pGopApiSts->Gop4GwinIsEnable = FALSE;
5362 }
5363 break;
5364 case 5: //gop5
5365 {
5366 pGopApiSts->Gop5GwinIsEnable = FALSE;
5367 }
5368 break;
5369 default:
5370 break;
5371 }
5372 }
5373
5374 for (i=0; i<MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal); i++)
5375 {
5376 //need refine check using DRV_GOPDstType or EN_GOP_DST_TYPE
5377 DRV_GOPDstType enGOPDst = E_DRV_GOP_DST_INVALID;
5378 pGopApiSts->u16GopNumStrWinHSize[i] = g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchWidth[i];
5379 pGopApiSts->u16GopNumStrWinVSize[i] = g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchHeight[i];
5380 //need refine check using DRV_GOPDstType or EN_GOP_DST_TYPE
5381 (MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, i, &enGOPDst));
5382 (_GOP_Map_DRVDst2API_Enum_(pInstance,&(pGopApiSts->eGOPNumDstType[i]), enGOPDst));
5383
5384 switch (i)
5385 {
5386 case 0: //gop0
5387 {
5388 MS_U8 u8GWinNum = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,i);
5389 for (j=0; j < u8GWinNum; j++)
5390 {
5391 pGopApiSts->Gop0GwinIsEnable[j] = GOP_GWIN_IsEnable(pInstance,j);
5392 }
5393 }
5394 break;
5395 case 1: //gop1
5396 {
5397 MS_U8 u8GWinNum = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,i);
5398 for (j=0; j < u8GWinNum; j++)
5399 {
5400 pGopApiSts->Gop1GwinIsEnable[j] = GOP_GWIN_IsEnable(pInstance,_GOP_SelGwinId2(pInstance,GOPTYPE.GOP1, (MS_U32)j));
5401 }
5402 }
5403 break;
5404 case 2: //gop2
5405 {
5406 pGopApiSts->Gop2GwinIsEnable = GOP_GWIN_IsEnable(pInstance,_GOP_SelGwinId2(pInstance,GOPTYPE.GOP2, 0));
5407 }
5408 break;
5409 case 3: //gop3
5410 {
5411 pGopApiSts->Gop3GwinIsEnable = GOP_GWIN_IsEnable(pInstance,_GOP_SelGwinId2(pInstance,GOPTYPE.GOP3, 0));
5412 }
5413 break;
5414 case 4: //gop4
5415 {
5416 pGopApiSts->Gop4GwinIsEnable = GOP_GWIN_IsEnable(pInstance,_GOP_SelGwinId2(pInstance,GOPTYPE.GOP4, 0));
5417 }
5418 break;
5419 case 5: //gop5
5420 {
5421 pGopApiSts->Gop5GwinIsEnable = GOP_GWIN_IsEnable(pInstance,_GOP_SelGwinId2(pInstance,GOPTYPE.GOP5, 0));
5422 }
5423 break;
5424 default:
5425 break;
5426 }
5427 }
5428 return(GOP_API_SUCCESS);
5429 }
5430
GOP_GetInfo(void * pInstance,GOP_ApiInfo * pGopApiInfo)5431 MS_U32 GOP_GetInfo(void* pInstance,GOP_ApiInfo* pGopApiInfo)
5432 {
5433 MS_U8 u8GwinNum=0, i;
5434 EN_GOP_DST_TYPE GopDst;
5435
5436 #ifdef INSTANT_PRIVATE
5437 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5438 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5439 #endif
5440
5441 for (i=0; i<MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal); i++)
5442 {
5443 u8GwinNum += MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,i);
5444 }
5445
5446 for (i=0; i < MAX_GOP_DST_SUPPORT; i++)
5447 {
5448 //need refine check using DRV_GOPDstType or EN_GOP_DST_TYPE
5449 if (MDrv_GOP_GWIN_SetDstPlane(g_pGOPCtxLocal, 0, (DRV_GOPDstType)i,TRUE)==GOP_SUCCESS)
5450 {
5451 _GOP_Map_DRVDst2API_Enum_(pInstance,&GopDst, (DRV_GOPDstType)i);
5452 pGopApiInfo->SupportGOPDst[i] = GopDst;
5453 }
5454 else
5455 {
5456 pGopApiInfo->SupportGOPDst[i] = (EN_GOP_DST_TYPE)0xFF;
5457 }
5458 }
5459
5460 pGopApiInfo->u8MaxGOPNum = MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal);
5461 pGopApiInfo->u8MaxGwinNum = u8GwinNum;
5462 return(GOP_API_SUCCESS);
5463 }
GOP_GWIN_SetGWinShared(void * pInstance,MS_U8 winId,MS_BOOL bIsShared)5464 MS_U32 GOP_GWIN_SetGWinShared(void* pInstance,MS_U8 winId, MS_BOOL bIsShared)
5465 {
5466 #ifdef INSTANT_PRIVATE
5467 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5468 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5469 #endif
5470
5471 if (!_GOP_IsGwinIdValid(pInstance,winId))
5472 {
5473 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,winId);
5474 return(GOP_API_FAIL);
5475 }
5476
5477 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[winId].bIsShared = true;
5478 return GOP_API_SUCCESS;
5479 }
GOP_GWIN_SetGWinSharedCnt(void * pInstance,MS_U8 winId,MS_U16 u16SharedCnt)5480 MS_U32 GOP_GWIN_SetGWinSharedCnt(void* pInstance,MS_U8 winId, MS_U16 u16SharedCnt)
5481 {
5482 #ifdef INSTANT_PRIVATE
5483 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5484 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5485 #endif
5486
5487 if (!_GOP_IsGwinIdValid(pInstance,winId))
5488 {
5489 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,winId);
5490 return(GOP_API_FAIL);
5491 }
5492
5493 g_pGOPCtxLocal->pGOPCtxShared->gwinMap[winId].u16SharedCnt = u16SharedCnt;
5494 return GOP_API_SUCCESS;
5495 }
5496
GOP_GWIN_Switch2Gwin(void * pInstance,MS_U8 winId,void * pSet)5497 MS_U32 GOP_GWIN_Switch2Gwin(void* pInstance,MS_U8 winId, void* pSet)
5498 {
5499 MS_U32 u32fbId;
5500 MS_U16 fbFmt;
5501 MS_PHY u64GeDstAdr=0;
5502 GOP_WinFB_INFO* pwinFB;
5503 DRV_GOP_CBFmtInfo* FmtInfo = (DRV_GOP_CBFmtInfo*)pSet;
5504
5505 #ifdef INSTANT_PRIVATE
5506 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5507 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5508 #endif
5509
5510 if (!_GOP_IsGwinIdValid(pInstance,winId))
5511 {
5512 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,winId);
5513 return(GOP_API_FAIL);
5514 }
5515 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,winId))
5516 {
5517 GOP_M_ERR("[%s][%d]GWIN %d is not exist\n",__FUNCTION__,__LINE__,winId);
5518 return(GOP_API_FAIL);
5519 }
5520
5521 u32fbId = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[winId].u32CurFBId;
5522 pwinFB = _GetWinFB(pInstance,u32fbId);
5523
5524 if(pwinFB == NULL)
5525 {
5526 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId);
5527 return(GOP_API_FAIL);
5528 }
5529 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
5530 {
5531 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId);
5532 return(GOP_API_FAIL);
5533 }
5534
5535 if (0==pwinFB->in_use)
5536 {
5537 GOP_M_ERR("[%s][%d]FbId %td is not allocated\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId);
5538 return(GOP_API_FAIL);
5539
5540 }
5541
5542 g_pGOPCtxLocal->current_winId = winId;
5543 u64GeDstAdr=pwinFB->addr;
5544 MDrv_GOP_ConvertAPIAddr2HAL(g_pGOPCtxLocal, winId, &u64GeDstAdr);
5545 fbFmt = pwinFB->fbFmt;
5546 if ( (pwinFB->fbFmt & 0xFF) == E_MS_FMT_ARGB1555 )
5547 fbFmt = E_MS_FMT_ARGB1555_DST | (E_MS_FMT_ARGB1555_DST << 8);
5548
5549 if(fpSetFBFmt != NULL)
5550 {
5551 fpSetFBFmt(pwinFB->pitch, u64GeDstAdr,fbFmt);
5552 FmtInfo->u64Addr = u64GeDstAdr;
5553 FmtInfo->u16Pitch = pwinFB->pitch;
5554 FmtInfo->u16Fmt = fbFmt;
5555 }
5556 else
5557 {
5558 MS_DEBUG_MSG(GOP_M_INFO("%s: SetFBFmt is not hooked. Bypass switch...\n", __FUNCTION__));
5559 }
5560 return(GOP_API_SUCCESS);
5561 }
5562
GOP_GWIN_IsGwinExist(void * pInstance,MS_U8 gId)5563 MS_U32 GOP_GWIN_IsGwinExist(void* pInstance,MS_U8 gId)
5564 {
5565 MS_U32 ret;
5566 if (!_GOP_IsGwinIdValid(pInstance,gId))
5567 {
5568 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,gId);
5569 return(GOP_API_FAIL);
5570 }
5571 ret = _GOP_GWIN_IsGwinExistInClient(pInstance,gId);
5572 return ret;
5573 }
GOP_GWIN_GetFreeWinID(void * pInstance)5574 MS_U32 GOP_GWIN_GetFreeWinID(void* pInstance)
5575 {
5576 MS_U8 GWID = GWIN_ID_INVALID;
5577 MS_U8 i=0,j=0;
5578 MS_U16 k=0,l=0;
5579
5580 #ifdef INSTANT_PRIVATE
5581 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5582 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5583 #endif
5584
5585 if (!_GOP_IsGopNumValid(pInstance,MDrv_GOP_Get(g_pGOPCtxLocal)))
5586 {
5587 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,MDrv_GOP_Get(g_pGOPCtxLocal));
5588 return(GWIN_ID_INVALID);
5589 }
5590
5591 if (MDrv_GOP_Get(g_pGOPCtxLocal)==1) //gop1
5592 {
5593 i = _GOP_SelGwinId2(pInstance,GOPTYPE.GOP1,0);
5594 j = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,GOPTYPE.GOP1);
5595 }
5596 else if (MDrv_GOP_Get(g_pGOPCtxLocal)==0)
5597 {
5598 i = _GOP_SelGwinId2(pInstance,GOPTYPE.GOP0,0);
5599 j = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,GOPTYPE.GOP0);
5600 }
5601 else if (MDrv_GOP_Get(g_pGOPCtxLocal)==2)
5602 {
5603 i = _GOP_SelGwinId2(pInstance,GOPTYPE.GOP2,0);
5604 j = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,GOPTYPE.GOP2);
5605 }
5606 else if (MDrv_GOP_Get(g_pGOPCtxLocal)==3)
5607 {
5608 i = _GOP_SelGwinId2(pInstance,GOPTYPE.GOP3,0);
5609 j = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,GOPTYPE.GOP3);
5610 }
5611 else if (MDrv_GOP_Get(g_pGOPCtxLocal)==4)
5612 {
5613 i = _GOP_SelGwinId2(pInstance,GOPTYPE.GOP4,0);
5614 j = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,GOPTYPE.GOP4);
5615 }
5616 else if (MDrv_GOP_Get(g_pGOPCtxLocal)==5)
5617 {
5618 i = _GOP_SelGwinId2(pInstance,GOPTYPE.GOP5,0);
5619 j = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,GOPTYPE.GOP5);
5620 }
5621 else
5622 {
5623 return(GWIN_ID_INVALID);
5624 }
5625
5626 if(!_GOP_IsGwinIdValid(pInstance,i))
5627 {
5628 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,i);
5629 return(GWIN_ID_INVALID);
5630 }
5631 k = i+j;
5632 for(l=i; l < k; l++)
5633 {
5634 if(DRV_MAX_GWIN_FB_SUPPORT<=g_pGOPCtxLocal->pGOPCtxShared->gwinMap[l].u32CurFBId)
5635 {
5636 GWID = l;
5637 break;
5638 }
5639 }
5640 return(GWID);
5641 }
GOP_GWIN_GetFBfromGWIN(void * pInstance,MS_U8 gwinId)5642 MS_U32 GOP_GWIN_GetFBfromGWIN(void* pInstance,MS_U8 gwinId)
5643 {
5644 GOP_WinFB_INFO* pwinFB;
5645
5646 #ifdef INSTANT_PRIVATE
5647 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5648 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5649 #endif
5650
5651 if (!_GOP_IsGwinIdValid(pInstance,gwinId))
5652 {
5653 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,gwinId);
5654 return(GWIN_ID_INVALID);
5655 }
5656 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,gwinId))
5657 {
5658 GOP_M_ERR("[%s][%d]GWIN %d is not exist\n",__FUNCTION__,__LINE__,gwinId);
5659 return(GWIN_ID_INVALID);
5660 }
5661
5662 pwinFB = _GetWinFB(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gwinId].u32CurFBId);
5663
5664 if(pwinFB == NULL)
5665 {
5666 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gwinId].u32CurFBId);
5667 return(GWIN_ID_INVALID);
5668 }
5669 if (!_GOP_IsFbIdValid(pInstance,g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gwinId].u32CurFBId))
5670 {
5671 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gwinId].u32CurFBId);
5672 return(GWIN_ID_INVALID);
5673 }
5674 if (0 == pwinFB->in_use)
5675 {
5676 GOP_M_ERR("[%s][%d]GWIN %d not allocated\n",__FUNCTION__,__LINE__,gwinId);
5677 return(GWIN_ID_INVALID);
5678 }
5679
5680 return(g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gwinId].u32CurFBId);
5681 }
5682
GOP_FB_Get(void * pInstance)5683 MS_U32 GOP_FB_Get(void* pInstance)
5684 {
5685 #ifdef INSTANT_PRIVATE
5686 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5687 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5688 #endif
5689
5690 if(GOP_WINFB_POOL2 == g_pGOPCtxLocal->pGOPCtxShared->fb_currentPoolId)
5691 {
5692 return 1;
5693 }
5694 else
5695 {
5696 return 0;
5697 }
5698 /* //Change to if to fix parasoft error
5699 switch(g_pGOPCtxLocal->pGOPCtxShared->fb_currentPoolId)
5700 {
5701 case GOP_WINFB_POOL2:
5702 return 1;
5703 default:
5704 return 0;
5705 }*/
5706 return GOP_API_SUCCESS;
5707 }
GOP_FB_SEL(void * pInstance,MS_U8 u8FB)5708 MS_U32 GOP_FB_SEL(void* pInstance,MS_U8 u8FB)
5709 {
5710 #ifdef INSTANT_PRIVATE
5711 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5712 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5713 #endif
5714
5715 switch(u8FB)
5716 {
5717 case 0: // gwinFB1
5718 g_pGOPCtxLocal->pGOPCtxShared->fb_currentPoolId = GOP_WINFB_POOL1;
5719 break;
5720 case 1: // gwinFB2
5721 g_pGOPCtxLocal->pGOPCtxShared->fb_currentPoolId = GOP_WINFB_POOL2;
5722 break;
5723 default:
5724 break;
5725 }
5726 return GOP_API_SUCCESS;
5727 }
GOP_GWIN_Is32FBExist(void * pInstance,MS_U32 u32fbId)5728 MS_U32 GOP_GWIN_Is32FBExist(void* pInstance,MS_U32 u32fbId)
5729 {
5730 GOP_WinFB_INFO* pwinFB;
5731
5732 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
5733 {
5734 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
5735 return FALSE;
5736 }
5737
5738 pwinFB = _GetWinFB(pInstance,u32fbId);
5739
5740 if(pwinFB == NULL)
5741 {
5742 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
5743 return FALSE;
5744 }
5745
5746 return pwinFB->obtain;
5747 }
5748
GOP_GWIN_GetFreeFbID(void * pInstance)5749 MS_U32 GOP_GWIN_GetFreeFbID(void* pInstance)
5750 {
5751 MS_U32 i;
5752 MS_U32 u32FBId = 0xFFFFFFFF;
5753 GOP_WinFB_INFO* pwinFB;
5754 for(i=0; i<DRV_MAX_GWIN_FB_SUPPORT; i++)
5755 {
5756 if(!GOP_GWIN_Is32FBExist(pInstance,i))
5757 {
5758 u32FBId = i;
5759 pwinFB = _GetWinFB(pInstance,u32FBId);
5760 pwinFB->obtain = 1;
5761 break;
5762 }
5763 }
5764 return u32FBId;
5765 }
5766
GOP_Set3DOSDMode(void * pInstance,MS_U8 u8Gwin,MS_U16 u16MainFBId,MS_U16 u16SubFBId,EN_GOP_3D_MODETYPE en3DMode)5767 MS_U32 GOP_Set3DOSDMode(void* pInstance,MS_U8 u8Gwin, MS_U16 u16MainFBId, MS_U16 u16SubFBId,EN_GOP_3D_MODETYPE en3DMode)
5768 {
5769 MS_U8 u8GOP;
5770 GOP_Result enRet = GOP_FAIL;
5771 GOP_WinFB_INFO* pwinFB;
5772 MS_PHY TLBSubAddr=0;
5773
5774 #ifdef INSTANT_PRIVATE
5775 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5776 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5777 #endif
5778 pwinFB = _GetWinFB(pInstance,u16SubFBId);
5779
5780 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,u8Gwin);
5781
5782 switch(en3DMode)
5783 {
5784 case E_GOP_3D_DISABLE:
5785 {
5786 enRet = MDrv_GOP_Set3DOSD_Mode(g_pGOPCtxLocal, u8GOP, E_DRV_GOP_3D_DISABLE);
5787 if(enRet != GOP_SUCCESS)
5788 {
5789 return((E_GOP_API_Result)enRet);
5790 }
5791 break;
5792 }
5793 case E_GOP_3D_SWITH_BY_FRAME:
5794 case E_GOP_3D_SIDE_BY_SYDE:
5795 case E_GOP_3D_TOP_BOTTOM:
5796 case E_GOP_3D_LINE_ALTERNATIVE:
5797 case E_GOP_3D_FRAMEPACKING:
5798 {
5799
5800 if(pwinFB == NULL)
5801 {
5802 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%d\n",__FUNCTION__,__LINE__,u16SubFBId);
5803 return(GWIN_NO_AVAILABLE);
5804 }
5805
5806 if(pwinFB->height == 1080)
5807 {
5808 g_pGOPCtxLocal->GOP_FramePacking_Gap = 45;
5809 }
5810 else if( pwinFB->height == 720)
5811 {
5812 g_pGOPCtxLocal->GOP_FramePacking_Gap = 30;
5813 }
5814 else
5815 {
5816 g_pGOPCtxLocal->GOP_FramePacking_Gap = 0;
5817 }
5818
5819 enRet = MDrv_GOP_Set3DOSD_Mode(g_pGOPCtxLocal, u8GOP, (EN_DRV_GOP_3D_MODE)en3DMode);
5820 if(enRet != GOP_SUCCESS)
5821 {
5822 return((E_GOP_API_Result)enRet);
5823 }
5824 break;
5825 }
5826 default:
5827 GOP_M_ERR("[%s]not support 3D OSD case: %d\n",__FUNCTION__, en3DMode);
5828 return(GOP_API_FAIL);
5829 }
5830
5831 if(GOP_MapFB2Win(pInstance,u16MainFBId,u8Gwin) != GOP_API_SUCCESS)
5832 {
5833 GOP_M_ERR("[%s] can't map Main fbid:%d to gwin:%d\n",__FUNCTION__,u16MainFBId,u8Gwin);
5834 return(GOP_API_FAIL);
5835 }
5836
5837 if(en3DMode != E_GOP_3D_DISABLE)
5838 {
5839 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP])
5840 {
5841 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
5842 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
5843 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOP, &GopDst);
5844 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
5845 if(bHMirror || bVMirror)
5846 {
5847 GOP_GwinInfo stGwinInfo;
5848 GOP_GetWinInfo(pInstance,u8Gwin, &stGwinInfo);
5849 stGwinInfo.u32DRAMRBlkStart = pwinFB->addr;
5850 _GOP_GWIN_SetTLBHVMirrorDRAMAddr(pInstance,u8Gwin, bHMirror, bVMirror, &stGwinInfo);
5851 pwinFB->addr = stGwinInfo.u32DRAMRBlkStart;
5852 }
5853 }
5854 else
5855 {
5856 if(u8GOP > GOPTYPE.GOP0)
5857 {
5858 MS_BOOL bHMirror = FALSE, bVMirror = FALSE;
5859 DRV_GOPDstType GopDst =E_DRV_GOP_DST_INVALID;
5860 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOP, &GopDst);
5861 _GOP_GWIN_IsEnableMirror(pInstance,GopDst, &bHMirror, &bVMirror);
5862 if(bHMirror || bVMirror)
5863 {
5864 GOP_GwinInfo stGwinInfo;
5865 GOP_GetWinInfo(pInstance,u8Gwin, &stGwinInfo);
5866 stGwinInfo.u32DRAMRBlkStart = pwinFB->addr;
5867 _GOP_GWIN_SetHVMirrorDRAMAddr(pInstance,u8Gwin, bHMirror, bVMirror, &stGwinInfo);
5868 pwinFB->addr = stGwinInfo.u32DRAMRBlkStart;
5869 }
5870 }
5871 }
5872 if(g_pGOPCtxLocal->pGOPCtxShared->bTLB[u8GOP])
5873 {
5874 TLBSubAddr = (pwinFB->addr/PAGE_SIZE)*TLB_PER_ENTRY_SIZE + g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[u8GOP];
5875 MDrv_GOP_SetTLBSubAddr(g_pGOPCtxLocal,u8GOP,TLBSubAddr);
5876 MDrv_GOP_Set3DOSD_Sub(g_pGOPCtxLocal,u8Gwin, pwinFB->addr%(PAGE_SIZE*PER_MIU_TLB_ENTRY_COUNT));
5877 }
5878 else
5879 {
5880 MDrv_GOP_Set3DOSD_Sub(g_pGOPCtxLocal,u8Gwin, pwinFB->addr);
5881 }
5882 }
5883 else
5884 {
5885 MDrv_GOP_Set3DOSD_Sub(g_pGOPCtxLocal,u8Gwin, 0x0); //clear sub address
5886 }
5887 MDrv_GOP_Set3DOSD_Middle(g_pGOPCtxLocal, u8GOP);
5888 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
5889 return(GOP_API_SUCCESS);
5890 }
5891
GOP_GWIN_SetGPUtileMode(void * pInstance,MS_U8 u8Gwin,EN_GOP_GPU_TILE_MODE tilemode)5892 MS_U32 GOP_GWIN_SetGPUtileMode(void* pInstance,MS_U8 u8Gwin, EN_GOP_GPU_TILE_MODE tilemode)
5893 {
5894 #ifdef INSTANT_PRIVATE
5895 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5896 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5897 #endif
5898
5899 if (!_GOP_IsGwinIdValid(pInstance,u8Gwin))
5900 {
5901 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8Gwin);
5902 return GOP_API_FAIL;
5903 }
5904
5905 MDrv_GOP_GWIN_SetGPUTileMode(g_pGOPCtxLocal, u8Gwin, tilemode);
5906
5907 return GOP_API_SUCCESS;
5908 }
5909
GOP_SetGOPClk(void * pInstance,MS_U8 gopNum,EN_GOP_DST_TYPE eDstType)5910 MS_U32 GOP_SetGOPClk(void* pInstance,MS_U8 gopNum, EN_GOP_DST_TYPE eDstType)
5911 {
5912 DRV_GOPDstType GopDst;
5913
5914 #ifdef INSTANT_PRIVATE
5915 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5916 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5917 #endif
5918
5919 if (!_GOP_IsGopNumValid(pInstance,gopNum))
5920 {
5921 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,gopNum);
5922 return(GOP_API_FAIL);
5923 }
5924 (_GOP_Map_APIDst2DRV_Enum(pInstance,eDstType, &GopDst));
5925 (MDrv_GOP_SetGOPClk(g_pGOPCtxLocal, gopNum, GopDst));
5926 return(GOP_API_SUCCESS);
5927 }
GOP_GWIN_SetBnkForceWrite(void * pInstance,MS_U8 u8GOP,MS_BOOL bEnable)5928 MS_U32 GOP_GWIN_SetBnkForceWrite(void* pInstance,MS_U8 u8GOP, MS_BOOL bEnable)
5929 {
5930 #ifdef INSTANT_PRIVATE
5931 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5932 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5933 #endif
5934
5935 if(g_pGOPCtxLocal == NULL)
5936 {
5937 bInitBkFWR[u8GOP] = bEnable;
5938 return GOP_API_SUCCESS;
5939 }
5940 else
5941 {
5942 if(!g_pGOPCtxLocal->pGopChipProperty->bBnkForceWrite)
5943 {
5944 GOP_M_ERR("[%s][%d] GOP not support bank force write function in this chip version \n",__FUNCTION__,__LINE__);
5945 return(GOP_API_FAIL);
5946 }
5947 else
5948 {
5949 bInitBkFWR[u8GOP] = bEnable;
5950 MDrv_GOP_GWIN_SetBnkForceWrite(g_pGOPCtxLocal, u8GOP, bEnable);
5951 return(GOP_API_SUCCESS);
5952 }
5953 }
5954 }
GOP_GWIN_SetForceWrite(void * pInstance,MS_BOOL bEnable)5955 MS_U32 GOP_GWIN_SetForceWrite(void* pInstance,MS_BOOL bEnable)
5956 {
5957 //It's used for supernova special used. (by Jupiter)
5958 //There should no driver request before init.
5959 //Supernova wants to easly control AP flow, it will set gop force write before gop init.
5960 //Driver must recode the FRWR status and set it during gop init.
5961 #ifdef INSTANT_PRIVATE
5962 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5963 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5964 #endif
5965
5966 if(g_pGOPCtxLocal == NULL)
5967 {
5968 bInitFWR = bEnable;
5969 return GOP_API_SUCCESS;
5970 }
5971 else
5972 {
5973 g_pGOPCtxLocal->bInitFWR = bEnable;
5974 MDrv_GOP_GWIN_SetForceWrite(g_pGOPCtxLocal, bEnable);
5975 return(GOP_API_SUCCESS);
5976 }
5977 }
GOP_Set3D_LR_FrameExchange(void * pInstance,MS_U8 u8GOP)5978 MS_U32 GOP_Set3D_LR_FrameExchange(void* pInstance,MS_U8 u8GOP)
5979 {
5980 GOP_Result enRet = GOP_FAIL;
5981 #ifdef INSTANT_PRIVATE
5982 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
5983 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
5984 #endif
5985
5986 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
5987 {
5988 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
5989 return(GOP_API_FAIL);
5990 }
5991
5992 enRet = MDrv_GOP_Set3D_LR_FrameExchange(g_pGOPCtxLocal, u8GOP);
5993 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
5994 return enRet;
5995 }
GOP_Enable_VEOSD(void * pInstance,MS_U8 u8GOP,MS_BOOL bEn)5996 MS_U32 GOP_Enable_VEOSD(void* pInstance,MS_U8 u8GOP, MS_BOOL bEn)
5997 {
5998 MS_U8 GOPNum = u8GOP;
5999 MS_BOOL bret;
6000 DRV_GOPDstType pGopDst = E_DRV_GOP_DST_INVALID;
6001 #ifdef INSTANT_PRIVATE
6002 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6003 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6004 #endif
6005
6006 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, u8GOP, &pGopDst);
6007
6008 if((pGopDst == E_DRV_GOP_DST_MIXER2VE) || (pGopDst == E_DRV_GOP_DST_MIXER2OP) || (pGopDst == E_DRV_GOP_DST_MIXER2OP1))
6009 {
6010 GOPNum = GOPTYPE.MIXER-1;
6011 }
6012 else if(pGopDst == E_DRV_GOP_DST_INVALID)
6013 {
6014 GOP_M_ERR("[%s][%d]Wrong GOP Destination!",__FUNCTION__,__LINE__);
6015 return GOP_API_FAIL;
6016 }
6017
6018 bret = MDrv_GOP_Set_VE_MUX(g_pGOPCtxLocal, GOPNum, bEn);
6019
6020 if(bret)
6021 {
6022 return GOP_API_SUCCESS;
6023 }
6024 else
6025 {
6026 return GOP_API_FAIL;
6027 }
6028 }
6029
GOP_OutputLayerSwitch(void * pInstance,MS_U8 u8GOP)6030 MS_U32 GOP_OutputLayerSwitch(void* pInstance,MS_U8 u8GOP)
6031 {
6032 MS_U8 i;
6033 #ifdef INSTANT_PRIVATE
6034 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6035 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6036 #endif
6037
6038 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
6039 {
6040 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
6041 return(GOP_API_FAIL);
6042 }
6043
6044 GOP_M_INFO("---%s %d: PID[%td], TID[%td] u8GOP=%u\n", __FUNCTION__, __LINE__, (ptrdiff_t)getpid(), (ptrdiff_t)MsOS_GetOSThreadID(), u8GOP);
6045
6046 MDrv_GOP_SetGOPHighPri(g_pGOPCtxLocal, u8GOP);
6047 for (i=0; i<MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal); i++)
6048 {
6049 _GOP_InitHSPDByGOP(pInstance,i);
6050 }
6051 return GOP_API_SUCCESS;
6052 }
GOP_GWIN_SwapOverlapWin(void * pInstance,MS_U8 u8GOP,MS_U8 u8win)6053 MS_U32 GOP_GWIN_SwapOverlapWin(void* pInstance,MS_U8 u8GOP, MS_U8 u8win)
6054 {
6055 MS_U8 i, *temp;
6056 GOP_GwinPriority GopGwinPri;
6057 #ifdef INSTANT_PRIVATE
6058 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6059 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6060 #endif
6061
6062
6063 memset(&GopGwinPri, 0, sizeof(GOP_GwinPriority));
6064
6065 if (!_GOP_IsGwinIdValid(pInstance,u8win))
6066 {
6067 GOP_M_ERR("[%s][%d]GWIN %d is out of range\n",__FUNCTION__,__LINE__,u8win);
6068 return(GOP_API_FAIL);
6069 }
6070 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
6071 {
6072 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
6073 return(GOP_API_FAIL);
6074 }
6075
6076 if (u8GOP==1) //GOP1
6077 {
6078 if(4 == MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,1))
6079 {
6080 MDrv_GOP_GWIN_GetGwinPriority(g_pGOPCtxLocal, 1, &GopGwinPri);
6081 temp = (MS_U8*)&GopGwinPri.Gop0_GwinPri;
6082
6083 for (i=0; i<MDrv_GOP_GetGwinNum(g_pGOPCtxLocal, 1); i++)
6084 {
6085 if (temp[i] == (u8win-MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,0))) //find
6086 {
6087 temp[i] = temp[0];
6088 temp[0] = (u8win-MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,0));
6089 break;
6090 }
6091 }
6092
6093 MDrv_GOP_GWIN_SetGwinPriority(g_pGOPCtxLocal, 1, &GopGwinPri);
6094 }
6095 else
6096 {
6097 GopGwinPri.Gop1_1stGwin = u8win-MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,0);
6098 MDrv_GOP_GWIN_SetGwinPriority(g_pGOPCtxLocal, 1, &GopGwinPri);
6099 }
6100 }
6101 else //GOP0
6102 {
6103 MDrv_GOP_GWIN_GetGwinPriority(g_pGOPCtxLocal, 0, &GopGwinPri);
6104 temp = (MS_U8*)&GopGwinPri.Gop0_GwinPri;
6105
6106 for (i=0; i<MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,0); i++)
6107 {
6108 if (temp[i] == u8win) //find
6109 {
6110 temp[i] = temp[0];
6111 temp[0] = u8win;
6112 break;
6113 }
6114 }
6115
6116 MDrv_GOP_GWIN_SetGwinPriority(g_pGOPCtxLocal, 0, &GopGwinPri);
6117 }
6118 return(GOP_API_SUCCESS);
6119 }
GOP_SetGOPBWStrength(void * pInstance,EN_GOP_BW_STRENGTH eGOPBWStr,MS_U8 u8GOP)6120 MS_U32 GOP_SetGOPBWStrength(void* pInstance,EN_GOP_BW_STRENGTH eGOPBWStr, MS_U8 u8GOP)
6121 {
6122 #ifdef INSTANT_PRIVATE
6123 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6124 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6125 #endif
6126
6127 if (u8GOP !=0xc && !_GOP_IsGwinIdValid(pInstance,u8GOP))
6128 {
6129 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nInvaild gop num!!"));
6130 return(GOP_API_FAIL);
6131 }
6132
6133 if(eGOPBWStr == E_GOP_BW_STRONG)
6134 MDrv_GOP_SetGOPBWStrength(g_pGOPCtxLocal, u8GOP,E_GOP_BURSTLEN_LONG);
6135 else if(eGOPBWStr == E_GOP_BW_MIDDLE)
6136 MDrv_GOP_SetGOPBWStrength(g_pGOPCtxLocal, u8GOP,E_GOP_BURSTLEN_MIDDLE);
6137 else if(eGOPBWStr == E_GOP_BW_WEAK)
6138 MDrv_GOP_SetGOPBWStrength(g_pGOPCtxLocal, u8GOP,E_GOP_BURSTLEN_SHORT);
6139 else
6140 {
6141 return(GOP_API_INVALID_PARAMETERS);
6142 }
6143
6144 return(GOP_API_SUCCESS);
6145 }
GOP_GetGOPBWStrength(void * pInstance,MS_U8 u8GOP,EN_GOP_BW_STRENGTH * curBW)6146 MS_U32 GOP_GetGOPBWStrength(void* pInstance,MS_U8 u8GOP, EN_GOP_BW_STRENGTH* curBW)
6147 {
6148 MS_U32 gopbw;
6149 EN_GOP_BW_STRENGTH ret;
6150 #ifdef INSTANT_PRIVATE
6151 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6152 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6153 #endif
6154
6155
6156 if (!_GOP_IsGwinIdValid(pInstance,u8GOP))
6157 {
6158 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nInvaild gop num!!"));
6159 return(GOP_API_FAIL);
6160 }
6161 gopbw = MDrv_GOP_GetGOPBWStrength(g_pGOPCtxLocal, u8GOP);
6162
6163 if(gopbw == E_GOP_BURSTLEN_LONG )
6164 ret = E_GOP_BW_STRONG;
6165 else if(gopbw == E_GOP_BURSTLEN_MIDDLE )
6166 ret = E_GOP_BW_MIDDLE;
6167 else if(gopbw == E_GOP_BURSTLEN_SHORT )
6168 ret = E_GOP_BW_WEAK;
6169 else
6170 ret = E_GOP_BW_UNKNOWN;
6171
6172 if(curBW != NULL)
6173 *curBW = ret;
6174 else
6175 return(GOP_API_INVALID_PARAMETERS);
6176
6177 return(GOP_API_SUCCESS);
6178 }
GOP_EnableLBCouple(void * pInstance,MS_U8 u8GOP,MS_BOOL bEnable)6179 MS_U32 GOP_EnableLBCouple(void* pInstance,MS_U8 u8GOP, MS_BOOL bEnable)
6180 {
6181 #ifdef INSTANT_PRIVATE
6182 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6183 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6184 #endif
6185
6186 MDrv_GOP_EnableLBCouple(g_pGOPCtxLocal, u8GOP, bEnable);
6187 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
6188 return GOP_API_SUCCESS;
6189 }
6190
GOP_SetGOPYUV(void * pInstance,MS_U8 u8GOP)6191 MS_U32 GOP_SetGOPYUV(void* pInstance,MS_U8 u8GOP)
6192 {
6193 #ifdef INSTANT_PRIVATE
6194 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6195 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6196 #endif
6197
6198 if(u8GOP !=0xC &&!_GOP_IsGwinIdValid(pInstance,u8GOP))
6199 {
6200 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nInvaild gop num!!"));
6201 return(GOP_API_FAIL);
6202 }
6203 MDrv_GOP_SetGOPYUV(g_pGOPCtxLocal, u8GOP);
6204 return(GOP_API_SUCCESS);
6205 }
6206
GOP_IsRegUpdated(void * pInstance,MS_U8 u8GopType)6207 MS_U32 GOP_IsRegUpdated(void* pInstance,MS_U8 u8GopType)
6208 {
6209 #ifdef INSTANT_PRIVATE
6210 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6211 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6212 #endif
6213
6214 if (MDrv_GOP_GetGOPACK(g_pGOPCtxLocal, u8GopType))
6215 {
6216 return(GOP_API_SUCCESS);
6217 }
6218 return(GOP_API_FAIL);
6219 }
6220
GOP_TestPatternAlpha_Enable(void * pInstance,MS_BOOL bTSTAlpha)6221 MS_U32 GOP_TestPatternAlpha_Enable(void* pInstance,MS_BOOL bTSTAlpha)
6222 {
6223 DRV_GOP_TSTPATTERN drv_TstPattern;
6224 memset(&drv_TstPattern, 0, sizeof(DRV_GOP_TSTPATTERN));
6225 #ifdef INSTANT_PRIVATE
6226 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6227 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6228 #endif
6229
6230 drv_TstPattern.bTSTClr_Alpha_En = bTSTAlpha;
6231 MDrv_GOP_TestPatternAlpha_Enable(g_pGOPCtxLocal, drv_TstPattern.bTSTClr_Alpha_En);
6232 return GOP_API_SUCCESS;
6233 }
6234
GOP_OC_SetOCFBinfo(void * pInstance,MS_PHY u64Addr,EN_GOP_OC_SEL_TYPE BankMode,MS_U32 enBufSize)6235 MS_U32 GOP_OC_SetOCFBinfo(void* pInstance,MS_PHY u64Addr, EN_GOP_OC_SEL_TYPE BankMode, MS_U32 enBufSize)
6236 {
6237 DRV_GOP_OC_INFO OCinfo;
6238 MS_U16 PanelWidth,PanelHeight;
6239 E_GOP_API_Result enRet = GOP_API_FAIL;
6240 MS_U8 u8CurGOP = 0;
6241 #ifdef INSTANT_PRIVATE
6242 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6243 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6244 #endif
6245
6246 u8CurGOP = MDrv_GOP_Get(g_pGOPCtxLocal);
6247 memset(&OCinfo, 0, sizeof(DRV_GOP_OC_INFO));
6248
6249 PanelWidth = g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP];
6250 PanelHeight = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8CurGOP];
6251
6252 OCinfo.u16GOP_OC_HSIZE = PanelWidth;
6253 OCinfo.u16GOP_OC_VSIZE = PanelHeight;
6254 OCinfo.u32GOP_OC_FETCH = ( ((PanelWidth >>1) + (PanelWidth /10)) << 2) * PanelHeight; // PanelWidth *0.6(Compression Ratio) *4(8888fmt)
6255
6256 if(enBufSize < (OCinfo.u32GOP_OC_FETCH << BankMode))
6257 {
6258 GOP_M_ERR("[%s] ERROR, OC Buffer size not enough , input BufSize:0x%tx\n",__FUNCTION__,(ptrdiff_t)enBufSize);
6259 return (GOP_API_FAIL);
6260 }
6261 else
6262 {
6263 switch(BankMode)
6264 {
6265 case E_GOP_OC_SEL_2BankMode:
6266 OCinfo.u8GOP_OC_BANK_MODE = 1;
6267 break;
6268 case E_GOP_OC_SEL_4BankMode:
6269 OCinfo.u8GOP_OC_BANK_MODE = 0;
6270 break;
6271 default:
6272 OCinfo.u8GOP_OC_BANK_MODE = 1;
6273 break;
6274 }
6275 }
6276
6277 OCinfo.u64GOP_OC_DRAM_RBLK = u64Addr ;
6278 OCinfo.u64GOP_OC_ADDRPROTECT_STR = u64Addr;
6279 OCinfo.u64GOP_OC_ADDRPROTECT_END = u64Addr + enBufSize;
6280
6281 enRet = (E_GOP_API_Result)MDrv_GOP_OC_SetOCInfo(g_pGOPCtxLocal,&OCinfo);
6282
6283 return(enRet);
6284 }
6285
GOP_VE_SetOutputTiming(void * pInstance,GOP_VE_TIMINGTYPE mode)6286 MS_U32 GOP_VE_SetOutputTiming(void* pInstance,GOP_VE_TIMINGTYPE mode)
6287 {
6288 #ifdef INSTANT_PRIVATE
6289 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6290 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6291 #endif
6292 E_GOP_API_Result enRet=GOP_API_FAIL;
6293 enRet = (E_GOP_API_Result)MDrv_GOP_VE_SetOutputTiming(g_pGOPCtxLocal, mode);
6294 return enRet;
6295 }
6296
GOP_MIXER_SetOutputTiming(void * pInstance,GOP_MIXER_TIMINGTYPE mode,GOP_MixerTiming * pMT)6297 MS_U32 GOP_MIXER_SetOutputTiming(void* pInstance,GOP_MIXER_TIMINGTYPE mode, GOP_MixerTiming *pMT)
6298 {
6299 E_GOP_API_Result enRet=GOP_API_FAIL;
6300 GOP_DRV_MixerTiming MT;
6301 #ifdef INSTANT_PRIVATE
6302 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6303 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6304 #endif
6305
6306 if(pMT != NULL)
6307 {
6308 MT.hstart = pMT->hstart;
6309 MT.vstart = pMT->vstart;
6310 MT.vend = pMT->vend;
6311 MT.hend = pMT->hend;
6312 MT.htotal = pMT->htotal;
6313 MT.hsyncdelay = 0;
6314 }
6315
6316 if(pMT == NULL)
6317 {
6318 return(GOP_API_INVALID_PARAMETERS);
6319 }
6320
6321 enRet = (E_GOP_API_Result)MDrv_GOP_MIXER_SetOutputTiming(g_pGOPCtxLocal, mode, &MT);
6322 return(enRet);
6323 }
GOP_MIXER_SetMIXER2OPOutputTiming(void * pInstance,GOP_Mixer2OPTiming * pMT)6324 MS_U32 GOP_MIXER_SetMIXER2OPOutputTiming(void* pInstance,GOP_Mixer2OPTiming *pMT)
6325 {
6326 E_GOP_API_Result enRet=GOP_API_FAIL;
6327 GOP_DRV_MixerTiming MT;
6328 #ifdef INSTANT_PRIVATE
6329 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6330 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6331 #endif
6332
6333
6334 if(pMT != NULL)
6335 {
6336 MT.hstart = pMT->hstart;
6337 MT.vstart = pMT->vstart;
6338 MT.vend = pMT->vend;
6339 MT.hend = pMT->hend;
6340 MT.htotal = pMT->htotal;
6341 MT.hsyncdelay = pMT->hsyncdelay;
6342 }
6343
6344 if(pMT == NULL)
6345 {
6346 return(GOP_API_INVALID_PARAMETERS);
6347 }
6348
6349 enRet = (E_GOP_API_Result)MDrv_GOP_MIXER_SetOutputTiming(g_pGOPCtxLocal, GOP_CUSTOM_OP , &MT);
6350 return(enRet);
6351 }
GOP_MIXER_EnableVfilter(void * pInstance,MS_BOOL bEnable)6352 MS_U32 GOP_MIXER_EnableVfilter(void* pInstance,MS_BOOL bEnable)
6353 {
6354 E_GOP_API_Result enRet=GOP_API_FAIL;
6355 #ifdef INSTANT_PRIVATE
6356 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6357 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6358 #endif
6359 enRet = (E_GOP_API_Result)MDrv_GOP_MIXER_EnableVfilter(g_pGOPCtxLocal, bEnable);
6360
6361 return(enRet);
6362 }
6363
GOP_MIXER_EnableOldBlendingMode(void * pInstance,MS_U8 u8GOP,MS_BOOL bEnable)6364 MS_U32 GOP_MIXER_EnableOldBlendingMode(void* pInstance, MS_U8 u8GOP, MS_BOOL bEnable)
6365 {
6366 E_GOP_API_Result enRet=GOP_API_FAIL;
6367 #ifdef INSTANT_PRIVATE
6368 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6369 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6370 #endif
6371 enRet = (E_GOP_API_Result)MDrv_GOP_MIXER_EnableOldBlendMode(g_pGOPCtxLocal, u8GOP, bEnable);
6372
6373 return(enRet);
6374 }
6375
GOP_GWIN_SetRelativeWinPrio(void * pInstance,MS_U8 u8GOP,GOP_GwinPri * pGwinPri)6376 MS_U32 GOP_GWIN_SetRelativeWinPrio(void* pInstance,MS_U8 u8GOP, GOP_GwinPri *pGwinPri)
6377 {
6378 GOP_GwinPriority GopGwinPri;
6379 MS_U8 u8Idx;
6380 MS_U8 u8Idx2;
6381 #ifdef INSTANT_PRIVATE
6382 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6383 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6384 #endif
6385
6386 //Parameter check:
6387 if(u8GOP>=MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal)|| (NULL == pGwinPri)
6388 || (pGwinPri->u8GwinNum > 4) || (pGwinPri->u8GwinNum <= 0))
6389 {
6390 return(GOP_API_INVALID_PARAMETERS);
6391 }
6392
6393 u8Idx2 = (u8GOP==0) ? MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,0) : (MS_U8)g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum;
6394 for(u8Idx=0; u8Idx<pGwinPri->u8GwinNum; u8Idx++)
6395 {
6396 if(pGwinPri->u8GwinPri[u8Idx]>=u8Idx2)
6397 {
6398 return(GOP_API_INVALID_PARAMETERS);
6399 }
6400 }
6401
6402 //for GOP2,GOP3.no need to set the relative prio
6403 if ((u8GOP==2) || (u8GOP==3))
6404 {
6405 return(GOP_API_SUCCESS);
6406 }
6407
6408 //Handle GOP1:
6409 if(u8GOP==1)
6410 {
6411 u8Idx2 = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,0);
6412 if(pGwinPri->u8GwinPri[0]<u8Idx2)
6413 {
6414 return(GOP_API_INVALID_PARAMETERS);
6415 }
6416 GopGwinPri.Gop1_1stGwin = pGwinPri->u8GwinPri[0] - u8Idx2;
6417 //Adjust currently hw priority to app requested relative priority:
6418 MDrv_GOP_GWIN_SetGwinPriority(g_pGOPCtxLocal, 1, &GopGwinPri);
6419 return(GOP_API_SUCCESS);
6420 }
6421
6422 //Handle GOP0:
6423 //Get Currently HW Setting:
6424 MDrv_GOP_GWIN_GetGwinPriority(g_pGOPCtxLocal, u8GOP, &GopGwinPri);
6425
6426
6427 u8Idx2 = 0x0;
6428 for(u8Idx=0; u8Idx<pGwinPri->u8GwinNum; u8Idx++)
6429 {
6430 if(pGwinPri->u8GwinPri[u8Idx] == GopGwinPri.Gop0_GwinPri.u81stGwin)
6431 {
6432 if(u8Idx2 & 0x1)
6433 {
6434 return(GOP_API_INVALID_PARAMETERS);
6435 }
6436
6437 u8Idx2 |= 0x1;
6438 }
6439 else if(pGwinPri->u8GwinPri[u8Idx] == GopGwinPri.Gop0_GwinPri.u82stGwin)
6440 {
6441 if(u8Idx2 & 0x2)
6442 {
6443 return(GOP_API_INVALID_PARAMETERS);
6444 }
6445
6446 u8Idx2 |= 0x2;
6447 }
6448 else if(pGwinPri->u8GwinPri[u8Idx] == GopGwinPri.Gop0_GwinPri.u83stGwin)
6449 {
6450 if(u8Idx2 & 0x4)
6451 {
6452 return(GOP_API_INVALID_PARAMETERS);
6453 }
6454
6455 u8Idx2 |= 0x4;
6456 }
6457 else if(pGwinPri->u8GwinPri[u8Idx] == GopGwinPri.Gop0_GwinPri.u84stGwin)
6458 {
6459 if(u8Idx2 & 0x8)
6460 {
6461 return(GOP_API_INVALID_PARAMETERS);
6462 }
6463
6464 u8Idx2 |= 0x8;
6465 }
6466 }
6467
6468 u8Idx=0;
6469 if(u8Idx2 & 0x1)
6470 {
6471 GopGwinPri.Gop0_GwinPri.u81stGwin = pGwinPri->u8GwinPri[u8Idx];
6472 u8Idx++;
6473 }
6474
6475 if(u8Idx2 & 0x2)
6476 {
6477 GopGwinPri.Gop0_GwinPri.u82stGwin = pGwinPri->u8GwinPri[u8Idx];
6478 u8Idx++;
6479 }
6480
6481 if(u8Idx2 & 0x4)
6482 {
6483 GopGwinPri.Gop0_GwinPri.u83stGwin = pGwinPri->u8GwinPri[u8Idx];
6484 u8Idx++;
6485 }
6486
6487 if(u8Idx2 & 0x8)
6488 {
6489 GopGwinPri.Gop0_GwinPri.u84stGwin = pGwinPri->u8GwinPri[u8Idx];
6490 u8Idx++;
6491 }
6492
6493 MDrv_GOP_GWIN_SetGwinPriority(g_pGOPCtxLocal, 0, &GopGwinPri);
6494
6495 return(GOP_API_SUCCESS);
6496 }
6497
6498
6499 //==================================================================
Ioctl_GOP_DWIN_Init(void * pInstance)6500 MS_U32 Ioctl_GOP_DWIN_Init(void* pInstance)
6501 {
6502 E_GOPD_FIFO_DEPTH gopdFifoDepth;
6503 #ifdef INSTANT_PRIVATE
6504 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6505 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6506 #endif
6507
6508 if(g_pGOPCtxLocal ==NULL)
6509 {
6510 MS_BOOL bFirstInstance;
6511 GOP_PreInit_Ctx(pInstance, &bFirstInstance);
6512 if (MDrv_GOP_SetIOMapBase(g_pGOPCtxLocal) != TRUE)
6513 {
6514 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nget IO base fail"));
6515 return GOP_API_FAIL;
6516 }
6517 }
6518
6519 // MDrv_GOP_DWIN_SelectSourceFmt(GOPDWIN_DATA_FMT_YUV);
6520 //MDrv_GOP_DWIN_SelectSource(GOPDWIN_DATA_SRC_SCALAR);
6521 MDrv_GOP_DWIN_Set_CTRL0(g_pGOPCtxLocal, 0x0000, 0xFFFF); // Clear all
6522 MDrv_GOP_DWIN_Set_CTRL0(g_pGOPCtxLocal, 0x0000, 0x0080); // Set continuous capture
6523
6524
6525 // Set DMA burst access length
6526 gopdFifoDepth = (E_GOPD_FIFO_DEPTH)MDrv_GOP_GetRegForm(g_pGOPCtxLocal, GOPTYPE.DWIN, 0xff);
6527 switch(gopdFifoDepth)
6528 {
6529 case E_GOPD_FIFO_DEPTH_64:
6530 MDrv_GOP_SetGOPBWStrength(g_pGOPCtxLocal, 0xC, E_GOP_BURSTLEN_MIDDLE);
6531 break;
6532 case E_GOPD_FIFO_DEPTH_128:
6533 MDrv_GOP_SetGOPBWStrength(g_pGOPCtxLocal, 0xC, E_GOP_BURSTLEN_LONG);
6534 break;
6535 case E_GOPD_FIFO_DEPTH_256:
6536 MDrv_GOP_SetGOPBWStrength(g_pGOPCtxLocal, 0xC, E_GOP_BURSTLEN_LONG);
6537 break;
6538 default:
6539 GOP_M_ERR("\n[%s][%d] Not supported GOPD FIFO depth: %d\n", __FUNCTION__,__LINE__, gopdFifoDepth); // bob.fu
6540 }
6541 return GOP_API_SUCCESS;
6542 }
6543
Ioctl_GOP_Get_ScaleDst(void * pInstance,MS_U8 u8GOPNum,MS_U16 * pHScaleDst,MS_U16 * pVScaleDst)6544 MS_U32 Ioctl_GOP_Get_ScaleDst(void* pInstance,MS_U8 u8GOPNum,MS_U16 *pHScaleDst,MS_U16 *pVScaleDst)
6545 {
6546 #ifdef INSTANT_PRIVATE
6547 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6548 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6549 #endif
6550
6551 *pHScaleDst = g_pGOPCtxLocal->pGOPCtxShared->u16HScaleDst[u8GOPNum];
6552 *pVScaleDst = g_pGOPCtxLocal->pGOPCtxShared->u16VScaleDst[u8GOPNum];
6553 return GOP_API_SUCCESS;
6554 }
6555
6556 //==================================================================
6557 //////////////////////////////////////////////////
6558 // - GOP ioctl function.
6559 //////////////////////////////////////////////////
6560
Ioctl_GOP_Init(void * pInstance,MS_U8 u8GOP,GOP_InitInfo * pGopInit)6561 MS_U32 Ioctl_GOP_Init(void* pInstance,MS_U8 u8GOP,GOP_InitInfo *pGopInit)
6562 {
6563 MS_U16 u8Idx;
6564 #if 0
6565 DRV_GopPaletteEntry pPalArray[256];
6566 #else
6567 DRV_GopPaletteEntry *pPalArray = NULL;
6568 #endif
6569 MS_BOOL bFirstInstance = FALSE;
6570 MS_BOOL resCtxInit;
6571 DRV_GOPDstType GopDst;
6572 #ifdef INSTANT_PRIVATE
6573 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6574 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6575 #endif
6576
6577 //NULL pointer protect
6578 if(NULL == pGopInit)
6579 {
6580 GOP_M_INFO("[%s][%d] input parameter is NULL\n",__FUNCTION__,__LINE__);
6581 //GOP_LIB_VER GOPLib;
6582 resCtxInit = _GOP_Init_Ctx(pInstance,&bFirstInstance);
6583 APIGOP_ASSERT(resCtxInit, GOP_M_FATAL("failed to init GOP context\n"));
6584 if (bFirstInstance)
6585 {
6586 g_pGOPCtxLocal->pGOPCtxShared->bDummyInit = TRUE;
6587 }
6588
6589 if (MDrv_GOP_SetIOMapBase(g_pGOPCtxLocal) != TRUE)
6590 {
6591 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nget IO base fail"));
6592 return GOP_API_FAIL;
6593 }
6594 }
6595 else
6596 {
6597 //GOP_LIB_VER GOPLib;
6598 resCtxInit = _GOP_Init_Ctx(pInstance,&bFirstInstance);
6599 APIGOP_ASSERT(resCtxInit, GOP_M_FATAL("failed to init GOP context\n"));
6600 bFirstInit = FALSE;
6601 if (g_pGOPCtxLocal->pGOPCtxShared->bDummyInit)
6602 {
6603 //other GOP init should work as the first instance flow
6604 bFirstInstance = TRUE;
6605 g_pGOPCtxLocal->pGOPCtxShared->bInitShared = TRUE;
6606 g_pGOPCtxLocal->pGOPCtxShared->bDummyInit = FALSE;
6607 }
6608
6609 if (!_GOP_IsGopNumValid(pInstance,u8GOP))
6610 {
6611 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
6612 return GOP_API_FAIL;
6613 }
6614
6615 //init GOP global variable
6616 if(g_pGOPCtxLocal->pGOPCtxShared->bInitShared)
6617 {
6618 g_pGOPCtxLocal->Gwin_H_Dup = FALSE;
6619 g_pGOPCtxLocal->Gwin_V_Dup = FALSE;
6620 g_pGOPCtxLocal->current_winId = GOP0_Gwin0Id;
6621 g_pGOPCtxLocal->pGOPCtxShared->fbPool1.GWinFB_Pool_BaseAddr = pGopInit->u32GOPRBAdr;
6622 g_pGOPCtxLocal->pGOPCtxShared->fbPool1.u32GWinFB_Pool_MemLen = pGopInit->u32GOPRBLen;
6623 g_pGOPCtxLocal->pGOPCtxShared->fbPool1.u32FirstFBIdInPool = INVALID_POOL_NEXT_FBID;
6624 g_pGOPCtxLocal->pGOPCtxShared->fbPool1.poolId= GOP_WINFB_POOL1;
6625 g_pGOPCtxLocal->pGOPCtxShared->fbPool2.GWinFB_Pool_BaseAddr = 0;
6626 g_pGOPCtxLocal->pGOPCtxShared->fbPool2.u32GWinFB_Pool_MemLen = 0;
6627 g_pGOPCtxLocal->pGOPCtxShared->fbPool2.u32FirstFBIdInPool = INVALID_POOL_NEXT_FBID;
6628 g_pGOPCtxLocal->pGOPCtxShared->fbPool2.poolId= GOP_WINFB_POOL2;
6629 g_pGOPCtxLocal->pGOPCtxShared->fb_currentPoolId = GOP_WINFB_POOL1;
6630 g_pGOPCtxLocal->pGOPCtxShared->phyGOPRegdmaAdr = pGopInit->u32GOPRegdmaAdr;
6631 g_pGOPCtxLocal->pGOPCtxShared->u32GOPRegdmaLen = pGopInit->u32GOPRegdmaLen;
6632 }
6633
6634 if(pGopInit->bEnableVsyncIntFlip == TRUE)
6635 g_pGOPCtxLocal->pGOPCtxShared->bEnableVsyncIntFlip = TRUE;
6636
6637 if (MDrv_GOP_SetIOMapBase(g_pGOPCtxLocal) != TRUE)
6638 {
6639 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\nget IO base fail"));
6640 return GOP_API_FAIL;
6641 }
6642
6643 g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8GOP] = pGopInit->u16PanelWidth;
6644 g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8GOP] = pGopInit->u16PanelHeight;
6645 g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[u8GOP] = pGopInit->u16PanelHStr;
6646
6647 MDrv_GOP_GWIN_ForceWrite_Update(g_pGOPCtxLocal, u8GOP, TRUE);//if use double buffer write in GOP init state, GOP HW cannot wait V-Sync to update register
6648
6649 if(g_pGOPCtxLocal->pGOPCtxShared->bInitShared)
6650 {
6651 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_MUX))
6652 MDrv_GOP_InitMux(g_pGOPCtxLocal);
6653 }
6654 if(FALSE == g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[u8GOP])
6655 {
6656
6657 if(g_pGOPCtxLocal->pGopChipProperty->bPixelModeSupport)
6658 {
6659 g_pGOPCtxLocal->pGOPCtxShared->bPixelMode[u8GOP] = TRUE;
6660 }
6661 //Not initialized yet:
6662 GOP_GWIN_InitByGOP(pInstance,bFirstInstance, u8GOP);
6663
6664 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_GWIN))
6665 MDrv_GOP_Init(g_pGOPCtxLocal, u8GOP, pGopInit->u32GOPRegdmaAdr, pGopInit->u32GOPRegdmaLen, pGopInit->bEnableVsyncIntFlip);
6666 #if (FPGA_TEST)
6667 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
6668 MDrv_GOP_GWIN_SetDstPlane(g_pGOPCtxLocal, u8GOP, E_DRV_GOP_DST_VOP,FALSE);
6669 MDrv_GOP_GWIN_SetStretchWin(u8GOP, E_GOP_DST_VOP,0, 0, g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth, g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight) ;
6670
6671 (_GOP_Map_APIDst2DRV_Enum(pInstance,E_GOP_DST_VOP, &GopDst));
6672 MDrv_GOP_SetGOPClk(g_pGOPCtxLocal, u8GOP, E_GOP_DST_VOP);
6673 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP,DRV_GOPOUT_RGB);
6674 #else
6675 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_SET_DST_OP))
6676 {
6677 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
6678 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal,u8GOP,TRUE);
6679 MDrv_GOP_GWIN_SetDstPlane(g_pGOPCtxLocal, u8GOP, E_DRV_GOP_DST_OP0,FALSE);
6680 (_GOP_Map_APIDst2DRV_Enum(pInstance,E_GOP_DST_OP0, &GopDst));
6681 MDrv_GOP_SetGOPClk(g_pGOPCtxLocal, u8GOP, GopDst);
6682 }
6683
6684 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_STRETCHWIN))
6685 MDrv_GOP_GWIN_SetStretchWin(g_pGOPCtxLocal,u8GOP,0, 0, g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8GOP], g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8GOP]) ;
6686 #endif
6687 if (u8GOP==0)
6688 {
6689 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP0);
6690 }
6691 else if (u8GOP==1)
6692 {
6693 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP1);
6694 }
6695 else if (u8GOP==2)
6696 {
6697 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP2);
6698 }
6699 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_ENABLE_TRANSCLR))
6700 MDrv_GOP_GWIN_EnableTransClr(g_pGOPCtxLocal,u8GOP, (GOP_TransClrFmt)0, FALSE);
6701
6702 if(!g_pGOPCtxLocal->pGopChipProperty->bInitNotEnableGOPToSC) //u4 mux init setting, enable GOP to SC in GOP init would cause problem
6703 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, TRUE);
6704 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_GWIN))
6705 {
6706 g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[u8GOP] = TRUE;
6707 }
6708 }
6709
6710 MDrv_GOP_PerClientInit(g_pGOPCtxLocal, u8GOP, pGopInit->u32GOPRegdmaAdr, pGopInit->u32GOPRegdmaLen, pGopInit->bEnableVsyncIntFlip);
6711 _GOP_InitHSPDByGOP(pInstance,u8GOP); //Fix me, temporary solution for removing calling of "MApi_GOP_GWIN_OutputLayerSwitch"
6712 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_IGNORE_PALETTE))
6713 {
6714 pPalArray = malloc(sizeof(DRV_GopPaletteEntry)*256);
6715 if(pPalArray != NULL)
6716 {
6717 for (u8Idx=0; u8Idx<256; u8Idx++)
6718 {
6719 pPalArray[u8Idx].RGB.u8A = pPalArray[u8Idx].RGB.u8R = pPalArray[u8Idx].RGB.u8G = pPalArray[u8Idx].RGB.u8B = 0;
6720 }
6721
6722 MDrv_GOP_GWIN_SetPaletteOpt(g_pGOPCtxLocal,u8GOP, pPalArray, 0, 255, E_DRV_GOP_PAL_ARGB8888);
6723 MDrv_GOP_GWIN_2GSetPaletteOpt(g_pGOPCtxLocal,u8GOP, pPalArray, 0, 255);
6724 //MApi_GOP_GWIN_SetPalette();
6725
6726 if(pPalArray != NULL)
6727 {
6728 free(pPalArray);
6729 pPalArray = NULL;
6730 }
6731 }
6732 else
6733 {
6734 APIGOP_ASSERT(FALSE, GOP_M_FATAL("[%s][%d]Error!! malloc fail, pPalArray[256]\n", __FUNCTION__, __LINE__));
6735 }
6736 }
6737
6738 if(bFirstInstance)
6739 {
6740 MDrv_GOP_SetVOPNBL(g_pGOPCtxLocal,FALSE);
6741 }
6742 MDrv_GOP_GWIN_ForceWrite_Update(g_pGOPCtxLocal, u8GOP, FALSE);
6743 }
6744
6745 //restore force write setting
6746 MDrv_GOP_GWIN_SetForceWrite(g_pGOPCtxLocal, g_pGOPCtxLocal->bInitFWR);
6747 MDrv_GOP_GWIN_SetBnkForceWrite(g_pGOPCtxLocal,u8GOP,bInitBkFWR[u8GOP]);
6748 // apiGOP_DBG("[OUT]\n");
6749 return GOP_API_SUCCESS;
6750 }
6751
6752
Ioctl_GOP_GetCaps(void * pInstance,EN_GOP_CAPS eCapType,MS_U32 * pRet,MS_U32 ret_size)6753 MS_U32 Ioctl_GOP_GetCaps(void* pInstance,EN_GOP_CAPS eCapType, MS_U32* pRet, MS_U32 ret_size)
6754 {
6755 #ifdef INSTANT_PRIVATE
6756 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6757 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6758 #endif
6759
6760 if(eCapType != E_GOP_CAP_VERSION)
6761 APIGOP_CHECK_INIT();
6762
6763 E_GOP_API_Result enRet = GOP_API_SUCCESS;
6764 switch(eCapType)
6765 {
6766 case E_GOP_CAP_WORD_UNIT:
6767 {
6768 *((MS_U16 *)pRet) = g_pGOPCtxLocal->pGopChipProperty->WordUnit;
6769 break;
6770 }
6771 case E_GOP_CAP_GWIN_NUM:
6772 {
6773 *pRet = g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum;
6774 break;
6775 }
6776 case E_GOP_CAP_VERSION:
6777 {
6778 char ver[] = MSIF_GOP_LIBVER;
6779 char blnum[] = MSIF_GOP_BUILDNUM;
6780 char cl[] = MSIF_GOP_CHANGELIST;
6781 GOP_LIB_VER * pLibVer;
6782
6783 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
6784 if(ret_size != sizeof(GOP_LIB_VER))
6785 {
6786 GOP_M_ERR("[%s] ERROR, invalid input structure size :%td on E_GOP_CAP_VERSION\n",__FUNCTION__,(ptrdiff_t)ret_size);
6787 return GOP_API_FAIL;
6788 }
6789 #endif
6790 pLibVer = (GOP_LIB_VER *)pRet;
6791
6792 pLibVer->GOP_LibVer = atoi(ver);
6793 pLibVer->GOP_BuildNum = atoi(blnum);
6794 pLibVer->GOP_ChangeList = atoi(cl);
6795
6796 break;
6797 }
6798 case E_GOP_CAP_CONSALPHA_VALIDBITS:
6799 {
6800 *pRet = g_pGOPCtxLocal->pGopChipProperty->Default_ConsAlpha_bits;
6801 break;
6802 }
6803 case E_GOP_CAP_PALETTE:
6804 {
6805 MS_U32 i;
6806 MS_U16 tmp;
6807 GOP_CAP_PAL_TYPE* pPal;
6808
6809 pPal = (GOP_CAP_PAL_TYPE *)pRet;
6810 memset(pPal,0,sizeof(GOP_CAP_PAL_TYPE));
6811
6812 for(i=0;i< _GOP_GetMaxGOPNum(pInstance);i++)
6813 {
6814 tmp = MDrv_GOP_GetRegForm(g_pGOPCtxLocal,i,0xff);
6815 if(tmp & E_GOP_CAP_PAL_SIZE_MASK)
6816 {
6817 pPal->GOP_NumOfTbl++;
6818 pPal->GOP_PalTbl[i] = tmp & E_GOP_CAP_PAL_SIZE_MASK ;
6819 pPal->GOP_PalTblIdx |= 1<<i;
6820 }
6821 }
6822
6823 break;
6824 }
6825 case E_GOP_CAP_DWIN:
6826 {
6827 PGOP_DWIN_CAP pDwinCap;
6828 pDwinCap = (PGOP_DWIN_CAP)pRet;
6829 Mdrv_GOP_GetDWinCapability(g_pGOPCtxLocal, (PDRV_GOP_DWIN_CAP)pDwinCap);
6830 break;
6831 }
6832 case E_GOP_CAP_GOP_MUX:
6833 {
6834 if(pRet != NULL)
6835 {
6836 PST_DRV_GOP_MUX_CAP_EX pstDrvMuxCapEx = (PST_DRV_GOP_MUX_CAP_EX)(void*)pRet;
6837 if(Mdrv_GOP_GetMuxPriority(g_pGOPCtxLocal, (PST_DRV_GOP_MUX_CAP_EX)pstDrvMuxCapEx))
6838 {
6839 pstDrvMuxCapEx->bNeedSetMUX1ToIP0 = g_pGOPCtxLocal->pGopChipProperty->bNeedSetMUX1ToIP0;
6840 pstDrvMuxCapEx->bNeedSetMUX3ToIP0 = g_pGOPCtxLocal->pGopChipProperty->bNeedSetMUX3ToIP0;
6841 pstDrvMuxCapEx->bNewMux = g_pGOPCtxLocal->pGopChipProperty->bNewMux;
6842 }
6843 else
6844 {
6845 enRet = GOP_API_FAIL;
6846 }
6847 }
6848 else
6849 {
6850 APIGOP_ASSERT(0, GOP_M_FATAL("Invalid input parameter: NULL pointer\n"));
6851 }
6852
6853 break;
6854 }
6855 case E_GOP_CAP_PIXELMODE_SUPPORT:
6856 {
6857 *pRet = g_pGOPCtxLocal->pGopChipProperty->bPixelModeSupport;
6858 break;
6859 }
6860 case E_GOP_CAP_STRETCH:
6861 {
6862 if(pRet != NULL)
6863 {
6864 MS_U8 i;
6865 PGOP_CAP_STRETCH_INFO pGOPStretchInfo= (PGOP_CAP_STRETCH_INFO)pRet;
6866 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
6867 if(ret_size != sizeof(GOP_CAP_STRETCH_INFO))
6868 {
6869 GOP_M_ERR("[%s] ERROR, invalid input structure size :%td on E_GOP_CAP_STRETCH\n",__FUNCTION__,(ptrdiff_t)ret_size);
6870 return GOP_API_FAIL;
6871 }
6872 #endif
6873 pGOPStretchInfo->GOP_VStretch_Support=0;
6874 for(i=0;i<MIN(sizeof(g_pGOPCtxLocal->pGopChipProperty->bGOPWithVscale),(sizeof(pGOPStretchInfo->GOP_VStretch_Support)*8));i++)
6875 {
6876 if(g_pGOPCtxLocal->pGopChipProperty->bGOPWithVscale[i])
6877 {
6878 pGOPStretchInfo->GOP_VStretch_Support |= BIT(i);
6879 }
6880 else
6881 {
6882 pGOPStretchInfo->GOP_VStretch_Support &= ~(BIT(i));
6883 }
6884 }
6885 }
6886 else
6887 {
6888 APIGOP_ASSERT(0, GOP_M_FATAL("Invalid input parameter: NULL pointer\n"));
6889 }
6890 break;
6891 }
6892 case E_GOP_CAP_TLBMODE_SUPPORT:
6893 {
6894 if(pRet != NULL)
6895 {
6896 MS_U8 i;
6897 PGOP_CAP_TLB_INFO pGOPTLBInfo= (PGOP_CAP_TLB_INFO)pRet;
6898 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
6899 if(ret_size != sizeof(GOP_CAP_TLB_INFO))
6900 {
6901 GOP_M_ERR("[%s] ERROR, invalid input structure size :%td on E_GOP_CAP_TLBMODE_SUPPORT\n",__FUNCTION__,(ptrdiff_t)ret_size);
6902 return GOP_API_FAIL;
6903 }
6904 #endif
6905 pGOPTLBInfo->GOP_TLB_Support=0;
6906 for(i=0; i < MAX_GOP_SUPPORT; i++)
6907 {
6908 if(g_pGOPCtxLocal->pGopChipProperty->bTLBSupport[i])
6909 {
6910 pGOPTLBInfo->GOP_TLB_Support |= BIT(i);
6911 }
6912 else
6913 {
6914 pGOPTLBInfo->GOP_TLB_Support &= ~(BIT(i));
6915 }
6916 }
6917 }
6918 else
6919 {
6920 APIGOP_ASSERT(0, GOP_M_FATAL("Invalid input parameter: NULL pointer\n"));
6921 }
6922 break;
6923 }
6924 case E_GOP_CAP_AFBC_SUPPORT:
6925 {
6926 if(pRet != NULL)
6927 {
6928 MS_U8 i;
6929 PGOP_CAP_AFBC_INFO pGOPAFBCInfo= (PGOP_CAP_AFBC_INFO)pRet;
6930 if(ret_size != sizeof(GOP_CAP_AFBC_INFO))
6931 {
6932 printf("[%s] ERROR, invalid input structure size :%td on E_GOP_CAP_AFBC_MODE_SUPPORT\n",__FUNCTION__,(ptrdiff_t)ret_size);
6933 return GOP_API_FAIL;
6934 }
6935 pGOPAFBCInfo->GOP_AFBC_Support=0;
6936 for(i=0; i < MAX_GOP_SUPPORT; i++)
6937 {
6938 if(g_pGOPCtxLocal->pGopChipProperty->bAFBC_Support[i])
6939 {
6940 pGOPAFBCInfo->GOP_AFBC_Support |= BIT(i);
6941 }
6942 else
6943 {
6944 pGOPAFBCInfo->GOP_AFBC_Support &= ~(BIT(i));
6945 }
6946 }
6947 }
6948 else
6949 {
6950 APIGOP_ASSERT(0, printf("Invalid input parameter: NULL pointer\n"));
6951 }
6952 break;
6953 }
6954 case E_GOP_CAP_BNKFORCEWRITE:
6955 {
6956 *pRet = g_pGOPCtxLocal->pGopChipProperty->bBnkForceWrite;
6957 break;
6958 }
6959 default:
6960 GOP_M_ERR("[%s]not support GOP capability case: %d\n",__FUNCTION__, eCapType);
6961 enRet = GOP_API_FAIL;
6962 }
6963
6964 return enRet;
6965 }
6966
6967
Ioctl_GOP_SetConfig(void * pInstance,EN_GOP_CONFIG_TYPE cfg_type,MS_U32 * pCfg,MS_U32 u32Size)6968 MS_U32 Ioctl_GOP_SetConfig(void* pInstance,EN_GOP_CONFIG_TYPE cfg_type,MS_U32* pCfg,MS_U32 u32Size)
6969 {
6970 MS_BOOL bFirstInstance;
6971 MS_BOOL resCtxInit;
6972 EN_GOP_IGNOREINIT *pGOPIgnoreInit;
6973 DRV_GOP_CONSALPHA_BITS *pGOPAlphaBits;
6974 #ifdef INSTANT_PRIVATE
6975 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
6976 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
6977 #endif
6978
6979 switch(cfg_type)
6980 {
6981 case E_GOP_IGNOREINIT:
6982 resCtxInit = GOP_PreInit_Ctx(pInstance,&bFirstInstance);
6983 APIGOP_ASSERT(resCtxInit, GOP_M_FATAL("failed to init GOP context\n"));
6984
6985 pGOPIgnoreInit = (EN_GOP_IGNOREINIT *)(pCfg);
6986 g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit = (DRV_GOP_IGNOREINIT)(*pGOPIgnoreInit);
6987 /*To control that do not affect the normal flow in MApi_GOP_Init and MApi_GOP_InitByGOP*/
6988 if(E_GOP_IGNORE_DISABLE != *pGOPIgnoreInit)
6989 {
6990 bFirstInit = TRUE;
6991 }
6992 break;
6993 case E_GOP_CONSALPHA_BITS:
6994
6995
6996 pGOPAlphaBits = (DRV_GOP_CONSALPHA_BITS *)(pCfg);
6997 *(g_pGOPCtxLocal->pGopConsAlphaBits) = *pGOPAlphaBits;
6998 break;
6999 default:
7000
7001 break;
7002 }
7003
7004 return GOP_API_SUCCESS;
7005
7006
7007
7008
7009 }
7010
Ioctl_GOP_GetConfig(void * pInstance,EN_GOP_CONFIG_TYPE cfg_type,MS_U32 * pCfg,MS_U32 u32Size)7011 MS_U32 Ioctl_GOP_GetConfig(void* pInstance,EN_GOP_CONFIG_TYPE cfg_type,MS_U32* pCfg,MS_U32 u32Size)
7012 {
7013 #ifdef INSTANT_PRIVATE
7014 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
7015 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
7016 #endif
7017
7018 switch(cfg_type)
7019 {
7020 case E_GOP_IGNOREINIT:
7021 {
7022 EN_GOP_IGNOREINIT *penGOPIgnoreInit;
7023 penGOPIgnoreInit = (EN_GOP_IGNOREINIT*)pCfg;
7024 *penGOPIgnoreInit = (EN_GOP_IGNOREINIT)g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit;
7025 break;
7026 }
7027 case E_GOP_CONSALPHA_BITS:
7028 {
7029 DRV_GOP_CONSALPHA_BITS *penGOPAlphaBits;
7030 penGOPAlphaBits = (DRV_GOP_CONSALPHA_BITS *)pCfg;
7031 penGOPAlphaBits = g_pGOPCtxLocal->pGopConsAlphaBits;
7032 break;
7033 }
7034 default:
7035
7036 break;
7037 }
7038
7039 return GOP_API_SUCCESS;
7040 }
7041
Ioctl_GOP_SetProperty(void * pInstance,EN_GOP_PROPERTY type,MS_U32 gop,MS_U32 * pSet,MS_U32 u32Size)7042 MS_U32 Ioctl_GOP_SetProperty(void* pInstance,EN_GOP_PROPERTY type,MS_U32 gop, MS_U32* pSet, MS_U32 u32Size)
7043 {
7044 #ifdef INSTANT_PRIVATE
7045 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
7046 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
7047 #endif
7048
7049 switch(type)
7050 {
7051 case E_GOP_MIUSEL:
7052 {
7053 E_DRV_GOP_SEL_TYPE miusel;
7054 if(u32Size != sizeof(EN_GOP_SEL_TYPE))
7055 {
7056 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7057 return GOP_API_FAIL;
7058 }
7059
7060 miusel = (E_DRV_GOP_SEL_TYPE)*pSet;
7061 GOP_MIUSel(pInstance,gop,(EN_GOP_SEL_TYPE)miusel);
7062
7063 break;
7064 }
7065 case E_GOP_CONTRAST:
7066 {
7067 PGOP_CONTRAST pRGB = (PGOP_CONTRAST)pSet;
7068 if(u32Size != sizeof(GOP_CONTRAST))
7069 {
7070 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7071 return GOP_API_FAIL;
7072 }
7073
7074 GOP_SetContrast(pInstance,gop,pRGB->y, pRGB->u, pRGB->v);
7075
7076
7077 break;
7078 }
7079 case E_GOP_BRIGHTNESS:
7080 {
7081 PGOP_BRIGHTNESS pBri = (PGOP_BRIGHTNESS)pSet;
7082 if(u32Size != sizeof(GOP_BRIGHTNESS))
7083 {
7084 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7085 return GOP_API_FAIL;
7086 }
7087
7088 GOP_SetBrightness(pInstance,gop,pBri->Brightness, pBri->bMSB);
7089 break;
7090 }
7091 case E_GOP_OUTPUT_COLOR:
7092 {
7093 EN_GOP_OUTPUT_COLOR output;
7094 if(u32Size != sizeof(EN_GOP_OUTPUT_COLOR))
7095 {
7096 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7097 return GOP_API_FAIL;
7098 }
7099
7100 output = (EN_GOP_OUTPUT_COLOR)*pSet;
7101 GOP_SetOutputColor(pInstance,gop,output);
7102
7103 break;
7104
7105 }
7106 case E_GOP_UV_SWAP:
7107 {
7108 MS_BOOL bEn;
7109 if(u32Size != sizeof(MS_BOOL))
7110 {
7111 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7112 return GOP_API_FAIL;
7113 }
7114
7115 bEn = (MS_BOOL)*pSet;
7116 GOP_SetUVSwap(pInstance,gop,bEn);
7117
7118 break;
7119 }
7120 case E_GOP_YC_SWAP:
7121 {
7122 MS_BOOL bEn;
7123 if(u32Size != sizeof(MS_BOOL))
7124 {
7125 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7126 return GOP_API_FAIL;
7127 }
7128
7129 bEn = (MS_BOOL)*pSet;
7130 GOP_SetYCSwap(pInstance,gop,bEn);
7131
7132 break;
7133 }
7134 case E_GOP_HSTART:
7135 {
7136 MS_U16 u16PanelHStr;
7137
7138 if(u32Size != sizeof(MS_U16))
7139 {
7140 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7141 return GOP_API_FAIL;
7142 }
7143
7144 u16PanelHStr = (MS_U16)*pSet;
7145 GOP_SetHStart(pInstance,gop,u16PanelHStr);
7146
7147 break;
7148 }
7149 case E_GOP_TRANSCOLOR:
7150 {
7151 PGOP_TRANSCOLOR ptrans_clr;
7152 MS_U32 clr;
7153 MS_U32 fullclr = 0;
7154 EN_GOP_TRANSCLR_FMT fmt;
7155
7156 if(u32Size != sizeof(GOP_TRANSCOLOR))
7157 {
7158 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7159 return GOP_API_FAIL;
7160 }
7161
7162 ptrans_clr = (PGOP_TRANSCOLOR)pSet;
7163
7164 clr = ptrans_clr->color;
7165 fmt = ptrans_clr->fmt;
7166
7167 if(ptrans_clr->transclr_property == EN_TRANSCLR_SET_COLOR)
7168 {
7169 if(fmt == GOPTRANSCLR_FMT0)
7170 {
7171 /***** !RGB555 *****/
7172 fullclr = ((clr>>10)&0x1f)<<3; // R
7173 fullclr |= ((clr>>12)&0x7);
7174 fullclr = fullclr << 8;
7175 fullclr |= ((clr>>5)&0x1f)<<3; // G
7176 fullclr |= ((clr>>7)&0x7);
7177 fullclr = fullclr << 8;
7178 fullclr |= (clr&0x1f)<<3; // B
7179 fullclr |= ((clr>>2)&0x7); // B
7180 MDrv_GOP_GWIN_SetTransClr_8888(g_pGOPCtxLocal,gop, fullclr, 0);
7181 }
7182 else if(fmt == GOPTRANSCLR_FMT1)
7183 {
7184 /***** index mode *****/
7185 MDrv_GOP_GWIN_ReadPalette(g_pGOPCtxLocal,gop, clr, &fullclr);
7186 MDrv_GOP_GWIN_SetTransClr_8888(g_pGOPCtxLocal,gop, fullclr, 0);
7187 }
7188 else if(fmt == GOPTRANSCLR_FMT2) //ARGB8888
7189 {
7190 fullclr = ptrans_clr->color;
7191 MDrv_GOP_GWIN_SetTransClr_8888(g_pGOPCtxLocal,gop, fullclr, 0);
7192 }else if(fmt == GOPTRANSCLR_FMT3)
7193 {
7194 fullclr = (clr&0xff)<<16; //V
7195 fullclr |= ((clr>>8)&0xff)<<8; //Y
7196 fullclr |= ((clr>>16)&0xff); //U
7197 MDrv_GOP_GWIN_SetTransClr_YUV(g_pGOPCtxLocal, gop, fullclr, 0x0);
7198 }
7199
7200 //MDrv_GOP_GWIN_SetTransClr_8888(g_pGOPCtxLocal,gop, fullclr, 0);
7201 }
7202 else if(ptrans_clr->transclr_property == EN_TRANSCLR_ENABLE)
7203 {
7204 //MDrv_GOP_GWIN_EnableTransClr(g_pGOPCtxLocal,gop, (GOP_TransClrFmt)GOPTRANSCLR_FMT0,ptrans_clr->bEn);
7205 MDrv_GOP_GWIN_EnableTransClr(g_pGOPCtxLocal,gop, (GOP_TransClrFmt)fmt,ptrans_clr->bEn);
7206 if((fmt==GOPTRANSCLR_FMT0)&&((fmt != GOPTRANSCLR_FMT0)&&(fmt != GOPTRANSCLR_FMT2)))
7207 {
7208 printf("%s,Fail: GOPTRANSCLR FMT0 not Match Format\n",__FUNCTION__);
7209 return GOP_API_FAIL;
7210 }
7211 else if((fmt==GOPTRANSCLR_FMT1)&&(fmt != GOPTRANSCLR_FMT1))
7212 {
7213 printf("%s,Fail: GOPTRANSCLR FMT1 not Match Format\n",__FUNCTION__);
7214 return GOP_API_FAIL;
7215 }
7216 }
7217 break;
7218
7219 }
7220 case E_GOP_PROGRESSIVE:
7221 {
7222 MS_BOOL bEn;
7223 if(u32Size != sizeof(MS_BOOL))
7224 {
7225 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7226 return GOP_API_FAIL;
7227 }
7228
7229 bEn = (MS_BOOL)*pSet;
7230 GOP_SetProgressive(pInstance,gop,bEn);
7231 break;
7232 }
7233 case E_GOP_ALPHAINVERSE:
7234 {
7235 MS_BOOL bEn;
7236 if(u32Size != sizeof(MS_BOOL))
7237 {
7238 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7239 return GOP_API_FAIL;
7240 }
7241 bEn = (MS_BOOL)*pSet;
7242 GOP_SetAlphaInverse(pInstance,gop, bEn);
7243 break;
7244 }
7245 case E_GOP_PREALPHAMODE:
7246 {
7247 MS_BOOL bEn;
7248 if(u32Size != sizeof(MS_BOOL))
7249 {
7250 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7251 return GOP_API_FAIL;
7252 }
7253 bEn = (MS_BOOL)*pSet;
7254
7255 MDrv_GOP_SetGOPEnable2Mode1(g_pGOPCtxLocal, gop, bEn);
7256
7257 break;
7258 }
7259 case E_GOP_FIELD_INVERSE:
7260 {
7261 MS_BOOL bEn;
7262 if(u32Size != sizeof(MS_BOOL))
7263 {
7264 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7265 return GOP_API_FAIL;
7266 }
7267 bEn = (MS_BOOL)*pSet;
7268
7269 MDrv_GOP_GWIN_SetFieldInver(g_pGOPCtxLocal,gop ,bEn);
7270
7271 break;
7272 }
7273 case E_GOP_OUTPUT_TIMING:
7274 {
7275 PST_GOP_TIMING_INFO pstInfo;
7276 if(u32Size != sizeof(ST_GOP_TIMING_INFO))
7277 {
7278 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7279 return GOP_API_FAIL;
7280 }
7281 pstInfo = (PST_GOP_TIMING_INFO)pSet;
7282 GOP_SetPanelTiming(pInstance,gop, pstInfo);
7283 break;
7284 }
7285 case E_GOP_PIXELBASE_ENABLE:
7286 {
7287 if(u32Size != sizeof(MS_BOOL))
7288 {
7289 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7290 return GOP_API_FAIL;
7291 }
7292 g_pGOPCtxLocal->pGOPCtxShared->bPixelMode[gop]=(MS_BOOL)*pSet;
7293 break;
7294 }
7295 case E_GOP_CLK:
7296 {
7297 EN_GOP_DST_TYPE eDstType;
7298 if(u32Size != sizeof(EN_GOP_DST_TYPE))
7299 {
7300 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7301 return GOP_API_FAIL;
7302 }
7303 eDstType = (EN_GOP_DST_TYPE)*pSet;
7304 GOP_SetGOPClk(pInstance,gop,eDstType);
7305 break;
7306 }
7307 case E_GOP_FORCE_WRITE:
7308 {
7309 MS_BOOL bEn;
7310 if(u32Size != sizeof(MS_BOOL))
7311 {
7312 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7313 return GOP_API_FAIL;
7314 }
7315 bEn = (MS_BOOL)*pSet;
7316 GOP_GWIN_SetForceWrite(pInstance,bEn);
7317 break;
7318 }
7319 case E_GOP_BANK_FORCE_WRITE:
7320 {
7321 MS_BOOL bEn;
7322 if(u32Size != sizeof(MS_BOOL))
7323 {
7324 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7325 return GOP_API_FAIL;
7326 }
7327 bEn = (MS_BOOL)*pSet;
7328 GOP_GWIN_SetBnkForceWrite(pInstance,gop,bEn);
7329 break;
7330 }
7331 case E_GOP_3D_LR_EXCHANGE:
7332 {
7333 GOP_Set3D_LR_FrameExchange(pInstance,gop);
7334 break;
7335 }
7336 case E_GOP_VE_OSD:
7337 {
7338 MS_BOOL bEn;
7339 if(u32Size != sizeof(MS_BOOL))
7340 {
7341 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7342 return GOP_API_FAIL;
7343 }
7344 bEn = (MS_BOOL)*pSet;
7345 GOP_Enable_VEOSD(pInstance,gop,bEn);
7346 break;
7347 }
7348 case E_GOP_OUTPUT_LAYER_SWITCH:
7349 {
7350 GOP_OutputLayerSwitch(pInstance,gop);
7351 break;
7352 }
7353 case E_GOP_SWAP_OVERLAP_WIN:
7354 {
7355 MS_U8 u8win;
7356 if(u32Size != sizeof(MS_U8))
7357 {
7358 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7359 return GOP_API_FAIL;
7360 }
7361 u8win = (MS_U8)*pSet;
7362 GOP_GWIN_SwapOverlapWin(pInstance,gop,u8win);
7363 break;
7364 }
7365 case E_GOP_BW_STRENGTH:
7366 {
7367 EN_GOP_BW_STRENGTH eGOPBWStr;
7368 if(u32Size != sizeof(EN_GOP_BW_STRENGTH))
7369 {
7370 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7371 return GOP_API_FAIL;
7372 }
7373 eGOPBWStr = (EN_GOP_BW_STRENGTH)*pSet;
7374 GOP_SetGOPBWStrength(pInstance,eGOPBWStr,gop);
7375 break;
7376 }
7377 case E_GOP_LB_COUPLE:
7378 {
7379 MS_BOOL bEn;
7380 if(u32Size != sizeof(MS_BOOL))
7381 {
7382 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7383 return GOP_API_FAIL;
7384 }
7385 bEn = (MS_BOOL)*pSet;
7386 GOP_EnableLBCouple(pInstance,gop,bEn);
7387 break;
7388 }
7389 case E_GOP_RELATIVE_WIN_PRIO:
7390 {
7391 GOP_GwinPri *pGwinPri = (GOP_GwinPri *)pSet;
7392 if(u32Size != sizeof(GOP_GwinPri))
7393 {
7394 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7395 return GOP_API_FAIL;
7396 }
7397 GOP_GWIN_SetRelativeWinPrio(pInstance,gop,pGwinPri);
7398 break;
7399 }
7400 case E_GOP_YUV:
7401 {
7402 GOP_SetGOPYUV(pInstance,gop);
7403 break;
7404 }
7405 case E_GOP_REG_UPDATED:
7406 {
7407 break;
7408 }
7409 case E_GOP_RESOURCE:
7410 {
7411 GOP_ResetGOP(pInstance,gop);
7412 break;
7413 }
7414
7415 case E_GOP_MULTI_ALPHA_ENABLE:
7416 {
7417 MS_BOOL bEn;
7418 if(u32Size != sizeof(MS_BOOL))
7419 {
7420 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7421 return GOP_API_FAIL;
7422 }
7423 bEn = (MS_BOOL)*pSet;
7424
7425 MDrv_GOP_GWIN_EnableMultiAlpha(g_pGOPCtxLocal, gop, bEn);
7426 break;
7427 }
7428 case E_GOP_GWIN_TLB_ENABLE:
7429 {
7430 PGOP_TLB_Enable pTLB_Enable = (PGOP_TLB_Enable)pSet;
7431 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
7432 if(u32Size != sizeof(GOP_TLB_Enable))
7433 {
7434 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
7435 return GOP_API_FAIL;
7436 }
7437 #endif
7438 if(!g_pGOPCtxLocal->pGopChipProperty->bTLBSupport[pTLB_Enable->gop_idx])
7439 {
7440 GOP_M_ERR("[%s][%d]GOP %d Not Support TLB\n",__FUNCTION__,__LINE__,pTLB_Enable->gop_idx);
7441 return GOP_API_FAIL;
7442 }
7443 g_pGOPCtxLocal->pGOPCtxShared->bTLB[pTLB_Enable->gop_idx] = pTLB_Enable->bEn;
7444 g_pGOPCtxLocal->pGOPCtxShared->u64TLBAddress[pTLB_Enable->gop_idx] = pTLB_Enable->u64TLBAddr;
7445 //Enable TLB
7446 MDrv_GOP_TLBEnable(g_pGOPCtxLocal,pTLB_Enable->gop_idx, pTLB_Enable->bEn);
7447 break;
7448 }
7449 case E_GOP_AFBC_CORE_RESET:
7450 {
7451 if(u32Size != sizeof(MS_BOOL))
7452 {
7453 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7454 return GOP_API_FAIL;
7455 }
7456 MDrv_GOP_AFBC_Core_Reset(g_pGOPCtxLocal,gop);
7457 break;
7458 }
7459 case E_GOP_AFBC_CORE_ENABLE:
7460 {
7461 MS_BOOL bEn;
7462 if(u32Size != sizeof(MS_BOOL))
7463 {
7464 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7465 return GOP_API_FAIL;
7466 }
7467 bEn = (MS_BOOL)*pSet;
7468 MDrv_GOP_AFBC_Core_Enable(g_pGOPCtxLocal,gop,bEn);
7469 break;
7470 }
7471 default:
7472 {
7473 GOP_M_ERR("[%s] invalid input case:%d\n",__FUNCTION__, type);
7474 }
7475
7476 }
7477
7478 return GOP_API_SUCCESS;
7479
7480 }
7481
7482
Ioctl_GOP_GetProperty(void * pInstance,EN_GOP_PROPERTY type,MS_U32 gop,MS_U32 * pSet,MS_U32 u32Size)7483 MS_U32 Ioctl_GOP_GetProperty(void* pInstance,EN_GOP_PROPERTY type,MS_U32 gop, MS_U32* pSet, MS_U32 u32Size)
7484 {
7485 #ifdef INSTANT_PRIVATE
7486 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
7487 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
7488 #endif
7489
7490 switch(type)
7491 {
7492 case E_GOP_MIUSEL:
7493 {
7494 E_DRV_GOP_SEL_TYPE *pMIUSel = (E_DRV_GOP_SEL_TYPE *)pSet;
7495 if(u32Size != sizeof(E_DRV_GOP_SEL_TYPE))
7496 {
7497 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7498 return GOP_API_FAIL;
7499 }
7500
7501 *pMIUSel = (E_DRV_GOP_SEL_TYPE)GOP_GetMIUSel(pInstance,gop);
7502
7503 break;
7504 }
7505 case E_GOP_CONTRAST:
7506 {
7507 PGOP_CONTRAST pRGB = (PGOP_CONTRAST)pSet;
7508 if(u32Size != sizeof(GOP_CONTRAST))
7509 {
7510 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7511 return GOP_API_FAIL;
7512 }
7513
7514 GOP_GetContrast(pInstance,gop,&(pRGB->y), &(pRGB->u), &(pRGB->v));
7515
7516 break;
7517 }
7518 case E_GOP_BRIGHTNESS:
7519 {
7520 PGOP_BRIGHTNESS pBri = (PGOP_BRIGHTNESS)pSet;
7521 MS_U16* pu16Brightness = (MS_U16*)&(pBri->Brightness);
7522 if(u32Size != sizeof(GOP_BRIGHTNESS))
7523 {
7524 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7525 return GOP_API_FAIL;
7526 }
7527
7528 GOP_GetBrightness(pInstance,gop, pu16Brightness, &(pBri->bMSB));
7529 break;
7530 }
7531 case E_GOP_ALPHAINVERSE:
7532 {
7533 MS_BOOL *pbAlphaInverse = (MS_BOOL *)pSet;
7534 if(u32Size != sizeof(MS_BOOL))
7535 {
7536 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7537 return GOP_API_FAIL;
7538 }
7539
7540 *pbAlphaInverse = GOP_GetAlphaInverse(pInstance,gop);
7541
7542 break;
7543 }
7544 case E_GOP_HSCALE_RATIO:
7545 {
7546 MS_U16 *pHscale = (MS_U16 *)pSet;
7547 if(u32Size != sizeof(MS_U16))
7548 {
7549 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7550 return GOP_API_FAIL;
7551 }
7552 *pHscale = GOP_Get_Hscale(pInstance,gop);
7553 break;
7554 }
7555 case E_GOP_VSCALE_RATIO:
7556 {
7557 MS_U16 *pVscale = (MS_U16 *)pSet;
7558 if(u32Size != sizeof(MS_U16))
7559 {
7560 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7561 return GOP_API_FAIL;
7562 }
7563 *pVscale = GOP_Get_Vscale(pInstance,gop);
7564 break;
7565 }
7566 case E_GOP_HSTART:
7567 {
7568 MS_U16 *pu16HStart = (MS_U16 *)pSet;
7569 if (u32Size != sizeof(MS_U16))
7570 {
7571 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7572 return GOP_API_FAIL;
7573 }
7574 *pu16HStart = g_pGOPCtxLocal->pGOPCtxShared->u16PnlHStr[gop];
7575 break;
7576 }
7577 case E_GOP_OUTPUT_TIMING:
7578 {
7579 PST_GOP_TIMING_INFO pstInfo;
7580 if(u32Size != sizeof(ST_GOP_TIMING_INFO))
7581 {
7582 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7583 return GOP_API_FAIL;
7584 }
7585 pstInfo = (PST_GOP_TIMING_INFO)pSet;
7586 GOP_GetPanelTiming(pInstance,gop, pstInfo);
7587 break;
7588 }
7589 case E_GOP_PIXELBASE_ENABLE:
7590 {
7591 PGOP_SET_PROPERTY_PARAM pstInfo;
7592 MS_BOOL *pbEn;
7593 if(u32Size != sizeof(MS_BOOL))
7594 {
7595 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7596 return GOP_API_FAIL;
7597 }
7598 pstInfo = (PGOP_SET_PROPERTY_PARAM)(void*)pSet;
7599 pbEn = (MS_BOOL*)(pstInfo->pSetting);
7600 *pbEn = g_pGOPCtxLocal->pGOPCtxShared->bPixelMode[pstInfo->gop_idx];
7601 break;
7602 }
7603 case E_GOP_MULTI_ALPHA_ENABLE:
7604 {
7605 PGOP_SET_PROPERTY_PARAM pstInfo;
7606 MS_BOOL *pbEn;
7607 if(u32Size != sizeof(MS_BOOL))
7608 {
7609 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7610 return GOP_API_FAIL;
7611 }
7612 pstInfo = (PGOP_SET_PROPERTY_PARAM)(void*)pSet;
7613 pbEn = (MS_BOOL*)(pstInfo->pSetting);
7614 *pbEn = MDrv_GOP_GWIN_IsMultiAlphaEnable(g_pGOPCtxLocal, pstInfo->gop_idx);
7615 break;
7616 }
7617
7618 case E_GOP_PREALPHAMODE:
7619 case E_GOP_FIELD_INVERSE:
7620 case E_GOP_FORCE_WRITE:
7621 case E_GOP_BANK_FORCE_WRITE:
7622 case E_GOP_3D_LR_EXCHANGE:
7623 case E_GOP_VE_OSD:
7624 case E_GOP_OUTPUT_LAYER_SWITCH:
7625 case E_GOP_SWAP_OVERLAP_WIN:
7626 case E_GOP_LB_COUPLE:
7627 case E_GOP_YUV:
7628 case E_GOP_OUTPUT_COLOR:
7629 case E_GOP_UV_SWAP:
7630 case E_GOP_YC_SWAP:
7631 case E_GOP_RELATIVE_WIN_PRIO:
7632 break;
7633 case E_GOP_BW_STRENGTH:
7634 {
7635 EN_GOP_BW_STRENGTH *peGOPBWStr = (EN_GOP_BW_STRENGTH *)pSet;;
7636 if(u32Size != sizeof(EN_GOP_BW_STRENGTH))
7637 {
7638 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7639 return GOP_API_FAIL;
7640 }
7641 GOP_GetGOPBWStrength(pInstance,gop,peGOPBWStr);
7642 break;
7643 }
7644 case E_GOP_REG_UPDATED:
7645 {
7646 MS_BOOL *pUpdated = (MS_BOOL *)pSet;
7647 if(u32Size != sizeof(MS_BOOL))
7648 {
7649 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7650 return GOP_API_FAIL;
7651 }
7652 *pUpdated = GOP_IsRegUpdated(pInstance,gop);
7653 break;
7654 }
7655 case E_GOP_MAXFBNUM:
7656 {
7657 MS_U32 *pMAXFBNum = (MS_U32 *)pSet;
7658 if(u32Size != sizeof(MS_U32))
7659 {
7660 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7661 return GOP_API_FAIL;
7662 }
7663 *pMAXFBNum = DRV_MAX_GWIN_FB_SUPPORT;
7664 break;
7665 }
7666 case E_GOP_NUM_IS_INIT:
7667 {
7668 GOP_InitInfo *pGOPInitInfo = (GOP_InitInfo *)pSet;
7669 if(u32Size != sizeof(GOP_InitInfo))
7670 {
7671 GOP_M_ERR("[%s][%d] input structure size ERROR!! \n",__FUNCTION__,__LINE__);
7672 return GOP_API_FAIL;
7673 }
7674 GOP_CTX_DRV_SHARED *pDrvGOPShared;
7675 MS_BOOL bNeedInitShared = FALSE;
7676 pDrvGOPShared = (GOP_CTX_DRV_SHARED*)MDrv_GOP_GetShareMemory(&bNeedInitShared);
7677 if(pDrvGOPShared->apiCtxShared.bGopHasInitialized[gop])
7678 {
7679 pGOPInitInfo->u16PanelWidth = pDrvGOPShared->apiCtxShared.u16PnlWidth[gop];
7680 pGOPInitInfo->u16PanelHeight = pDrvGOPShared->apiCtxShared.u16PnlHeight[gop];
7681 pGOPInitInfo->u16PanelHStr = pDrvGOPShared->apiCtxShared.u16PnlHStr[gop];
7682 pGOPInitInfo->bEnableVsyncIntFlip = pDrvGOPShared->apiCtxShared.bEnableVsyncIntFlip;
7683 pGOPInitInfo->u32GOPRBAdr = pDrvGOPShared->apiCtxShared.fbPool1.GWinFB_Pool_BaseAddr;
7684 pGOPInitInfo->u32GOPRBLen = pDrvGOPShared->apiCtxShared.fbPool1.u32GWinFB_Pool_MemLen;
7685 pGOPInitInfo->u32GOPRegdmaAdr = pDrvGOPShared->apiCtxShared.phyGOPRegdmaAdr;
7686 pGOPInitInfo->u32GOPRegdmaLen = pDrvGOPShared->apiCtxShared.u32GOPRegdmaLen;
7687 //printf("pGOPInitInfo->u16PanelWidth=%d\n",pGOPInitInfo->u16PanelWidth);
7688 //printf("pGOPInitInfo->u16PanelHeight=%d\n",pGOPInitInfo->u16PanelHeight);
7689 //printf("pGOPInitInfo->u16PanelHStr=%d\n",pGOPInitInfo->u16PanelHStr);
7690 //printf("pGOPInitInfo->bEnableVsyncIntFlip=%d\n",pGOPInitInfo->bEnableVsyncIntFlip);
7691 //printf("pGOPInitInfo->u32GOPRBAdr=0x%x\n",pGOPInitInfo->u32GOPRBAdr);
7692 //printf("pGOPInitInfo->u32GOPRBLen=%d\n",pGOPInitInfo->u32GOPRBLen);
7693 //printf("pGOPInitInfo->u32GOPRegdmaAdr=0x%x\n",pGOPInitInfo->u32GOPRegdmaAdr);
7694 //printf("pGOPInitInfo->u32GOPRegdmaLen=%d\n",pGOPInitInfo->u32GOPRegdmaLen);
7695 }
7696 else
7697 return GOP_API_FAIL;
7698 break;
7699 }
7700 default:
7701 GOP_M_ERR("[%s] This status(%d) can't be query\n",__FUNCTION__,type);
7702 break;
7703
7704 }
7705
7706 return GOP_API_SUCCESS;
7707
7708 }
7709
_IsGopInOPMux(void * pInstance,MS_U8 u8GopNum)7710 static MS_BOOL _IsGopInOPMux(void* pInstance,MS_U8 u8GopNum)
7711 {
7712 MS_U8 i, GetGopNum = 0;
7713 #ifdef INSTANT_PRIVATE
7714 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
7715 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
7716 #endif
7717 for (i=0; i<MDrv_GetMaxMuxOPNum(); i++)
7718 {
7719 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, (Gop_MuxSel)i);
7720 if (u8GopNum==GetGopNum)
7721 {
7722 return TRUE;
7723 }
7724 }
7725 return FALSE;
7726 }
7727
_IsGopInDualOPMux(void * pInstance,MS_U8 u8GopNum)7728 static MS_BOOL _IsGopInDualOPMux(void* pInstance, MS_U8 u8GopNum)
7729 {
7730 MS_U8 i, GetGopNum = 0;
7731 #ifdef INSTANT_PRIVATE
7732 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
7733 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
7734 #endif
7735 for (i=E_GOP_DUALRATE_OP_MUX0; i<=E_GOP_DUALRATE_OP_MUX2; i++)
7736 {
7737 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &GetGopNum, (Gop_MuxSel)i);
7738 if (u8GopNum==GetGopNum)
7739 {
7740 return TRUE;
7741 }
7742 }
7743 return FALSE;
7744 }
7745
7746
Ioctl_GOP_SetDst(void * pInstance,MS_U8 u8GOP,EN_GOP_DST_TYPE dsttype)7747 MS_U32 Ioctl_GOP_SetDst(void* pInstance,MS_U8 u8GOP, EN_GOP_DST_TYPE dsttype)
7748 {
7749 MS_U8 u8GetGOPNum =0, u8Mux0GopNum =0, i;
7750 DRV_GOPDstType GopDst;
7751 Gop_MuxSel OPMux = MAX_GOP_MUX_SUPPORT;
7752
7753 #ifdef INSTANT_PRIVATE
7754 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
7755 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
7756 #endif
7757
7758 if ((!_GOP_IsGopNumValid(pInstance,u8GOP)))
7759 {
7760 GOP_M_ERR("[%s][%d]GOP %d is out of range\n",__FUNCTION__,__LINE__,u8GOP);
7761 return GOP_API_FAIL;
7762 }
7763
7764 GOP_M_INFO("---%s %d: PID[%td], TID[%td] u8GOP=%u, DstType=0x%tx\n", __FUNCTION__, __LINE__, (ptrdiff_t)getpid(), (ptrdiff_t)MsOS_GetOSThreadID(), u8GOP, (ptrdiff_t)dsttype);
7765
7766 /*Set GOP dst and check input dst type is vaild or not for different chip first */
7767 (_GOP_Map_APIDst2DRV_Enum(pInstance,dsttype, &GopDst));
7768 (MDrv_GOP_GWIN_SetDstPlane(g_pGOPCtxLocal, u8GOP, GopDst,FALSE));
7769
7770 // Set GOP dst output blending to SC/Mixer
7771 switch(GopDst)
7772 {
7773
7774 case E_DRV_GOP_DST_IP0:
7775 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux) //t8, there are new mux for ip/mvop
7776 {
7777 //printf("\n=============%s===============\n",__FUNCTION__);
7778 //printf("Set to New IP Mux GOP:%d\n",u8GOP);
7779 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_IP0_MUX);
7780 _GOP_InitHSPDByGOP(pInstance,u8GOP);
7781 }
7782 else //In IP case, gop should open in OP mux0 ~ mux3
7783 {
7784
7785 if (g_pGOPCtxLocal->pGopChipProperty->bNeedSetMUX1ToIP0)
7786 {
7787 if (!_IsGopInMux1(pInstance,u8GOP))
7788 {
7789 /*save current mux setting*/
7790 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7791 {
7792 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
7793 }
7794 g_pGOPCtxLocal->IsChgMux= TRUE;
7795 /*force change input parameter u8GOP to mux1*/
7796 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7797 {
7798
7799 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
7800 if (u8GOP == u8GetGOPNum)
7801 {
7802 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8Mux0GopNum, E_GOP_MUX1);
7803 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8Mux0GopNum, (Gop_MuxSel)i);
7804 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_MUX1);
7805 g_pGOPCtxLocal->u8ChgIpMuxGop = u8Mux0GopNum;
7806 if( u8Mux0GopNum < _GOP_GetMaxGOPNum(pInstance))
7807 _GOP_InitHSPDByGOP(pInstance,u8Mux0GopNum);
7808 _GOP_InitHSPDByGOP(pInstance,u8GOP);
7809 }
7810 }
7811
7812 }
7813 }
7814 else if(g_pGOPCtxLocal->pGopChipProperty->bNeedSetMUX3ToIP0)
7815 {
7816 if (!_IsGopInMux3(pInstance,u8GOP))
7817 {
7818 /*save current mux setting*/
7819 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7820 {
7821 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
7822 }
7823 g_pGOPCtxLocal->IsChgMux= TRUE;
7824 /*force change input parameter u8GOP to mux3*/
7825 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7826 {
7827 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
7828 if (u8GOP == u8GetGOPNum)
7829 {
7830 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8Mux0GopNum, E_GOP_MUX3);
7831 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8Mux0GopNum, (Gop_MuxSel)i);
7832 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_MUX3);
7833 if( u8Mux0GopNum < _GOP_GetMaxGOPNum(pInstance))
7834 _GOP_InitHSPDByGOP(pInstance,u8Mux0GopNum);
7835 _GOP_InitHSPDByGOP(pInstance,u8GOP);
7836 }
7837 }
7838 }
7839 }
7840 else
7841 {
7842 if (!_IsGopInMux0(pInstance,u8GOP)) //jasmine:FIXME
7843 {
7844 /*save current mux setting*/
7845 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7846 {
7847 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
7848 }
7849 g_pGOPCtxLocal->IsChgMux= TRUE;
7850 /*force change input parameter u8GOP to mux0*/
7851 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7852 {
7853 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
7854 if (u8GOP == u8GetGOPNum)
7855 {
7856 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8Mux0GopNum, E_GOP_MUX0);
7857 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8Mux0GopNum, (Gop_MuxSel)i);
7858 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_MUX0);
7859 if( u8Mux0GopNum < _GOP_GetMaxGOPNum(pInstance))
7860 _GOP_InitHSPDByGOP(pInstance,u8Mux0GopNum);
7861 _GOP_InitHSPDByGOP(pInstance,u8GOP);
7862 }
7863 }
7864 }
7865 }
7866 }
7867 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
7868 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
7869 if (u8GOP==0)
7870 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_IP0_SEL_GOP0);
7871 else if (u8GOP==1)
7872 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_IP0_SEL_GOP1);
7873 else
7874 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_IP0_SEL_GOP2);
7875 //MApi_GOP_GWIN_OutputColor(GOPOUT_YUV);
7876 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, TRUE);
7877 break;
7878
7879 case E_DRV_GOP_DST_MIXER2VE:
7880 //jasmine:FIXME
7881 if(g_pGOPCtxLocal->pGopChipProperty->bGOPMixerToVE)
7882 {
7883 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
7884 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
7885 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP,DRV_GOPOUT_YUV);
7886 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, TRUE);
7887
7888 MDrv_GOP_SetGOPClk(g_pGOPCtxLocal,u8GOP,E_DRV_GOP_DST_MIXER2VE);
7889
7890 MDrv_GOP_GWIN_SetMixerDstPlane(g_pGOPCtxLocal,u8GOP,GopDst);
7891
7892 (MDrv_GOP_MIXER_SetGOPEnable2Mixer(g_pGOPCtxLocal, u8GOP, TRUE));
7893 (MDrv_GOP_Set_VE_MUX(g_pGOPCtxLocal, (GOPTYPE.MIXER-1),TRUE));
7894 }
7895 else
7896 {
7897 GOP_M_INFO("[%s][%d] Not Support GOPMixerToVE in this chip version.\n",__FUNCTION__,__LINE__);
7898 }
7899 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
7900 break;
7901
7902 case E_DRV_GOP_DST_OP0:
7903 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
7904
7905 if((g_pGOPCtxLocal->pGopChipProperty->bNewMux) && (!_IsGopInOPMux(pInstance,u8GOP)))
7906 {
7907 //_CleanGopMux(u8GOP);
7908 OPMux = _GetNonUseOPMux(pInstance);
7909 if(OPMux != MAX_GOP_MUX_SUPPORT)
7910 {
7911 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, OPMux);
7912 }
7913 else
7914 {
7915 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_MUX2);
7916 }
7917 }
7918
7919 /*
7920 For U4, mux value may has mixer and at least one GOP is not in mux
7921 To check if the GOP number is in MUX0 to MUX3
7922 If not, find the mux value which is mixer, replace mixer by the GOP number
7923 */
7924 if(!_IsGopInMux0To3(pInstance,u8GOP))
7925 {
7926 /*save current mux setting*/
7927 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7928 {
7929 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
7930 }
7931 g_pGOPCtxLocal->IsChgMux= TRUE;
7932 /*force set input parameter u8GOP to the mux which is mixer*/
7933 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7934 {
7935 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
7936 if ((GOPTYPE.MIXER-1) == u8GetGOPNum) //Find mixer(0x4)
7937 {
7938 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, (Gop_MuxSel)i);
7939 }
7940 }
7941 }
7942
7943 if(g_pGOPCtxLocal->pGopChipProperty->bNeedSetMUX3ToIP0) //For u4 and k1, mux3 only to IP (can not to OP)
7944 {
7945 if (_IsGopInMux3(pInstance,u8GOP))
7946 {
7947 /*save current mux setting*/
7948 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7949 {
7950 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
7951 }
7952 g_pGOPCtxLocal->IsChgMux= TRUE;
7953
7954 /*force change input parameter u8GOP exchange mux with GOP3*/
7955 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7956 {
7957 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
7958 if (GOPTYPE.GOP3 == u8GetGOPNum)
7959 {
7960 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, (Gop_MuxSel)i);
7961 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, GOPTYPE.GOP3, E_GOP_MUX3);
7962 }
7963 }
7964 }
7965 }
7966 else if(g_pGOPCtxLocal->pGopChipProperty->bNeedSetMUX1ToIP0)
7967 {
7968 if (_IsGopInMux1(pInstance,u8GOP)&&_IsGopInMux0To3(pInstance,g_pGOPCtxLocal->u8ChgIpMuxGop))
7969 {
7970 /*save current mux setting*/
7971 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7972 {
7973 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
7974 }
7975 g_pGOPCtxLocal->IsChgMux= TRUE;
7976
7977 /*force change input parameter u8GOP exchange mux with GOP3*/
7978 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
7979 {
7980 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
7981 if (g_pGOPCtxLocal->u8ChgIpMuxGop == u8GetGOPNum)
7982 {
7983 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, (Gop_MuxSel)i);
7984 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GetGOPNum, E_GOP_MUX1);
7985 g_pGOPCtxLocal->u8ChgIpMuxGop = 0xFF;
7986 if( u8GetGOPNum < _GOP_GetMaxGOPNum(pInstance))
7987 _GOP_InitHSPDByGOP(pInstance,u8GetGOPNum);
7988 }
7989 }
7990 }
7991 }
7992
7993 if (u8GOP==0)
7994 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP0);
7995 else if (u8GOP==1)
7996 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP1);
7997 else
7998 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP2);
7999
8000 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, TRUE);
8001
8002 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8003 if (g_pGOPCtxLocal->pGopChipProperty->bOpInterlace == TRUE)
8004 {
8005 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
8006 }
8007 else
8008 {
8009 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
8010 }
8011 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8012 break;
8013
8014 case E_DRV_GOP_DST_OP1:
8015 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8016 {
8017 //_CleanGopMux(u8GOP);
8018 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_OP1_MUX);
8019 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8020 }
8021
8022 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_SC1OP_SEL);
8023 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
8024 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, TRUE);
8025 MDrv_GOP_GWIN_SetVSyncinverse(g_pGOPCtxLocal,u8GOP, FALSE);
8026 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8027 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8028 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8029 break;
8030
8031 case E_DRV_GOP_DST_VOP:
8032 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8033 {
8034 //_CleanGopMux(u8GOP);
8035 GOP_M_INFO("\n=============%s===============\n",__FUNCTION__);
8036 GOP_M_INFO("Set to New MVOP Mux GOP:%d\n",u8GOP);
8037 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_VOP0_MUX);
8038 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8039 }
8040 else if (!_IsGopInMux0(pInstance,u8GOP))
8041 {
8042 g_pGOPCtxLocal->IsChgMux= TRUE;
8043 /*save current mux setting*/
8044 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
8045 {
8046 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
8047 }
8048
8049 /*force change input parameter u8GOP to mux0*/
8050 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
8051 {
8052 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
8053 if (u8GOP == u8GetGOPNum)
8054 {
8055 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8Mux0GopNum, E_GOP_MUX0);
8056 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8Mux0GopNum, (Gop_MuxSel)i);
8057 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_MUX0);
8058 if( u8Mux0GopNum < _GOP_GetMaxGOPNum(pInstance))
8059 _GOP_InitHSPDByGOP(pInstance,u8Mux0GopNum);
8060 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8061 }
8062 }
8063 }
8064
8065 #if (FPGA_TEST)
8066 GOP_SetOutputColor(pInstance,u8GOP,GOPOUT_RGB);
8067 #else
8068 GOP_SetOutputColor(pInstance,u8GOP,GOPOUT_YUV);
8069 #endif
8070
8071 if (u8GOP==0)
8072 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP0);
8073 else if (u8GOP==1)
8074 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP1);
8075 else
8076 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP2);
8077
8078 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_MVOP_SEL);
8079 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8080 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
8081 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8082 break;
8083
8084 case E_DRV_GOP_DST_VOP_SUB:
8085 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8086 {
8087 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_VOP0_SUB_MUX);
8088 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8089 }
8090
8091 #if (FPGA_TEST)
8092 GOP_SetOutputColor(pInstance,u8GOP,GOPOUT_RGB);
8093 #else
8094 GOP_SetOutputColor(pInstance,u8GOP,GOPOUT_YUV);
8095 #endif
8096 if (u8GOP==0)
8097 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP0);
8098 else if (u8GOP==1)
8099 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP1);
8100 else
8101 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP2);
8102
8103 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_SUBMVOP_SEL);
8104 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8105 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8106 break;
8107 case E_DRV_GOP_DST_IP1:
8108 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8109 {
8110 //_CleanGopMux(u8GOP);
8111 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_IP1_MUX);
8112 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8113 }
8114 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8115 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, FALSE);
8116 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_IP1_SEL);
8117 MDrv_GOP_SetGOPClk(g_pGOPCtxLocal,u8GOP,E_DRV_GOP_DST_IP1);
8118 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, TRUE);
8119 break;
8120
8121 case E_DRV_GOP_DST_IP0_SUB:
8122 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8123 {
8124 //_CleanGopMux(u8GOP);
8125 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_IP0_SUB_MUX);
8126 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8127 }
8128 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8129 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, FALSE);
8130 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_SUBIP0_SEL);
8131 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, TRUE);
8132 break;
8133 case E_DRV_GOP_DST_DIP:
8134 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8135 {
8136 //_CleanGopMux(u8GOP);
8137 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_DIP_MUX);
8138 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8139 }
8140 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8141 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP, FALSE);
8142 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_DIP_SEL);
8143 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8144 break;
8145 case E_DRV_GOP_DST_MIXER2OP:
8146
8147 if(g_pGOPCtxLocal->pGopChipProperty->bNewMux)
8148 {
8149 //_CleanGopMux(u8GOP);
8150 if(!_IsGopInMux0To2(pInstance,(GOPTYPE.MIXER-1)))
8151 {
8152 OPMux = _GetNonUseOPMux(pInstance);
8153 if(OPMux != MAX_GOP_MUX_SUPPORT)
8154 {
8155 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, (GOPTYPE.MIXER-1), OPMux);
8156 }
8157 else
8158 {
8159 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, (GOPTYPE.MIXER-1), E_GOP_MUX2);
8160 }
8161 }
8162 }
8163 else
8164 {
8165
8166 g_pGOPCtxLocal->IsChgMux= TRUE;
8167 /*save current mux setting*/
8168 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
8169 {
8170 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &g_pGOPCtxLocal->MS_MuxGop[i], (Gop_MuxSel)i);
8171 //printf("\n %s, before E_GOP_DST_MIXER2VE--->MS_MuxGop[%d]=%d\n",__FUNCTION__,i,u8GetGOPNum);
8172 }
8173 /*Set current mux to mixer.*/
8174 for (i=0; i<MAX_GOP_MUX_SUPPORT; i++)
8175 {
8176 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8GetGOPNum, (Gop_MuxSel)i);
8177 if (u8GOP == u8GetGOPNum)
8178 {
8179 //Set current GOP mux to mixer
8180 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, (GOPTYPE.MIXER-1), (Gop_MuxSel)i);
8181 break;
8182 }
8183 }
8184
8185 }
8186 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, (GOPTYPE.MIXER-1), TRUE); //To find the mux which is mixer, open SC blending
8187 //MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8188 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, TRUE);
8189 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, DRV_GOPOUT_YUV);
8190 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP,TRUE);
8191
8192 MDrv_GOP_GWIN_SetMixerDstPlane(g_pGOPCtxLocal,u8GOP,GopDst);
8193 //MDrv_GOP_GWIN_SetHSPipe(g_pGOPCtxLocal, u8GOP, 0);
8194 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8195 (MDrv_GOP_MIXER_SetGOPEnable2Mixer(g_pGOPCtxLocal, u8GOP, TRUE));
8196 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8197 break;
8198
8199 case E_DRV_GOP_DST_MIXER2OP1:
8200 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, (GOPTYPE.MIXER-1), E_GOP_OP1_MUX);
8201 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_SC1OP_SEL);
8202 //MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, GOPTYPE.MIXER, TRUE); //To find the mux which is mixer, open SC blending
8203 //MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8204 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
8205 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP, DRV_GOPOUT_YUV);
8206 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal, u8GOP,TRUE);
8207
8208 MDrv_GOP_GWIN_SetMixerDstPlane(g_pGOPCtxLocal,u8GOP,GopDst);
8209 //MDrv_GOP_GWIN_SetHSPipe(g_pGOPCtxLocal, u8GOP, 0);
8210 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8211 (MDrv_GOP_MIXER_SetGOPEnable2Mixer(g_pGOPCtxLocal, u8GOP, TRUE));
8212 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8213 break;
8214
8215 case E_DRV_GOP_DST_FRC:
8216 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8217 _GOP_InitHSPDByGOP(pInstance,u8GOP); //require update registers at the end of this function after dwin capture in OP
8218 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
8219 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8220 break;
8221 case E_DRV_GOP_DST_VE:
8222 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8223 MDrv_GOP_GWIN_EnableProgressive(g_pGOPCtxLocal, u8GOP, FALSE);
8224 MDrv_GOP_GWIN_OutputColor(g_pGOPCtxLocal,u8GOP,DRV_GOPOUT_YUV);
8225 MDrv_GOP_GWIN_SetAlphaInverse(g_pGOPCtxLocal,u8GOP,FALSE);
8226
8227 MDrv_GOP_SetGOPClk(g_pGOPCtxLocal,u8GOP,E_DRV_GOP_DST_VE);
8228
8229 MDrv_GOP_GWIN_SetVSyncinverse(g_pGOPCtxLocal,u8GOP, TRUE);
8230 //MDrv_GOP_Mask_First_Hsync(g_pGOPCtxLocal,u8GOP, TRUE );
8231 if(!(g_pGOPCtxLocal->sGOPConfig.eGopIgnoreInit & E_GOP_BOOTLOGO_IGNORE_VEOSDEN))
8232 {
8233 (MDrv_GOP_Set_VE_MUX(g_pGOPCtxLocal, u8GOP, TRUE));
8234 }
8235 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8236 break;
8237 case E_DRV_GOP_DST_GOPScaling:
8238 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
8239 if((g_pGOPCtxLocal->pGopChipProperty->bNewMux) && (!_IsGopInMux0To2(pInstance,u8GOP)))
8240 {
8241 //_CleanGopMux(u8GOP);
8242 OPMux = _GetNonUseOPMux(pInstance);
8243 if(OPMux != MAX_GOP_MUX_SUPPORT)
8244 {
8245 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, OPMux);
8246 }
8247 else
8248 {
8249 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_MUX2);
8250 }
8251 }
8252
8253 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_GS_MUX);
8254
8255 if (u8GOP==0)
8256 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP0);
8257 else if (u8GOP==1)
8258 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP1);
8259 else
8260 MDrv_GOP_SetIPSel2SC(g_pGOPCtxLocal, MS_DRV_NIP_SEL_GOP2);
8261
8262 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, TRUE);
8263 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8264 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8265 break;
8266 case E_DRV_GOP_DST_BYPASS:
8267 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
8268 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8269 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, E_GOP_BYPASS_MUX0);
8270 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8271 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8272 break;
8273
8274 case E_DRV_GOP_DST_OP_DUAL_RATE:
8275 _GOP_SetOCCapability(pInstance,u8GOP, GopDst);
8276 _GOP_InitHSPDByGOP(pInstance,u8GOP);
8277 if((!_IsGopInDualOPMux(pInstance,u8GOP)))
8278 {
8279 OPMux = _GetNonUseDualOPMux(pInstance);
8280 if(OPMux != MAX_GOP_MUX_SUPPORT)
8281 {
8282 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, u8GOP, OPMux);
8283 }
8284 }
8285 MDrv_GOP_SetGOPEnable2SC(g_pGOPCtxLocal, u8GOP, FALSE);
8286 MDrv_GOP_SelfFirstHs(g_pGOPCtxLocal, u8GOP, FALSE);
8287 break;
8288
8289 default:
8290 MS_ASSERT(0);
8291 return GOP_API_ENUM_NOT_SUPPORTED;
8292 }
8293
8294 (MDrv_GOP_SetGOPClk(g_pGOPCtxLocal, u8GOP, GopDst));
8295 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal, u8GOP);
8296 return GOP_API_SUCCESS;
8297 }
8298
Ioctl_GOP_GetDst(void * pInstance,MS_U32 gop,MS_U32 * pDst)8299 MS_U32 Ioctl_GOP_GetDst(void* pInstance,MS_U32 gop, MS_U32* pDst)
8300 {
8301 #ifdef INSTANT_PRIVATE
8302 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8303 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8304 #endif
8305
8306 DRV_GOPDstType enDst = E_DRV_GOP_DST_INVALID;
8307
8308 (MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, gop, &enDst));
8309 _GOP_Map_DRVDst2API_Enum_(pInstance,(EN_GOP_DST_TYPE *)pDst, enDst);
8310 return GOP_API_SUCCESS;
8311
8312 }
8313
Ioctl_GOP_SetMux(void * pInstance,PGOP_SETMUX pGopMuxConfig,MS_U32 u32SizeOfMuxInfo)8314 MS_U32 Ioctl_GOP_SetMux(void* pInstance,PGOP_SETMUX pGopMuxConfig, MS_U32 u32SizeOfMuxInfo)
8315 {
8316 MS_U8 i;
8317 Gop_MuxSel EnGOPMux;
8318 #ifdef INSTANT_PRIVATE
8319 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8320 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8321 #endif
8322
8323 if(u32SizeOfMuxInfo != sizeof(GOP_SETMUX) || (pGopMuxConfig == NULL))
8324 {
8325 GOP_M_ERR("\nthe GOP_MuxConfig is NULL or struct mismatch in drivr\n");
8326 return GOP_API_FAIL;
8327 }
8328 GOP_M_INFO("---%s %d: PID[%td], TID[%td] MuxCount=%tu\n", __FUNCTION__, __LINE__, (ptrdiff_t)getpid(), (ptrdiff_t)MsOS_GetOSThreadID(), (ptrdiff_t)pGopMuxConfig->MuxCount);
8329
8330 #if 0
8331 for(i=0; i<pGopMuxConfig->u8MuxCounts; i++)
8332 {
8333 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, pGopMuxConfig->GopMux[i].u8GopIndex, (Gop_MuxSel) pGopMuxConfig->GopMux[i].u8MuxIndex);
8334 }
8335
8336 #endif
8337
8338 for(i=0; i<pGopMuxConfig->MuxCount; i++)
8339 {
8340 _GOP_MAP_MUX_Enum(pInstance,(EN_Gop_MuxSel)pGopMuxConfig->mux[i], &EnGOPMux);
8341 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, pGopMuxConfig->gop[i], EnGOPMux);
8342 }
8343
8344 return GOP_API_SUCCESS;
8345
8346 }
8347
8348
Ioctl_GOP_SetMirror(void * pInstance,MS_U32 gop,EN_GOP_MIRROR_TYPE mirror)8349 MS_U32 Ioctl_GOP_SetMirror(void* pInstance,MS_U32 gop, EN_GOP_MIRROR_TYPE mirror)
8350 {
8351 // To do: to modify and control each gop mirror setting.
8352 switch(mirror)
8353 {
8354 case E_GOP_MIRROR_NONE:
8355 default:
8356 {
8357 GOP_GWIN_SetHMirror(pInstance,FALSE);
8358 GOP_GWIN_SetVMirror(pInstance,FALSE);
8359 break;
8360 }
8361 case E_GOP_MIRROR_H_ONLY:
8362 {
8363 GOP_GWIN_SetHMirror(pInstance,TRUE);
8364 //GOP_GWIN_SetVMirror(pInstance,FALSE);
8365 break;
8366 }
8367 case E_GOP_MIRROR_H_NONE:
8368 {
8369 GOP_GWIN_SetHMirror(pInstance,FALSE);
8370 break;
8371 }
8372 case E_GOP_MIRROR_V_ONLY:
8373 {
8374 //GOP_GWIN_SetHMirror(pInstance,FALSE);
8375 GOP_GWIN_SetVMirror(pInstance,TRUE);
8376 break;
8377 }
8378 case E_GOP_MIRROR_V_NONE:
8379 {
8380 GOP_GWIN_SetVMirror(pInstance,FALSE);
8381 break;
8382 }
8383 case E_GOP_MIRROR_HV:
8384 {
8385 GOP_GWIN_SetHMirror(pInstance,TRUE);
8386 GOP_GWIN_SetVMirror(pInstance,TRUE);
8387 break;
8388 }
8389
8390 }
8391
8392 return GOP_API_SUCCESS;
8393 }
8394
Ioctl_GOP_GetMirror(void * pInstance,MS_U32 gop,EN_GOP_MIRROR_TYPE * mirror)8395 MS_U32 Ioctl_GOP_GetMirror(void* pInstance,MS_U32 gop, EN_GOP_MIRROR_TYPE* mirror)
8396 {
8397 MS_BOOL bHMirror;
8398 MS_BOOL bVMirror;
8399 #ifdef INSTANT_PRIVATE
8400 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8401 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8402 #endif
8403 //need refine
8404 bHMirror = g_pGOPCtxLocal->pGOPCtxShared->bHMirror;
8405 bVMirror = g_pGOPCtxLocal->pGOPCtxShared->bVMirror;
8406
8407 if((bHMirror == TRUE)&&(bVMirror == TRUE))
8408 {
8409 *mirror = E_GOP_MIRROR_HV;
8410 }
8411 else if((bHMirror == TRUE)&&(bVMirror == FALSE))
8412 {
8413 *mirror = E_GOP_MIRROR_H_ONLY;
8414 }
8415 else if((bHMirror == FALSE)&&(bVMirror == TRUE))
8416 {
8417 *mirror = E_GOP_MIRROR_V_ONLY;
8418 }
8419 else
8420 {
8421 *mirror = E_GOP_MIRROR_NONE;
8422 }
8423
8424 return GOP_API_SUCCESS;
8425 }
8426
8427
Ioctl_GOP_GetStatus(void * pInstance,EN_GOP_STATUS type,MS_U32 * pStatus,MS_U32 u32Size)8428 MS_U32 Ioctl_GOP_GetStatus(void* pInstance,EN_GOP_STATUS type, MS_U32* pStatus, MS_U32 u32Size)
8429 {
8430 #ifdef INSTANT_PRIVATE
8431 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8432 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8433 #endif
8434
8435 if(pStatus == NULL)
8436 {
8437 GOP_M_ERR("[%s][%d] ERROR - Input null pointer on type:%d\n",__FUNCTION__,__LINE__,type);
8438 return GOP_API_INVALID_PARAMETERS;
8439 }
8440
8441 switch(type)
8442 {
8443 case E_GOP_STATUS_INIT:
8444 {
8445 PGOP_INIT_STATUS ptr = (PGOP_INIT_STATUS)pStatus;
8446 if(u32Size != sizeof(GOP_INIT_STATUS))
8447 {
8448 return GOP_API_INVALID_PARAMETERS;
8449 }
8450 ptr->bInit = g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[ptr->gop_idx];
8451
8452 break;
8453 }
8454 case E_GOP_STATUS_GOP_MAXNUM:
8455 {
8456 MS_U8 *pMaxGopNum = (MS_U8 *) pStatus;
8457 *pMaxGopNum = MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal);
8458 break;
8459 }
8460 case E_GOP_STATUS_GWIN_MAXNUM:
8461 {
8462 PGOP_GWIN_NUM ptr = (PGOP_GWIN_NUM)pStatus;
8463 if(u32Size != sizeof(GOP_GWIN_NUM))
8464 {
8465 GOP_M_ERR("[%s] Error (%d)\n",__FUNCTION__,__LINE__);
8466 return (GOP_API_INVALID_PARAMETERS);
8467 }
8468 if(ptr->gop_idx > MDrv_GOP_GetMaxGOPNum(g_pGOPCtxLocal))
8469 {
8470 GOP_M_ERR("[%s] Error (%d)\n",__FUNCTION__,__LINE__);
8471 return (GOP_API_INVALID_PARAMETERS);
8472 }
8473
8474 ptr->gwin_num = MDrv_GOP_GetGwinNum(g_pGOPCtxLocal,ptr->gop_idx);
8475 break;
8476 }
8477 case E_GOP_STATUS_GWIN_TOTALNUM:
8478 {
8479 MS_U8 *pGwinNum = (MS_U8 *) pStatus;
8480 if(u32Size != sizeof(MS_U8))
8481 {
8482 GOP_M_ERR("[%s] Error (%d)\n",__FUNCTION__,__LINE__);
8483 return (GOP_API_INVALID_PARAMETERS);
8484 }
8485 *pGwinNum = (MS_U8)g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum;
8486 break;
8487
8488 }
8489 case E_GOP_STATUS_VERSION:
8490 {
8491 break;
8492 }
8493 case E_GOP_STATUS_MUX:
8494 {
8495
8496 break;
8497 }
8498 case E_GOP_STATUS_CURRENT_GOP:
8499 {
8500 MS_U32* pCurrentGop = (MS_U32*)pStatus;
8501 *pCurrentGop = GOP_GetCurrentGOP(pInstance);
8502 break;
8503 }
8504 case E_GOP_STATUS_CURRENT_GWIN:
8505 {
8506 MS_U32* pCurrentGwin = (MS_U32*)pStatus;
8507 *pCurrentGwin = GOP_GetCurrentGWin(pInstance);
8508 break;
8509 }
8510 case E_GOP_STATUS_CURRENT_FBID:
8511 {
8512 MS_U32* pCurrentFbid = (MS_U32*)pStatus;
8513 *pCurrentFbid = GOP_GetCurrentFBID(pInstance);
8514 break;
8515 }
8516 default:
8517 {
8518 GOP_M_ERR("[%s] invalid input case:%d\n",__FUNCTION__, type);
8519 }
8520
8521 }
8522
8523 return GOP_API_SUCCESS;
8524
8525 }
8526
8527
8528
8529
8530 //******************************************************************************
8531 /// API for Test Pattern Type Select
8532 /// @param eTstPatternType \b IN: Test Pattern Type
8533 /// @param MS_U32 u32ARGB \b IN: ARGB Color
8534 /// @return GOP_API_SUCCESS - Success
8535 /// @return GOP_API_FAIL - Failure
8536 //******************************************************************************
Ioctl_GOP_TestPattern(void * pInstance,EN_GOP_TST_PATTERN eTstPatternType,MS_U32 u32ARGB)8537 MS_U32 Ioctl_GOP_TestPattern(void* pInstance,EN_GOP_TST_PATTERN eTstPatternType, MS_U32 u32ARGB)
8538 {
8539 DRV_GOP_TSTPATTERN drv_TstPattern;
8540 EN_GOP_TST_PATTERN eCurTPMode;
8541 MS_U8 u8CurGOP = 0;
8542 #ifdef INSTANT_PRIVATE
8543 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8544 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8545 #endif
8546
8547
8548 u8CurGOP = MDrv_GOP_Get(g_pGOPCtxLocal);
8549
8550 if( MDrv_GOP_TestPattern_IsVaild(g_pGOPCtxLocal) != GOP_SUCCESS)
8551 {
8552 return GOP_API_FAIL;
8553 }
8554
8555 //Back up
8556 eCurTPMode = (EN_GOP_TST_PATTERN)g_pGOPCtxLocal->pGOPCtxShared->GOP_TestPatternMode;
8557 if(eCurTPMode == E_GOP_TP_DISABLE)
8558 {
8559 GOP_M_INFO("[%s (%d)] cur:%d input mode:%d GOPBK Read\n",__FUNCTION__,__LINE__,eCurTPMode, eTstPatternType);
8560 MDrv_GOP_BNK(g_pGOPCtxLocal, E_DRV_GOP_BNK_READ);
8561 }
8562
8563 g_pGOPCtxLocal->pGOPCtxShared->GOP_TestPatternMode = eTstPatternType;
8564
8565 memset(&drv_TstPattern, 0, sizeof(DRV_GOP_TSTPATTERN));
8566
8567 switch(eTstPatternType)
8568 {
8569 case E_GOP_TP_DISABLE:
8570 drv_TstPattern.bTSTClr_En = 0;
8571 GOP_M_INFO("[%s (%d)] cur:%d input mode:%d GOPBK write\n",__FUNCTION__,__LINE__,eCurTPMode, eTstPatternType);
8572 MDrv_GOP_BNK(g_pGOPCtxLocal, E_DRV_GOP_BNK_WRITE);
8573 return GOP_API_SUCCESS;
8574 break;
8575 case E_GOP_TP_GRAY16:
8576 drv_TstPattern.bTSTClr_En = 1;
8577 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc= 256/(16-1);
8578 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=1;
8579 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step= (g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /16);
8580 break;
8581 case E_GOP_TP_GRAY16_INVERSE:
8582 drv_TstPattern.bTSTClr_En=1;
8583 drv_TstPattern.u8R_stc = 0xFF;
8584 drv_TstPattern.u8G_stc = 0xFF;
8585 drv_TstPattern.u8B_stc = 0xFF;
8586 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(16-1);
8587 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=0;
8588 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /16);
8589 break;
8590 case E_GOP_TP_GRAY32:
8591 drv_TstPattern.bTSTClr_En=1;
8592 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(32-1);
8593 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=1;
8594 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /32)-1;
8595 break;
8596 case E_GOP_TP_GRAY32_INVERSE:
8597 drv_TstPattern.bTSTClr_En=1;
8598 drv_TstPattern.u8R_stc = 0xFF;
8599 drv_TstPattern.u8G_stc = 0xFF;
8600 drv_TstPattern.u8B_stc = 0xFF;
8601 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(32-1);
8602 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=0;
8603 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /32)-1;
8604 break;
8605 case E_GOP_TP_GRAY64:
8606 drv_TstPattern.bTSTClr_En=1;
8607 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(64-1);
8608 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=1;
8609 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /64);
8610 break;
8611 case E_GOP_TP_GRAY64_INVERSE:
8612 drv_TstPattern.bTSTClr_En=1;
8613 drv_TstPattern.u8R_stc = 0xFF;
8614 drv_TstPattern.u8G_stc = 0xFF;
8615 drv_TstPattern.u8B_stc = 0xFF;
8616 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(64-1);
8617 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=0;
8618 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /64);
8619 break;
8620 case E_GOP_TP_GRAY256:
8621 drv_TstPattern.bTSTClr_En=1;
8622 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(256-1);
8623 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=1;
8624 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /256);
8625 break;
8626 case E_GOP_TP_GRAY256_INVERSE:
8627 drv_TstPattern.bTSTClr_En=1;
8628 drv_TstPattern.u8R_stc = 0xFF;
8629 drv_TstPattern.u8G_stc = 0xFF;
8630 drv_TstPattern.u8B_stc = 0xFF;
8631 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=256/(256-1);
8632 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=0;
8633 drv_TstPattern.u8HR_step=drv_TstPattern.u8HG_step=drv_TstPattern.u8HB_step=(g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /256);
8634 break;
8635 case E_GOP_TP_BLACK:
8636 drv_TstPattern.bTSTClr_En=1;
8637 break;
8638 case E_GOP_TP_WHITE:
8639 drv_TstPattern.bTSTClr_En=1;
8640 drv_TstPattern.u8R_stc = 0xFF;
8641 drv_TstPattern.u8G_stc = 0xFF;
8642 drv_TstPattern.u8B_stc = 0xFF;
8643 break;
8644 case E_GOP_TP_CLR:
8645 drv_TstPattern.bTSTClr_En=1;
8646 drv_TstPattern.u8R_stc = u32ARGB>>16;
8647 drv_TstPattern.u8G_stc = u32ARGB>>8;
8648 drv_TstPattern.u8B_stc = u32ARGB;
8649 break;
8650 case E_GOP_TP_BW_DOT:
8651 drv_TstPattern.bTSTClr_En=1;
8652 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=127;
8653 drv_TstPattern.u8VR_inc=drv_TstPattern.u8VG_inc=drv_TstPattern.u8VB_inc=127;
8654 drv_TstPattern.u8HR_step=0x1;
8655 drv_TstPattern.u8HG_step=0x1;
8656 drv_TstPattern.u8HB_step=0x1;
8657 drv_TstPattern.u8VR_step=0x1;
8658 drv_TstPattern.u8VG_step=0x1;
8659 drv_TstPattern.u8VB_step=0x1;
8660 break;
8661 case E_GOP_TP_BW_CROSS:
8662 drv_TstPattern.bTSTClr_En=1;
8663 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=0xFF;
8664 drv_TstPattern.u8VR_inc=drv_TstPattern.u8VG_inc=drv_TstPattern.u8VB_inc=0xFF;
8665 drv_TstPattern.u8HR_step = drv_TstPattern.u8HG_step = drv_TstPattern.u8HB_step = 128*g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /1920-1;
8666 drv_TstPattern.u8VR_step = drv_TstPattern.u8VG_step = drv_TstPattern.u8VB_step = 128*g_pGOPCtxLocal->pGOPCtxShared->u16PnlHeight[u8CurGOP] /1080-1;
8667 break;
8668 case E_GOP_TP_BW_LINE:
8669 drv_TstPattern.bTSTClr_En=1;
8670 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=127;
8671 drv_TstPattern.u8VR_inc=drv_TstPattern.u8VG_inc=drv_TstPattern.u8VB_inc=0;
8672 break;
8673 case E_GOP_TP_CLR_BAR:
8674 drv_TstPattern.u8R_stc = 0xFF;
8675 drv_TstPattern.u8G_stc = 0xFF;
8676 drv_TstPattern.u8B_stc = 0xFF;
8677 break;
8678 case E_GOP_TP_CLR_BAR_INVERSE:
8679 drv_TstPattern.bTSTClr_En=1;
8680 drv_TstPattern.u8TSTClr_Hdup=3;
8681 drv_TstPattern.u8TSTClr_Vdup=0;
8682
8683 drv_TstPattern.u8HR_inc=drv_TstPattern.u8HG_inc=drv_TstPattern.u8HB_inc=255;
8684 drv_TstPattern.u8HR_inc_signz=drv_TstPattern.u8HG_inc_signz=drv_TstPattern.u8HB_inc_signz=1;
8685 drv_TstPattern.u8HB_step = 60*g_pGOPCtxLocal->pGOPCtxShared->u16PnlWidth[u8CurGOP] /1920;
8686 drv_TstPattern.u8HR_step = (drv_TstPattern.u8HB_step << 1) + 1;
8687 drv_TstPattern.u8HG_step = (drv_TstPattern.u8HR_step << 1) + 1;
8688 break;
8689 default:
8690 return GOP_API_ENUM_NOT_SUPPORTED;
8691 break;
8692 }
8693
8694 drv_TstPattern.u8TSTClr_Alpha = u32ARGB>>24;
8695
8696 _GOP_TestPattern(pInstance,&drv_TstPattern);
8697
8698 return GOP_API_SUCCESS;
8699
8700 }
8701
8702
8703
Ioctl_GOP_Set_Stretch(void * pInstance,EN_GOP_STRETCH_TYPE enStretchType,MS_U32 gop,PGOP_STRETCH_INFO pStretchInfo)8704 MS_U32 Ioctl_GOP_Set_Stretch(void* pInstance,EN_GOP_STRETCH_TYPE enStretchType,MS_U32 gop ,PGOP_STRETCH_INFO pStretchInfo)
8705 {
8706 MS_BOOL bEn = FALSE;
8707 DRV_GOPDstType enGopDst = E_DRV_GOP_DST_INVALID;
8708 EN_GOP_DST_TYPE enApiGopDst = MAX_GOP_DST_SUPPORT;
8709 #ifdef INSTANT_PRIVATE
8710 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8711 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8712 #endif
8713
8714 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal,gop, &enGopDst);
8715
8716 if(enStretchType & E_GOP_STRETCH_WIN)
8717 {
8718 _GOP_Map_DRVDst2API_Enum_(pInstance,&enApiGopDst, enGopDst);
8719 GOP_SetStretchWin(pInstance, gop, enApiGopDst, pStretchInfo->SrcRect.x, pStretchInfo->SrcRect.y,pStretchInfo->SrcRect.w,pStretchInfo->SrcRect.h);
8720 }
8721
8722 if (enStretchType & E_GOP_STRETCH_WIN_POSITION)
8723 {
8724 GOP_SetStretchWinPosition(pInstance,gop, pStretchInfo->SrcRect.x, pStretchInfo->SrcRect.y);
8725 }
8726
8727 if(enStretchType & E_GOP_STRETCH_HSCALE)
8728 {
8729 if(pStretchInfo->SrcRect.w != pStretchInfo->DstRect.w)
8730 {
8731 bEn = TRUE;
8732 }
8733 GOP_Set_Hscale(pInstance,gop,bEn,pStretchInfo->SrcRect.w,pStretchInfo->DstRect.w);
8734 }
8735
8736 if(enStretchType & E_GOP_STRETCH_VSCALE)
8737 {
8738 if(pStretchInfo->SrcRect.h != pStretchInfo->DstRect.h)
8739 {
8740 bEn = TRUE;
8741 }
8742 GOP_Set_Vscale(pInstance,gop,bEn,pStretchInfo->SrcRect.h,pStretchInfo->DstRect.h);
8743 }
8744
8745 if(enStretchType & E_GOP_STRETCH_HSTRETCH_MODE)
8746 {
8747 GOP_GWIN_Set_HStretchMode(pInstance,gop,pStretchInfo->enHMode);
8748 }
8749
8750 if(enStretchType & E_GOP_STRETCH_VSTRETCH_MODE)
8751 {
8752 GOP_GWIN_Set_VStretchMode(pInstance,gop,pStretchInfo->enVMode);
8753 }
8754
8755 if(enStretchType & E_GOP_STRETCH_TRANSPCOLOR_MODE)
8756 {
8757 GOP_GWIN_Set_TranspColorStretchMode(pInstance,gop,pStretchInfo->enTColorMode);
8758 }
8759 return GOP_API_SUCCESS;
8760 }
8761
8762
Ioctl_GOP_Get_Stretch(void * pInstance,EN_GOP_STRETCH_TYPE enStretchType,MS_U32 gop,PGOP_STRETCH_INFO pStretchInfo)8763 MS_U32 Ioctl_GOP_Get_Stretch(void* pInstance,EN_GOP_STRETCH_TYPE enStretchType,MS_U32 gop ,PGOP_STRETCH_INFO pStretchInfo)
8764 {
8765 #ifdef INSTANT_PRIVATE
8766 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8767 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8768 #endif
8769
8770 if(enStretchType & E_GOP_STRETCH_WIN)
8771 {
8772 MS_U16 x,y,w,h;
8773
8774 MDrv_GOP_GWIN_Get_StretchWin(g_pGOPCtxLocal, gop, &x, &y, &w, &h);
8775 pStretchInfo->SrcRect.x = (MS_U32)x;
8776 pStretchInfo->SrcRect.y = (MS_U32)y;
8777 pStretchInfo->SrcRect.w = (MS_U32)w;
8778 pStretchInfo->SrcRect.h = (MS_U32)h;
8779 }
8780
8781 return GOP_API_SUCCESS;
8782 }
8783
8784
Ioctl_GOP_GWin_SetProperty(void * pInstance,EN_GOP_GWIN_PROPERTY type,MS_U32 gwin,MS_U32 * pSet,MS_U32 u32Size)8785 MS_U32 Ioctl_GOP_GWin_SetProperty(void* pInstance,EN_GOP_GWIN_PROPERTY type,MS_U32 gwin, MS_U32* pSet, MS_U32 u32Size)
8786 {
8787 switch(type)
8788 {
8789 case E_GOP_GWIN_BLENDING:
8790 {
8791 MS_BOOL bEn;
8792 PGOP_GWIN_BLENDING pInfo = (PGOP_GWIN_BLENDING)pSet;
8793
8794 if(u32Size != sizeof(GOP_GWIN_BLENDING))
8795 return GOP_API_INVALID_PARAMETERS;
8796
8797 bEn = (MS_BOOL)*pSet;
8798
8799 GOP_GWIN_SetBlending(pInstance,gwin,pInfo->bEn, pInfo->Coef);
8800
8801 break;
8802 }
8803 case E_GOP_GWIN_NEWAPLHA:
8804 {
8805 MS_BOOL bEn;
8806
8807 if(u32Size != sizeof(MS_BOOL))
8808 return GOP_API_INVALID_PARAMETERS;
8809
8810 bEn = (MS_BOOL)*pSet;
8811
8812 GOP_GWIN_SetNewAlphaMode(pInstance,gwin,bEn);
8813 break;
8814 }
8815 case E_GOP_GWIN_ENABLE:
8816 {
8817 MS_BOOL bEn;
8818
8819 if(u32Size != sizeof(MS_BOOL))
8820 return GOP_API_INVALID_PARAMETERS;
8821
8822 bEn = (MS_BOOL)*pSet;
8823
8824 GOP_GWIN_SetEnable(pInstance,gwin,bEn);
8825
8826 break;
8827 }
8828 case E_GOP_GWIN_BLINK:
8829 {
8830 PGOP_GWIN_BLINK pRate = (PGOP_GWIN_BLINK)pSet;
8831 if(u32Size != sizeof(GOP_GWIN_BLINK))
8832 return GOP_API_INVALID_PARAMETERS;
8833
8834 GOP_GWIN_SetBlink(pInstance,pRate->bEn,gwin, pRate->rate);
8835 break;
8836 }
8837 case E_GOP_GWIN_SHARE:
8838 {
8839 MS_BOOL bEn;
8840 if(u32Size != sizeof(MS_BOOL))
8841 return GOP_API_INVALID_PARAMETERS;
8842 bEn = (MS_BOOL)*pSet;
8843 GOP_GWIN_SetGWinShared(pInstance,gwin, bEn);
8844 break;
8845 }
8846 case E_GOP_GWIN_SHARE_CNT:
8847 {
8848 MS_U16 u16SharedCnt;
8849 if(u32Size != sizeof(MS_U16))
8850 return GOP_API_INVALID_PARAMETERS;
8851 u16SharedCnt = (MS_U16)*pSet;
8852 GOP_GWIN_SetGWinSharedCnt(pInstance,gwin, u16SharedCnt);
8853 break;
8854 }
8855 case E_GOP_GWIN_SWITCH_2_GWIN:
8856 {
8857 GOP_GWIN_Switch2Gwin(pInstance,gwin,(void*)pSet);
8858 break;
8859 }
8860 case E_GOP_GWIN_3D_MODE:
8861 {
8862 GOP_GWIN_3D_MODE *pst3DMode = (GOP_GWIN_3D_MODE *)pSet;
8863 if(u32Size != sizeof(GOP_GWIN_3D_MODE))
8864 return GOP_API_INVALID_PARAMETERS;
8865 GOP_Set3DOSDMode(pInstance,gwin,(MS_U16)pst3DMode->u32MainFBId,(MS_U16)pst3DMode->u32SubFBId,pst3DMode->en3DMode);
8866 break;
8867 }
8868 case E_GOP_GWIN_EXIST:
8869 {
8870 break;
8871 }
8872 case E_GOP_GWIN_FREE_ID:
8873 {
8874 break;
8875 }
8876 case E_GOP_GWIN_GET_FB:
8877 {
8878 break;
8879 }
8880 case E_GOP_GWIN_GET_GOP:
8881 {
8882 break;
8883 }
8884 case E_GOP_GWIN_GPUTILE:
8885 {
8886 EN_GOP_GPU_TILE_MODE tilemode;
8887 if(u32Size != sizeof(EN_GOP_GPU_TILE_MODE))
8888 {
8889 return GOP_API_INVALID_PARAMETERS;
8890 }
8891 tilemode = (EN_GOP_GPU_TILE_MODE)*pSet;
8892 GOP_GWIN_SetGPUtileMode(pInstance,gwin,tilemode);
8893 break;
8894 }
8895 }
8896
8897
8898 return GOP_API_SUCCESS;
8899
8900 }
8901
8902
8903
Ioctl_GOP_GWin_GetProperty(void * pInstance,EN_GOP_GWIN_PROPERTY type,MS_U32 gwin,MS_U32 * pSet,MS_U32 u32Size)8904 MS_U32 Ioctl_GOP_GWin_GetProperty(void* pInstance,EN_GOP_GWIN_PROPERTY type,MS_U32 gwin, MS_U32* pSet, MS_U32 u32Size)
8905 {
8906 #ifdef INSTANT_PRIVATE
8907 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
8908 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
8909 #endif
8910 switch(type)
8911 {
8912 case E_GOP_GWIN_BLENDING:
8913 {
8914 break;
8915 }
8916 case E_GOP_GWIN_NEWAPLHA:
8917 {
8918 MS_BOOL bEn=FALSE;
8919
8920 if(u32Size != sizeof(MS_BOOL))
8921 return GOP_API_INVALID_PARAMETERS;
8922 MDrv_GOP_GWIN_GetGwinNewAlphaModeEnable(g_pGOPCtxLocal, gwin, &bEn);
8923 *pSet = bEn;
8924
8925 break;
8926 }
8927 case E_GOP_GWIN_ENABLE:
8928 {
8929 MS_BOOL *pbEn = (MS_BOOL*)pSet;
8930
8931 if(u32Size != sizeof(MS_BOOL))
8932 return GOP_API_INVALID_PARAMETERS;
8933
8934 *pbEn = GOP_GWIN_IsEnable(pInstance,gwin);
8935
8936 break;
8937 }
8938 case E_GOP_GWIN_BLINK:
8939 {
8940 break;
8941 }
8942 case E_GOP_GWIN_SHARE:
8943 {
8944 break;
8945 }
8946 case E_GOP_GWIN_SHARE_CNT:
8947 {
8948 break;
8949 }
8950 case E_GOP_GWIN_SWITCH_2_GWIN:
8951 {
8952 break;
8953 }
8954 case E_GOP_GWIN_3D_MODE:
8955 {
8956 break;
8957 }
8958 case E_GOP_GWIN_EXIST:
8959 {
8960 MS_U8 *pExist = (MS_U8*)pSet;
8961
8962 if(u32Size != sizeof(MS_U8))
8963 return GOP_API_INVALID_PARAMETERS;
8964
8965 *pExist = (MS_U8)GOP_GWIN_IsGwinExist(pInstance,gwin);
8966 break;
8967 }
8968 case E_GOP_GWIN_FREE_ID:
8969 {
8970 MS_U8 *pFreeId = (MS_U8*)pSet;
8971
8972 if(u32Size != sizeof(MS_U8))
8973 return GOP_API_INVALID_PARAMETERS;
8974 *pFreeId = (MS_U8)GOP_GWIN_GetFreeWinID(pInstance);
8975 break;
8976 }
8977 case E_GOP_GWIN_GET_FB:
8978 {
8979 MS_U32 *pFbId = (MS_U32*)pSet;
8980
8981 if(u32Size != sizeof(MS_U32))
8982 return GOP_API_INVALID_PARAMETERS;
8983
8984 *pFbId = GOP_GWIN_GetFBfromGWIN(pInstance,gwin);
8985 break;
8986 }
8987 case E_GOP_GWIN_GET_GOP:
8988 {
8989 MS_U32 *pGOP = (MS_U32*)pSet;
8990 if(u32Size != sizeof(MS_U32))
8991 return GOP_API_INVALID_PARAMETERS;
8992
8993 *pGOP = (MS_U32)MDrv_DumpGopByGwinId(g_pGOPCtxLocal,gwin);
8994 break;
8995 }
8996 case E_GOP_GWIN_GPUTILE:
8997 {
8998 break;
8999 }
9000 }
9001
9002
9003 return GOP_API_SUCCESS;
9004
9005 }
9006
Ioctl_GOP_FB_SetProperty(void * pInstance,EN_GOP_FB_PROPERTY type,MS_U32 FBId,MS_U32 * pSet,MS_U32 u32Size)9007 MS_U32 Ioctl_GOP_FB_SetProperty(void* pInstance,EN_GOP_FB_PROPERTY type,MS_U32 FBId, MS_U32* pSet, MS_U32 u32Size)
9008 {
9009 switch(type)
9010 {
9011 case E_GOP_FB_POOLID:
9012 {
9013 MS_U8 *pPool = (MS_U8*)pSet;
9014
9015 if(u32Size != sizeof(MS_U8))
9016 return GOP_API_INVALID_PARAMETERS;
9017
9018 GOP_FB_SEL(pInstance,*pPool);
9019 break;
9020 }
9021 case E_GOP_FB_EXIST:
9022 {
9023 break;
9024 }
9025 case E_GOP_FB_OBTAIN:
9026 {
9027 break;
9028 }
9029 }
9030
9031 return GOP_API_SUCCESS;
9032 }
9033
Ioctl_GOP_FB_GetProperty(void * pInstance,EN_GOP_FB_PROPERTY type,MS_U32 FBId,MS_U32 * pSet,MS_U32 u32Size)9034 MS_U32 Ioctl_GOP_FB_GetProperty(void* pInstance,EN_GOP_FB_PROPERTY type,MS_U32 FBId, MS_U32* pSet, MS_U32 u32Size)
9035 {
9036 switch(type)
9037 {
9038 case E_GOP_FB_POOLID:
9039 {
9040 MS_U8 *pPool = (MS_U8*)pSet;
9041
9042 if(u32Size != sizeof(MS_U8))
9043 return GOP_API_INVALID_PARAMETERS;
9044
9045 *pPool = (MS_U8)GOP_FB_Get(pInstance);
9046 break;
9047 }
9048
9049 case E_GOP_FB_EXIST:
9050 {
9051 MS_U8 *pExist = (MS_U8*)pSet;
9052
9053 if(u32Size != sizeof(MS_U8))
9054 return GOP_API_INVALID_PARAMETERS;
9055 *pExist = (MS_U8)GOP_GWIN_Is32FBExist(pInstance,FBId);
9056 break;
9057 }
9058 case E_GOP_FB_OBTAIN:
9059 {
9060 MS_U32 *pFreeFbID = (MS_U32*)pSet;
9061
9062 if(u32Size != sizeof(MS_U32))
9063 return GOP_API_INVALID_PARAMETERS;
9064 *pFreeFbID = (MS_U32)GOP_GWIN_GetFreeFbID(pInstance);
9065 break;
9066 }
9067 }
9068
9069 return GOP_API_SUCCESS;
9070 }
9071
Ioctl_GOP_DWIN_SetProperty(void * pInstance,EN_GOP_DWIN_PROPERTY type,MS_U32 * pSet,MS_U32 u32Size)9072 MS_U32 Ioctl_GOP_DWIN_SetProperty(void* pInstance,EN_GOP_DWIN_PROPERTY type,MS_U32* pSet, MS_U32 u32Size)
9073 {
9074 #ifdef INSTANT_PRIVATE
9075 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9076 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9077 #endif
9078
9079 switch(type)
9080 {
9081 case E_GOP_DWIN_R2Y:
9082 {
9083 MS_BOOL bEn;
9084
9085 if(u32Size != sizeof(MS_BOOL))
9086 return GOP_API_INVALID_PARAMETERS;
9087
9088 bEn = (MS_BOOL)*pSet;
9089 MDrv_GOP_DWIN_EnableR2YCSC(g_pGOPCtxLocal, bEn);
9090 break;
9091 }
9092 case E_GOP_DWIN_UV_SWAP:
9093 {
9094 MS_BOOL bEn;
9095
9096 if(u32Size != sizeof(MS_BOOL))
9097 return GOP_API_INVALID_PARAMETERS;
9098
9099 bEn = (MS_BOOL)*pSet;
9100 MDrv_GOP_DWIN_SetUVSwap(g_pGOPCtxLocal, bEn);
9101 break;
9102 }
9103 case E_GOP_DWIN_UV_SAMPLE:
9104 {
9105 EN_GOP_DWIN_UVSAMPLE_Mode enMode;
9106
9107 if(u32Size != sizeof(EN_GOP_DWIN_UVSAMPLE_Mode))
9108 return GOP_API_INVALID_PARAMETERS;
9109
9110 enMode = (EN_GOP_DWIN_UVSAMPLE_Mode)*pSet;
9111 MDrv_GOP_DWIN_SetUVSample(g_pGOPCtxLocal, (MS_U8)enMode);
9112 break;
9113 }
9114 case E_GOP_DWIN_SOURCE_SCAN_TYPE:
9115 {
9116 EN_GOP_DWIN_SCAN_MODE enMode;
9117
9118 if(u32Size != sizeof(EN_GOP_DWIN_SCAN_MODE))
9119 return GOP_API_INVALID_PARAMETERS;
9120
9121 enMode = (EN_GOP_DWIN_SCAN_MODE)*pSet;
9122 MDrv_GOP_DWIN_SelectSourceScanType(g_pGOPCtxLocal,(EN_GOP_DWIN_SCAN_TYPE)enMode);
9123 break;
9124 }
9125 case E_GOP_DWIN_ALPHA_VALUE:
9126 {
9127 MS_U8 u8Value;
9128
9129 if(u32Size != sizeof(MS_U8))
9130 return GOP_API_INVALID_PARAMETERS;
9131
9132 u8Value = (MS_U8)*pSet;
9133 MDrv_GOP_DWIN_SetAlphaValue(g_pGOPCtxLocal, u8Value);
9134 break;
9135 }
9136 case E_GOP_DWIN_ALPHA_SOURCE:
9137 {
9138 EN_GOP_DWIN_ALPHA_SRC enSource;
9139
9140 if(u32Size != sizeof(EN_GOP_DWIN_ALPHA_SRC))
9141 return GOP_API_INVALID_PARAMETERS;
9142
9143 enSource = (EN_GOP_DWIN_ALPHA_SRC)*pSet;
9144 MDrv_GOP_DWIN_SetAlphaSrc(g_pGOPCtxLocal, (MS_U8)enSource);
9145 break;
9146 }
9147 case E_GOP_DWIN_ALPHA_INVERSE:
9148 {
9149 MS_BOOL bEn;
9150
9151 if(u32Size != sizeof(MS_BOOL))
9152 return GOP_API_INVALID_PARAMETERS;
9153
9154 bEn = (MS_BOOL)*pSet;
9155 MDrv_GOP_DWIN_SetAlphaInverse(g_pGOPCtxLocal, bEn);
9156 break;
9157 }
9158 case E_GOP_DWIN_SKIP_FRAME:
9159 {
9160 MS_U32 u32Count;
9161
9162 if(u32Size != sizeof(MS_U32))
9163 return GOP_API_INVALID_PARAMETERS;
9164
9165 u32Count = (MS_U32)*pSet;
9166 MDrv_GOP_DWIN_SetSkipFrame(g_pGOPCtxLocal, u32Count);
9167 break;
9168 }
9169 case E_GOP_DWIN_PINPON:
9170 {
9171 PGOP_PINPON_INFO pPinpon = (PGOP_PINPON_INFO)pSet;
9172 if(u32Size != sizeof(GOP_PINPON_INFO))
9173 return GOP_API_INVALID_PARAMETERS;
9174 MDrv_GOP_Set_BufferPINPON(g_pGOPCtxLocal,pPinpon->u64Addr0,pPinpon->u64Addr1);
9175 break;
9176 }
9177 case E_GOP_DWIN_INTERRUP_INFO:
9178 {
9179 break;
9180 }
9181 case E_GOP_DWIN_CAPTURE_INFO:
9182 {
9183 break;
9184 }
9185 }
9186 return GOP_API_SUCCESS;
9187 }
Ioctl_GOP_DWIN_GetProperty(void * pInstance,EN_GOP_DWIN_PROPERTY type,MS_U32 * pSet,MS_U32 u32Size)9188 MS_U32 Ioctl_GOP_DWIN_GetProperty(void* pInstance,EN_GOP_DWIN_PROPERTY type,MS_U32* pSet, MS_U32 u32Size)
9189 {
9190 switch(type)
9191 {
9192 case E_GOP_DWIN_R2Y:
9193 {
9194 break;
9195 }
9196 case E_GOP_DWIN_UV_SWAP:
9197 {
9198 break;
9199 }
9200 case E_GOP_DWIN_UV_SAMPLE:
9201 {
9202 break;
9203 }
9204 case E_GOP_DWIN_SOURCE_SCAN_TYPE:
9205 {
9206 break;
9207 }
9208 case E_GOP_DWIN_ALPHA_VALUE:
9209 {
9210 break;
9211 }
9212 case E_GOP_DWIN_ALPHA_SOURCE:
9213 {
9214 break;
9215 }
9216 case E_GOP_DWIN_ALPHA_INVERSE:
9217 {
9218 break;
9219 }
9220 case E_GOP_DWIN_SKIP_FRAME:
9221 {
9222 break;
9223 }
9224 case E_GOP_DWIN_PINPON:
9225 {
9226 break;
9227 }
9228 case E_GOP_DWIN_INTERRUP_INFO:
9229 {
9230 break;
9231 }
9232 case E_GOP_DWIN_CAPTURE_INFO:
9233 {
9234 break;
9235 }
9236
9237 }
9238 return GOP_API_SUCCESS;
9239 }
9240
Ioctl_GOP_MIXER_SetProperty(void * pInstance,EN_GOP_MIXER_PROPERTY type,MS_U32 * pSet,MS_U32 u32Size)9241 MS_U32 Ioctl_GOP_MIXER_SetProperty(void* pInstance,EN_GOP_MIXER_PROPERTY type,MS_U32* pSet, MS_U32 u32Size)
9242 {
9243 switch(type)
9244 {
9245 case E_GOP_MIXER_OUTPUT_TIMING:
9246 {
9247 PGOP_MIXER_TIMING_INFO pMTInfo = (PGOP_MIXER_TIMING_INFO )pSet;
9248
9249 if(u32Size != sizeof(GOP_MIXER_TIMING_INFO))
9250 return GOP_API_INVALID_PARAMETERS;
9251 GOP_MIXER_SetOutputTiming(pInstance,pMTInfo->mode,&(pMTInfo->pMT));
9252 break;
9253 }
9254 case E_GOP_MIXER_TO_OP_OUTPUT_TIMING:
9255 {
9256 GOP_Mixer2OPTiming *pMT = (GOP_Mixer2OPTiming *)pSet;
9257
9258 if(u32Size != sizeof(GOP_Mixer2OPTiming))
9259 return GOP_API_INVALID_PARAMETERS;
9260 GOP_MIXER_SetMIXER2OPOutputTiming(pInstance,pMT);
9261 break;
9262 }
9263 case E_GOP_MIXER_V_FILTER:
9264 {
9265 MS_BOOL bEn;
9266
9267 if(u32Size != sizeof(MS_BOOL))
9268 return GOP_API_INVALID_PARAMETERS;
9269
9270 bEn = (MS_BOOL)*pSet;
9271 GOP_MIXER_EnableVfilter(pInstance,bEn);
9272 break;
9273 }
9274 case E_GOP_MIXER_OLD_BLENDING_MODE:
9275 {
9276 GOP_MixerOldBlendingMode* pMOBM;
9277
9278 if(u32Size != sizeof(GOP_MixerOldBlendingMode))
9279 return GOP_API_INVALID_PARAMETERS;
9280
9281 pMOBM = (GOP_MixerOldBlendingMode*)pSet;
9282 GOP_MIXER_EnableOldBlendingMode(pInstance, pMOBM->u8GOP, pMOBM->bEnable);
9283 break;
9284 }
9285 }
9286 return GOP_API_SUCCESS;
9287 }
9288
Ioctl_GOP_MIXER_GetProperty(void * pInstance,EN_GOP_MIXER_PROPERTY type,MS_U32 * pSet,MS_U32 u32Size)9289 MS_U32 Ioctl_GOP_MIXER_GetProperty(void* pInstance,EN_GOP_MIXER_PROPERTY type,MS_U32* pSet, MS_U32 u32Size)
9290 {
9291 switch(type)
9292 {
9293 case E_GOP_MIXER_OUTPUT_TIMING:
9294 {
9295 break;
9296 }
9297 case E_GOP_MIXER_TO_OP_OUTPUT_TIMING:
9298 {
9299 break;
9300 }
9301 case E_GOP_MIXER_V_FILTER:
9302 {
9303 break;
9304 }
9305 case E_GOP_MIXER_OLD_BLENDING_MODE:
9306 {
9307 break;
9308 }
9309 }
9310 return GOP_API_SUCCESS;
9311 }
9312
Ioctl_GOP_VE_SetProperty(void * pInstance,EN_GOP_VE_PROPERTY type,MS_U32 * pSet,MS_U32 u32Size)9313 MS_U32 Ioctl_GOP_VE_SetProperty(void* pInstance,EN_GOP_VE_PROPERTY type,MS_U32* pSet, MS_U32 u32Size)
9314 {
9315 switch(type)
9316 {
9317 case E_GOP_VE_OUTPUT_TIMING:
9318 {
9319 PGOP_VE_TIMING_INFO pVEInfo = (PGOP_VE_TIMING_INFO )pSet;
9320
9321 if(u32Size != sizeof(GOP_VE_TIMING_INFO))
9322 return GOP_API_INVALID_PARAMETERS;
9323 GOP_VE_SetOutputTiming(pInstance, pVEInfo->mode);
9324 break;
9325 }
9326 }
9327 return GOP_API_SUCCESS;
9328 }
9329
Ioctl_GOP_MapFB2Win(void * pInstance,MS_U32 fbid,MS_U32 gwin)9330 MS_U32 Ioctl_GOP_MapFB2Win(void* pInstance,MS_U32 fbid, MS_U32 gwin)
9331 {
9332 E_GOP_API_Result eRet=GOP_API_FAIL;
9333
9334 eRet = GOP_MapFB2Win(pInstance,fbid,gwin);
9335 return eRet;
9336 }
9337
Ioctl_GOP_Dwin_Capture(void * pInstance,PGOP_CAPTURE_INFO pinfo)9338 MS_U32 Ioctl_GOP_Dwin_Capture(void* pInstance,PGOP_CAPTURE_INFO pinfo)
9339 {
9340 DRV_GOP_DWIN_INFO DwinInfo;
9341 #ifdef INSTANT_PRIVATE
9342 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9343 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9344 #endif
9345
9346 memset(&DwinInfo,0, sizeof(DRV_GOP_DWIN_INFO));
9347
9348 DwinInfo.u16HPixelStart = pinfo->rect.x;
9349 DwinInfo.u16HPixelEnd = pinfo->rect.x + pinfo->rect.w;
9350 DwinInfo.u16VPixelStart = pinfo->rect.y;
9351 DwinInfo.u16VPixelEnd = pinfo->rect.y + pinfo->rect.h;
9352
9353 DwinInfo.u64TFDRAMAddr = pinfo->addr[0];
9354 DwinInfo.u64BFDRAMAddr = pinfo->addr1[0];
9355
9356 DwinInfo.u8fmt = pinfo->fmt;
9357 //Fix me : pinfo->pitch is Number of pixels per horizontal line.
9358 if (pinfo->pitch == pinfo->rect.w)
9359 {
9360 DwinInfo.u16DRAMJumpLen = 0; //Pitch and width are qual
9361 }
9362 else
9363 {
9364 if (GOP_DWIN_FMT_ARGB8888 == pinfo->fmt)
9365 {
9366 DwinInfo.u16DRAMJumpLen = (pinfo->pitch - pinfo->rect.w) * 4; // 1 pixel occupy 4 bytes
9367 }
9368 else
9369 {
9370 DwinInfo.u16DRAMJumpLen = (pinfo->pitch - pinfo->rect.w) * 2; // 1 pixel occupy 2 bytes
9371 }
9372 }
9373
9374 MDrv_GOP_DWIN_SetDataFmt(g_pGOPCtxLocal,(DRV_GOP_DWIN_DATA_FMT)pinfo->fmt);
9375 MDrv_GOP_DWIN_SetSourceSel(g_pGOPCtxLocal,(DRV_GOP_DWIN_SRC_SEL)pinfo->src);
9376 MDrv_GOP_SetClkForCapture(g_pGOPCtxLocal, (DRV_GOP_DWIN_SRC_SEL)pinfo->src);
9377
9378
9379 if (MDrv_GOP_GetMIULen(g_pGOPCtxLocal)< pinfo->addr[0])
9380 {
9381 //Check DWIN MIU Setting is correct
9382 if (MDrv_GOP_GetDWINMIU(g_pGOPCtxLocal)!=1)
9383 {
9384 GOP_M_INFO("\n %s %d DWIN fb addr > MIUO length\n", __FUNCTION__,__LINE__);
9385 MDrv_GOP_SetDWINMIU(g_pGOPCtxLocal, 1);
9386 }
9387 }
9388 else //dwin FB address < MIU0, FB should be in MIU 0
9389 {
9390 //Check DWIN MIU Setting is correct, Error handling
9391 if (MDrv_GOP_GetDWINMIU(g_pGOPCtxLocal)==1)
9392 {
9393 GOP_M_INFO("\n %s %d, DWIN MIU setting should be MIU 0\n",__FUNCTION__,__LINE__);
9394 MDrv_GOP_SetDWINMIU(g_pGOPCtxLocal, 0);
9395 }
9396 }
9397 if (MDrv_GOP_GetMIULen(g_pGOPCtxLocal)< pinfo->addr1[0])
9398 {
9399 //Check DWIN MIU Setting is correct
9400 if (MDrv_GOP_GetDWINMIU(g_pGOPCtxLocal)!=1)
9401 {
9402 GOP_M_INFO("\n %s %d DWIN fb addr > MIUO length\n",__FUNCTION__,__LINE__);
9403 MDrv_GOP_SetDWINMIU(g_pGOPCtxLocal, 1);
9404 }
9405 }
9406 else //dwin FB address < MIU0, FB should be in MIU 0
9407 {
9408 //Check DWIN MIU Setting is correct, Error handling
9409 if (MDrv_GOP_GetDWINMIU(g_pGOPCtxLocal)==1)
9410 {
9411 GOP_M_INFO("\n %s %d DWIN MIU setting should be MIU 0\n",__FUNCTION__,__LINE__);
9412 MDrv_GOP_SetDWINMIU(g_pGOPCtxLocal, 0);
9413 }
9414 }
9415
9416 if((DwinInfo.u64TFDRAMAddr-DwinInfo.u64BFDRAMAddr)!=0)
9417 {
9418 MDrv_GOP_DWIN_SetWinInfo(g_pGOPCtxLocal, &DwinInfo);
9419 }
9420 else
9421 {
9422 if(pinfo->bEn ==TRUE)
9423 {
9424 GOP_M_INFO("\n %s %d, DWIN fb addr is invalid\n",__FUNCTION__,__LINE__);
9425 }
9426 }
9427 MDrv_GOP_DWIN_SelectSourceScanType(g_pGOPCtxLocal, (EN_GOP_DWIN_SCAN_TYPE)pinfo->bInterlace);
9428
9429 if((pinfo->framecount == 1) && (pinfo->bEn == FALSE)){
9430 if(pinfo->bWait == TRUE)
9431 MDrv_GOP_DWIN_CaptureOneFrame(g_pGOPCtxLocal);
9432 else
9433 MDrv_GOP_DWIN_CaptureOneFrame2(g_pGOPCtxLocal);
9434 }else
9435 MDrv_GOP_DWIN_EnableCaptureStream(g_pGOPCtxLocal, pinfo->bEn);
9436
9437 return GOP_API_SUCCESS;
9438 }
9439
9440
Ioctl_GOP_Dwin_Intr(void * pInstance,EN_GOP_DWIN_INTR intr_type,MS_U32 * pIntr,MS_U32 u32Size)9441 MS_U32 Ioctl_GOP_Dwin_Intr(void* pInstance,EN_GOP_DWIN_INTR intr_type, MS_U32* pIntr ,MS_U32 u32Size)
9442 {
9443 #ifdef INSTANT_PRIVATE
9444 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9445 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9446 #endif
9447
9448 switch(intr_type)
9449 {
9450 case E_GOP_DWIN_INTR_CONTROL:
9451 {
9452 MS_BOOL bEn;
9453 MS_U32 IntrMask;
9454 PGOP_DWIN_INTR_CTRL pIntrCtrl = (PGOP_DWIN_INTR_CTRL)pIntr;
9455
9456 if(u32Size != sizeof(GOP_DWIN_INTR_CTRL))
9457 return GOP_API_INVALID_PARAMETERS;
9458
9459 bEn = (MS_BOOL)pIntrCtrl->intrEn;
9460 IntrMask = pIntrCtrl->mask;
9461
9462 MDrv_GOP_DWIN_EnableIntr(g_pGOPCtxLocal, IntrMask, bEn);
9463
9464 break;
9465 }
9466 case E_GOP_DWIN_INTR_GETINFO:
9467 {
9468 if(u32Size != sizeof(MS_U16))
9469 return GOP_API_INVALID_PARAMETERS;
9470
9471 *pIntr = MDrv_GOP_DWIN_GetIntrStatus(g_pGOPCtxLocal);
9472
9473 break;
9474 }
9475 case E_GOP_DWIN_INTR_GETINFO_TIMEOUT:
9476 {
9477 PGOP_DWIN_INTR_TIME_OUT pIntrTimeout = (PGOP_DWIN_INTR_TIME_OUT)pIntr;
9478
9479 if(u32Size != sizeof(GOP_DWIN_INTR_TIME_OUT))
9480 return GOP_API_INVALID_PARAMETERS;
9481 GOP_DWIN_GetDWinIntInfoTimeout(pInstance,&pIntrTimeout->DWinIntInfo,pIntrTimeout->u32Timeout);
9482 break;
9483 }
9484 }
9485
9486 return GOP_API_SUCCESS;
9487
9488 }
9489
9490
9491
Ioctl_GOP_SetWinInfo(void * pInstance,MS_U32 gwinId,PGOP_BUFFER_INFO pInfo)9492 MS_U32 Ioctl_GOP_SetWinInfo(void* pInstance,MS_U32 gwinId,PGOP_BUFFER_INFO pInfo)
9493 {
9494 MS_U8 u8GOP;
9495 GOP_GwinInfo wininfo;
9496 DRV_GOP_AFBC_Info sAFBCWinProperty;
9497 memset(&sAFBCWinProperty, 0, sizeof(DRV_GOP_AFBC_Info));
9498 #ifdef INSTANT_PRIVATE
9499 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9500 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9501 #endif
9502
9503 wininfo.clrType = (EN_GOP_COLOR_TYPE)pInfo->fbFmt;
9504 wininfo.u16DispHPixelStart = pInfo->disp_rect.x;
9505 wininfo.u16DispVPixelStart = pInfo->disp_rect.y;
9506 wininfo.u16RBlkHPixSize = pInfo->width;
9507 wininfo.u16RBlkVPixSize = pInfo->height;
9508 wininfo.u32DRAMRBlkStart = pInfo->addr;
9509 wininfo.u16RBlkHRblkSize = pInfo->pitch;
9510 wininfo.u16DispHPixelEnd = pInfo->disp_rect.x + pInfo->disp_rect.w;
9511 wininfo.u16DispVPixelEnd = pInfo->disp_rect.y + pInfo->disp_rect.h;
9512 wininfo.u16WinX = 0;
9513 wininfo.u16WinY = 0;
9514
9515 if ((wininfo.u16DispHPixelEnd - wininfo.u16DispHPixelStart) > wininfo.u16RBlkHPixSize)
9516 {
9517 GOP_M_ERR("[%s][%d] display H Area > Buffer, x=%td, w=%td, disp_w=%td\n",__FUNCTION__,__LINE__, (ptrdiff_t)pInfo->disp_rect.x, (ptrdiff_t)pInfo->disp_rect.w, (ptrdiff_t)pInfo->width);
9518 wininfo.u16DispHPixelEnd = wininfo.u16DispHPixelStart + wininfo.u16RBlkHPixSize;
9519 }
9520 if ((wininfo.u16DispVPixelEnd - wininfo.u16DispVPixelStart) > wininfo.u16RBlkVPixSize)
9521 {
9522 GOP_M_ERR("[%s][%d] display V Area > Buffer, y=%td, h=%td, disp_h=%td\n",__FUNCTION__,__LINE__, (ptrdiff_t)pInfo->disp_rect.y, (ptrdiff_t)pInfo->disp_rect.h, (ptrdiff_t)pInfo->height);
9523 wininfo.u16DispVPixelEnd = wininfo.u16DispVPixelStart + wininfo.u16RBlkVPixSize;
9524 }
9525
9526 GOP_M_INFO("\33[0;36m %s:%d u8win = %td \33[m \n",__FUNCTION__,__LINE__, (ptrdiff_t)gwinId);
9527
9528 if (!_GOP_IsGwinIdValid(pInstance,gwinId))
9529 {
9530 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gwinId);
9531 return GOP_API_FAIL;
9532 }
9533 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,gwinId);
9534
9535 if(u8GOP == GOPTYPE.GOP0)
9536 {
9537 _SetGop0WinInfo(pInstance,gwinId, &wininfo);
9538 }
9539 else if(u8GOP == GOPTYPE.GOP1)
9540 {
9541 _SetGop1WinInfo(pInstance,gwinId, &wininfo);
9542 }
9543 else
9544 {
9545 _SetGop23WinInfo(pInstance,gwinId, &wininfo);
9546 }
9547 if(g_pGOPCtxLocal->pGopChipProperty->bAFBC_Support[u8GOP]==TRUE)
9548 {
9549 sAFBCWinProperty.u16HPixelStart = wininfo.u16DispHPixelStart;
9550 sAFBCWinProperty.u16HPixelEnd = wininfo.u16DispHPixelEnd;
9551 sAFBCWinProperty.u16Pitch = wininfo.u16RBlkHRblkSize;
9552 sAFBCWinProperty.u16VPixelStart = wininfo.u16DispVPixelStart;
9553 sAFBCWinProperty.u16VPixelEnd= wininfo.u16DispVPixelEnd;
9554 sAFBCWinProperty.u64DRAMAddr = wininfo.u32DRAMRBlkStart;
9555 MDrv_GOP_GWIN_AFBCSetWindow(g_pGOPCtxLocal, u8GOP, &sAFBCWinProperty,FALSE);
9556 }
9557 MDrv_GOP_GWIN_UpdateReg(g_pGOPCtxLocal,u8GOP);
9558
9559 return GOP_API_SUCCESS;
9560 }
9561
9562
9563
Ioctl_GOP_GetWinInfo(void * pInstance,MS_U32 gwinId,PGOP_BUFFER_INFO pInfo)9564 MS_U32 Ioctl_GOP_GetWinInfo(void* pInstance,MS_U32 gwinId,PGOP_BUFFER_INFO pInfo)
9565 {
9566 GOP_GwinInfo wininfo;
9567
9568
9569 if (!_GOP_IsGwinIdValid(pInstance,gwinId))
9570 {
9571 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gwinId);
9572 return GOP_API_FAIL;
9573 }
9574
9575 if (pInfo == NULL)
9576 {
9577 GOP_M_ERR("[%s][%d]pinfo is NULL\n",__FUNCTION__,__LINE__);
9578 return GOP_API_FAIL;
9579 }
9580
9581 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,gwinId)) //To check the gwin is exist
9582 {
9583 GOP_M_ERR("[%s][%d]GWIN %td is not exist\n",__FUNCTION__,__LINE__,(ptrdiff_t)gwinId);
9584 return GOP_API_FAIL;
9585 //ASSERT(0);
9586 }
9587
9588 GOP_GetWinInfo(pInstance,gwinId, &wininfo);
9589
9590 pInfo->addr = wininfo.u32DRAMRBlkStart;
9591 pInfo->disp_rect.x = wininfo.u16DispHPixelStart;
9592 pInfo->disp_rect.y = wininfo.u16DispVPixelStart;
9593 pInfo->disp_rect.w = wininfo.u16DispHPixelEnd - wininfo.u16DispHPixelStart;
9594 pInfo->disp_rect.h = wininfo.u16DispVPixelEnd - wininfo.u16DispVPixelStart;
9595 pInfo->width = wininfo.u16RBlkHPixSize;
9596 pInfo->height = wininfo.u16RBlkVPixSize;
9597 pInfo->pitch = wininfo.u16RBlkHRblkSize;
9598 pInfo->fbFmt = (MS_U32)wininfo.clrType;
9599
9600 return GOP_API_SUCCESS;
9601
9602 }
9603
9604
Ioctl_GOP_Win_Enable(void * pInstance,MS_U32 gwinId,MS_BOOL bEn)9605 MS_U32 Ioctl_GOP_Win_Enable(void* pInstance,MS_U32 gwinId,MS_BOOL bEn)
9606 {
9607 MS_U16 regval2;
9608 MS_U32 u32fbId;
9609 GOP_WinFB_INFO* pwinFB;
9610 MS_U8 gwinNum = 0;
9611 MS_U8 i;
9612 #ifdef INSTANT_PRIVATE
9613 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9614 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9615 #endif
9616
9617
9618 if (!_GOP_IsGwinIdValid(pInstance,gwinId))
9619 {
9620 GOP_M_ERR("[%s][%d]GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)gwinId);
9621 return GOP_API_FAIL;
9622 }
9623
9624 //printf("GWINID=%d,Enable=%d\n",(MS_U8)winId,(MS_U8)bEnable);
9625 if (!_GOP_GWIN_IsGwinExistInClient(pInstance,gwinId))
9626 {
9627 GOP_M_ERR("[%s][%d]GWIN %td is not exist\n",__FUNCTION__,__LINE__,(ptrdiff_t)gwinId);
9628 //__ASSERT(0);
9629 return GOP_API_FAIL;
9630 }
9631
9632 // printf(" u8win=%02bx, bEnable=%02bx\n",u8win,bEnable);
9633 u32fbId = g_pGOPCtxLocal->pGOPCtxShared->gwinMap[gwinId].u32CurFBId;
9634 pwinFB = _GetWinFB(pInstance,u32fbId);
9635
9636 if(pwinFB == NULL)
9637 {
9638 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9639 return GOP_API_FAIL;
9640 }
9641
9642 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
9643 {
9644 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9645 return GOP_API_FAIL;
9646 }
9647
9648 if (0 == pwinFB->in_use)
9649 {
9650 msWarning(ERR_GWIN_ID_NOT_ALLOCATED);
9651 GOP_M_ERR("[%s][%d]GWIN %td not allocated\n",__FUNCTION__,__LINE__,(ptrdiff_t)gwinId);
9652 return GOP_API_FAIL;
9653 }
9654 pwinFB->enable = bEn;
9655
9656 for(i = 0; i < (MS_U8)g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum ; i++)
9657 {
9658 if(GOP_GWIN_IsEnable(pInstance,i) == TRUE)
9659 {
9660 gwinNum |= 1<<i;
9661 }
9662 }
9663
9664 regval2 = gwinNum;
9665
9666 if (bEn == 0) // Turn off GOP
9667 {
9668 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, gwinId, FALSE);
9669 if ((regval2 & ~(1<<gwinId)) == 0)
9670 {
9671 if(fpXCReduceBWForOSD!=NULL)
9672 {
9673 fpXCReduceBWForOSD(XC_MAIN_WINDOW, FALSE);
9674 }
9675 }
9676 }
9677 else //turn on GOP
9678 {
9679 //printf("gop on, interlace=%bx\n", IsSrcInterlace());
9680 if(fpXCReduceBWForOSD!=NULL)
9681 {
9682 fpXCReduceBWForOSD(XC_MAIN_WINDOW, TRUE);
9683 }
9684 MDrv_GOP_GWIN_EnableGwin(g_pGOPCtxLocal, gwinId, TRUE);
9685 }
9686
9687 return GOP_API_SUCCESS;
9688
9689 }
9690
9691
9692 //******************************************************************************
9693 /// API for set GWIN resolution in one function
9694 /// @param u8GwinId \b IN: GWin ID
9695 /// @param u8FbId \b IN: Frame Buffer ID
9696 /// @param pGwinInfo \b IN: pointer to GOP_GwinInfo structure
9697 /// @param pStretchInfo \b IN: pointer to GOP_StretchInfo
9698 /// @param direction \b IN: to decide which direction to stretch
9699 /// @param u16DstWidth \b IN: set scaled width if H direction is specified
9700 /// @param u16DstHeight \b IN: set scaled height if V direction is specified
9701 /// @return GOP_API_SUCCESS - Success
9702 //******************************************************************************
Ioctl_GOP_SetDisplay(void * pInstance,PGOP_GWINDISPLAY_INFO pInfo)9703 MS_U32 Ioctl_GOP_SetDisplay(void* pInstance,PGOP_GWINDISPLAY_INFO pInfo)
9704 {
9705 MS_U8 u8GOP;
9706 MS_U32 GwinId = pInfo->gwin;
9707 MS_U16 u16Tmp, u16OrigWidth = 0;
9708 MS_U16 gwin_w, stretch_w;
9709 MS_BOOL u16OrgUpdateRegOnce = FALSE;
9710 GOP_StretchInfo* pStretchInfo;
9711 GOP_GwinInfo* pGwinInfo = NULL;
9712 MS_U32 u32FbId;
9713 EN_GOP_STRETCH_DIRECTION direction;
9714 MS_U16 u16DstWidth, u16DstHeight;
9715 #ifdef INSTANT_PRIVATE
9716 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9717 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9718 #endif
9719
9720 u32FbId = pInfo->fbid;
9721 direction = pInfo->dir;
9722 u16DstWidth = pInfo->dst_size.w;
9723 u16DstHeight = pInfo->dst_size.h;
9724
9725 pGwinInfo = &(pInfo->gwin_info);
9726 pStretchInfo = &(pInfo->stretch_info);
9727
9728 u16OrgUpdateRegOnce = g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE];
9729 //Save old update_reg_once state, and change to update_reg_once=TRUE internally
9730 if(u16OrgUpdateRegOnce == FALSE)
9731 {
9732 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = TRUE;
9733 }
9734 GOP_MapFB2Win(pInstance,u32FbId,GwinId);
9735
9736 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal,GwinId);
9737 //MApi_GOP_GWIN_Set_STRETCHWIN(u8GOP, pStretchInfo->eDstType,pStretchInfo->x, pStretchInfo->y
9738 // , pStretchInfo->width, pStretchInfo->height);
9739 _GOP_Get_StretchWin(pInstance,u8GOP, &u16Tmp, &u16Tmp, &u16OrigWidth, &u16Tmp);
9740
9741 gwin_w = pGwinInfo->u16DispHPixelEnd - pGwinInfo->u16DispHPixelStart;
9742
9743 if(gwin_w > pStretchInfo->width)
9744 stretch_w = gwin_w;
9745 else
9746 stretch_w = pStretchInfo->width;
9747
9748 _GOP_GWIN_Align_StretchWin(pInstance,u8GOP,pStretchInfo->eDstType , &pStretchInfo->x, &pStretchInfo->y, &stretch_w, &pStretchInfo->height, _GOP_GetBPP(pInstance,pGwinInfo->clrType));
9749 //Store API use stretch window
9750 g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchWidth[u8GOP] = stretch_w;
9751 g_pGOPCtxLocal->pGOPCtxShared->u16APIStretchHeight[u8GOP]= pStretchInfo->height;
9752
9753 _GOP_GWIN_Adjust_3DStretchWin(pInstance,u8GOP, &pStretchInfo->x, &pStretchInfo->y, &stretch_w, &pStretchInfo->height);
9754 if (u16OrigWidth <= stretch_w)//Set a large one, set htt first
9755 MDrv_GOP_GWIN_SetHTotal(g_pGOPCtxLocal, u8GOP, stretch_w);
9756
9757 MDrv_GOP_GWIN_SetStretchWin(g_pGOPCtxLocal, u8GOP, pStretchInfo->x, pStretchInfo->y, stretch_w, pStretchInfo->height);
9758
9759 if(u16DstWidth <= pStretchInfo->width)
9760 GOP_Set_Hscale(pInstance,u8GOP,FALSE, pStretchInfo->width, u16DstWidth);
9761 else if (direction & E_GOP_H_STRETCH)
9762 GOP_Set_Hscale(pInstance,u8GOP,TRUE, pStretchInfo->width, u16DstWidth);
9763
9764 if(u16DstHeight < pStretchInfo->height)
9765 GOP_Set_Vscale(pInstance,u8GOP,FALSE, pStretchInfo->height, u16DstHeight);
9766 else if (direction & E_GOP_V_STRETCH)
9767 GOP_Set_Vscale(pInstance,u8GOP,TRUE, pStretchInfo->height, u16DstHeight);
9768
9769 GOP_SetWinInfo(pInstance,GwinId,pGwinInfo);
9770
9771 //Restore update_reg_once and trigger register writes in
9772 if(u16OrgUpdateRegOnce == FALSE)
9773 {
9774 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = u16OrgUpdateRegOnce;
9775 }
9776
9777 if (u16OrigWidth > stretch_w)//Set a small one, set htt after Gwin regsiter updated
9778 MDrv_GOP_GWIN_SetHTotal(g_pGOPCtxLocal, u8GOP, stretch_w);
9779
9780 return GOP_API_SUCCESS;
9781 }
9782
9783
9784
Ioctl_GOP_Win_Destroy(void * pInstance,MS_U32 gId)9785 MS_U32 Ioctl_GOP_Win_Destroy(void* pInstance,MS_U32 gId)
9786 {
9787 E_GOP_API_Result eRet=GOP_API_FAIL;
9788 eRet = GOP_Win_Destroy(pInstance,gId);
9789 return eRet;
9790 }
9791
9792
Ioctl_GFlip_ClearFlipQueue(void * pInstance,MS_U32 gwin)9793 MS_U32 Ioctl_GFlip_ClearFlipQueue(void* pInstance,MS_U32 gwin)
9794 {
9795 #ifdef INSTANT_PRIVATE
9796 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9797 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9798 #endif
9799 return (E_GOP_API_Result)MDrv_GOP_GWIN_ClearFlipQueue(g_pGOPCtxLocal,gwin);
9800
9801 }
9802
9803
9804
Ioctl_GFlip_SwitchGwin(void * pInstance,PGOP_GWIN_FLIP_WIN_INFO pflip)9805 MS_U32 Ioctl_GFlip_SwitchGwin(void* pInstance,PGOP_GWIN_FLIP_WIN_INFO pflip)
9806 {
9807
9808
9809 switch(pflip->enFlip)
9810 {
9811 case GOP_FLIP_BY_FBID:
9812 GOP_SwitchByFBID(pInstance,pflip->GwinId, pflip->FbId, pflip->WaitTagID, pflip->pQueueCnt);
9813 break;
9814 case GOP_FLIP_BY_ADDR:
9815 GOP_SwitchByAddr(pInstance,pflip->GwinId, pflip->FlipAddr, pflip->SubFlipAddr, pflip->WaitTagID, pflip->pQueueCnt, pflip->b3DEnable);
9816 break;
9817
9818 }
9819 return GOP_API_SUCCESS;
9820
9821 }
9822
Ioctl_GFlip_SwitchMultiGwin(void * pInstance,PGOP_GWIN_FLIP_MULTI_WIN_INFO pMultiflip)9823 MS_U32 Ioctl_GFlip_SwitchMultiGwin(void* pInstance,PGOP_GWIN_FLIP_MULTI_WIN_INFO pMultiflip)
9824 {
9825
9826
9827 GOP_MultiSwitchByAddr(pInstance,pMultiflip);
9828 return GOP_API_SUCCESS;
9829
9830 }
9831
9832
Ioctl_GOP_FBCreate(void * pInstance,EN_GOP_CREATEBUFFER_TYPE fbtype,PGOP_BUFFER_INFO pBuff,MS_U32 fbId)9833 MS_U32 Ioctl_GOP_FBCreate(void* pInstance,EN_GOP_CREATEBUFFER_TYPE fbtype,PGOP_BUFFER_INFO pBuff,MS_U32 fbId)
9834 {
9835
9836
9837 if(fbtype == GOP_CREATE_BUFFER)
9838 GOP_CreateBuffer(pInstance,pBuff,fbId);
9839 else if(fbtype == GOP_CREATE_BUFFER_BYADDR)
9840 GOP_CreateBufferByAddr(pInstance,pBuff,fbId);
9841
9842 return GOP_API_SUCCESS;
9843
9844 }
9845
9846
Ioctl_GOP_FBDestroy(void * pInstance,MS_U32 * pId)9847 MS_U32 Ioctl_GOP_FBDestroy(void* pInstance,MS_U32* pId)
9848 {
9849 GOP_WinFB_INFO* pwinFB;
9850 MS_U32 u32fbId;
9851
9852 u32fbId = *pId;
9853
9854 if (DRV_MAX_GWIN_FB_SUPPORT <= u32fbId)
9855 {
9856 msWarning(ERR_FB_ID_OUT_OF_RANGE);
9857 MS_DEBUG_MSG( GOP_M_ERR( "%s(u32fbId:%d....), fbId out of bound\n",__FUNCTION__, (ptrdiff_t)u32fbId) );
9858 return GWIN_NO_AVAILABLE;
9859
9860 }
9861 pwinFB = _GetWinFB(pInstance,u32fbId);
9862
9863 if(pwinFB == NULL)
9864 {
9865 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId);
9866 return GWIN_NO_AVAILABLE;
9867 }
9868
9869 if(0 == pwinFB->in_use)
9870 {
9871 msWarning(ERR_FB_ID_NOT_ALLOCATED);
9872 MS_DEBUG_MSG( GOP_M_ERR("[%s][%d]: u32fbId=%d is not in existence\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32fbId));
9873 return GWIN_NO_AVAILABLE;
9874
9875 }
9876
9877 GOP_FB_Destroy(pInstance,u32fbId);
9878
9879 return GWIN_OK;
9880
9881 }
9882
Ioctl_GOP_GetFBInfo(void * pInstance,MS_U32 u32fbId,PGOP_BUFFER_INFO pBuff)9883 MS_U32 Ioctl_GOP_GetFBInfo(void* pInstance,MS_U32 u32fbId, PGOP_BUFFER_INFO pBuff)
9884 {
9885 GOP_WinFB_INFO* pwinFB;
9886
9887
9888 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
9889 {
9890 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9891 return GOP_API_FAIL;
9892 }
9893
9894 pwinFB = _GetWinFB(pInstance,u32fbId);
9895
9896 if(pwinFB == NULL)
9897 {
9898 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9899 return GOP_API_FAIL;
9900 }
9901
9902 if(pwinFB->in_use ==0)
9903 {
9904 msWarning(ERR_FB_ID_NOT_ALLOCATED);
9905 GOP_M_ERR("[%s][%d]: u32fbId=%td is not in existence\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9906 return GOP_API_FAIL;
9907 }
9908
9909 pBuff->addr= pwinFB->addr;
9910 pBuff->fbFmt = pwinFB->fbFmt;
9911 pBuff->width = pwinFB->width;
9912 pBuff->height = pwinFB->height;
9913 pBuff->pitch = pwinFB->pitch;
9914 pBuff->disp_rect.x = pwinFB->x0;
9915 pBuff->disp_rect.w = pwinFB->x1 - pwinFB->x0;
9916 pBuff->disp_rect.y = pwinFB->y0;
9917 pBuff->disp_rect.h = pwinFB->y1 - pwinFB->y0;
9918
9919 return GOP_API_SUCCESS;
9920
9921 }
9922
Ioctl_GOP_SetFBInfo(void * pInstance,MS_U32 u32fbId,PGOP_BUFFER_INFO pBuff)9923 MS_U32 Ioctl_GOP_SetFBInfo(void* pInstance,MS_U32 u32fbId, PGOP_BUFFER_INFO pBuff)
9924 {
9925 GOP_WinFB_INFO* pwinFB;
9926
9927
9928 if (!_GOP_IsFbIdValid(pInstance,u32fbId))
9929 {
9930 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9931 return GOP_API_FAIL;
9932 }
9933 pwinFB = _GetWinFB(pInstance,u32fbId);
9934
9935 if(pwinFB == NULL)
9936 {
9937 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32fbId);
9938 return GOP_API_FAIL;
9939 }
9940
9941 pwinFB->enable = 1 ;
9942 pwinFB->gWinId = 0xFF ;
9943 pwinFB->fbFmt = pBuff->fbFmt ;
9944 pwinFB->width = pBuff->width ;
9945 pwinFB->height = pBuff->height ;
9946
9947 pwinFB->x0 = pBuff->disp_rect.x;
9948 pwinFB->x1 = pBuff->disp_rect.x + pBuff->disp_rect.w;
9949 pwinFB->y0 = pBuff->disp_rect.y ;
9950 pwinFB->y1 = pBuff->disp_rect.y + pBuff->disp_rect.h;
9951 pwinFB->s_x = 0;
9952 pwinFB->s_y = 0;
9953 pwinFB->dispWidth = pBuff->disp_rect.w ;
9954 pwinFB->dispHeight = pBuff->disp_rect.h;
9955
9956 if(pwinFB->in_use && GOP_WINFB_POOL_NULL== pwinFB->poolId)
9957 {
9958 pwinFB->addr = pBuff->addr ;
9959 pwinFB->size = pBuff->pitch * pBuff->height;
9960 pwinFB->pitch = pBuff->pitch ;
9961 }
9962
9963 return GOP_API_SUCCESS;
9964 }
9965
9966
GOP_TriggerRegWriteIn(void * pInstance,MS_U32 gop,MS_BOOL bForceWriteIn,MS_BOOL bSync)9967 MS_U32 GOP_TriggerRegWriteIn(void* pInstance,MS_U32 gop, MS_BOOL bForceWriteIn, MS_BOOL bSync)
9968 {
9969 #ifdef INSTANT_PRIVATE
9970 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9971 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9972 #endif
9973
9974 MDrv_GOP_TriggerRegWriteIn(g_pGOPCtxLocal, gop, bForceWriteIn, bSync);
9975 return GOP_API_SUCCESS;
9976
9977
9978 }
GOP_UpdateOnce(void * pInstance,MS_U32 gop,MS_BOOL bUpdateOnce,MS_BOOL bSync)9979 MS_U32 GOP_UpdateOnce(void* pInstance,MS_U32 gop, MS_BOOL bUpdateOnce, MS_BOOL bSync)
9980 {
9981 #ifdef INSTANT_PRIVATE
9982 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9983 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
9984 #endif
9985
9986 g_pGOPCtxLocal->bUpdateRegOnce[GOP_PUBLIC_UPDATE] = bUpdateOnce;
9987 if(bUpdateOnce == FALSE)
9988 {
9989 MDrv_GOP_GWIN_UpdateRegWithSync(g_pGOPCtxLocal, gop, bSync);
9990 }
9991 return GOP_API_SUCCESS;
9992
9993 }
9994
GOP_UpdateCurrentOnce(void * pInstance,MS_U16 u16GopMask,MS_BOOL bUpdateOnce,MS_BOOL bSync)9995 MS_U32 GOP_UpdateCurrentOnce(void* pInstance, MS_U16 u16GopMask, MS_BOOL bUpdateOnce, MS_BOOL bSync)
9996 {
9997 #ifdef INSTANT_PRIVATE
9998 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
9999 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10000 #endif
10001 MS_U16 u16GopIdx = 0;
10002 for (u16GopIdx = 0; u16GopIdx < MAX_GOP_SUPPORT; u16GopIdx++)
10003 {
10004 if ((u16GopMask & (1<<u16GopIdx)) != 0)
10005 {
10006 g_pGOPCtxLocal->bUpdateRegOnce[u16GopIdx] = bUpdateOnce;
10007 }
10008 }
10009 if(bUpdateOnce == FALSE)
10010 {
10011 MDrv_GOP_GWIN_UpdateRegWithMaskSync(g_pGOPCtxLocal, u16GopMask, bSync);
10012 }
10013 return GOP_API_SUCCESS;
10014
10015 }
10016
Ioctl_GOP_TriggerRegWriteIn(void * pInstance,MS_U32 gop,EN_GOP_UPDATE_TYPE update_type,MS_BOOL bEn,MS_BOOL bSync)10017 MS_U32 Ioctl_GOP_TriggerRegWriteIn(void* pInstance,MS_U32 gop, EN_GOP_UPDATE_TYPE update_type, MS_BOOL bEn, MS_BOOL bSync)
10018 {
10019
10020 #ifdef INSTANT_PRIVATE
10021 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10022 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10023 #endif
10024
10025 switch(update_type)
10026 {
10027 case E_GOP_UPDATE_FORCEWRITE:
10028 {
10029 GOP_TriggerRegWriteIn(pInstance,gop, bEn, bSync);
10030 break;
10031 }
10032 case E_GOP_UPDATE_CURRENT_ONCE:
10033 {
10034 GOP_UpdateCurrentOnce(pInstance, gop, bEn, bSync);
10035 break;
10036 }
10037 default:
10038 case E_GOP_UPDATE_ONCE:
10039 {
10040 GOP_UpdateOnce(pInstance,gop, bEn, bSync);
10041 break;
10042 }
10043
10044 }
10045
10046 return GOP_API_SUCCESS;
10047
10048 }
10049
10050
Ioctl_GOP_Select(void * pInstance,EN_GOP_SELECT_TYPE sel,MS_U32 id,MS_U32 * pSet)10051 MS_U32 Ioctl_GOP_Select(void* pInstance,EN_GOP_SELECT_TYPE sel, MS_U32 id, MS_U32* pSet)
10052 {
10053 #ifdef INSTANT_PRIVATE
10054 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10055 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10056 #endif
10057 DRV_GOP_CBFmtInfo* FmtInfo = (DRV_GOP_CBFmtInfo*)pSet;
10058
10059 switch(sel)
10060 {
10061 case EN_GOP_SEL_GOP:
10062 {
10063 if (!_GOP_IsGopNumValid(pInstance,id))
10064 {
10065 GOP_M_ERR("[%s][%d]GOP %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)id);
10066 return GOP_API_FAIL;
10067 }
10068 MDrv_GOP_Sel(g_pGOPCtxLocal, id);
10069 break;
10070 }
10071 case EN_GOP_SEL_GWIN:
10072 break;
10073 case EN_GOP_SEL_FB:
10074 {
10075 MS_U16 fbFmt;
10076 GOP_WinFB_INFO* pwinFB;
10077
10078 // printf("[%s] We DO NOT suggest to use this function\n",__FUNCTION__);
10079 // printf("[%s] Please use GFX MApi_GFX_SetDstBufferInfo() !!\n",__FUNCTION__);
10080
10081 if (!_GOP_IsFbIdValid(pInstance,id))
10082 {
10083 GOP_M_ERR("[%s][%d]FbId %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)id);
10084 return GOP_API_FAIL;
10085 }
10086 pwinFB = _GetWinFB(pInstance,id);
10087
10088 if(pwinFB == NULL)
10089 {
10090 GOP_M_ERR("[%s][%d]GetWinFB Fail : WrongFBID=%td\n",__FUNCTION__,__LINE__,(ptrdiff_t)id);
10091 return GOP_API_FAIL;
10092 }
10093
10094 if(0 == pwinFB->in_use)
10095 {
10096 msWarning(ERR_FB_ID_NOT_ALLOCATED);
10097 GOP_M_ERR("[%s][%d]: u32fbId=%td is not in existence\n",__FUNCTION__,__LINE__,(ptrdiff_t)id);
10098 return GOP_API_FAIL;
10099 }
10100
10101 fbFmt = pwinFB->fbFmt;
10102 if ( (pwinFB->fbFmt & 0xFF) == E_MS_FMT_ARGB1555 )
10103 fbFmt = E_MS_FMT_ARGB1555_DST | (E_MS_FMT_ARGB1555_DST << 8);
10104
10105 if(fpSetFBFmt != NULL)
10106 {
10107 fpSetFBFmt(pwinFB->pitch, pwinFB->addr,fbFmt);
10108 FmtInfo->u64Addr = pwinFB->addr;
10109 FmtInfo->u16Pitch = pwinFB->pitch;
10110 FmtInfo->u16Fmt = fbFmt;
10111 }
10112 else
10113 {
10114 FmtInfo->u64Addr = pwinFB->addr;
10115 FmtInfo->u16Pitch = pwinFB->pitch;
10116 FmtInfo->u16Fmt = fbFmt;
10117 }
10118 break;
10119 }
10120 }
10121
10122 return GOP_API_SUCCESS;
10123
10124 }
10125
Ioctl_GOP_Register_CB(void * pInstance,GOP_CB_TYPE cb_type,void * pCB,MS_U32 u32Size)10126 MS_U32 Ioctl_GOP_Register_CB(void* pInstance,GOP_CB_TYPE cb_type, void* pCB, MS_U32 u32Size)
10127 {
10128 #ifdef MSOS_TYPE_LINUX_KERNEL
10129
10130 #else
10131 switch(cb_type)
10132 {
10133 case GOP_CB_XC_INTERLACE:
10134 {
10135 _fpXCIsInterlace = pCB;
10136 break;
10137 }
10138 case GOP_CB_XC_REDUCE_BW:
10139 {
10140 fpXCReduceBWForOSD = pCB;
10141 break;
10142 }
10143 case GOP_CB_XC_PANEL_HSTART:
10144 {
10145 _fpXCGetCapHStart = pCB;
10146 break;
10147 }
10148 case GOP_CB_GFX_FBFMT:
10149 {
10150 fpSetFBFmt = pCB;
10151 break;
10152 }
10153 case GOP_CB_EVENT_NOTIFY:
10154 {
10155 fpEventNotify = pCB;
10156 break;
10157 }
10158 case GOP_CB_DWIN_INFO:
10159 {
10160 fpXCSetDwinInfo = pCB;
10161 break;
10162 }
10163 default:
10164 {
10165 GOP_M_ERR("[%s][%d] invalid input call back function type\n",__FUNCTION__,__LINE__);
10166 return GOP_API_INVALID_PARAMETERS;
10167 }
10168 }
10169 #endif
10170 return (GOP_API_SUCCESS);
10171 }
10172
10173
10174
10175
10176
Ioctl_GOP_Palette_EntrySet(void * pInstance,PGOP_PALETTE_ENTRY pClutEntry)10177 MS_U32 Ioctl_GOP_Palette_EntrySet(void* pInstance,PGOP_PALETTE_ENTRY pClutEntry)
10178 {
10179 #ifdef INSTANT_PRIVATE
10180 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10181 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10182 #endif
10183
10184 if(pClutEntry->palSrc == E_GOP_4G_PALETTE)
10185 {
10186 MDrv_GOP_GWIN_SetPaletteOpt(g_pGOPCtxLocal,pClutEntry->gop_idx, (DRV_GopPaletteEntry*)pClutEntry->pClut, pClutEntry->start, pClutEntry->end, E_DRV_GOP_PAL_ARGB8888);
10187 }
10188 else
10189 {
10190 MDrv_GOP_GWIN_2GSetPaletteOpt(g_pGOPCtxLocal,pClutEntry->gop_idx, (DRV_GopPaletteEntry*)pClutEntry->pClut, pClutEntry->start, pClutEntry->end);
10191 }
10192 return GOP_API_SUCCESS;
10193
10194 }
10195
Ioctl_GOP_Palette_EntryGet(void * pInstance,PGOP_PALETTE_ENTRY pClutEntry)10196 MS_U32 Ioctl_GOP_Palette_EntryGet(void* pInstance,PGOP_PALETTE_ENTRY pClutEntry)
10197 {
10198 MS_U32 i =0;
10199 MS_U32 PalVal=0;
10200 #ifdef INSTANT_PRIVATE
10201 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10202 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10203 #endif
10204
10205 if(pClutEntry->palSrc == E_GOP_4G_PALETTE)
10206 {
10207 for(i=pClutEntry->start; i< pClutEntry->end; i++)
10208 {
10209 MDrv_GOP_GWIN_ReadPalette(g_pGOPCtxLocal,pClutEntry->gop_idx, i, &PalVal);
10210 *pClutEntry->pClut = PalVal;
10211 }
10212 }
10213 else
10214 {
10215 for(i=pClutEntry->start; i< pClutEntry->end; i++)
10216 {
10217 MDrv_GOP_GWIN_2GReadPalette(g_pGOPCtxLocal,pClutEntry->gop_idx, i, &PalVal);
10218 }
10219 }
10220 return GOP_API_SUCCESS;
10221
10222 }
10223
10224
Ioctl_GOP_Palette_Set_Config(void * pInstance,MS_U32 gop,DRV_GopPalReadType type,EN_GOP_PALETTE src)10225 MS_U32 Ioctl_GOP_Palette_Set_Config(void* pInstance,MS_U32 gop, DRV_GopPalReadType type,EN_GOP_PALETTE src)
10226 {
10227 #ifdef INSTANT_PRIVATE
10228 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10229 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10230 #endif
10231
10232 if(src == E_GOP_4G_PALETTE)
10233 {
10234 MDrv_GOP_GWIN_SetPaletteRead(g_pGOPCtxLocal,gop, type);
10235 }
10236 else
10237 {
10238 MDrv_GOP_GWIN_2GSetPaletteRead(g_pGOPCtxLocal,gop, type);
10239 }
10240 return GOP_API_SUCCESS;
10241 }
10242
Ioctl_GOP_MISC(void * pInstance,EN_GOP_MISC_TYPE type,MS_U32 * pSet,MS_U32 u32Size)10243 MS_U32 Ioctl_GOP_MISC(void* pInstance,EN_GOP_MISC_TYPE type, MS_U32* pSet, MS_U32 u32Size)
10244 {
10245 #ifdef INSTANT_PRIVATE
10246 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10247 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10248 #endif
10249
10250 switch(type)
10251 {
10252 case E_GOP_MISC_ENABLE_T3D:
10253 {
10254 MS_BOOL bEn;
10255 if(u32Size != sizeof(MS_BOOL))
10256 {
10257 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10258 return GOP_API_FAIL;
10259 }
10260
10261 bEn = (MS_BOOL)*pSet;
10262 GOP_GWIN_EnableT3DMode(pInstance,bEn);
10263 break;
10264 }
10265 case E_GOP_MISC_SET_CAPTURE_CLK:
10266 {
10267 if(u32Size != sizeof(MS_U32))
10268 {
10269 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10270 return GOP_API_FAIL;
10271 }
10272 MDrv_GOP_SetClkForCapture(g_pGOPCtxLocal, GOP_DRV_DWIN_SRC_OP);
10273 break;
10274 }
10275 case E_GOP_MISC_POWER_OFF:
10276 {
10277 if(u32Size != sizeof(MS_U32))
10278 {
10279 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10280 return GOP_API_FAIL;
10281 }
10282 GOP_PowerOff(pInstance);
10283 break;
10284 }
10285 case E_GOP_MISC_POWER_ON:
10286 {
10287 if(u32Size != sizeof(MS_U32))
10288 {
10289 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10290 return GOP_API_FAIL;
10291 }
10292 GOP_PowerOn(pInstance);
10293 break;
10294 }
10295 case E_GOP_MISC_GET_RT_STATUS:
10296 {
10297 if(u32Size != sizeof(GOP_ApiStatus))
10298 {
10299 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10300 return GOP_API_FAIL;
10301 }
10302 GOP_ApiStatus *pGopApiSts = (GOP_ApiStatus *)pSet;
10303 GOP_GetRTStatus(pInstance,pGopApiSts);
10304 break;
10305 }
10306 case E_GOP_MISC_GET_INFO:
10307 {
10308 if(u32Size != sizeof(GOP_ApiInfo))
10309 {
10310 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10311 return GOP_API_FAIL;
10312 }
10313 GOP_ApiInfo *pGopApiInfo = (GOP_ApiInfo *)pSet;
10314 GOP_GetInfo(pInstance,pGopApiInfo);
10315 break;
10316 }
10317 case E_GOP_MISC_AT_EXIT:
10318 {
10319 if(u32Size != sizeof(MS_U32))
10320 {
10321 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10322 return GOP_API_FAIL;
10323 }
10324 Ioctl_GOP_AtExit(pInstance);
10325 break;
10326 }
10327 case E_GOP_MISC_OC_FB_INFO:
10328 {
10329 if(u32Size != sizeof(GOP_OC_FB_INFO))
10330 {
10331 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10332 return GOP_API_FAIL;
10333 }
10334 PGOP_OC_FB_INFO pOCFbInfo = (PGOP_OC_FB_INFO)(void*)pSet;
10335 GOP_OC_SetOCFBinfo(pInstance,pOCFbInfo->u64Addr,pOCFbInfo->BankMode,pOCFbInfo->enBufSize);
10336 break;
10337 }
10338 case E_GOP_MISC_TESTPATTERN_ALPHA:
10339 {
10340 MS_BOOL bEn;
10341 if(u32Size != sizeof(MS_BOOL))
10342 {
10343 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10344 return GOP_API_FAIL;
10345 }
10346
10347 bEn = (MS_BOOL)*pSet;
10348 GOP_TestPatternAlpha_Enable(pInstance,bEn);
10349 break;
10350 }
10351 case E_GOP_MISC_DELETE_GWINSIZE:
10352 {
10353 if(u32Size != sizeof(GOP_DeleteWinSize_PARAM))
10354 {
10355 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10356 return GOP_API_FAIL;
10357 }
10358
10359 GOP_DeleteWinSize_PARAM* gop_VaildSize = (GOP_DeleteWinSize_PARAM*)pSet;
10360 MDrv_GOP_GWIN_DeleteWinHVSize(g_pGOPCtxLocal, gop_VaildSize->u32GOP_idx, gop_VaildSize->u32HSize, gop_VaildSize->u32VSize);
10361 break;
10362 }
10363 case E_GOP_MISC_SET_DBG_LEVEL:
10364 {
10365 if(u32Size != sizeof(MS_U32))
10366 {
10367 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10368 return GOP_API_FAIL;
10369 }
10370 u32GOPDbgLevel_mapi= (MS_U32)*pSet;
10371 MDrv_GOP_SetDbgLevel(*pSet);
10372 break;
10373 }
10374 }
10375 return GOP_API_SUCCESS;
10376 }
10377
Ioctl_GOP_PowerState(void * pInstance,MS_U32 u32PowerState,void * pModule)10378 MS_U32 Ioctl_GOP_PowerState(void* pInstance,MS_U32 u32PowerState, void* pModule)
10379 {
10380 static MS_U16 u16ActWin = 0;
10381
10382 MS_U8 i=0;
10383 MS_U32 u32Return = GOP_API_FAIL;
10384 MS_U8 u8GwinIdx = INVALID_GWIN_ID;
10385 MS_U16 u16WinNum = 0;
10386
10387 GOP_CTX_DRV_SHARED* pDrvGOPShared=NULL;
10388 MS_BOOL bNeedInitShared = FALSE;
10389 #ifdef INSTANT_PRIVATE
10390 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10391 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10392 #endif
10393
10394 GOP_M_INFO("[%s][%d] IoctlGOP STR PowerState=%tx\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32PowerState);
10395
10396 pDrvGOPShared = (GOP_CTX_DRV_SHARED*)MDrv_GOP_GetShareMemory(&bNeedInitShared);
10397
10398 if(pDrvGOPShared->apiCtxShared.bEnableVsyncIntFlip ==FALSE)//Usr RedLine:GFLIP Suspend/Resume
10399 {
10400 switch(u32PowerState)
10401 {
10402 case E_POWER_SUSPEND:
10403 GOP_M_INFO("[%s][%d] IoctlGOP STR Suspend Start!!!!!\n",__FUNCTION__,__LINE__);
10404 MDrv_GOP_GWIN_PowerState(pInstance, u32PowerState, pModule);
10405 GOP_M_INFO("[%s][%d] IoctlGOP STR Suspend End!!!!!\n",__FUNCTION__,__LINE__);
10406 u32Return=GOP_API_SUCCESS;
10407 break;
10408 case E_POWER_RESUME:
10409 GOP_M_INFO("[%s][%d] IoctlGOP Resume Start!!!!!\n",__FUNCTION__,__LINE__);
10410 MDrv_GOP_GWIN_PowerState(pInstance, u32PowerState, pModule);
10411 GOP_M_INFO("[%s][%d] IoctlGOP STR Resume End!!!!!\n",__FUNCTION__,__LINE__);
10412 u32Return=GOP_API_SUCCESS;
10413 break;
10414 default:
10415 GOP_M_ERR("[%s][%d] PowerState:%tx not Implement now!!!\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32PowerState);
10416 break;
10417 }
10418 }
10419 else//Kernel RedLine:GFLIP Suspend/Resume
10420 {
10421 u16WinNum = (MS_U8)g_pGOPCtxLocal->pGopChipProperty->TotalGwinNum;
10422
10423 switch(u32PowerState)
10424 {
10425 case E_POWER_SUSPEND:
10426 {
10427 for(i = 0; i < u16WinNum ; i++)
10428 {
10429 if(GOP_GWIN_IsEnable(pInstance,i) == TRUE)
10430 {
10431 u16ActWin |= 1<<i;
10432 GOP_GWIN_SetEnable(pInstance,i, FALSE);
10433 }
10434 }
10435
10436 }
10437 break;
10438 case E_POWER_RESUME:
10439 {
10440 if (u16ActWin != INVALID_GWIN_ID)
10441 {
10442 for (u8GwinIdx = 0; u8GwinIdx < u16WinNum; u8GwinIdx++)
10443 {
10444 if (0 != (u16ActWin & (1<<u8GwinIdx)))
10445 {
10446 GOP_GWIN_SetEnable(pInstance,u8GwinIdx, TRUE);
10447 GOP_GWIN_SetForceWrite(pInstance,TRUE);
10448 GOP_GWIN_SetForceWrite(pInstance,FALSE);
10449 }
10450 }
10451 }
10452 else
10453 {
10454 GOP_M_INFO("[%s] Error!!! Need suspend first!!!\n",__FUNCTION__);
10455 }
10456 u16ActWin = 0;
10457 }
10458 break;
10459 default:
10460 GOP_M_ERR("[%s][%d] PowerState:%tx not Implement now!!!\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32PowerState);
10461 break;
10462 }
10463 u32Return=GOP_API_SUCCESS;
10464 }
10465
10466 return u32Return;
10467 }
10468
Ioctl_GOP_PINPON(void * pInstance,EN_GOP_PINPON_PROPERTY en_pro,MS_U32 * pSet,MS_U32 u32Size)10469 MS_U32 Ioctl_GOP_PINPON(void* pInstance,EN_GOP_PINPON_PROPERTY en_pro, MS_U32* pSet, MS_U32 u32Size)
10470 {
10471 #ifdef INSTANT_PRIVATE
10472 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10473 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10474 #endif
10475 switch(en_pro)
10476 {
10477 case E_GOP_SET_PINPON:
10478 {
10479 if(u32Size != sizeof(GOP_SET_PINPON_INFO))
10480 {
10481 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10482 return GOP_API_FAIL;
10483 }
10484 PGOP_SET_PINPON_INFO pPINPONInfo = (PGOP_SET_PINPON_INFO)pSet;
10485
10486 MS_U8 u8GOP;
10487 MS_U8 u8FirstGwinByGOP;
10488
10489 u8GOP = MDrv_DumpGopByGwinId(g_pGOPCtxLocal, pPINPONInfo->GwinId);
10490 u8FirstGwinByGOP = MDrv_GOP_SelGwinIdByGOP(g_pGOPCtxLocal, u8GOP, 0);
10491
10492 //check it is the first gwin on this GOP
10493 if(pPINPONInfo->GwinId != u8FirstGwinByGOP)
10494 {
10495 GOP_M_ERR("[%s][%d] gwin:%d PINPON mode only support the first gwin on GOP:%d\n",__FUNCTION__,__LINE__,pPINPONInfo->GwinId,u8GOP);
10496 return GOP_API_FAIL;
10497 }
10498
10499 MDrv_GOP_Set_PINPON(g_pGOPCtxLocal, u8GOP, pPINPONInfo->bEnable, pPINPONInfo->mode);
10500 break;
10501 }
10502 }
10503 return GOP_API_SUCCESS;
10504 }
10505
Ioctl_GOP_Fade(void * pInstance,EN_GOP_FADE_SET_TYPE type,MS_U32 * pSet,MS_U32 u32Size)10506 MS_U32 Ioctl_GOP_Fade(void* pInstance,EN_GOP_FADE_SET_TYPE type, MS_U32* pSet, MS_U32 u32Size)
10507 {
10508 #ifdef INSTANT_PRIVATE
10509 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10510 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10511 #endif
10512 E_GOP_API_Result ret = GOP_API_FAIL;
10513 switch(type)
10514 {
10515 case E_GOP_FADE_CONFIG:
10516 {
10517 if(u32Size != sizeof(GOP_FADE_INFO))
10518 {
10519 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10520 return GOP_API_FAIL;
10521 }
10522 PGOP_FADE_INFO pFadeInfo = (PGOP_FADE_INFO)pSet;
10523 if (!_GOP_IsGwinIdValid(pInstance,pFadeInfo->gwin_idx))
10524 {
10525 GOP_M_ERR("[%s][%d] GWIN %td is out of range\n",__FUNCTION__,__LINE__,(ptrdiff_t)pFadeInfo->gwin_idx);
10526 return GOP_API_FAIL;
10527 }
10528 if ( (pFadeInfo->eGwinFadeType!=E_GOP_GWIN_FADE_TYPE_IN) && (pFadeInfo->eGwinFadeType!=E_GOP_GWIN_FADE_TYPE_OUT))
10529 {
10530 APIGOP_ASSERT(FALSE, GOP_M_FATAL("\n[%s][%d] unknow gop fade type", __FUNCTION__,__LINE__));
10531 return GOP_API_FAIL;
10532 }
10533
10534 ret= (E_GOP_API_Result)MDrv_GOP_GWIN_SetFadeInOut(g_pGOPCtxLocal, pFadeInfo->gwin_idx, (DRV_GOP_FADE_TYPE)pFadeInfo->eGwinFadeType, pFadeInfo->bEnable, pFadeInfo->u8FadeRate);
10535 break;
10536 }
10537 }
10538 return ret;
10539 }
10540
10541
Ioctl_GOP_Scroll(void * pInstance,EN_GOP_SCROLL_TYPE type,MS_U32 * pSet,MS_U32 u32Size)10542 MS_U32 Ioctl_GOP_Scroll(void* pInstance,EN_GOP_SCROLL_TYPE type, MS_U32* pSet, MS_U32 u32Size)
10543 {
10544 #ifdef INSTANT_PRIVATE
10545 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10546 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10547 #endif
10548
10549 switch(type)
10550 {
10551 case E_GOP_SCROLL_CONFIG:
10552 {
10553 if(u32Size != sizeof(GOP_SCROLL_INFO))
10554 {
10555 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10556 return GOP_API_FAIL;
10557 }
10558 PGOP_SCROLL_INFO pScrollInfo = (PGOP_SCROLL_INFO)pSet;
10559 if (pScrollInfo->type == E_GOP_SCROLL_DOWN || pScrollInfo->type == E_GOP_SCROLL_UP)
10560 {
10561 MDrv_GOP_GWIN_SetVScroll(g_pGOPCtxLocal, pScrollInfo->u8WinId, (E_GOP_SCROLL_TYPE)pScrollInfo->type, (MS_U32)pScrollInfo->u16Offset, pScrollInfo->bEnable);
10562 }
10563 else
10564 {
10565 MDrv_GOP_GWIN_SetHScroll(g_pGOPCtxLocal,pScrollInfo->u8WinId, (E_GOP_SCROLL_TYPE)pScrollInfo->type, (MS_U32)pScrollInfo->u16Offset, pScrollInfo->bEnable);
10566 }
10567 break;
10568 }
10569 case E_GOP_SCROLL_RATE:
10570 {
10571 MS_U8 u8rate;
10572 if(u32Size != sizeof(MS_U8))
10573 {
10574 GOP_M_ERR("[%s][%d] size ERROR!! \n",__FUNCTION__,__LINE__);
10575 return GOP_API_FAIL;
10576 }
10577
10578 u8rate = (MS_U8)*pSet;
10579 MDrv_GOP_GWIN_SetScrollRate(g_pGOPCtxLocal, u8rate);
10580 break;
10581 }
10582 }
10583 return GOP_API_SUCCESS;
10584 }
10585
Ioctl_GOP_Interrupt(void * pInstance,MS_U8 u8Gop,MS_BOOL bEnable)10586 static int Ioctl_GOP_Interrupt(void* pInstance,MS_U8 u8Gop,MS_BOOL bEnable)
10587 {
10588 #ifdef INSTANT_PRIVATE
10589 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10590 UtopiaInstanceGetPrivate(pInstance, (void*)&psGOPInstPri);
10591 #endif
10592
10593 MDrv_GOP_GWIN_Interrupt(g_pGOPCtxLocal,u8Gop,bEnable);
10594 return GOP_API_SUCCESS;
10595 }
10596
Ioctl_GOP_AtExit(void * pInstance)10597 void Ioctl_GOP_AtExit(void* pInstance)
10598 {
10599 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10600 GOP_AtExit(pInstance);
10601 #else
10602 GOP_M_INFO("not enable MSOS_TYPE_LINUX\n");
10603 #endif
10604 }
10605
10606 #ifdef MSOS_TYPE_LINUX_KERNEL
GOPStr(MS_U32 u32PowerState,void * pModule)10607 MS_U32 GOPStr(MS_U32 u32PowerState, void* pModule)
10608 {
10609 MS_U32 u32Return=UTOPIA_STATUS_FAIL;
10610
10611 #if(GFLIP_ENABLE==FALSE)
10612 switch(u32PowerState)
10613 {
10614 case E_POWER_SUSPEND:
10615 GOP_M_INFO("[%s][%d] Kernel STR Suspend Start!!!!!\n",__FUNCTION__,__LINE__);
10616 MDrv_GOP_GWIN_PowerState(NULL, u32PowerState, pModule);
10617 GOP_M_INFO("[%s][%d] Kernel STR Suspend End!!!!!\n",__FUNCTION__,__LINE__);
10618 u32Return=UTOPIA_STATUS_SUCCESS;
10619 break;
10620 case E_POWER_RESUME:
10621 GOP_M_INFO("[%s][%d] Kernel STR Resume Start!!!!!\n",__FUNCTION__,__LINE__);
10622 MDrv_GOP_GWIN_PowerState(NULL, u32PowerState, pModule);
10623 GOP_M_INFO("[%s][%d] Kernel STR Resume End!!!!!\n",__FUNCTION__,__LINE__);
10624 u32Return=UTOPIA_STATUS_SUCCESS;
10625 break;
10626 default:
10627 GOP_M_ERR("[%s][%d] PowerState:%x not Implement now!!!\n",__FUNCTION__,__LINE__,u32PowerState);
10628 break;
10629 }
10630 #else
10631 //Kernel RedLine:GFLIP Suspend/Resume
10632 u32Return=UTOPIA_STATUS_SUCCESS;
10633 #endif
10634 return u32Return;
10635 }
10636 #endif
10637
10638 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
GOPMdbIoctl(MS_U32 u32Cmd,const void * const pArgs)10639 MS_U32 GOPMdbIoctl(MS_U32 u32Cmd, const void* const pArgs)
10640 {
10641 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
10642 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
10643 void* pInstance = NULL;
10644 pInstance = UtopiaModuleGetLocalInstantList(MODULE_GOP, pInstance);
10645
10646 switch(u32Cmd)
10647 {
10648 case MDBCMD_CMDLINE:
10649 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
10650 //MdbPrint(paraCmdLine->u64ReqHdl,"LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
10651 //MdbPrint(paraCmdLine->u64ReqHdl,"u32CmdSize: %d\n", paraCmdLine->u32CmdSize);
10652 //MdbPrint(paraCmdLine->u64ReqHdl,"pcCmdLine: %s\n", paraCmdLine->pcCmdLine);
10653 MDrv_GOP_MDCMD_EchoCmd(pInstance, paraCmdLine->u64ReqHdl, paraCmdLine->pcCmdLine);
10654 paraCmdLine->result = MDBRESULT_SUCCESS_FIN;
10655 break;
10656 case MDBCMD_GETINFO:
10657 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
10658 MDrv_GOP_MDCMD_GETINFO(pInstance, paraGetInfo->u64ReqHdl);
10659 paraGetInfo->result = MDBRESULT_SUCCESS_FIN;
10660 break;
10661 default:
10662 break;
10663 }
10664 return 0;
10665 }
10666 #endif
10667
10668 // this func will be call to init by utopia20 framework
GOPRegisterToUtopia(void)10669 void GOPRegisterToUtopia(void)
10670 {
10671 // 1. deal with module
10672 void* pUtopiaModule = NULL;
10673 UtopiaModuleCreate(MODULE_GOP, 8, &pUtopiaModule);
10674 UtopiaModuleRegister(pUtopiaModule);
10675 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
10676 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)GOPOpen, (FUtopiaClose)GOPClose, (FUtopiaIOctl)GOPIoctl);
10677 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
10678 UtopiaModuleRegisterMdbNode("gop", (FUtopiaMdbIoctl)GOPMdbIoctl);
10679 #endif
10680 #if defined(MSOS_TYPE_LINUX_KERNEL)
10681 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule, (FUtopiaSTR)GOPStr);
10682 UtopiaModuleSetSTRPrivate(pUtopiaModule, sizeof(GFLIP_REGS_SAVE_AREA));
10683 #endif
10684
10685 // 2. deal with resource
10686 void* psResource = NULL;
10687 // start func to add res, call once will create 2 access in resource. Also can declare BDMA_POOL_ID_BDMA1 for another channel depend on driver owner.
10688 UtopiaModuleAddResourceStart(pUtopiaModule, GOP_POOL_ID_GOP0);
10689 // resource can alloc private for internal use, ex, BDMA_RESOURCE_PRIVATE
10690 UtopiaResourceCreate("gop0", sizeof(GOP_RESOURCE_PRIVATE), &psResource);
10691 // func to reg res
10692 UtopiaResourceRegister(pUtopiaModule, psResource, GOP_POOL_ID_GOP0);
10693
10694 UtopiaModuleAddResourceEnd(pUtopiaModule, GOP_POOL_ID_GOP0);
10695
10696
10697 }
10698
GOPOpen(void ** ppInstance,const void * const pAttribute)10699 MS_U32 GOPOpen(void** ppInstance, const void* const pAttribute)
10700 {
10701 GOP_INSTANT_PRIVATE *pGopPri = NULL;
10702 GOP_M_INFO("\n[GOP INFO] gop open\n");
10703 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__));
10704 // instance is allocated here, also can allocate private for internal use, ex, BDMA_INSTANT_PRIVATE
10705 UtopiaInstanceCreate(sizeof(GOP_INSTANT_PRIVATE), ppInstance);
10706 // setup func in private and assign the calling func in func ptr in instance private
10707 UtopiaInstanceGetPrivate(*ppInstance, (void**)&pGopPri);
10708
10709 #ifdef MSOS_TYPE_LINUX_KERNEL
10710 #if GFLIP_ENABLE
10711 extern MS_U32 MDrv_GFLIP_InitTimer(void);
10712 if(_devGFLIPCnt==0)
10713 {
10714 MDrv_GFLIP_InitTimer();
10715 }
10716 _devGFLIPCnt++;
10717 #endif
10718 #endif
10719 return UTOPIA_STATUS_SUCCESS;
10720 }
10721
GOPIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)10722 MS_U32 GOPIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
10723 {
10724 void* pModule = NULL;
10725 UtopiaInstanceGetModule(pInstance, &pModule);
10726 MS_U32 u32Ret = GOP_API_SUCCESS;
10727 GOP_INSTANT_PRIVATE* psGOPInstPri = NULL;
10728 MS_BOOL bLocked = FALSE;
10729 UtopiaInstanceGetPrivate(pInstance, (void**)&psGOPInstPri);
10730
10731 if(u32Cmd == MAPI_CMD_GOP_RESETPOOL)
10732 {
10733 GOP_CTX_DRV_SHARED* pDrvGOPShared=NULL;
10734 MS_BOOL bNeedInitShared = FALSE;
10735 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10736 pDrvGOPShared = (GOP_CTX_DRV_SHARED*)(void*)MDrv_GOP_GetShareMemory(&bNeedInitShared);
10737 if(pDrvGOPShared == NULL)
10738 {
10739 GOP_M_ERR("[%s] [%d] Shm pointer is NULL!!!! \n",__FUNCTION__,__LINE__);
10740 return UTOPIA_STATUS_FAIL;
10741 }
10742 if((pDrvGOPShared->apiCtxShared.GOPLockPid != 0))
10743 {
10744 #if defined(MSOS_TYPE_LINUX)
10745 if (kill(pDrvGOPShared->apiCtxShared.GOPLockPid, 0) == ESRCH)
10746 #endif
10747 {
10748 GOP_M_INFO("[%s] [%d] apiCtxShared.GOPLockPid 0x%tx not existance!!! \n",__FUNCTION__,__LINE__, (ptrdiff_t)pDrvGOPShared->apiCtxShared.GOPLockPid);
10749 UtopiaModuleResetPool(pModule,GOP_POOL_ID_GOP0);
10750 }
10751 }
10752 #endif
10753 return UTOPIA_STATUS_SUCCESS;
10754 }
10755
10756 if( (u32Cmd != MAPI_CMD_GOP_INTERRUPT) && (u32Cmd != MAPI_CMD_GOP_MUTEX) && (g_pGOPCtxLocal != NULL) && (g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid != MsOS_GetOSThreadID()) )
10757 {
10758 if(UtopiaResourceObtain(pModule, GOP_POOL_ID_GOP0, &(psGOPInstPri->pResource)) != 0)
10759 {
10760 GOP_M_ERR("[%s %d]UtopiaResourceObtainToInstant fail\n",__FUNCTION__,__LINE__);
10761 return 0xFFFFFFFF;
10762 }
10763 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10764 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = (GETPIDTYPE)getpid();
10765 #endif
10766 bLocked=TRUE;
10767 }
10768 //printf("[%s] cmd:%lx\n",__FUNCTION__,u32Cmd);
10769
10770 switch(u32Cmd)
10771 {
10772 case MAPI_CMD_GOP_INIT:
10773 {
10774 PGOP_INIT_PARAM ptr = (PGOP_INIT_PARAM)pArgs;
10775
10776 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
10777 if(ptr->u32Size != sizeof(GOP_InitInfo))
10778 {
10779 GOP_M_INFO("[%s][%d] input structure size non match!! (input:%tx require:%tx\n",__FUNCTION__,__LINE__,(ptrdiff_t)ptr->u32Size, sizeof(GOP_INIT_PARAM));
10780 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
10781 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10782 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
10783 #endif
10784 UtopiaResourceRelease(psGOPInstPri->pResource);
10785 return UTOPIA_STATUS_PARAMETER_ERROR;
10786 }
10787 #endif
10788 u32Ret = Ioctl_GOP_Init(pInstance,ptr->gop_idx,(GOP_InitInfo*)(void*)ptr->pInfo);
10789
10790 break;
10791 }
10792 case MAPI_CMD_GOP_GET_CHIPCAPS:
10793 {
10794 PGOP_GETCAPS_PARAM ptr = (PGOP_GETCAPS_PARAM)pArgs;
10795
10796 u32Ret = Ioctl_GOP_GetCaps(pInstance,(EN_GOP_CAPS)ptr->caps,ptr->pInfo,ptr->u32Size);
10797
10798 break;
10799 }
10800 case MAPI_CMD_GOP_SET_CONFIG:
10801 {
10802 PGOP_SETCONFIG_PARAM ptr = (PGOP_SETCONFIG_PARAM)pArgs;
10803 u32Ret = Ioctl_GOP_SetConfig(pInstance,ptr->cfg_type, ptr->pCfg, ptr->u32Size);
10804 break;
10805
10806 }
10807 case MAPI_CMD_GOP_GET_CONFIG:
10808 {
10809 PGOP_SETCONFIG_PARAM ptr = (PGOP_SETCONFIG_PARAM)pArgs;
10810 u32Ret = Ioctl_GOP_GetConfig(pInstance,ptr->cfg_type, ptr->pCfg, ptr->u32Size);
10811 break;
10812 }
10813 case MAPI_CMD_GOP_SET_PROPERTY:
10814 {
10815 PGOP_SET_PROPERTY_PARAM ptr = (PGOP_SET_PROPERTY_PARAM)pArgs;
10816
10817
10818 u32Ret = Ioctl_GOP_SetProperty(pInstance,ptr->en_pro ,ptr->gop_idx, ptr->pSetting,ptr->u32Size);
10819
10820 break;
10821 }
10822 case MAPI_CMD_GOP_GET_PROPERTY:
10823 {
10824 PGOP_SET_PROPERTY_PARAM ptr = (PGOP_SET_PROPERTY_PARAM)pArgs;
10825
10826
10827 u32Ret = Ioctl_GOP_GetProperty(pInstance,ptr->en_pro ,ptr->gop_idx, ptr->pSetting,ptr->u32Size);
10828
10829 break;
10830 }
10831 case MAPI_CMD_GOP_SET_DST:
10832 {
10833 PGOP_SETDST_PARAM ptr = (PGOP_SETDST_PARAM)pArgs;
10834
10835 u32Ret = Ioctl_GOP_SetDst(pInstance,ptr->gop_idx, ptr->en_dst);
10836 break;
10837 }
10838 case MAPI_CMD_GOP_GET_DST:
10839 {
10840 PGOP_GETDST_PARAM ptr = (PGOP_GETDST_PARAM)pArgs;
10841 if(ptr->u32Size != sizeof(EN_GOP_DST_TYPE))
10842 {
10843 GOP_M_INFO("[%s][%d] Cmd:%td input structure size non match!! (input:0x%tx require:0x%tx\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32Cmd,(ptrdiff_t)ptr->u32Size, sizeof(EN_GOP_DST_TYPE));
10844 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
10845 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10846 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
10847 #endif
10848 UtopiaResourceRelease(psGOPInstPri->pResource);
10849 return UTOPIA_STATUS_PARAMETER_ERROR;
10850 }
10851
10852 u32Ret = Ioctl_GOP_GetDst(pInstance,ptr->gop_idx, ptr->pDst);
10853 break;
10854 }
10855 case MAPI_CMD_GOP_SET_MUX:
10856 {
10857 PGOP_SETMUX_PARAM ptr = (PGOP_SETMUX_PARAM)pArgs;
10858 //PGOP_MuxConfig pMux = (PGOP_MuxConfig)ptr->pMuxInfo;
10859 PGOP_SETMUX pMux = (PGOP_SETMUX)ptr->pMuxInfo;
10860 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
10861 if(ptr->u32Size != sizeof(GOP_SETMUX))
10862 {
10863 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
10864 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10865 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
10866 #endif
10867 UtopiaResourceRelease(psGOPInstPri->pResource);
10868 return UTOPIA_STATUS_PARAMETER_ERROR;
10869 }
10870 #endif
10871 u32Ret = Ioctl_GOP_SetMux(pInstance,pMux, ptr->u32Size);
10872 break;
10873 }
10874 case MAPI_CMD_GOP_SET_LAYER:
10875 {
10876 PGOP_SETLAYER_PARAM ptr = (PGOP_SETLAYER_PARAM)pArgs;
10877 PGOP_SETLayer pLayer = (PGOP_SETLayer)ptr->pLayerInfo;
10878 MS_U16 i = 0;
10879 Gop_MuxSel enMux = E_GOP_MUX_INVAILD;
10880 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
10881 if(ptr->u32Size != sizeof(GOP_SETLayer))
10882 {
10883 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
10884 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10885 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
10886 #endif
10887 UtopiaResourceRelease(psGOPInstPri->pResource);
10888 return UTOPIA_STATUS_PARAMETER_ERROR;
10889 }
10890 #endif
10891 if(g_pGOPCtxLocal == NULL)
10892 {
10893 return UTOPIA_STATUS_FAIL;
10894 }
10895 for (i = 0; i < pLayer->u32LayerCount; i++)
10896 {
10897 MDrv_GOP_MapLayer2Mux(g_pGOPCtxLocal, pLayer->u32Layer[i], pLayer->u32Gop[i], (MS_U32 *)&enMux);
10898 MDrv_GOP_GWIN_SetMux(g_pGOPCtxLocal, pLayer->u32Gop[i], enMux);
10899 if (g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[pLayer->u32Gop[i]])
10900 {
10901 _GOP_InitHSPDByGOP(pInstance, pLayer->u32Gop[i]);
10902 }
10903 }
10904 break;
10905 }
10906
10907 case MAPI_CMD_GOP_GET_LAYER:
10908 {
10909 PGOP_SETLAYER_PARAM ptr = (PGOP_SETLAYER_PARAM)pArgs;
10910 PGOP_SETLayer pLayer = (PGOP_SETLayer)ptr->pLayerInfo;
10911 MS_U16 i = 0;
10912 DRV_GOPDstType enDst[MAX_GOP_SUPPORT] = {E_DRV_GOP_DST_INVALID};
10913 MS_BOOL bHasOP0 = FALSE;
10914 MS_BOOL bHasDualOP0 = FALSE;
10915 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
10916 if(ptr->u32Size != sizeof(GOP_SETLayer))
10917 {
10918 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
10919 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
10920 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
10921 #endif
10922 UtopiaResourceRelease(psGOPInstPri->pResource);
10923 return UTOPIA_STATUS_PARAMETER_ERROR;
10924 }
10925 #endif
10926 //get all gop dst
10927 for (i = 0; i < MAX_GOP_SUPPORT; i++)
10928 {
10929 enDst[i] = E_DRV_GOP_DST_INVALID;
10930 if (g_pGOPCtxLocal->pGOPCtxShared->bGopHasInitialized[i])
10931 {
10932 MDrv_GOP_GWIN_GetDstPlane(g_pGOPCtxLocal, i, &enDst[i]);
10933 }
10934 }
10935
10936 pLayer->u32LayerCount = 0;
10937 // record all gop
10938 for (i = 0; i < MAX_GOP_SUPPORT; i++)
10939 {
10940 switch (enDst[i])
10941 {
10942 case E_DRV_GOP_DST_OP0:
10943 {
10944 if (!bHasOP0)
10945 {
10946 MS_U32 u32Layer = 0;
10947 // record all op gop
10948 for (u32Layer = 0; u32Layer < MAX_GOP_MUX_OPNum; u32Layer++)
10949 {
10950 MS_U8 u8Gop = 0;
10951 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8Gop, g_pGOPCtxLocal->pGopChipProperty->GOP_MapLayer2Mux[u32Layer]);
10952 if ((u8Gop < MAX_GOP_SUPPORT) && (enDst[u8Gop] == E_DRV_GOP_DST_OP0))
10953 {
10954 pLayer->u32Gop[pLayer->u32LayerCount] = u8Gop;
10955 pLayer->u32Layer[pLayer->u32LayerCount] = u32Layer;
10956 pLayer->u32LayerCount++;
10957 }
10958 }
10959 bHasOP0 = TRUE;
10960 }
10961 break;
10962 }
10963 case E_DRV_GOP_DST_OP_DUAL_RATE:
10964 if (!bHasDualOP0)
10965 {
10966 MS_U32 u32Layer = 0;
10967
10968 for (u32Layer = 0; u32Layer < MAX_GOP_DualMUX_Num; u32Layer++)
10969 {
10970 MS_U8 u8Gop = 0;
10971 MDrv_GOP_GWIN_GetMux(g_pGOPCtxLocal, &u8Gop, g_pGOPCtxLocal->pGopChipProperty->GOP_MapLayer2DualOpMux[u32Layer]);
10972 if ((u8Gop < MAX_GOP_SUPPORT) && (enDst[u8Gop] == E_DRV_GOP_DST_OP_DUAL_RATE))
10973 {
10974 pLayer->u32Gop[pLayer->u32LayerCount] = u8Gop;
10975 pLayer->u32Layer[pLayer->u32LayerCount] = u32Layer;
10976 pLayer->u32LayerCount++;
10977 }
10978 }
10979 bHasDualOP0 = TRUE;
10980 }
10981 break;
10982 default:
10983 break;
10984
10985 }
10986 }
10987 break;
10988 }
10989
10990 case MAPI_CMD_GOP_SET_MIRROR:
10991 {
10992 PGOP_SETMIRROR_PARAM ptr = (PGOP_SETMIRROR_PARAM)pArgs;
10993 u32Ret = Ioctl_GOP_SetMirror(pInstance,ptr->gop_idx, ptr->dir);
10994
10995 break;
10996 }
10997 case MAPI_CMD_GOP_GET_MIRROR:
10998 {
10999 PGOP_GETMIRROR_PARAM ptr = (PGOP_GETMIRROR_PARAM)pArgs;
11000 u32Ret = Ioctl_GOP_GetMirror(pInstance,ptr->gop_idx, ptr->pdir);
11001
11002 break;
11003 }
11004 case MAPI_CMD_GOP_GET_STATUS:
11005 {
11006 PGOP_GET_STATUS_PARAM ptr = (PGOP_GET_STATUS_PARAM)pArgs;
11007
11008 u32Ret = Ioctl_GOP_GetStatus(pInstance,ptr->en_status, ptr->pStatus,ptr->u32Size);
11009
11010 break;
11011 }
11012 case MAPI_CMD_GOP_TESTPATTERN:
11013 {
11014 PGOP_TEST_PATTERN_PARAM ptr = (PGOP_TEST_PATTERN_PARAM)pArgs;
11015
11016 u32Ret = Ioctl_GOP_TestPattern(pInstance,ptr->TestPatternType,ptr->u32ARGB);
11017 break;
11018 }
11019 //Stretch Win
11020 case MAPI_CMD_GOP_GWIN_SET_STRETCH:
11021 {
11022 PGOP_STRETCH_SET_PARAM ptr = (PGOP_STRETCH_SET_PARAM)pArgs;
11023 PGOP_STRETCH_INFO pInfo = (PGOP_STRETCH_INFO)ptr->pStretch;
11024 if(ptr->u32Size != sizeof(GOP_STRETCH_INFO))
11025 {
11026 GOP_M_ERR("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11027 return GOP_API_INVALID_PARAMETERS;
11028 }
11029
11030 u32Ret = Ioctl_GOP_Set_Stretch(pInstance,ptr->enStrtchType,ptr->gop_idx,pInfo);
11031 break;
11032 }
11033 case MAPI_CMD_GOP_GWIN_GET_STRETCH:
11034 {
11035 PGOP_STRETCH_SET_PARAM ptr = (PGOP_STRETCH_SET_PARAM)pArgs;
11036 PGOP_STRETCH_INFO pInfo = (PGOP_STRETCH_INFO)ptr->pStretch;
11037 if(ptr->u32Size != sizeof(GOP_STRETCH_INFO))
11038 {
11039 GOP_M_ERR("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11040 return GOP_API_INVALID_PARAMETERS;
11041 }
11042
11043 u32Ret = Ioctl_GOP_Get_Stretch(pInstance,ptr->enStrtchType,ptr->gop_idx,pInfo);
11044 break;
11045 }
11046
11047 //GWIN info
11048 case MAPI_CMD_GOP_GWIN_SET_PROPERTY:
11049 {
11050 PGOP_GWIN_PROPERTY_PARAM ptr = (PGOP_GWIN_PROPERTY_PARAM)pArgs;
11051
11052 u32Ret = Ioctl_GOP_GWin_SetProperty(pInstance,ptr->en_property, ptr->GwinId, ptr->pSet, ptr->u32Size);
11053
11054 break;
11055 }
11056 case MAPI_CMD_GOP_GWIN_GET_PROPERTY:
11057 {
11058 PGOP_GWIN_PROPERTY_PARAM ptr = (PGOP_GWIN_PROPERTY_PARAM)pArgs;
11059
11060 u32Ret = Ioctl_GOP_GWin_GetProperty(pInstance,ptr->en_property, ptr->GwinId, ptr->pSet, ptr->u32Size);
11061
11062 break;
11063 }
11064
11065 case MAPI_CMD_GOP_GWIN_MAPFB2WIN:
11066 {
11067 PGOP_GWIN_MAPFBINFO_PARAM ptr = (PGOP_GWIN_MAPFBINFO_PARAM)pArgs;
11068 //PGOP_BUFFER_INFO pInfo = (PGOP_BUFFER_INFO)ptr->pinfo;
11069
11070 u32Ret = Ioctl_GOP_MapFB2Win(pInstance,ptr->fbid,ptr->GwinId);
11071
11072 break;
11073 }
11074 case MAPI_CMD_GOP_GWIN_SET_WININFO:
11075 {
11076 PGOP_GWIN_SETWININFO_PARAM ptr = (PGOP_GWIN_SETWININFO_PARAM)pArgs;
11077 PGOP_BUFFER_INFO pInfo = (PGOP_BUFFER_INFO)ptr->pinfo;
11078
11079 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11080 if(ptr->u32Size != sizeof(GOP_BUFFER_INFO))
11081 {
11082 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11083 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11084 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11085 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11086 #endif
11087 UtopiaResourceRelease(psGOPInstPri->pResource);
11088 return UTOPIA_STATUS_PARAMETER_ERROR;
11089 }
11090 #endif
11091 u32Ret = Ioctl_GOP_SetWinInfo(pInstance,ptr->GwinId,pInfo);
11092
11093 break;
11094 }
11095 case MAPI_CMD_GOP_GWIN_GET_WININFO:
11096 {
11097 PGOP_GWIN_SETWININFO_PARAM ptr = (PGOP_GWIN_SETWININFO_PARAM)pArgs;
11098 PGOP_BUFFER_INFO pInfo = (PGOP_BUFFER_INFO)ptr->pinfo;
11099 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11100 if(ptr->u32Size != sizeof(GOP_BUFFER_INFO))
11101 {
11102 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11103 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11104 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11105 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11106 #endif
11107 UtopiaResourceRelease(psGOPInstPri->pResource);
11108 return UTOPIA_STATUS_PARAMETER_ERROR;
11109 }
11110 #endif
11111 u32Ret = Ioctl_GOP_GetWinInfo(pInstance,ptr->GwinId,pInfo);
11112
11113 break;
11114 }
11115
11116 #if 0
11117 case MAPI_CMD_GOP_GWIN_ENABLE:
11118 {
11119 PGOP_GWIN_WIN_ENABLE_PARAM ptr = (PGOP_GWIN_WIN_ENABLE_PARAM)pArgs;
11120 MS_BOOL bEn;
11121
11122 bEn = (MS_BOOL)*(ptr->pEn);
11123 u32Ret = Ioctl_GOP_Win_Enable(ptr->GwinId, bEn);
11124
11125 break;
11126 }
11127 #endif
11128 case MAPI_CMD_GOP_GWIN_SETDISPLAY:
11129 {
11130 PGOP_GWIN_DISPLAY_PARAM ptr = (PGOP_GWIN_DISPLAY_PARAM)pArgs;
11131 PGOP_GWINDISPLAY_INFO pInfo = (PGOP_GWINDISPLAY_INFO)ptr->pDisplayInfo;
11132 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11133 if(ptr->u32Size != sizeof(GOP_GWINDISPLAY_INFO))
11134 {
11135 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11136 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11137 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11138 #endif
11139 UtopiaResourceRelease(psGOPInstPri->pResource);
11140 return UTOPIA_STATUS_PARAMETER_ERROR;
11141 }
11142 #endif
11143 u32Ret = Ioctl_GOP_SetDisplay(pInstance,pInfo);
11144 break;
11145 }
11146 case MAPI_CMD_GOP_GWIN_DESTROY:
11147 {
11148 PGOP_GWIN_DESTROY_PARAM ptr = (PGOP_GWIN_DESTROY_PARAM)pArgs;
11149
11150 u32Ret = Ioctl_GOP_Win_Destroy(pInstance,ptr->GwinId);
11151 }
11152 break;
11153 //GFLIP
11154 case MAPI_CMD_GOP_GFLIP_CLEARQUEUE:
11155 {
11156 PGOP_GWIN_CLEARQUEUE_PARAM ptr = (PGOP_GWIN_CLEARQUEUE_PARAM)pArgs;
11157 PGOP_GWIN_CLEARQUEUE_INFO pInfo = (PGOP_GWIN_CLEARQUEUE_INFO)ptr->pClearInfo;
11158 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11159 if(ptr->u32Size != sizeof(GOP_GWIN_CLEARQUEUE_INFO))
11160 {
11161 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11162 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11163 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11164 #endif
11165 UtopiaResourceRelease(psGOPInstPri->pResource);
11166 return UTOPIA_STATUS_PARAMETER_ERROR;
11167 }
11168 #endif
11169 u32Ret = Ioctl_GFlip_ClearFlipQueue(pInstance,pInfo->GwinId);
11170 }
11171 break;
11172
11173 case MAPI_CMD_GOP_GFLIP_SWITCHGWIN:
11174 {
11175 PGOP_GWIN_GFLIP_SWITCH_GWIN_PARAM ptr = (PGOP_GWIN_GFLIP_SWITCH_GWIN_PARAM)pArgs;
11176 PGOP_GWIN_FLIP_WIN_INFO pFlip = (PGOP_GWIN_FLIP_WIN_INFO)ptr->pFlipInfo;
11177 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11178 if(ptr->u32Size != sizeof(GOP_GWIN_FLIP_WIN_INFO))
11179 {
11180 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11181 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11182 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11183 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11184 #endif
11185 UtopiaResourceRelease(psGOPInstPri->pResource);
11186 return UTOPIA_STATUS_PARAMETER_ERROR;
11187 }
11188 #endif
11189 if(bLocked)
11190 {
11191 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11192 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11193 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11194 #endif
11195 UtopiaResourceRelease(psGOPInstPri->pResource);
11196 bLocked = FALSE;
11197 }
11198 u32Ret = Ioctl_GFlip_SwitchGwin(pInstance,pFlip);
11199 break;
11200 }
11201 case MAPI_CMD_GOP_GFLIP_SWITCHMULTIGWIN:
11202 {
11203 PGOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM ptr = (PGOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM)pArgs;
11204 PGOP_GWIN_FLIP_MULTI_WIN_INFO pMultiFlip = (PGOP_GWIN_FLIP_MULTI_WIN_INFO)ptr->pMultiFlipInfo;
11205 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11206 if(ptr->u32Size != sizeof(GOP_GWIN_FLIP_MULTI_WIN_INFO))
11207 {
11208 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11209 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11210 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11211 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11212 #endif
11213 UtopiaResourceRelease(psGOPInstPri->pResource);
11214 return UTOPIA_STATUS_PARAMETER_ERROR;
11215 }
11216 #endif
11217 if(bLocked)
11218 {
11219 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11220 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11221 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11222 #endif
11223 UtopiaResourceRelease(psGOPInstPri->pResource);
11224 bLocked = FALSE;
11225 }
11226
11227 u32Ret = Ioctl_GFlip_SwitchMultiGwin(pInstance,pMultiFlip);
11228 break;
11229 }
11230 case MAPI_CMD_GOP_GFLIP_RESTORE_VSYNC_LMT:
11231 {
11232 if(FALSE == MDrv_GOP_RestoreFromVsyncLimitation(g_pGOPCtxLocal))
11233 {
11234 u32Ret = GOP_API_FAIL;
11235 }
11236 u32Ret = GOP_API_SUCCESS;
11237
11238 break;
11239 }
11240 //FB Info
11241 case MAPI_CMD_GOP_FB_CREATE:
11242 {
11243 PGOP_CREATE_BUFFER_PARAM ptr = (PGOP_CREATE_BUFFER_PARAM)pArgs;
11244 PGOP_BUFFER_INFO pBuff = (PGOP_BUFFER_INFO)ptr->pBufInfo;
11245 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11246 if(ptr->u32Size != sizeof(GOP_BUFFER_INFO)) //error handling for invalid ptr
11247 {
11248 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11249 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11250 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11251 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11252 #endif
11253 UtopiaResourceRelease(psGOPInstPri->pResource);
11254 return UTOPIA_STATUS_PARAMETER_ERROR;
11255 }
11256 #endif
11257
11258 u32Ret = Ioctl_GOP_FBCreate(pInstance,ptr->fb_type,pBuff,ptr->fbid);
11259 break;
11260 }
11261 case MAPI_CMD_GOP_FB_DESTROY:
11262 {
11263 PGOP_DELETE_BUFFER_PARAM ptr = (PGOP_DELETE_BUFFER_PARAM)pArgs;
11264
11265 if(ptr->u32Size != sizeof(MS_U32)) //error handling for invalid ptr
11266 {
11267 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11268 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11269 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11270 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11271 #endif
11272 UtopiaResourceRelease(psGOPInstPri->pResource);
11273 return UTOPIA_STATUS_PARAMETER_ERROR;
11274 }
11275 u32Ret = Ioctl_GOP_FBDestroy(pInstance,ptr->pBufId);
11276
11277 break;
11278 }
11279 case MAPI_CMD_GOP_FB_SETINFO:
11280 {
11281 PGOP_FB_INFO_PARAM ptr = (PGOP_FB_INFO_PARAM)pArgs;
11282 PGOP_BUFFER_INFO pBuff = (PGOP_BUFFER_INFO)ptr->pBufInfo;
11283 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11284 if(ptr->u32Size != sizeof(GOP_BUFFER_INFO)) //error handling for invalid ptr
11285 {
11286 GOP_M_INFO("[%s] (%d) Info structure Error!!\n",__FUNCTION__,__LINE__);
11287 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11288 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11289 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11290 #endif
11291 UtopiaResourceRelease(psGOPInstPri->pResource);
11292 return UTOPIA_STATUS_PARAMETER_ERROR;
11293 }
11294 #endif
11295 u32Ret = Ioctl_GOP_SetFBInfo(pInstance,ptr->fbid,pBuff);
11296
11297 break;
11298 }
11299 case MAPI_CMD_GOP_FB_GETINFO:
11300 {
11301 PGOP_FB_INFO_PARAM ptr = (PGOP_FB_INFO_PARAM)pArgs;
11302 PGOP_BUFFER_INFO pBuff = (PGOP_BUFFER_INFO)ptr->pBufInfo;
11303
11304 u32Ret = Ioctl_GOP_GetFBInfo(pInstance,ptr->fbid,pBuff);
11305 break;
11306 }
11307
11308 case MAPI_CMD_GOP_FB_SET_PROPERTY:
11309 {
11310 PGOP_FB_PROPERTY_PARAM ptr = (PGOP_FB_PROPERTY_PARAM)pArgs;
11311
11312 u32Ret = Ioctl_GOP_FB_SetProperty(pInstance,ptr->en_property, ptr->FBId, ptr->pSet, ptr->u32Size);
11313
11314 break;
11315 }
11316 case MAPI_CMD_GOP_FB_GET_PROPERTY:
11317 {
11318 PGOP_FB_PROPERTY_PARAM ptr = (PGOP_FB_PROPERTY_PARAM)pArgs;
11319
11320 u32Ret = Ioctl_GOP_FB_GetProperty(pInstance,ptr->en_property, ptr->FBId, ptr->pSet, ptr->u32Size);
11321
11322 break;
11323 }
11324
11325 //palette
11326 case MAPI_CMD_GOP_PALETTE_SET_CONFIG:
11327 {
11328 PGOP_PALETTE_CONFIG_PARAM ptr = (PGOP_PALETTE_CONFIG_PARAM)pArgs;
11329 PGOP_PAL_OPT pPalSet = (PGOP_PAL_OPT)ptr->pPaletteInfo;
11330
11331 if(ptr->u32Size != sizeof(GOP_PAL_OPT))
11332 {
11333 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11334 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11335 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11336 #endif
11337 UtopiaResourceRelease(psGOPInstPri->pResource);
11338 return UTOPIA_STATUS_PARAMETER_ERROR;
11339 }
11340
11341 u32Ret = Ioctl_GOP_Palette_Set_Config(pInstance,pPalSet->gop_idx, (DRV_GopPalReadType)pPalSet->paltype,pPalSet->palSrc);
11342
11343 }
11344 break;
11345 case MAPI_CMD_GOP_PALETTE_SET_ENTRY:
11346 {
11347 PGOP_PALETTE_SET_PARAM ptr = (PGOP_PALETTE_SET_PARAM)pArgs;
11348 PGOP_PALETTE_ENTRY pPal = (PGOP_PALETTE_ENTRY)ptr->pClut;
11349
11350 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11351 if(ptr->u32Size != sizeof(GOP_PALETTE_ENTRY))
11352 {
11353 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11354 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11355 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11356 #endif
11357 UtopiaResourceRelease(psGOPInstPri->pResource);
11358 return UTOPIA_STATUS_PARAMETER_ERROR;
11359 }
11360 #endif
11361 u32Ret = Ioctl_GOP_Palette_EntrySet(pInstance,pPal);
11362 }
11363 break;
11364 case MAPI_CMD_GOP_PALETTE_GET_ENTRY:
11365 {
11366 PGOP_PALETTE_SET_PARAM ptr = (PGOP_PALETTE_SET_PARAM)pArgs;
11367 PGOP_PALETTE_ENTRY pPal = (PGOP_PALETTE_ENTRY)ptr->pClut;
11368
11369 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11370 if(ptr->u32Size != sizeof(GOP_PALETTE_ENTRY))
11371 {
11372 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11373 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11374 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11375 #endif
11376 UtopiaResourceRelease(psGOPInstPri->pResource);
11377 return UTOPIA_STATUS_PARAMETER_ERROR;
11378 }
11379 #endif
11380 u32Ret = Ioctl_GOP_Palette_EntryGet(pInstance,pPal);
11381 break;
11382 }
11383 //Fade
11384 case MAPI_CMD_GOP_GWIN_SET_FADE:
11385 {
11386 PGOP_SET_FADE_PARAM ptr = (PGOP_SET_FADE_PARAM)pArgs;
11387 u32Ret = Ioctl_GOP_Fade(pInstance,ptr->en_type,ptr->pSetting,ptr->u32Size);
11388 break;
11389 }
11390 //Scroll
11391 case MAPI_CMD_GOP_SET_SCROLL:
11392 {
11393 PGOP_SCROLL_PARAM ptr = (PGOP_SCROLL_PARAM)pArgs;
11394 u32Ret = Ioctl_GOP_Scroll(pInstance,ptr->scroll_type,ptr->pCfg,ptr->u32Size);
11395 break;
11396 }
11397 //PINPON
11398 case MAPI_CMD_GOP_SET_PINPON:
11399 {
11400 PGOP_SET_PINPON_PARAM ptr = (PGOP_SET_PINPON_PARAM)pArgs;
11401 u32Ret = Ioctl_GOP_PINPON(pInstance,ptr->en_pro,ptr->pSetting,ptr->u32Size);
11402 break;
11403 }
11404 //DWIN
11405 case MAPI_CMD_GOP_DWIN_INIT:
11406 {
11407 Ioctl_GOP_DWIN_Init(pInstance);
11408 break;
11409 }
11410 case MAPI_CMD_GOP_DWIN_CAPTURE:
11411 {
11412 PGOP_DWIN_CAPTURE_PARAM pDwinCapture = (PGOP_DWIN_CAPTURE_PARAM)pArgs;
11413 PGOP_CAPTURE_INFO pinfo = (PGOP_CAPTURE_INFO)pDwinCapture->pDwin;
11414 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11415 if(pDwinCapture->u32Size != sizeof(GOP_CAPTURE_INFO)) //error handling for invalid ptr
11416 {
11417 GOP_M_INFO("[%s][%d] Capture Info structure Error!!\n",__FUNCTION__,__LINE__);
11418 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11419 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11420 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11421 #endif
11422 UtopiaResourceRelease(psGOPInstPri->pResource);
11423 return UTOPIA_STATUS_PARAMETER_ERROR;
11424 }
11425 #endif
11426 u32Ret = Ioctl_GOP_Dwin_Capture(pInstance,pinfo);
11427 break;
11428 }
11429 case MAPI_CMD_GOP_DWIN_SET_PROPERTY:
11430 {
11431 PGOP_DWIN_PROPERTY_PARAM ptr = (PGOP_DWIN_PROPERTY_PARAM)pArgs;
11432
11433 u32Ret = Ioctl_GOP_DWIN_SetProperty(pInstance,ptr->en_dwin_property,ptr->pDwinProp,ptr->u32Size);
11434 break;
11435 }
11436 case MAPI_CMD_GOP_DWIN_GET_PROPERTY:
11437 {
11438 PGOP_DWIN_PROPERTY_PARAM ptr = (PGOP_DWIN_PROPERTY_PARAM)pArgs;
11439
11440 u32Ret = Ioctl_GOP_DWIN_GetProperty(pInstance,ptr->en_dwin_property,ptr->pDwinProp,ptr->u32Size);
11441 break;
11442 }
11443 case MAPI_CMD_GOP_DWIN_INTR:
11444 {
11445 PGOP_DWIN_INTR_STATUS_PARAM pDwinIntr = (PGOP_DWIN_INTR_STATUS_PARAM)pArgs;
11446
11447 u32Ret = Ioctl_GOP_Dwin_Intr(pInstance,pDwinIntr->intr_type, pDwinIntr->pIntrInfo, pDwinIntr->u32Size);
11448 break;
11449 }
11450
11451
11452 //MISC
11453 case MAPI_CMD_GOP_UPDATE:
11454 {
11455 PGOP_UPDATE_PARAM ptr = (PGOP_UPDATE_PARAM)pArgs;
11456 PGOP_UPDATE_INFO pInfo = (PGOP_UPDATE_INFO)ptr->pUpdateInfo;
11457
11458 if(ptr->u32Size != sizeof(GOP_UPDATE_INFO))
11459 {
11460 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11461 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11462 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11463 #endif
11464 UtopiaResourceRelease(psGOPInstPri->pResource);
11465 return UTOPIA_STATUS_PARAMETER_ERROR;
11466 }
11467
11468 u32Ret = Ioctl_GOP_TriggerRegWriteIn(pInstance,pInfo->gop_idx,pInfo->update_type,pInfo->bEn,pInfo->bSync);
11469 break;
11470 }
11471 case MAPI_CMD_GOP_SELECTION:
11472 {
11473 PGOP_SELECTION_PROPERTY_PARAM ptr = (PGOP_SELECTION_PROPERTY_PARAM)pArgs;
11474
11475 u32Ret = Ioctl_GOP_Select(pInstance,ptr->sel_type, ptr->id, ptr->pinfo);
11476
11477 break;
11478 }
11479 case MAPI_CMD_GOP_REGISTER_CB:
11480 {
11481 PGOP_REGISTER_CB_PARAM ptr = (PGOP_REGISTER_CB_PARAM)pArgs;
11482
11483 u32Ret = Ioctl_GOP_Register_CB(pInstance,ptr->cb_type, ptr->pCB, ptr->u32Size);
11484
11485 break;
11486 }
11487 case MAPI_CMD_GOP_MUTEX:
11488 {
11489 GOP_MUTEX_PARAM *ptr = (GOP_MUTEX_PARAM*)pArgs;
11490
11491 #ifndef MSOS_TYPE_LINUX_KERNEL //Check size error when if(is_compat_task()==1)
11492 if(ptr->u32Size != sizeof(GOP_MUTEX_PARAM))
11493 {
11494 return UTOPIA_STATUS_PARAMETER_ERROR;
11495 }
11496 #endif
11497 if(ptr->en_mutex == E_GOP_LOCK)
11498 {
11499 if(UtopiaResourceObtain(pModule, GOP_POOL_ID_GOP0, &(psGOPInstPri->pResource)) != 0)
11500 {
11501 GOP_M_ERR("[%s %d]UtopiaResourceObtainToInstant fail\n",__FUNCTION__,__LINE__);
11502 return 0xFFFFFFFF;
11503 }
11504 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = MsOS_GetOSThreadID();
11505 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11506 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = (GETPIDTYPE)getpid();
11507 #endif
11508 }
11509 else if(ptr->en_mutex == E_GOP_UNLOCK)
11510 {
11511 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11512 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11513 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11514 #endif
11515 UtopiaResourceRelease(psGOPInstPri->pResource);
11516 }
11517 break;
11518 }
11519 case MAPI_CMD_GOP_MIXER_SET_PROPERTY:
11520 {
11521 PGOP_MIXER_PROPERTY_PARAM ptr = (PGOP_MIXER_PROPERTY_PARAM)pArgs;
11522
11523 u32Ret = Ioctl_GOP_MIXER_SetProperty(pInstance,ptr->en_mixer_property,ptr->pMixerProp,ptr->u32Size);
11524 break;
11525 }
11526 case MAPI_CMD_GOP_MIXER_GET_PROPERTY:
11527 {
11528 PGOP_MIXER_PROPERTY_PARAM ptr = (PGOP_MIXER_PROPERTY_PARAM)pArgs;
11529
11530 u32Ret = Ioctl_GOP_MIXER_GetProperty(pInstance,ptr->en_mixer_property,ptr->pMixerProp,ptr->u32Size);
11531 break;
11532 }
11533 case MAPI_CMD_GOP_VE_SET_PROPERTY:
11534 {
11535 PGOP_VE_PROPERTY_PARAM ptr = (PGOP_VE_PROPERTY_PARAM)pArgs;
11536
11537 u32Ret = Ioctl_GOP_VE_SetProperty(pInstance,ptr->en_ve_property,ptr->pVEProp,ptr->u32Size);
11538 break;
11539 }
11540 case MAPI_CMD_GOP_MISC:
11541 {
11542 PGOP_MISC_PARAM ptr = (PGOP_MISC_PARAM)pArgs;
11543 u32Ret = Ioctl_GOP_MISC(pInstance,ptr->misc_type,ptr->pMISC,ptr->u32Size);
11544 break;
11545 }
11546 case MAPI_CMD_GOP_POWERSTATE:
11547 {
11548 PGOP_POWERSTATE_PARAM ptr = (PGOP_POWERSTATE_PARAM)pArgs;
11549 MS_U8* u8Val = ptr->pInfo;
11550 u32Ret = Ioctl_GOP_PowerState(pInstance, (MS_U32)*u8Val, pModule);
11551 break;
11552 }
11553 case MAPI_CMD_GOP_INTERRUPT:
11554 {
11555 PGOP_INTERRUPT_PARAM ptr = (PGOP_INTERRUPT_PARAM)pArgs;
11556 MS_BOOL *pbEnable =(MS_BOOL *)ptr->pSetting;
11557 u32Ret = Ioctl_GOP_Interrupt(pInstance,ptr->gop_idx,*pbEnable);
11558 break;
11559 }
11560 default:
11561 break;
11562 }
11563
11564 if(bLocked)
11565 {
11566 g_pGOPCtxLocal->pGOPCtxShared->s32GOPLockTid = 0;
11567 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
11568 g_pGOPCtxLocal->pGOPCtxShared->GOPLockPid = 0;
11569 #endif
11570 UtopiaResourceRelease(psGOPInstPri->pResource);
11571 }
11572 if(u32Ret != GOP_API_SUCCESS)
11573 {
11574 GOP_M_ERR("[%s][%d] ERROR on cmd:0x%tx\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32Cmd);
11575 return UTOPIA_STATUS_FAIL;
11576 }
11577
11578 //printf("(%s) Done\n\n",__FUNCTION__);
11579
11580 return UTOPIA_STATUS_SUCCESS;
11581 }
11582
GOPClose(void * pInstance)11583 MS_U32 GOPClose(void* pInstance)
11584 {
11585 #ifdef MSOS_TYPE_LINUX_KERNEL
11586 extern MS_U32 MDrv_GFLIP_Del_Timer(void);
11587 if(_devGFLIPCnt==1)
11588 {
11589 MDrv_GFLIP_Del_Timer();
11590 }
11591 #endif
11592
11593 Ioctl_GOP_AtExit(pInstance);
11594 UtopiaInstanceDelete(pInstance);
11595
11596 return TRUE;
11597 }
11598
11599