1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 /// @file drvGFLIP.c
97 /// @brief MStar gflip Interface
98 /// @author MStar Semiconductor Inc.
99 /// @attention
100 /// <b><em></em></b>
101 ///////////////////////////////////////////////////////////////////////////////////////////////////
102
103 #define _MDRV_GFLIP_C
104
105 //=============================================================================
106 // Include Files
107 //=============================================================================
108 #include "MsCommon.h"
109 #include "regGOP.h"
110 #include "halGOP.h"
111 #include "drvGFLIP.h"
112 #include "halGFLIP.h"
113 #include "halCHIP.h"
114 #if defined(MSOS_TYPE_LINUX)
115 #include <sys/ioctl.h>
116 #include <unistd.h>
117 #include <fcntl.h> // O_RDWR
118 #include "mdrv_gflip_io.h"
119 #include <string.h>
120 #elif defined(MSOS_TYPE_LINUX_KERNEL)
121 #include "mdrv_gflip_io.h"
122 #endif
123 #include "drvGOP_priv.h"
124
125 //=============================================================================
126 // Compile options
127 //=============================================================================
128
129 //=============================================================================
130 // Debug Macros
131 //=============================================================================
132 #define GFLIP_DEBUG
133 #ifdef GFLIP_DEBUG
134 #define GFLIP_PRINT(fmt, args...) printf("[GFlip (Driver)][%05d] " fmt, __LINE__, ## args)
135 #define GFLIP_ASSERT(_cnd, _fmt, _args...) \
136 if (!(_cnd)) { \
137 GFLIP_PRINT(_fmt, ##_args); \
138 }
139 #else
140 #define GFLIP_PRINT(_fmt, _args...)
141 #define GFLIP_ASSERT(_cnd, _fmt, _args...)
142 #endif
143
144 //=============================================================================
145 // Macros
146 //=============================================================================
147
148 //=============================================================================
149 // Global Variables
150 //=============================================================================
151 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
152 #else
153 GOP_CTX_DRV_LOCAL*pGFLIP_IntGOPDrvLocalCtx = NULL;
154 //=============================================================================
155 // Local Function Prototypes
156 //=============================================================================
157 static void _MDrv_GFLIP_ResetFlipInfoPtr(MS_GOP_CTX_LOCAL *pGOPCtx, MS_U32 u32GopIdx);
158
159 //Irq Relaated(hw process):
160 static MS_BOOL _MDrv_GFLIP_ClearIRQ(GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx);
161 static MS_BOOL _MDrv_GFLIP_ProcessIRQ(GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx);
162 //Interrupt call back function:
163 void _MDrv_GFLIP_IntHandler(InterruptNum eIntNum);
164
165 //=============================================================================
166 // Local Function
167 //=============================================================================
168 //-------------------------------------------------------------------------------------------------
169 /// Reset Flip Info Reader/Writer ptr.
170 /// @param u32GopIdx \b IN: the idx of ptr's owner(gop)
171 /// @return void
172 /// @attention
173 /// <b>[MxLib] <em></em></b>
174 //-------------------------------------------------------------------------------------------------
_MDrv_GFLIP_ResetFlipInfoPtr(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U32 u32GopIdx)175 void _MDrv_GFLIP_ResetFlipInfoPtr(MS_GOP_CTX_LOCAL *pGOPCtx, MS_U32 u32GopIdx)
176 {
177 MS_U16 u16Idx;
178 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
179
180 for(u16Idx=0; u16Idx<MAX_GOP_GWIN; u16Idx++)
181 {
182 pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u16Idx] = 0;
183 pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u16Idx] = 0;
184 }
185 }
186
187 //-------------------------------------------------------------------------------------------------
188 /// Clear Irq
189 /// @param void
190 /// @return TRUE: success
191 /// @attention
192 /// <b>[MxLib] <em></em></b>
193 //-------------------------------------------------------------------------------------------------
_MDrv_GFLIP_ClearIRQ(GOP_CTX_DRV_LOCAL * pGOPDrvLocalCtx)194 MS_BOOL _MDrv_GFLIP_ClearIRQ(GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx)
195 {
196 MS_U32 u32GopIdx;
197
198 MHal_GFLIP_ClearDWINIRQ(&pGOPDrvLocalCtx->halCtxLocal, &pGOPDrvLocalCtx->gflipDWinIntInfo);
199
200 for(u32GopIdx=0; u32GopIdx<MAX_GOP_SUPPORT; u32GopIdx++)
201 {
202 if(MHal_GFLIP_IsVSyncInt(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx) == FALSE)
203 {
204 continue;
205 }
206
207 MHal_GFLIP_IntEnable(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx, FALSE);
208
209 if(MHal_GFLIP_IsVSyncInt(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx) == TRUE)
210 { //Wow...The Vsync Issue Happened...
211 MHal_GFLIP_HandleVsyncLimitation(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx); //different chip maybe has different handle.
212 pGOPDrvLocalCtx->bGFlipInVsyncLimitation[u32GopIdx] = TRUE;
213 continue;
214 }
215
216 MHal_GFLIP_IntEnable(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx, TRUE);
217 }
218
219 return TRUE;
220 }
221
222 //-------------------------------------------------------------------------------------------------
223 /// Process Irq
224 /// @param void
225 /// @return TRUE: success kickoff flip to gop
226 /// @return FALSE: no flip kickoff to gop
227 /// @attention
228 /// <b>[MxLib] <em>
229 /// step1: check src of vsync. interrupt
230 /// step2: check if any flip request in queue with this Gop
231 /// step3: check if TAG back
232 /// step4: set flip to GOP
233 /// step5: set ReadPtr to next, this entry consumed!
234 /// </em></b>
235 //-------------------------------------------------------------------------------------------------
_MDrv_GFLIP_ProcessIRQ(GOP_CTX_DRV_LOCAL * pGOPDrvLocalCtx)236 MS_BOOL _MDrv_GFLIP_ProcessIRQ(GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx)
237 {
238 MS_U32 u32GopIdx, u32GwinIdx, u32Addr;
239 MS_U8 u8MiuSel;
240
241 for(u32GopIdx=GFLIP_GOP_IDX_4G; u32GopIdx<MAX_GOP_SUPPORT; u32GopIdx++)
242 {
243 //step 1: check src of vsync. interrupt
244 if(MHal_GFLIP_IsVSyncInt(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx) == FALSE)
245 {
246 continue;
247 }
248
249 for(u32GwinIdx=0; u32GwinIdx<MAX_GOP_GWIN; u32GwinIdx++)
250 {
251 //step 2:check if any flip request in queue with this Gop:
252 if(pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx] == pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx]) //no any flip request in queue
253 {
254 continue;
255 }
256
257 //step 3: if get queue, check if TAG back.
258 if(MHal_GFLIP_IsTagIDBack(&pGOPDrvLocalCtx->halCtxLocal, pGOPDrvLocalCtx->GFlipInfo[u32GopIdx][u32GwinIdx][pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx]].u32TagId) == FALSE)
259 {
260 continue;
261 }
262
263 //Has Flip Request, and Tag Returned! we need programming flip address:
264 //step 4: if Tag Back: set flip to GOP.
265 u32Addr = pGOPDrvLocalCtx->GFlipInfo[u32GopIdx][u32GwinIdx][pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx]].u64Addr;
266 //GOP HW just read the relative offset of each MIU
267 _phy_to_miu_offset(u8MiuSel, u32Addr, u32Addr);
268 MHal_GFLIP_SetFlipToGop(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx, u32GwinIdx, u32Addr);
269
270 //Step 5: set ReadPtr to next, this entry consumed!
271 pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx] = (pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx]+1)%MAX_FLIP_ADDR_FIFO;
272 }
273 }
274
275 return TRUE;
276 }
277
278 //-------------------------------------------------------------------------------------------------
279 /// Handle GFLIP Interrupt notification handler
280 /// @param irq \b IN: interrupt number
281 /// @param devid \b IN: device id
282 /// @return IRQ_HANDLED
283 /// @attention
284 /// <b>[MxLib] <em></em></b>
285 //-------------------------------------------------------------------------------------------------
_MDrv_GFLIP_IntHandler(InterruptNum eIntNum)286 void _MDrv_GFLIP_IntHandler(InterruptNum eIntNum)
287 {
288 //process gflip interrupt:
289 if(pGFLIP_IntGOPDrvLocalCtx)
290 {
291 _MDrv_GFLIP_ProcessIRQ(pGFLIP_IntGOPDrvLocalCtx);
292
293 //clear interrupt
294 _MDrv_GFLIP_ClearIRQ(pGFLIP_IntGOPDrvLocalCtx);
295 }
296 MsOS_EnableInterrupt(E_INT_IRQ_GOP); //Need check if needed.
297 }
298
299 #endif
300 //////////////////////////////////////////////////////////////////////////////////////////////////////
301
302 //=============================================================================
303 // GFLIP Driver Function
304 //=============================================================================
305
306 //-------------------------------------------------------------------------------------------------
307 /// GFlip Init(reset flip info ptr, interrupt enable, etc..)
308 /// @param u32GopIdx \b IN:the idx of gop which need be initialized.
309 /// @return TRUE: success
310 /// @attention
311 /// <b>[Mxlib] <em></em></b>
312 //-------------------------------------------------------------------------------------------------
MDrv_GFLIP_Init(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U32 u32GopIdx,MS_BOOL bEnableVsyncIntFlip)313 MS_BOOL MDrv_GFLIP_Init(MS_GOP_CTX_LOCAL *pGOPCtx, MS_U32 u32GopIdx, MS_BOOL bEnableVsyncIntFlip)
314 {
315 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
316
317 if(u32GopIdx >= MAX_GOP_SUPPORT) //overflow
318 {
319 return FALSE;
320 }
321
322 pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx] = bEnableVsyncIntFlip;
323
324 if(TRUE == pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx])
325 {
326
327 #ifdef MSOS_TYPE_LINUX_KERNEL
328 #if GFLIP_ENABLE
329 extern MS_U32 _MDrv_GFLIPIO_Init(MS_U32 u32GopIdx);
330 if(_MDrv_GFLIPIO_Init(u32GopIdx))
331 {
332 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
333 return FALSE;
334 }
335 #endif
336 #elif defined(MSOS_TYPE_LINUX)
337 if(0> pGOPDrvLocalCtx->s32FdGFlip)
338 {
339 pGOPDrvLocalCtx->s32FdGFlip = open("/dev/gflip", O_RDWR);
340 if(0> pGOPDrvLocalCtx->s32FdGFlip)
341 {
342 GFLIP_PRINT("[%s][%d] open fail /dev/gflip\n", __FUNCTION__, __LINE__);
343 return FALSE;
344 }
345 }
346 if(pGOPDrvLocalCtx->s32FdGFlip >= 0)
347 {
348 if(ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_INIT, &u32GopIdx))
349 {
350 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
351 close(pGOPDrvLocalCtx->s32FdGFlip);
352 pGOPDrvLocalCtx->s32FdGFlip = -1;
353 return FALSE;
354 }
355 }
356 #else
357 {
358 pGFLIP_IntGOPDrvLocalCtx = pGOPDrvLocalCtx;
359
360 if((++pGOPDrvLocalCtx->u16GOPRefCnt[u32GopIdx]) > 1)
361 {
362 return TRUE;
363 }
364
365 //Attch IRQ:
366 MsOS_AttachInterrupt(E_INT_IRQ_GOP, (InterruptCb)_MDrv_GFLIP_IntHandler);
367 MsOS_EnableInterrupt(E_INT_IRQ_GOP); //Need check if needed.
368
369 //reset flip Info:
370 _MDrv_GFLIP_ResetFlipInfoPtr(pGOPCtx, u32GopIdx);
371 //enable gop hw interrupt:
372 MHal_GFLIP_IntEnable(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx,TRUE);
373 }
374 #endif
375 }
376 else
377 {
378 #ifdef MSOS_TYPE_LINUX
379 if(0> pGOPDrvLocalCtx->s32FdGFlip)
380 {
381 pGOPDrvLocalCtx->s32FdGFlip = open("/dev/gflip", O_RDWR);
382 if(0> pGOPDrvLocalCtx->s32FdGFlip)
383 {//In order to Get DWin Int Infor from Kernel, Open the GFlip Dev but not enable GFilp.
384 GFLIP_PRINT("[%s][%d] open fail /dev/gflip\n", __FUNCTION__, __LINE__);
385 return FALSE;
386 }
387 }
388 #elif defined(MSOS_TYPE_LINUX_KERNEL)
389 #else
390 pGFLIP_IntGOPDrvLocalCtx = pGOPDrvLocalCtx;
391
392 if((++pGOPDrvLocalCtx->u16GOPRefCnt[u32GopIdx]) > 1)
393 {
394 return TRUE;
395 }
396
397 _MDrv_GFLIP_ResetFlipInfoPtr(pGOPCtx, u32GopIdx);
398 #endif
399 MHal_GFLIP_IntEnable(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx, FALSE);
400 }
401
402 return TRUE;
403 }
404
405 //-------------------------------------------------------------------------------------------------
406 /// GFlip DeInit(interrupt disable)
407 /// @param u32GopIdx \b IN:the idx of gop which need be de-initialized.
408 /// @return TRUE: success
409 /// @attention
410 /// <b>[MxLib] <em></em></b>
411 //-------------------------------------------------------------------------------------------------
MDrv_GFLIP_DeInit(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U32 u32GopIdx)412 MS_BOOL MDrv_GFLIP_DeInit(MS_GOP_CTX_LOCAL *pGOPCtx, MS_U32 u32GopIdx)
413 {
414 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
415
416 if(u32GopIdx >= MAX_GOP_SUPPORT) //overflow
417 {
418 return FALSE;
419 }
420
421 if(TRUE == pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx])
422 {
423 #ifdef MSOS_TYPE_LINUX
424 {
425 close(pGOPDrvLocalCtx->s32FdGFlip);
426 pGOPDrvLocalCtx->s32FdGFlip = -1;
427 pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx] = FALSE; //Application not shared
428 }
429 #elif defined(MSOS_TYPE_LINUX_KERNEL)
430 {
431 pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx] = FALSE; //Application not shared
432 }
433 #else
434 {
435 if(0 == (--pGOPDrvLocalCtx->u16GOPRefCnt[u32GopIdx]))
436 {
437 MHal_GFLIP_IntEnable(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx, FALSE);
438 MsOS_DisableInterrupt(E_INT_IRQ_GOP);
439 MsOS_DetachInterrupt(E_INT_IRQ_GOP);
440 pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx] = FALSE;
441 }
442 }
443 #endif
444 }
445 else
446 {
447 #ifdef MSOS_TYPE_LINUX
448 {
449 close(pGOPDrvLocalCtx->s32FdGFlip);
450 pGOPDrvLocalCtx->s32FdGFlip = -1;
451 }
452 #elif defined(MSOS_TYPE_LINUX_KERNEL)
453 #else
454 pGOPDrvLocalCtx->u16GOPRefCnt[u32GopIdx]--;
455 #endif
456 }
457
458 return TRUE;
459 }
460
461 //-------------------------------------------------------------------------------------------------
462 /// Set Flip Info(flip request) to GFlip
463 /// @param u32GopIdx \b IN: the gop which flip kickoff to
464 /// @param u32GwinIdx \b IN: the gwin which flip kickoff to
465 /// @param u32Addr \b IN: the flip address which will be kickoff
466 /// @param u32TagId \b IN: the TagId need be waited before flip
467 /// @param u32QEntry \b IN: the queued flips, if current queued flips >= u32QEntry, won't set this flip request to gop
468 /// @param u32QEntry \b out: the current queued flips in GFLIP
469 /// @return TRUE: DDI call success
470 /// @attention
471 /// <b>[MxLib] <em>Flip when vsync interrupt, and the DDI used for set flip info to GFlip. </em></b>
472 //-------------------------------------------------------------------------------------------------
MDrv_GFLIP_SetMultiFlipInfo(MS_GOP_CTX_LOCAL * pGOPCtx,MS_GFLIP_MULTIINFO * pMultiinfo)473 MS_BOOL MDrv_GFLIP_SetMultiFlipInfo(MS_GOP_CTX_LOCAL*pGOPCtx,MS_GFLIP_MULTIINFO* pMultiinfo)
474 {
475 MS_BOOL bRet = TRUE;
476
477 #ifdef MSOS_TYPE_LINUX_KERNEL
478 #if GFLIP_ENABLE
479 extern MS_BOOL _MDrv_GFLIP_SetMultiFlipInfo(MS_GFLIP_MULTIINFO * pMultiFlipInfo);
480 if(!_MDrv_GFLIP_SetMultiFlipInfo(pMultiinfo))
481 {
482 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
483 return FALSE;
484 }
485 #endif
486 #elif defined(MSOS_TYPE_LINUX)
487 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
488
489 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
490 {
491 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
492 return FALSE;
493 }
494 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SETMULTIFLIPINFO,pMultiinfo))
495 {
496 GFLIP_PRINT("[%s][%d] fail!!!!\n",__FUNCTION__,__LINE__);
497 bRet = FALSE;
498 }
499 #endif
500 return bRet;
501 }
502
MDrv_GFLIP_SetTLBMultiFlipInfo(MS_GOP_CTX_LOCAL * pGOPCtx,MS_TLB_GFLIP_MULTIINFO * pTLBMultiinfo)503 MS_BOOL MDrv_GFLIP_SetTLBMultiFlipInfo(MS_GOP_CTX_LOCAL*pGOPCtx,MS_TLB_GFLIP_MULTIINFO* pTLBMultiinfo)
504 {
505 MS_BOOL bRet = TRUE;
506
507 #ifdef MSOS_TYPE_LINUX_KERNEL
508 #if GFLIP_ENABLE
509 extern MS_BOOL _MDrv_GFLIP_SetTLBMultiFlipInfo(MS_TLB_GFLIP_MULTIINFO * pTLBMultiFlipInfo);
510 if(!_MDrv_GFLIP_SetTLBMultiFlipInfo(pTLBMultiinfo))
511 {
512 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
513 return FALSE;
514 }
515 #endif
516 #elif defined(MSOS_TYPE_LINUX)
517 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
518
519 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
520 {
521 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
522 return FALSE;
523 }
524 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SETTLBMULTIFLIPINFO,pTLBMultiinfo))
525 {
526 GFLIP_PRINT("[%s][%d] fail!!!!\n",__FUNCTION__,__LINE__);
527 bRet = FALSE;
528 }
529 #endif
530 return bRet;
531 }
532
MDrv_GFLIP_SetFlipInfo(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U32 u32GopIdx,MS_U32 u32GwinIdx,MS_PHY u64MainAddress,MS_PHY u64SubAddress,MS_U32 u32TagId,MS_U32 * u32QEntry)533 MS_BOOL MDrv_GFLIP_SetFlipInfo(MS_GOP_CTX_LOCAL*pGOPCtx, MS_U32 u32GopIdx, MS_U32 u32GwinIdx, MS_PHY u64MainAddress, MS_PHY u64SubAddress, MS_U32 u32TagId, MS_U32 * u32QEntry)
534 {
535 MS_U16 u16WordUnit=0;
536 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
537 MS_U8 u8MiuSel=0xFF;
538 UNUSED(u8MiuSel);
539
540 if(pGOPDrvLocalCtx->apiCtxLocal.pGOPCtxShared->bPixelMode[u32GopIdx] == TRUE)
541 {
542 u16WordUnit = 1;
543 }
544 else
545 {
546 u16WordUnit = GOP_WordUnit;
547 }
548
549 //GOP HW just read the relative offset of each MIU
550 _phy_to_miu_offset(u8MiuSel, u64MainAddress, u64MainAddress);
551 if(TRUE == pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx])
552 {
553 if((u32GopIdx >= MAX_GOP_SUPPORT) || (u32GwinIdx >= MAX_GOP_GWIN)) //overflow
554 {
555 return FALSE;
556 }
557
558 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
559 {
560 MS_GFLIP_INFO stFlinInfo;
561 MS_BOOL bRet = TRUE;
562 #ifdef MSOS_TYPE_LINUX
563 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
564 {
565 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
566 return FALSE;
567 }
568 #endif
569
570 stFlinInfo.u32GopIdx = u32GopIdx;
571 stFlinInfo.u32GwinIdx = u32GwinIdx;
572 stFlinInfo.u64Addr= u64MainAddress;
573 stFlinInfo.u32TagId= u32TagId;
574 stFlinInfo.u32QEntry= *u32QEntry;
575 stFlinInfo.u32Result = TRUE;
576 if((pGOPCtx->pGOPCtxShared->GOP_StereoMode[u32GopIdx] != E_DRV_GOP_3D_DISABLE) &&
577 (u64SubAddress != 0))
578 {
579 MS_GFLIP_3DINFO st3DFlipInfo;
580 //GOP HW just read the relative offset of each MIU
581 _phy_to_miu_offset(u8MiuSel, u64SubAddress, u64SubAddress);
582 memcpy(&st3DFlipInfo, &stFlinInfo, sizeof(MS_GFLIP_INFO));
583 st3DFlipInfo.u64SubAddr = u64SubAddress;
584
585 #ifdef MSOS_TYPE_LINUX_KERNEL
586 #if GFLIP_ENABLE
587 extern MS_BOOL _MDrv_GFLIP_SetFlipInfo(MS_U32 u32GopIdx,MS_U32 u32GwinIdx,MS_PHY u32MainAddr,MS_PHY u32SubAddr,MS_U32 u32TagId,MS_U32 * u32QEntry,MS_U32 * u32Result);
588 if(!_MDrv_GFLIP_SetFlipInfo(stFlinInfo.u32GopIdx, stFlinInfo.u32GwinIdx, stFlinInfo.u64Addr, st3DFlipInfo.u64SubAddr, stFlinInfo.u32TagId, &(stFlinInfo.u32QEntry), &(stFlinInfo.u32Result)))
589 {
590 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
591 return FALSE;
592 }
593 #endif
594 #elif defined(MSOS_TYPE_LINUX)
595
596 if((pGOPCtx->pGOPCtxShared->bTLB[u32GopIdx]))
597 {
598 MS_TLB_GFLIP_3DINFO stTLB3DFlipInfo;
599 //GOP HW just read the relative offset of each MIU
600 memcpy(&stTLB3DFlipInfo, &st3DFlipInfo, sizeof(MS_GFLIP_INFO));
601 stTLB3DFlipInfo.bTLBEnable = pGOPCtx->pGOPCtxShared->bTLB[u32GopIdx];
602 stTLB3DFlipInfo.u64TLBAddr = pGOPCtx->pGOPCtxShared->u64TLBAddress[u32GopIdx];
603 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_TLBSET3DFLIPINFO, &stTLB3DFlipInfo))
604 {
605 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
606 bRet = FALSE;
607 }
608 }
609 else
610 {
611 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SET3DFLIPINFO, &st3DFlipInfo))
612 {
613 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
614 bRet = FALSE;
615 }
616 }
617 #endif
618 if(bRet)
619 {
620 memcpy(&stFlinInfo, &st3DFlipInfo, sizeof(MS_GFLIP_INFO));
621 }
622 else
623 {
624 return FALSE;
625 }
626 }
627 else
628 {
629 #ifdef MSOS_TYPE_LINUX_KERNEL
630 #if GFLIP_ENABLE
631 extern MS_BOOL _MDrv_GFLIP_SetFlipInfo(MS_U32 u32GopIdx, MS_U32 u32GwinIdx, MS_PHY u32MainAddr, MS_PHY u32SubAddr, MS_U32 u32TagId, MS_U32 * u32QEntry, MS_U32 *u32Result);
632 if(!_MDrv_GFLIP_SetFlipInfo(stFlinInfo.u32GopIdx, stFlinInfo.u32GwinIdx, stFlinInfo.u64Addr, 0, stFlinInfo.u32TagId, &stFlinInfo.u32QEntry, &stFlinInfo.u32Result))
633 {
634 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
635 return FALSE;
636 }
637 #endif
638 #elif defined(MSOS_TYPE_LINUX)
639 if((pGOPCtx->pGOPCtxShared->bTLB[u32GopIdx]))
640 {
641 MS_TLB_GFLIP_INFO stTLBFlinInfo;
642 //GOP HW just read the relative offset of each MIU
643 memcpy(&stTLBFlinInfo, &stFlinInfo, sizeof(MS_GFLIP_INFO));
644 stTLBFlinInfo.bTLBEnable = pGOPCtx->pGOPCtxShared->bTLB[u32GopIdx];
645 stTLBFlinInfo.u64TLBAddr = pGOPCtx->pGOPCtxShared->u64TLBAddress[u32GopIdx];
646 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_TLBSETFLIPINFO, &stTLBFlinInfo))
647 {
648 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
649 bRet = FALSE;
650 }
651 }
652 else
653 {
654 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SETFLIPINFO, &stFlinInfo))
655 {
656 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
657 bRet = FALSE;
658 }
659 }
660 #endif
661 }
662 if(bRet)
663 {
664 *u32QEntry = stFlinInfo.u32QEntry;
665 return stFlinInfo.u32Result;
666 }
667 else
668 {
669 return FALSE;
670 }
671 }
672 #else
673 {
674 MS_U32 u32NextWritePtr;
675 MS_U32 u32QCnt = 0;
676
677 if(TRUE == pGOPDrvLocalCtx->bGFlipInVsyncLimitation[u32GopIdx])
678 { //in handling vsync limitation status, just print the error and return true to avoid block app:
679 GFLIP_PRINT("\n !!! [%s][%d]Error. No Signal for GOP Clock Source and GFlip Vsync Interrupt disabled!!!\n",__FUNCTION__,__LINE__);
680 return TRUE;
681 }
682
683 u32NextWritePtr = (pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx]+1) % MAX_FLIP_ADDR_FIFO;
684 if(u32NextWritePtr !=pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx]) //can write
685 {
686 if(pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] >= pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx])
687 {
688 u32QCnt = pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] -pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx];
689 }
690 else
691 {
692 u32QCnt = MAX_FLIP_ADDR_FIFO + pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] - pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx];
693 }
694
695 if(u32QCnt >= *u32QEntry )
696 {
697 *u32QEntry = u32QCnt;
698 return FALSE;
699 }
700
701 pGOPDrvLocalCtx->GFlipInfo[u32GopIdx][u32GwinIdx][pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx]].u64Addr = (u64MainAddress/u16WordUnit);
702 pGOPDrvLocalCtx->GFlipInfo[u32GopIdx][u32GwinIdx][pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx]].u32TagId= u32TagId;
703 pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] = u32NextWritePtr;
704
705 //Hold on when New QCnt can't match requested QCnt:
706 //Fix issue if we set Flip Info and back which leads to App write to on-show window.
707 while(TRUE)
708 {
709 if(pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] >= pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx])
710 {
711 u32QCnt = pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] -pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx];
712 }
713 else
714 {
715 u32QCnt = MAX_FLIP_ADDR_FIFO + pGOPDrvLocalCtx->u32GFlipInfoWritePtr[u32GopIdx][u32GwinIdx] - pGOPDrvLocalCtx->u32GFlipInfoReadPtr[u32GopIdx][u32GwinIdx];
716 }
717
718 if( u32QCnt < *u32QEntry )
719 {
720 break;
721 }
722 }
723
724 //since do not do the sync. with mutex/spinlock, the return of avaiable queue number maybe not accurate.
725 *u32QEntry = (u32QCnt + 1);
726
727 return TRUE;
728 }
729 else
730 {
731 *u32QEntry = MAX_FLIP_ADDR_FIFO-1;
732 return FALSE;
733 }
734 }
735 #endif
736 }
737 else
738 {
739 MS_PHY u64tmp;
740 MS_U32 u32BankOffSet=0;
741 _GetBnkOfstByGop(u32GopIdx, &u32BankOffSet);
742
743 if((pGOPCtx->pGOPCtxShared->bTLB[u32GopIdx]))
744 {
745 if(pGOPCtx->pGOPCtxShared->u64TLBAddress[u32GopIdx])
746 {
747 u64tmp = pGOPCtx->pGOPCtxShared->u64TLBAddress[u32GopIdx] + (u64MainAddress/PAGE_SIZE)*TLB_PER_ENTRY_SIZE;
748 u64tmp /= ADDRESSING_8BYTE_UNIT;
749 HAL_GOP_Write16Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet+REG_TLB_BASE_ADDR_L, u64tmp&GOP_REG_WORD_MASK, GOP_REG_WORD_MASK);
750 HAL_GOP_Write16Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet+REG_TLB_BASE_ADDR_H, u64tmp>>16, GOP_REG_WORD_MASK);
751 u64tmp = u64MainAddress % (PAGE_SIZE*PER_MIU_TLB_ENTRY_COUNT);
752 u64tmp = u64tmp /u16WordUnit;
753 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_DRAM_RBLK_L(u32GwinIdx), u64tmp);
754 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_DRAM_RBLK_H(u32GwinIdx), 0);
755 }
756
757 if((pGOPCtx->pGOPCtxShared->GOP_StereoMode[u32GopIdx] != E_DRV_GOP_3D_DISABLE)&&(pGOPCtx->pGOPCtxShared->u64TLBAddress[u32GopIdx]!= 0))
758 {
759 u64tmp = pGOPCtx->pGOPCtxShared->u64TLBAddress[u32GopIdx] + (u64SubAddress/PAGE_SIZE)*TLB_PER_ENTRY_SIZE;
760 u64tmp /= ADDRESSING_8BYTE_UNIT;
761 HAL_GOP_Write16Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet+REG_TLB_BASE_ADDR_RVIEW_L, u64tmp&GOP_REG_WORD_MASK, GOP_REG_WORD_MASK);
762 HAL_GOP_Write16Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet+REG_TLB_BASE_ADDR_RVIEW_H, u64tmp>>16, GOP_REG_WORD_MASK);
763 u64tmp = u64SubAddress % (PAGE_SIZE*PER_MIU_TLB_ENTRY_COUNT);
764 u64tmp = u64tmp /u16WordUnit;
765 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_3DOSD_SUB_RBLK_L(u32GwinIdx), u64tmp);
766 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_3DOSD_SUB_RBLK_H(u32GwinIdx), 0);
767 }
768 }
769 else
770 {
771 u64tmp = u64MainAddress /u16WordUnit;
772 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_DRAM_RBLK_L(u32GwinIdx), u64tmp);
773 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_DRAM_RBLK_H(u32GwinIdx), u64tmp>>16);
774 if((pGOPCtx->pGOPCtxShared->GOP_StereoMode[u32GopIdx] != E_DRV_GOP_3D_DISABLE) && (u64SubAddress != 0))
775 {
776 u64tmp = u64SubAddress /u16WordUnit;
777 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_3DOSD_SUB_RBLK_L(u32GwinIdx), u64tmp);
778 HAL_GOP_Write32Reg(&pGOPDrvLocalCtx->halCtxLocal, u32BankOffSet + GOP_4G_3DOSD_SUB_RBLK_H(u32GwinIdx), u64tmp>>16);
779 }
780 }
781
782 MDrv_GOP_GWIN_UpdateReg(pGOPCtx,u32GopIdx);
783
784 return TRUE;
785 }
786 }
787
788 //-------------------------------------------------------------------------------------------------
789 /// Set Gwin Info(3D request) to GFlip
790 /// @param u32GopIdx \b IN: the gop which flip kickoff to
791 /// @param u32GwinIdx \b IN: the gwin which flip kickoff to
792 /// @param u32Addr \b IN: the flip address which will be kickoff
793 /// @param u32TagId \b IN: the TagId need be waited before flip
794 /// @param u32QEntry \b IN: the queued flips, if current queued flips >= u32QEntry, won't set this flip request to gop
795 /// @param u32QEntry \b out: the current queued flips in GFLIP
796 /// @return TRUE: DDI call success
797 /// @attention
798 /// <b>[MxLib] <em>Flip when vsync interrupt, and the DDI used for set flip info to GFlip. </em></b>
799 //-------------------------------------------------------------------------------------------------
MDrv_GFLIP_SetGwinInfo(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U8 u8GopIdx,MS_U8 u8GwinIdx,DRV_GOP_GWIN_INFO * pinfo)800 MS_BOOL MDrv_GFLIP_SetGwinInfo(MS_GOP_CTX_LOCAL*pGOPCtx, MS_U8 u8GopIdx, MS_U8 u8GwinIdx,DRV_GOP_GWIN_INFO* pinfo)
801 {
802 MS_GWIN_INFO MsGwinInfo;
803
804 MsGwinInfo.u8GopIdx = u8GopIdx;
805 MsGwinInfo.u8GwinIdx = u8GwinIdx;
806 MsGwinInfo.u64Addr = pinfo->u64DRAMRBlkStart;
807 MsGwinInfo.u16X = pinfo->u16DispHPixelStart;
808 MsGwinInfo.u16Y = pinfo->u16DispVPixelStart;
809 MsGwinInfo.u16W = pinfo->u16RBlkHPixSize;
810 MsGwinInfo.u16H = pinfo->u16RBlkVPixSize;
811 MsGwinInfo.clrType =(GFLIP_COLOR_TYPE)pinfo->clrType;
812 #ifdef MSOS_TYPE_LINUX_KERNEL
813 #if GFLIP_ENABLE
814 extern MS_BOOL _MDrv_GFLIP_SetGwinInfo(MS_GWIN_INFO stGwinInfo);
815 if(!_MDrv_GFLIP_SetGwinInfo(MsGwinInfo))
816 {
817 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
818 return FALSE;
819 }
820 #endif
821 #elif defined(MSOS_TYPE_LINUX)
822 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
823
824 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
825 {
826 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
827 return FALSE;
828 }
829 if(ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SETGWININFO, &MsGwinInfo))
830 {
831 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
832 return FALSE;
833 }
834
835 #endif
836 return TRUE;
837
838 }
839 //-------------------------------------------------------------------------------------------------
840 /// Restore HW Limitation -- Vsync Limitation.
841 /// @return TRUE: success
842 /// @attention
843 /// <b>[Mxlib] <em></em></b>
844 //-------------------------------------------------------------------------------------------------
MDrv_GFLIP_RestoreFromVsyncLimitation(MS_GOP_CTX_LOCAL * pGOPCtx)845 MS_BOOL MDrv_GFLIP_RestoreFromVsyncLimitation(MS_GOP_CTX_LOCAL *pGOPCtx)
846 {
847 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
848 MS_U32 u32GopIdx;
849 MS_BOOL bHasSignal = TRUE;
850 UNUSED(bHasSignal);
851
852 for(u32GopIdx=0; u32GopIdx<MAX_GOP_SUPPORT; u32GopIdx++)
853 {
854 //Only GFlip has the issue.
855 if(TRUE == pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx])
856 {
857 #ifdef MSOS_TYPE_LINUX_KERNEL
858 #if GFLIP_ENABLE
859 extern MS_BOOL _MDrv_GFLIP_RestoreFromVsyncLimitation(void);
860 if(!_MDrv_GFLIP_RestoreFromVsyncLimitation())
861 {
862 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
863 return FALSE;
864 }
865 #endif
866 #elif defined(MSOS_TYPE_LINUX)
867 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
868 {
869 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
870 return FALSE;
871 }
872 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SETINPUTSIGSTATUS, &bHasSignal))
873 {
874 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
875 return FALSE;
876 }
877
878 break; //Only one call into Kernel could restore All.
879
880 #else //GFlip UMD Handling:
881 if(TRUE == pGOPDrvLocalCtx->bGFlipInVsyncLimitation[u32GopIdx])
882 {
883 MHal_GFLIP_RestoreFromVsyncLimitation(&pGOPDrvLocalCtx->halCtxLocal, u32GopIdx);
884 pGOPDrvLocalCtx->bGFlipInVsyncLimitation[u32GopIdx] = FALSE;
885 }
886 #endif
887 }
888 }
889
890 return TRUE;
891 }
892
893 /******************************************************************************/
894 /// Get DWin Interrupt Information
895 /// @param pGFlipDWinIntInfo \b OUT: dwin interrup flag
896 /******************************************************************************/
MDrv_GFLIP_GetDWinIntInfo(MS_GOP_CTX_LOCAL * pGOPCtx,GFLIP_DWININT_INFO * pGFlipDWinIntInfo,MS_U32 u32Timeout)897 MS_BOOL MDrv_GFLIP_GetDWinIntInfo(MS_GOP_CTX_LOCAL *pGOPCtx, GFLIP_DWININT_INFO *pGFlipDWinIntInfo,MS_U32 u32Timeout)
898 {
899 MS_GFLIP_DWININT_INFO2 stGFlipDWinIntInfo;
900 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
901
902 stGFlipDWinIntInfo.bResetDWinIntInfo = TRUE;
903 stGFlipDWinIntInfo.u32Timeout = u32Timeout;
904
905 #ifdef MSOS_TYPE_LINUX_KERNEL
906 #if GFLIP_ENABLE
907 extern MS_BOOL _MDrv_GFLIP_GetDWinIntInfo(GFLIP_DWININT_INFO * pGFlipDWinIntInfo,MS_BOOL bResetDWinIntInfo,MS_U32 u32Timeout);
908 if(!_MDrv_GFLIP_GetDWinIntInfo(pGFlipDWinIntInfo, stGFlipDWinIntInfo.bResetDWinIntInfo, stGFlipDWinIntInfo.u32Timeout))
909 {
910 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
911 return FALSE;
912 }
913 pGFlipDWinIntInfo->u8DWinIntInfo = stGFlipDWinIntInfo.gflipDWinIntInfo.u8DWinIntInfo;
914 #endif
915 #elif defined(MSOS_TYPE_LINUX)
916 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
917 {
918 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
919 return FALSE;
920 }
921
922 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_GETDWININTINFO2, &stGFlipDWinIntInfo))
923 {
924 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
925 return FALSE;
926 }
927
928 pGFlipDWinIntInfo->u8DWinIntInfo = stGFlipDWinIntInfo.gflipDWinIntInfo.u8DWinIntInfo;
929 #else //will Add GFlip Handle in UMD GFlip later.
930 pGFlipDWinIntInfo->u8DWinIntInfo = pGOPDrvLocalCtx->gflipDWinIntInfo.u8DWinIntInfo;
931 pGOPDrvLocalCtx->gflipDWinIntInfo.u8DWinIntInfo = 0x0;
932 #endif
933 return TRUE;
934 }
935
936 /******************************************************************************/
937 /// Enable VE capture
938 /// @param pstVECapState \b OUT: VECAPTURESTATE flag
939 /******************************************************************************/
MDrv_GFLIP_EnaVECapture(MS_GOP_CTX_LOCAL * pGOPCtx,PMS_DRVGOP_VECAPTURESTATE pstVECapState)940 MS_BOOL MDrv_GFLIP_EnaVECapture(MS_GOP_CTX_LOCAL *pGOPCtx, PMS_DRVGOP_VECAPTURESTATE pstVECapState)
941 {
942 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
943 if(pGOPDrvLocalCtx != NULL)
944 {
945 #ifdef MSOS_TYPE_LINUX_KERNEL
946 #if GFLIP_ENABLE
947 #ifdef CONFIG_MSTAR_VE_CAPTURE_SUPPORT
948 extern MS_BOOL _MDrv_GFLIPIO_EnableVECapture(MS_GFLIP_VECAPTURESTATE * pVECaptureState);
949 if(_MDrv_GFLIPIO_EnableVECapture((MS_GFLIP_VECAPTURESTATE*)pstVECapState))
950 {
951 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
952 return FALSE;
953 }
954 #endif
955 #endif
956 #elif defined(MSOS_TYPE_LINUX)
957 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
958 {
959 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
960 return FALSE;
961 }
962
963 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_ENABLEVECAPTURE, (PMS_GFLIP_VECAPTURESTATE)pstVECapState))
964 {
965 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
966 return FALSE;
967 }
968 return pstVECapState->u8Result;
969 #endif
970 }
971 return TRUE; //Unsupport now
972 }
973
974 /******************************************************************************/
975 /// Get VE capture state
976 /// @param pstVECapState \b OUT: VECAPTURESTATE flag
977 /******************************************************************************/
MDrv_GFLIP_GetVECaptureState(MS_GOP_CTX_LOCAL * pGOPCtx,PMS_DRVGOP_VECAPTURESTATE pstVECapState)978 MS_BOOL MDrv_GFLIP_GetVECaptureState(MS_GOP_CTX_LOCAL *pGOPCtx, PMS_DRVGOP_VECAPTURESTATE pstVECapState)
979 {
980 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
981 if(pGOPDrvLocalCtx != NULL)
982 {
983 #ifdef MSOS_TYPE_LINUX_KERNEL
984 #if GFLIP_ENABLE
985 #ifdef CONFIG_MSTAR_VE_CAPTURE_SUPPORT
986 extern MS_BOOL MDrv_GFLIP_GetVECapCurState(MS_BOOL * pbEna,MS_U8 * pu8FramCount);
987 if(MDrv_GFLIP_GetVECapCurState(&pstVECapState->bEnable, &pstVECapState->u8FrameCount))
988 {
989 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
990 return FALSE;
991 }
992 #endif
993 #endif
994 #elif defined(MSOS_TYPE_LINUX)
995 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
996 {
997 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
998 return FALSE;
999 }
1000
1001 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_GETVECAPTURESTATE, (PMS_GFLIP_VECAPTURESTATE)pstVECapState))
1002 {
1003 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
1004 return FALSE;
1005 }
1006 //printf("GFLP=%u\n", pstVECapState->u8FrameCount);
1007 return pstVECapState->u8Result;
1008 #endif
1009 }
1010 return TRUE; //Unsupport now
1011 }
1012
1013 /******************************************************************************/
1014 /// Get VE capture state
1015 /// @param pstVECapState \b OUT: VECAPTURESTATE flag
1016 /******************************************************************************/
MDrv_GFLIP_VECaptureWaitOnFrame(MS_GOP_CTX_LOCAL * pGOPCtx,PMS_DRVGOP_VECAPTURESTATE pstVECapState)1017 MS_BOOL MDrv_GFLIP_VECaptureWaitOnFrame(MS_GOP_CTX_LOCAL *pGOPCtx, PMS_DRVGOP_VECAPTURESTATE pstVECapState)
1018 {
1019 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
1020 if(pGOPDrvLocalCtx != NULL)
1021 {
1022 #ifdef MSOS_TYPE_LINUX_KERNEL
1023 #if GFLIP_ENABLE
1024 #ifdef CONFIG_MSTAR_VE_CAPTURE_SUPPORT
1025 extern MS_BOOL MDrv_GFLIP_VECapWaitOnFrame(MS_BOOL * pbEna,MS_U8 * pu8FramNum);
1026 pstVECapState->u8Result= MDrv_GFLIP_VECapWaitOnFrame(&pstVECapState->bEnable, &pstVECapState->u8FrameCount);
1027 return pstVECapState->u8Result;
1028 #endif
1029 #endif
1030 #elif defined(MSOS_TYPE_LINUX)
1031 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
1032 {
1033 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
1034 return FALSE;
1035 }
1036
1037 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_VECAPTUREWAITONFRAME, (PMS_GFLIP_VECAPTURESTATE)pstVECapState))
1038 {
1039 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
1040 return FALSE;
1041 }
1042 //printf("GFLP=%u\n", pstVECapState->u8FrameCount);
1043 return pstVECapState->u8Result;
1044 #endif
1045 }
1046 return TRUE; //Unsupport now
1047 }
1048
1049
1050 /***********************************************************************/
1051 /// GFlip Clear Flip Queue(Clear the Flip queue)
1052 /// @param u32GopIdx \b IN:the idx of gop which Flip kick off to
1053 /// @param u32GwinIdx \b IN:the idx of gwin which Flip kick off to
1054 /// @return TRUE: success
1055 /// <b>[Mxlib] <em></em></b>
1056 /*******************************************************************88*/
MDrv_GFLIP_ClearFlipQueue(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U32 u32GopIdx,MS_U32 u32GwinIdx)1057 MS_BOOL MDrv_GFLIP_ClearFlipQueue(MS_GOP_CTX_LOCAL *pGOPCtx, MS_U32 u32GopIdx, MS_U32 u32GwinIdx)
1058 {
1059 MS_GFLIP_GOPGWINIDX stFlipQueueIdx;
1060 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
1061
1062 if((u32GopIdx >= MAX_GOP_SUPPORT) || (u32GwinIdx >= MAX_GOP_GWIN)) //overflow
1063 {
1064 return FALSE;
1065 }
1066
1067 if(TRUE == pGOPDrvLocalCtx->bEnableVsyncIntFlip[u32GopIdx])
1068 {
1069
1070 stFlipQueueIdx.u32GopIdx = u32GopIdx;
1071 stFlipQueueIdx.u32GwinIdx = u32GwinIdx;
1072 stFlipQueueIdx.u32Result = TRUE;
1073
1074 #ifdef MSOS_TYPE_LINUX_KERNEL
1075 #if GFLIP_ENABLE
1076 extern MS_BOOL _MDrv_GFLIP_ClearFlipQueue(MS_U32 u32GopIdx,MS_U32 u32GwinIdx);
1077 if(!_MDrv_GFLIP_ClearFlipQueue(u32GopIdx, u32GwinIdx))
1078 {
1079 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
1080 return FALSE;
1081 }
1082 return stFlipQueueIdx.u32Result;
1083 #endif
1084 #elif defined(MSOS_TYPE_LINUX)
1085 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
1086 {
1087 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
1088 return FALSE;
1089 }
1090 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_CLEARFLIPQUEUE, &stFlipQueueIdx))
1091 {
1092 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
1093 return FALSE;
1094 }
1095 return stFlipQueueIdx.u32Result;
1096 #else
1097 return FALSE;
1098 #endif
1099 }
1100 else
1101 {
1102 return FALSE;
1103 }
1104 }
1105
1106 //******************************************************************************
1107 /// notify kernel about 3D gpio pin
1108 /// @param pGOPCtx \b IN: gop context
1109 /// @param u32GPIO3DPin \b IN: GPIO 3D pin
1110 /// @return TURE: Success FALSE: Fail
1111 //******************************************************************************
MDrv_GFLIP_SetGPIO3DPin(MS_GOP_CTX_LOCAL * pGOPCtx,MS_U32 u32GPIO3DPin)1112 MS_BOOL MDrv_GFLIP_SetGPIO3DPin(MS_GOP_CTX_LOCAL*pGOPCtx, MS_U32 u32GPIO3DPin)
1113 {
1114 MS_GFLIP_INFO stFlinInfo;
1115
1116 stFlinInfo.u32GopIdx = 0;
1117 stFlinInfo.u32GwinIdx = 0;
1118 stFlinInfo.u64Addr= u32GPIO3DPin;
1119 stFlinInfo.u32TagId= 0;
1120 stFlinInfo.u32QEntry= 0;
1121 stFlinInfo.u32Result = TRUE;
1122
1123 #ifdef MSOS_TYPE_LINUX_KERNEL
1124 #if GFLIP_ENABLE
1125 extern MS_BOOL _MDrv_GFLIP_SetGPIO3DPin(MS_PHY u32Addr,MS_U32 * u32Result);
1126 if(!_MDrv_GFLIP_SetGPIO3DPin(stFlinInfo.u64Addr, &stFlinInfo.u32Result))
1127 {
1128 GFLIP_PRINT("[%s][%d] failed!\n", __FUNCTION__, __LINE__);
1129 return FALSE;
1130 }
1131 #else
1132 return FALSE;
1133 #endif
1134 #elif defined(MSOS_TYPE_LINUX)
1135 GOP_CTX_DRV_LOCAL*pGOPDrvLocalCtx = (GOP_CTX_DRV_LOCAL*)pGOPCtx;
1136
1137 if(0 > pGOPDrvLocalCtx->s32FdGFlip)
1138 {
1139 GFLIP_PRINT("[%s][%d]GLIP device not openedl!!!!\n",__FUNCTION__,__LINE__);
1140 return FALSE;
1141 }
1142 if (ioctl(pGOPDrvLocalCtx->s32FdGFlip, MDRV_GFLIP_IOC_SETGPIO3DPIN, &stFlinInfo))
1143 {
1144 GFLIP_PRINT("[%s][%d] Fail!!!!\n",__FUNCTION__,__LINE__);
1145 return FALSE;
1146 }
1147 return TRUE;
1148 #else
1149 return FALSE;
1150 #endif
1151 return TRUE;
1152 }
1153
1154