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 #include "MsTypes.h"
96 #ifndef MSOS_TYPE_LINUX_KERNEL
97 #include <stdio.h>
98 #include <string.h>
99 #endif
100 #include "MsDevice.h"
101 #include "utopia.h"
102 #include "utopia_dapi.h"
103 //#include "drvXC_IOPort.h" //apple ??????
104 #include "drvMVOP.h"
105 #include "MVOP_private.h"
106 #include "drvMVOP_v2.h"
107
108
109 // ========== Global definition ==========
110 void* pModuleMVOP = NULL;
111
112 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
MVOPMdbIoctl(MS_U32 u32Cmd,const void * const pArgs)113 MS_U32 MVOPMdbIoctl(MS_U32 u32Cmd, const void* const pArgs)
114 {
115 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
116 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
117 switch(u32Cmd)
118 {
119 case MDBCMD_CMDLINE:
120 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
121 break;
122 case MDBCMD_GETINFO:
123 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
124 //MVOP API?
125 MDrv_MVOP_GetMVOPMdbInfo_V2(paraGetInfo->u64ReqHdl);
126 break;
127 default:
128 break;
129 }
130 return 0;
131 }
132 #endif
133
MVOPRegisterToUtopia(FUtopiaOpen ModuleType)134 void MVOPRegisterToUtopia(FUtopiaOpen ModuleType)
135 {
136 // 1. deal with module
137 UtopiaModuleCreate(MODULE_MVOP, 0, &pModuleMVOP); //MODULE_MVOP???? where
138 UtopiaModuleRegister(pModuleMVOP);
139 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
140 UtopiaModuleSetupFunctionPtr(pModuleMVOP, (FUtopiaOpen)MVOPOpen, (FUtopiaClose)MVOPClose, (FUtopiaIOctl)MVOPIoctl);
141 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
142 UtopiaModuleRegisterMdbNode("mvop", (FUtopiaMdbIoctl)MVOPMdbIoctl);
143 #endif
144 #if defined(MSOS_TYPE_LINUX_KERNEL)
145 UtopiaModuleSetupSTRFunctionPtr(pModuleMVOP,(FUtopiaSTR)MVOPStr);
146 UtopiaModuleSetSTRPrivate(pModuleMVOP, sizeof(MVOP_INSTANCE_PRIVATE));
147 #endif
148
149 // 2. deal with resource , XC�ݥi��ݭn���resource�A�䤤�@�ӬOreadonly�A�t�~�@�ӬOXC��ӥ]��resource
150 void* psResource = NULL;
151
152 // 3. resource can allocate private for internal use
153 UtopiaModuleAddResourceStart(pModuleMVOP, E_MVOP_POOL_ID_INTERNAL);
154 UtopiaResourceCreate("MVOP", sizeof(MVOP_RESOURCE_PRIVATE), &psResource);
155 UtopiaResourceRegister(pModuleMVOP, psResource, E_MVOP_POOL_ID_INTERNAL);
156 UtopiaModuleAddResourceEnd(pModuleMVOP, E_MVOP_POOL_ID_INTERNAL);
157
158 // shall we init first?
159 }
160
MVOPStr(MS_U32 u32PowerState,void * pModule)161 MS_U32 MVOPStr(MS_U32 u32PowerState, void* pModule)
162 {
163 MVOP_INSTANCE_PRIVATE *psMVOPInstPri = NULL;
164 #if defined(MSOS_TYPE_LINUX_KERNEL)
165 UtopiaModuleGetSTRPrivate(pModule, (void**)&psMVOPInstPri);
166 #endif
167
168 if(psMVOPInstPri == NULL || psMVOPInstPri->fpMVOP_SetPowerState_Kernel == NULL)
169 {
170 return UTOPIA_STATUS_FAIL;
171 }
172
173 if (u32PowerState == E_POWER_SUSPEND)
174 {
175 void* pInstance = NULL;
176 stMVOP_SET_POWER_STATE tmpMVOPArgs;
177 tmpMVOPArgs.u16PowerState = E_POWER_SUSPEND;
178 tmpMVOPArgs.u32Ret = FALSE;
179 pstMVOP_SET_POWER_STATE pMVOPArgs = &tmpMVOPArgs;
180 pMVOPArgs->u32Ret = psMVOPInstPri->fpMVOP_SetPowerState_Kernel(pInstance, pMVOPArgs->u16PowerState);
181
182 return pMVOPArgs->u32Ret;
183 }
184 else if (u32PowerState == E_POWER_RESUME)
185 {
186 void* pInstance = NULL;
187 stMVOP_SET_POWER_STATE tmpMVOPArgs;
188 tmpMVOPArgs.u16PowerState = E_POWER_RESUME;
189 tmpMVOPArgs.u32Ret = FALSE;
190 pstMVOP_SET_POWER_STATE pMVOPArgs = &tmpMVOPArgs;
191 pMVOPArgs->u32Ret = psMVOPInstPri->fpMVOP_SetPowerState_Kernel(pInstance, pMVOPArgs->u16PowerState);
192
193 return pMVOPArgs->u32Ret;
194 }
195
196 return UTOPIA_STATUS_FAIL;
197 }
198
199
MVOPOpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)200 MS_U32 MVOPOpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
201 {
202 MVOP_INSTANCE_PRIVATE *psMVOPInstPri = NULL;
203 UtopiaInstanceCreate(sizeof(MVOP_INSTANCE_PRIVATE), ppInstance);
204 UtopiaInstanceGetPrivate(*ppInstance, (void**)&psMVOPInstPri);
205
206 //Main MVOP
207 psMVOPInstPri->fpMVOP_Init = MDrv_MVOP_Init_V2;
208 psMVOPInstPri->fpMVOP_Exit = MDrv_MVOP_Exit_V2;
209 psMVOPInstPri->fpMVOP_Enable = MDrv_MVOP_Enable_V2;
210 psMVOPInstPri->fpMVOP_SetInputCfg = MDrv_MVOP_SetInputCfg_V2;
211 psMVOPInstPri->fpMVOP_SetOutputCfg = MDrv_MVOP_SetOutputCfg_V2;
212
213 psMVOPInstPri->fpMVOP_EnableBlackBG = MDrv_MVOP_EnableBlackBG_V2;
214 psMVOPInstPri->fpMVOP_EnableUVShift = MDrv_MVOP_EnableUVShift_V2;
215 psMVOPInstPri->fpMVOP_SetMonoMode = MDrv_MVOP_SetMonoMode_V2;
216 psMVOPInstPri->fpMVOP_GetHSize = MDrv_MVOP_GetHSize_V2;
217 psMVOPInstPri->fpMVOP_GetVSize = MDrv_MVOP_GetVSize_V2;
218 psMVOPInstPri->fpMVOP_GetHStart = MDrv_MVOP_GetHStart_V2;
219 psMVOPInstPri->fpMVOP_GetVStart = MDrv_MVOP_GetVStart_V2;
220 psMVOPInstPri->fpMVOP_GetIsInterlace = MDrv_MVOP_GetIsInterlace_V2;
221 psMVOPInstPri->fpMVOP_GetIsHDuplicate = MDrv_MVOP_GetIsHDuplicate_V2;
222 psMVOPInstPri->fpMVOP_GetIsEnable = MDrv_MVOP_GetIsEnable_V2;
223 psMVOPInstPri->fpMVOP_GetOutputTiming = MDrv_MVOP_GetOutputTiming_V2;
224 psMVOPInstPri->fpMVOP_GetLibVer = MDrv_MVOP_GetLibVer_V2;
225 psMVOPInstPri->fpMVOP_CheckCapability = MDrv_MVOP_CheckCapability_V2;
226 psMVOPInstPri->fpMVOP_GetMaxHOffset = MDrv_MVOP_GetMaxHOffset_V2;
227 psMVOPInstPri->fpMVOP_GetMaxVOffset = MDrv_MVOP_GetMaxVOffset_V2;
228
229 psMVOPInstPri->fpMVOP_SetDbgLevel = MDrv_MVOP_SetDbgLevel_V2;
230 psMVOPInstPri->fpMVOP_GetInfo = MDrv_MVOP_GetInfo_V2;
231 psMVOPInstPri->fpMVOP_GetStatus = MDrv_MVOP_GetStatus_V2;
232 psMVOPInstPri->fpMVOP_SetClk = MDrv_MVOP_SetClk_V2;
233 psMVOPInstPri->fpMVOP_SetPattern = MDrv_MVOP_SetPattern_V2;
234 psMVOPInstPri->fpMVOP_SetTileFormat = MDrv_MVOP_SetTileFormat_V2;
235 psMVOPInstPri->fpMVOP_GetDstInfo = MDrv_MVOP_GetDstInfo_V2;
236 psMVOPInstPri->fpMVOP_SetFixVtt = MDrv_MVOP_SetFixVtt_V2;
237 psMVOPInstPri->fpMVOP_SetMMIOMapBase = MDrv_MVOP_SetMMIOMapBase_V2;
238 psMVOPInstPri->fpMVOP_MiuSwitch = MDrv_MVOP_MiuSwitch_V2;
239 psMVOPInstPri->fpMVOP_SetBaseAdd = MDrv_MVOP_SetBaseAdd_V2;
240 psMVOPInstPri->fpMVOP_SelOPField = MDrv_MVOP_SEL_OP_FIELD_V2;
241 psMVOPInstPri->fpMVOP_SetRegSizeFromMVD = MDrv_MVOP_SetRegSizeFromMVD_V2;
242 psMVOPInstPri->fpMVOP_SetStartPos = MDrv_MVOP_SetStartPos_V2;
243 psMVOPInstPri->fpMVOP_SetImageWidthHight = MDrv_MVOP_SetImageWidthHight_V2;
244 psMVOPInstPri->fpMVOP_SetVOPMirrorMode = MDrv_MVOP_SetVOPMirrorMode_V2;
245 psMVOPInstPri->fpMVOP_InvOPVS = MDrv_MVOP_INV_OP_VS_V2;
246 psMVOPInstPri->fpMVOP_ForceTop = MDrv_MVOP_FORCE_TOP_V2;
247 psMVOPInstPri->fpMVOP_EnableFreerunMode = MDrv_MVOP_EnableFreerunMode_V2;
248 psMVOPInstPri->fpMVOP_GetBaseAdd = MDrv_MVOP_GetBaseAdd_V2;
249
250 //Sub MVOP
251 psMVOPInstPri->fpMVOP_SubInit = MDrv_MVOP_SubInit_V2;
252 psMVOPInstPri->fpMVOP_SubExit = MDrv_MVOP_SubExit_V2;
253 psMVOPInstPri->fpMVOP_SubEnable = MDrv_MVOP_SubEnable_V2;
254 psMVOPInstPri->fpMVOP_SubSetInputCfg = MDrv_MVOP_SubSetInputCfg_V2;
255 psMVOPInstPri->fpMVOP_SubSetOutputCfg = MDrv_MVOP_SubSetOutputCfg_V2;
256
257 psMVOPInstPri->fpMVOP_SubEnableBlackBG = MDrv_MVOP_EnableBlackBG_V2;
258 psMVOPInstPri->fpMVOP_SubEnableUVShift = MDrv_MVOP_SubEnableUVShift_V2;
259 psMVOPInstPri->fpMVOP_SubSetMonoMode = MDrv_MVOP_SubSetMonoMode_V2;
260 psMVOPInstPri->fpMVOP_SubGetStatus = MDrv_MVOP_SubGetStatus_V2;
261 psMVOPInstPri->fpMVOP_SubGetHSize = MDrv_MVOP_SubGetHSize_V2;
262 psMVOPInstPri->fpMVOP_SubGetVSize = MDrv_MVOP_SubGetVSize_V2;
263 psMVOPInstPri->fpMVOP_SubGetHStart = MDrv_MVOP_SubGetHStart_V2;
264 psMVOPInstPri->fpMVOP_SubGetVStart = MDrv_MVOP_SubGetVStart_V2;
265 psMVOPInstPri->fpMVOP_SubGetIsInterlace = MDrv_MVOP_SubGetIsInterlace_V2;
266 psMVOPInstPri->fpMVOP_SubGetIsHDuplicate = MDrv_MVOP_SubGetIsHDuplicate_V2;
267 psMVOPInstPri->fpMVOP_SubGetIsEnable = MDrv_MVOP_SubGetIsEnable_V2;
268 psMVOPInstPri->fpMVOP_SubGetOutputTiming = MDrv_MVOP_SubGetOutputTiming_V2;
269 psMVOPInstPri->fpMVOP_SubCheckCapability = MDrv_MVOP_SubCheckCapability_V2;
270 psMVOPInstPri->fpMVOP_SubGetMaxHOffset = MDrv_MVOP_SubGetMaxHOffset_V2;
271 psMVOPInstPri->fpMVOP_SubGetMaxVOffset = MDrv_MVOP_SubGetMaxVOffset_V2;
272 psMVOPInstPri->fpMVOP_SubSetClk = MDrv_MVOP_SubSetClk_V2;
273 psMVOPInstPri->fpMVOP_SubSetPattern = MDrv_MVOP_SubSetPattern_V2;
274 psMVOPInstPri->fpMVOP_SubSetTileFormat = MDrv_MVOP_SubSetTileFormat_V2;
275 psMVOPInstPri->fpMVOP_SubGetDstInfo = MDrv_MVOP_SubGetDstInfo_V2;
276 psMVOPInstPri->fpMVOP_SubSetFixVtt = MDrv_MVOP_SubSetFixVtt_V2;
277 psMVOPInstPri->fpMVOP_SubSetMMIOMapBase = MDrv_MVOP_SubSetMMIOMapBase_V2;
278 psMVOPInstPri->fpMVOP_SubMiuSwitch = MDrv_MVOP_SubMiuSwitch_V2;
279 psMVOPInstPri->fpMVOP_SubSetBaseAdd = MDrv_MVOP_SubSetBaseAdd_V2;
280 psMVOPInstPri->fpMVOP_SubGetBaseAdd = MDrv_MVOP_SubGetBaseAdd_V2;
281 psMVOPInstPri->fpMVOP_SubSetVOPMirrorMode = MDrv_MVOP_SubSetVOPMirrorMode_V2;
282 psMVOPInstPri->fpMVOP_SubEnableFreerunMode = MDrv_MVOP_SubEnableFreerunMode_V2;
283
284
285 //Third MVOP
286 psMVOPInstPri->fpMVOP_ExInit = MDrv_MVOP_EX_Init_V2;
287 psMVOPInstPri->fpMVOP_ExExit = MDrv_MVOP_EX_Exit_V2;
288 psMVOPInstPri->fpMVOP_ExEnable = MDrv_MVOP_EX_Enable_V2;
289 psMVOPInstPri->fpMVOP_ExInputCfg = MDrv_MVOP_EX_SetInputCfg_V2;
290 psMVOPInstPri->fpMVOP_ExOutputCfg = MDrv_MVOP_EX_SetOutputCfg_V2;
291
292 psMVOPInstPri->fpMVOP_ExSetClk = MDrv_MVOP_EX_SetClk_V2;
293 psMVOPInstPri->fpMVOP_ExSetPattern = MDrv_MVOP_EX_SetPattern_V2;
294 psMVOPInstPri->fpMVOP_ExSetTileFormat = MDrv_MVOP_EX_SetTileFormat_V2;
295 psMVOPInstPri->fpMVOP_ExEnableUVShift = MDrv_MVOP_EX_EnableUVShift_V2;
296 psMVOPInstPri->fpMVOP_ExEnableBlackBG = MDrv_MVOP_EX_EnableBlackBG_V2;
297 psMVOPInstPri->fpMVOP_ExSetMonoMode = MDrv_MVOP_EX_SetMonoMode_V2;
298 psMVOPInstPri->fpMVOP_ExSetFixVtt = MDrv_MVOP_EX_SetFixVtt_V2;
299 psMVOPInstPri->fpMVOP_ExMiuSwitch = MDrv_MVOP_EX_MiuSwitch_V2;
300 psMVOPInstPri->fpMVOP_ExSetVOPMirrorMode = MDrv_MVOP_EX_SetVOPMirrorMode_V2;
301 psMVOPInstPri->fpMVOP_ExEnableFreerunMode = MDrv_MVOP_EX_EnableFreerunMode_V2;
302
303 psMVOPInstPri->fpMVOP_ExGetOutputTiming = MDrv_MVOP_EX_GetOutputTiming_V2;
304 psMVOPInstPri->fpMVOP_ExGetIsEnable = MDrv_MVOP_EX_GetIsEnable_V2;
305 psMVOPInstPri->fpMVOP_ExGetHSize = MDrv_MVOP_EX_GetHSize_V2;
306 psMVOPInstPri->fpMVOP_ExGetVSize = MDrv_MVOP_EX_GetVSize_V2;
307 psMVOPInstPri->fpMVOP_ExGetHStart = MDrv_MVOP_EX_GetHStart_V2;
308 psMVOPInstPri->fpMVOP_ExGetVStart = MDrv_MVOP_EX_GetVStart_V2;
309 psMVOPInstPri->fpMVOP_ExGetIsInterlace = MDrv_MVOP_EX_GetIsInterlace_V2;
310 psMVOPInstPri->fpMVOP_ExGetIsHDuplicate = MDrv_MVOP_EX_GetIsHDuplicate_V2;
311 psMVOPInstPri->fpMVOP_ExGetStatus = MDrv_MVOP_EX_GetStatus_V2;
312 psMVOPInstPri->fpMVOP_ExCheckCapability = MDrv_MVOP_EX_CheckCapability_V2;
313 psMVOPInstPri->fpMVOP_ExGetDstInfo = MDrv_MVOP_EX_GetDstInfo_V2;
314
315 psMVOPInstPri->fpMVOP_SendBlueScreen = MDrv_MVOP_SendBlueScreen_V2;
316 psMVOPInstPri->fpMVOP_SetCommand = MDrv_MVOP_SetCommand_V2;
317 psMVOPInstPri->fpMVOP_GetCommand = MDrv_MVOP_GetCommand_V2;
318 psMVOPInstPri->fpMVOP_SetFrequency = MDrv_MVOP_SetFrequency_V2;
319
320 psMVOPInstPri->fpMVOP_EnableInterrupt = MDrv_MVOP_EnableInterrupt_V2;
321 psMVOPInstPri->fpMVOP_GetIntStatus = MDrv_MVOP_GetIntStatus_V2;
322 psMVOPInstPri->fpMVOP_SubEnableInterrupt = MDrv_MVOP_SubEnableInterrupt_V2;
323 psMVOPInstPri->fpMVOP_SubGetIntStatus = MDrv_MVOP_SubGetIntStatus_V2;
324 psMVOPInstPri->fpMVOP_ExEnableInterrupt = MDrv_MVOP_EX_EnableInterrupt_V2;
325 psMVOPInstPri->fpMVOP_ExGetIntStatus = MDrv_MVOP_EX_GetIntStatus_V2;
326
327 psMVOPInstPri->fpMVOP_SetPowerState = MDrv_MVOP_SetPowerState_V2;
328 psMVOPInstPri->fpMVOP_SetPowerState_Kernel = MDrv_MVOP_SetPowerState_Kernel_V2;
329 #if defined(MSOS_TYPE_LINUX_KERNEL)
330 MVOP_INSTANCE_PRIVATE* psMVOPInstSTRPri = NULL;
331 UtopiaModuleGetSTRPrivate(pModuleMVOP, (void**)&psMVOPInstSTRPri);
332
333 psMVOPInstSTRPri->fpMVOP_SetPowerState_Kernel = MDrv_MVOP_SetPowerState_Kernel_V2;
334 #endif
335
336 return UTOPIA_STATUS_SUCCESS;
337 }
338
339
MVOPIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)340 MS_U32 MVOPIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
341 {
342 void* pModule = NULL;
343 void* pResource = NULL;
344 MVOP_INSTANCE_PRIVATE* psMVOPInstPri = NULL;
345
346 UtopiaInstanceGetModule(pInstance, &pModule);
347
348 if(UtopiaInstanceGetPrivate(pInstance, (void*)&psMVOPInstPri)!=UTOPIA_STATUS_SUCCESS)
349 {
350 printf("[%s,%5d] Instance Get Private failed\n",__FUNCTION__,__LINE__);
351 }
352
353 //printf("[%s,%5d] u32Cmd type = %ld\n",__FUNCTION__,__LINE__,u32Cmd);
354 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
355 switch(u32Cmd)
356 {
357 case E_MVOP_CMD_INIT:
358 {
359 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
360 {
361 printf("UtopiaResourceObtain fail\n");
362 return UTOPIA_STATUS_ERR_RESOURCE;
363 }
364 psMVOPInstPri->fpMVOP_Init(pInstance);
365 UtopiaResourceRelease(pResource);
366 u32Return = UTOPIA_STATUS_SUCCESS;
367 break;
368 }
369
370
371 case E_MVOP_CMD_EXIT:
372 {
373 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
374 {
375 printf("UtopiaResourceObtain fail\n");
376 return UTOPIA_STATUS_ERR_RESOURCE;
377 }
378 psMVOPInstPri->fpMVOP_Exit(pInstance);
379 UtopiaResourceRelease(pResource);
380 u32Return = UTOPIA_STATUS_SUCCESS;
381 break;
382 }
383
384
385 case E_MVOP_CMD_ENABLE:
386 {
387 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
388 {
389 printf("UtopiaResourceObtain fail\n");
390 return UTOPIA_STATUS_ERR_RESOURCE;
391 }
392 pstMVOP_ENABLE pMVOPArgs = (pstMVOP_ENABLE) pArgs;
393 psMVOPInstPri->fpMVOP_Enable(pInstance, pMVOPArgs->bEnable);
394 UtopiaResourceRelease(pResource);
395 u32Return = UTOPIA_STATUS_SUCCESS;
396 break;
397 }
398
399
400 case E_MVOP_CMD_SET_INPUTCFG:
401 {
402 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
403 {
404 printf("UtopiaResourceObtain fail\n");
405 return UTOPIA_STATUS_ERR_RESOURCE;
406 }
407 pstMVOP_SET_INPUTCFG pMVOPArgs = (pstMVOP_SET_INPUTCFG) pArgs;
408 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_SetInputCfg(pInstance, pMVOPArgs->in, pMVOPArgs->pCfg);
409 UtopiaResourceRelease(pResource);
410 u32Return = UTOPIA_STATUS_SUCCESS;
411 break;
412 }
413
414
415 case E_MVOP_CMD_SET_OTPUTCFG:
416 {
417 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
418 {
419 printf("UtopiaResourceObtain fail\n");
420 return UTOPIA_STATUS_ERR_RESOURCE;
421 }
422 pstMVOP_SET_OTPUTCFG pMVOPArgs = (pstMVOP_SET_OTPUTCFG) pArgs;
423 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_SetOutputCfg(pInstance, pMVOPArgs->pstVideoStatus, pMVOPArgs->bEnHDup);
424 UtopiaResourceRelease(pResource);
425 u32Return = UTOPIA_STATUS_SUCCESS;
426 break;
427 }
428
429 case E_MVOP_CMD_ENABLE_BLACK_BG:
430 {
431 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
432 {
433 printf("UtopiaResourceObtain fail\n");
434 return UTOPIA_STATUS_ERR_RESOURCE;
435 }
436 psMVOPInstPri->fpMVOP_EnableBlackBG(pInstance);
437 UtopiaResourceRelease(pResource);
438 u32Return = UTOPIA_STATUS_SUCCESS;
439 break;
440 }
441
442
443 case E_MVOP_CMD_ENABLE_UV_SHIFT:
444
445 {
446 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
447 {
448 printf("UtopiaResourceObtain fail\n");
449 return UTOPIA_STATUS_ERR_RESOURCE;
450 }
451 pstMVOP_ENABLE_UV_SHIFT pMVOPArgs = (pstMVOP_ENABLE_UV_SHIFT) pArgs;
452 psMVOPInstPri->fpMVOP_EnableUVShift(pInstance, pMVOPArgs->bEnable);
453 UtopiaResourceRelease(pResource);
454 u32Return = UTOPIA_STATUS_SUCCESS;
455 break;
456 }
457
458
459 case E_MVOP_CMD_SET_MONO_MODE:
460 {
461 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
462 {
463 printf("UtopiaResourceObtain fail\n");
464 return UTOPIA_STATUS_ERR_RESOURCE;
465 }
466 pstMVOP_SET_MONO_MODE pMVOPArgs = (pstMVOP_SET_MONO_MODE) pArgs;
467 psMVOPInstPri->fpMVOP_SetMonoMode(pInstance, pMVOPArgs->bEnable);
468 UtopiaResourceRelease(pResource);
469 u32Return = UTOPIA_STATUS_SUCCESS;
470 break;
471 }
472
473
474 case E_MVOP_CMD_GET_HSIZE:
475 {
476 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
477 {
478 printf("UtopiaResourceObtain fail\n");
479 return UTOPIA_STATUS_ERR_RESOURCE;
480 }
481
482 pstMVOP_GET_HSIZE pMVOPArgs = (pstMVOP_GET_HSIZE) pArgs;
483 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_GetHSize(pInstance);
484 UtopiaResourceRelease(pResource);
485 u32Return = UTOPIA_STATUS_SUCCESS;
486 break;
487 }
488
489
490 case E_MVOP_CMD_GET_VSIZE:
491 {
492 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
493 {
494 printf("UtopiaResourceObtain fail\n");
495 return UTOPIA_STATUS_ERR_RESOURCE;
496 }
497
498 pstMVOP_GET_VSIZE pMVOPArgs = (pstMVOP_GET_VSIZE) pArgs;
499 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_GetVSize(pInstance);
500 UtopiaResourceRelease(pResource);
501 u32Return = UTOPIA_STATUS_SUCCESS;
502 break;
503 }
504
505
506 case E_MVOP_CMD_GET_HSTART:
507 {
508 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
509 {
510 printf("UtopiaResourceObtain fail\n");
511 return UTOPIA_STATUS_ERR_RESOURCE;
512 }
513
514 pstMVOP_GET_HSTART pMVOPArgs = (pstMVOP_GET_HSTART) pArgs;
515 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_GetHStart(pInstance);
516 UtopiaResourceRelease(pResource);
517 u32Return = UTOPIA_STATUS_SUCCESS;
518 break;
519 }
520
521
522 case E_MVOP_CMD_GET_VSTART:
523 {
524 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
525 {
526 printf("UtopiaResourceObtain fail\n");
527 return UTOPIA_STATUS_ERR_RESOURCE;
528 }
529
530 pstMVOP_GET_VSTART pMVOPArgs = (pstMVOP_GET_VSTART) pArgs;
531 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_GetVStart(pInstance);
532
533 UtopiaResourceRelease(pResource);
534 u32Return = UTOPIA_STATUS_SUCCESS;
535 break;
536 }
537
538
539 case E_MVOP_CMD_GET_IS_INTERLACE:
540 {
541 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
542 {
543 printf("UtopiaResourceObtain fail\n");
544 return UTOPIA_STATUS_ERR_RESOURCE;
545 }
546
547 pstMVOP_GET_IS_INTERLACE pMVOPArgs = (pstMVOP_GET_IS_INTERLACE) pArgs;
548
549 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_GetIsInterlace(pInstance);
550
551 UtopiaResourceRelease(pResource);
552
553 printf("XC Exited\n");
554
555 u32Return = UTOPIA_STATUS_SUCCESS;
556 break;
557 }
558
559
560 case E_MVOP_CMD_GET_IS_HDUPLICATE:
561 {
562 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
563 {
564 printf("UtopiaResourceObtain fail\n");
565 return UTOPIA_STATUS_ERR_RESOURCE;
566 }
567
568 pstMVOP_GET_IS_HDUPLICATE pMVOPArgs = (pstMVOP_GET_IS_HDUPLICATE) pArgs;
569 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_GetIsHDuplicate(pInstance);
570
571 UtopiaResourceRelease(pResource);
572 u32Return = UTOPIA_STATUS_SUCCESS;
573 break;
574 }
575
576
577 case E_MVOP_CMD_GET_IS_ENABLE:
578 {
579 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
580 {
581 printf("UtopiaResourceObtain fail\n");
582 return UTOPIA_STATUS_ERR_RESOURCE;
583 }
584
585 pstMVOP_GET_IS_ENABLE pMVOPArgs = (pstMVOP_GET_IS_ENABLE) pArgs;
586 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_GetIsEnable(pInstance, pMVOPArgs->pbEnable);
587 UtopiaResourceRelease(pResource);
588 u32Return = UTOPIA_STATUS_SUCCESS;
589 break;
590 }
591
592
593 case E_MVOP_CMD_GET_OUTPUT_TIMING:
594 {
595 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
596 {
597 printf("UtopiaResourceObtain fail\n");
598 return UTOPIA_STATUS_ERR_RESOURCE;
599 }
600
601 pstMVOP_GET_OUTPUT_TIMING pMVOPArgs = (pstMVOP_GET_OUTPUT_TIMING) pArgs;
602 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_GetOutputTiming(pInstance, pMVOPArgs->pMVOPTiming);
603 UtopiaResourceRelease(pResource);
604 u32Return = UTOPIA_STATUS_SUCCESS;
605 break;
606 }
607
608
609 case E_MVOP_CMD_GET_LIBVER:
610 {
611 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
612 {
613 printf("UtopiaResourceObtain fail\n");
614 return UTOPIA_STATUS_ERR_RESOURCE;
615 }
616
617 pstMVOP_GET_LIBVER pMVOPArgs = (pstMVOP_GET_LIBVER) pArgs;
618 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_GetLibVer(pInstance, pMVOPArgs->ppVersion);
619
620 UtopiaResourceRelease(pResource);
621 u32Return = UTOPIA_STATUS_SUCCESS;
622 break;
623 }
624
625
626 case E_MVOP_CMD_CHECK_CAPABILITY:
627 {
628 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
629 {
630 printf("UtopiaResourceObtain fail\n");
631 return UTOPIA_STATUS_ERR_RESOURCE;
632 }
633
634 pstMVOP_CHECK_CAPABILITY pMVOPArgs = (pstMVOP_CHECK_CAPABILITY) pArgs;
635 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_CheckCapability(pInstance, pMVOPArgs->u16HSize, pMVOPArgs->u16VSize, pMVOPArgs->u16Fps);
636
637 UtopiaResourceRelease(pResource);
638 u32Return = UTOPIA_STATUS_SUCCESS;
639 break;
640 }
641
642
643 case E_MVOP_CMD_GET_MAX_HOFFSET:
644 {
645 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
646 {
647 printf("UtopiaResourceObtain fail\n");
648 return UTOPIA_STATUS_ERR_RESOURCE;
649 }
650
651 pstMVOP_GET_MAX_HOFFSET pMVOPArgs = (pstMVOP_GET_MAX_HOFFSET) pArgs;
652 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_GetMaxHOffset(pInstance, pMVOPArgs->u16HSize, pMVOPArgs->u16VSize, pMVOPArgs->u16Fps);
653
654 UtopiaResourceRelease(pResource);
655 u32Return = UTOPIA_STATUS_SUCCESS;
656 break;
657 }
658
659
660 case E_MVOP_CMD_GET_MAX_VOFFSET:
661 {
662 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
663 {
664 printf("UtopiaResourceObtain fail\n");
665 return UTOPIA_STATUS_ERR_RESOURCE;
666 }
667
668 pstMVOP_GET_MAX_VOFFSET pMVOPArgs = (pstMVOP_GET_MAX_VOFFSET) pArgs;
669 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_GetMaxVOffset(pInstance, pMVOPArgs->u16HSize, pMVOPArgs->u16VSize, pMVOPArgs->u16Fps);
670
671 UtopiaResourceRelease(pResource);
672 u32Return = UTOPIA_STATUS_SUCCESS;
673 break;
674 }
675
676
677 case E_MVOP_CMD_SET_DBG_LEVEL:
678 {
679 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
680 {
681 printf("UtopiaResourceObtain fail\n");
682 return UTOPIA_STATUS_ERR_RESOURCE;
683 }
684
685 pstMVOP_SET_DBG_LEVEL pMVOPArgs = (pstMVOP_SET_DBG_LEVEL) pArgs;
686 psMVOPInstPri->fpMVOP_SetDbgLevel(pInstance, pMVOPArgs->level);
687
688 UtopiaResourceRelease(pResource);
689 u32Return = UTOPIA_STATUS_SUCCESS;
690 break;
691 }
692
693
694 case E_MVOP_CMD_GET_INFO:
695 {
696 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
697 {
698 printf("UtopiaResourceObtain fail\n");
699 return UTOPIA_STATUS_ERR_RESOURCE;
700 }
701
702 pstMVOP_GET_INFO pMVOPArgs = (pstMVOP_GET_INFO) pArgs;
703 pMVOPArgs->pRet = psMVOPInstPri->fpMVOP_GetInfo(pInstance);
704
705 UtopiaResourceRelease(pResource);
706 u32Return = UTOPIA_STATUS_SUCCESS;
707 break;
708 }
709
710
711 case E_MVOP_CMD_GET_STATUS:
712 {
713 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
714 {
715 printf("UtopiaResourceObtain fail\n");
716 return UTOPIA_STATUS_ERR_RESOURCE;
717 }
718
719 pstMVOP_GET_STATUS pMVOPArgs = (pstMVOP_GET_STATUS) pArgs;
720 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_GetStatus(pInstance, pMVOPArgs->pMVOPStat);
721
722 UtopiaResourceRelease(pResource);
723 u32Return = UTOPIA_STATUS_SUCCESS;
724 break;
725 }
726
727 case E_MVOP_CMD_SET_CLK:
728 {
729 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
730 {
731 printf("UtopiaResourceObtain fail\n");
732 return UTOPIA_STATUS_ERR_RESOURCE;
733 }
734
735 pstMVOP_SET_CLK pMVOPArgs = (pstMVOP_SET_CLK) pArgs;
736 psMVOPInstPri->fpMVOP_SetClk(pInstance, pMVOPArgs->bEnable);
737
738 UtopiaResourceRelease(pResource);
739 u32Return = UTOPIA_STATUS_SUCCESS;
740 break;
741 }
742
743 case E_MVOP_CMD_SET_PATTERN:
744 {
745 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
746 {
747 printf("UtopiaResourceObtain fail\n");
748 return UTOPIA_STATUS_ERR_RESOURCE;
749 }
750
751 pstMVOP_SET_PATTERN pMVOPArgs = (pstMVOP_SET_PATTERN) pArgs;
752 psMVOPInstPri->fpMVOP_SetPattern(pInstance, pMVOPArgs->enMVOPPattern);
753
754 UtopiaResourceRelease(pResource);
755 u32Return = UTOPIA_STATUS_SUCCESS;
756 break;
757 }
758
759
760 case E_MVOP_CMD_SET_TILE_FORMAT:
761 {
762 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
763 {
764 printf("UtopiaResourceObtain fail\n");
765 return UTOPIA_STATUS_ERR_RESOURCE;
766 }
767
768 pstMVOP_SET_TILE_FORMAT pMVOPArgs = (pstMVOP_SET_TILE_FORMAT) pArgs;
769 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SetTileFormat(pInstance, pMVOPArgs->eTileFmt);
770
771 UtopiaResourceRelease(pResource);
772 u32Return = UTOPIA_STATUS_SUCCESS;
773 break;
774 }
775
776
777 case E_MVOP_CMD_GET_DST_INFO:
778 {
779 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
780 {
781 printf("UtopiaResourceObtain fail\n");
782 return UTOPIA_STATUS_ERR_RESOURCE;
783 }
784
785 pstMVOP_GET_DST_INFO pMVOPArgs = (pstMVOP_GET_DST_INFO) pArgs;
786 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_GetDstInfo(pInstance, pMVOPArgs->pDstInfo, pMVOPArgs->u32SizeofDstInfo);
787
788 UtopiaResourceRelease(pResource);
789 u32Return = UTOPIA_STATUS_SUCCESS;
790 break;
791 }
792
793
794 case E_MVOP_CMD_SET_FIXVTT:
795 {
796 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
797 {
798 printf("UtopiaResourceObtain fail\n");
799 return UTOPIA_STATUS_ERR_RESOURCE;
800 }
801
802 pstMVOP_SET_FIXVTT pMVOPArgs = (pstMVOP_SET_FIXVTT) pArgs;
803 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SetFixVtt(pInstance, pMVOPArgs->u16FixVtt);
804
805
806 UtopiaResourceRelease(pResource);
807 u32Return = UTOPIA_STATUS_SUCCESS;
808 break;
809 }
810
811
812 case E_MVOP_CMD_SET_MMIO_MAPBASE:
813 {
814 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
815 {
816 printf("UtopiaResourceObtain fail\n");
817 return UTOPIA_STATUS_ERR_RESOURCE;
818 }
819
820 pstMVOP_SET_MMIO_MAPBASE pMVOPArgs = (pstMVOP_SET_MMIO_MAPBASE) pArgs;
821 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SetMMIOMapBase(pInstance);
822
823 UtopiaResourceRelease(pResource);
824 u32Return = UTOPIA_STATUS_SUCCESS;
825 break;
826 }
827
828
829 case E_MVOP_CMD_MIU_SWITCH:
830 {
831 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
832 {
833 printf("UtopiaResourceObtain fail\n");
834 return UTOPIA_STATUS_ERR_RESOURCE;
835 }
836
837 pstMVOP_MIU_SWITCH pMVOPArgs = (pstMVOP_MIU_SWITCH) pArgs;
838 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_MiuSwitch(pInstance, pMVOPArgs->u8Miu);
839
840 UtopiaResourceRelease(pResource);
841 u32Return = UTOPIA_STATUS_SUCCESS;
842 break;
843 }
844
845
846 case E_MVOP_CMD_SET_BASEADD:
847 {
848 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
849 {
850 printf("UtopiaResourceObtain fail\n");
851 return UTOPIA_STATUS_ERR_RESOURCE;
852 }
853
854 pstMVOP_SET_BASEADD pMVOPArgs = (pstMVOP_SET_BASEADD) pArgs;
855 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SetBaseAdd(pInstance, pMVOPArgs->u32YOffset, pMVOPArgs->u32UVOffset, pMVOPArgs->bProgressive, pMVOPArgs->b422pack);
856
857 UtopiaResourceRelease(pResource);
858 u32Return = UTOPIA_STATUS_SUCCESS;
859 break;
860 }
861
862
863 case E_MVOP_CMD_SEL_OP_FIELD:
864 {
865 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
866 {
867 printf("UtopiaResourceObtain fail\n");
868 return UTOPIA_STATUS_ERR_RESOURCE;
869 }
870
871 pstMVOP_SEL_OP_FIELD pMVOPArgs = (pstMVOP_SEL_OP_FIELD) pArgs;
872 psMVOPInstPri->fpMVOP_SelOPField(pInstance, pMVOPArgs->bEnable);
873
874 UtopiaResourceRelease(pResource);
875 u32Return = UTOPIA_STATUS_SUCCESS;
876 break;
877 }
878
879
880 case E_MVOP_CMD_SET_REGSIZE_FROM_MVD:
881 {
882 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
883 {
884 printf("UtopiaResourceObtain fail\n");
885 return UTOPIA_STATUS_ERR_RESOURCE;
886 }
887
888 pstMVOP_SET_REGSIZE_FROM_MVD pMVOPArgs = (pstMVOP_SET_REGSIZE_FROM_MVD) pArgs;
889 psMVOPInstPri->fpMVOP_SetRegSizeFromMVD(pInstance, pMVOPArgs->bEnable);
890
891 UtopiaResourceRelease(pResource);
892 u32Return = UTOPIA_STATUS_SUCCESS;
893 break;
894 }
895
896
897 case E_MVOP_CMD_SET_START_POS:
898 {
899 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
900 {
901 printf("UtopiaResourceObtain fail\n");
902 return UTOPIA_STATUS_ERR_RESOURCE;
903 }
904
905 pstMVOP_SET_START_POS pMVOPArgs = (pstMVOP_SET_START_POS) pArgs;
906 psMVOPInstPri->fpMVOP_SetStartPos(pInstance, pMVOPArgs->u16Xpos, pMVOPArgs->u16Ypos);
907
908 UtopiaResourceRelease(pResource);
909 u32Return = UTOPIA_STATUS_SUCCESS;
910 break;
911 }
912
913
914 case E_MVOP_CMD_SET_IMAGE_WIDTH_HIGHT:
915 {
916 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
917 {
918 printf("UtopiaResourceObtain fail\n");
919 return UTOPIA_STATUS_ERR_RESOURCE;
920 }
921
922 pstMVOP_SET_IMAGE_WIDTH_HIGHT pMVOPArgs = (pstMVOP_SET_IMAGE_WIDTH_HIGHT) pArgs;
923 pMVOPArgs->bRet= psMVOPInstPri->fpMVOP_SetImageWidthHight(pInstance, pMVOPArgs->u16Width, pMVOPArgs->u16Height);
924
925 UtopiaResourceRelease(pResource);
926 u32Return = UTOPIA_STATUS_SUCCESS;
927 break;
928 }
929 case E_MVOP_CMD_SET_VOP_MIRROR_MODE:
930 {
931 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
932 {
933 printf("UtopiaResourceObtain fail\n");
934 return UTOPIA_STATUS_ERR_RESOURCE;
935 }
936
937 pstMVOP_SET_VOP_MIRROR_MODE pMVOPArgs = (pstMVOP_SET_VOP_MIRROR_MODE) pArgs;
938 psMVOPInstPri->fpMVOP_SetVOPMirrorMode(pInstance, pMVOPArgs->bEnable, pMVOPArgs->eMirrorMode);
939
940 UtopiaResourceRelease(pResource);
941 u32Return = UTOPIA_STATUS_SUCCESS;
942 break;
943 }
944
945 case E_MVOP_CMD_INV_OP_VS:
946 {
947 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
948 {
949 printf("UtopiaResourceObtain fail\n");
950 return UTOPIA_STATUS_ERR_RESOURCE;
951 }
952
953 pstMVOP_INV_OP_VS pMVOPArgs = (pstMVOP_INV_OP_VS) pArgs;
954 psMVOPInstPri->fpMVOP_InvOPVS(pInstance, pMVOPArgs->bEnable);
955
956 UtopiaResourceRelease(pResource);
957 u32Return = UTOPIA_STATUS_SUCCESS;
958 break;
959 }
960
961
962 case E_MVOP_CMD_FORCE_TOP:
963 {
964 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
965 {
966 printf("UtopiaResourceObtain fail\n");
967 return UTOPIA_STATUS_ERR_RESOURCE;
968 }
969
970 pstMVOP_FORCE_TOP MVOPArgs = (pstMVOP_FORCE_TOP) pArgs;
971 psMVOPInstPri->fpMVOP_ForceTop(pInstance, MVOPArgs->bEnable);
972
973 UtopiaResourceRelease(pResource);
974 u32Return = UTOPIA_STATUS_SUCCESS;
975 break;
976 }
977
978
979 case E_MVOP_CMD_ENABLE_FREERUN_MODE:
980 {
981 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
982 {
983 printf("UtopiaResourceObtain fail\n");
984 return UTOPIA_STATUS_ERR_RESOURCE;
985 }
986
987 pstMVOP_ENABLE_FREERUN_MODE pMVOPArgs = (pstMVOP_ENABLE_FREERUN_MODE) pArgs;
988 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_EnableFreerunMode(pInstance, pMVOPArgs->bEnable);
989
990 UtopiaResourceRelease(pResource);
991 u32Return = UTOPIA_STATUS_SUCCESS;
992 break;
993 }
994
995
996 case E_MVOP_CMD_GET_BASE_ADD:
997 {
998 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
999 {
1000 printf("UtopiaResourceObtain fail\n");
1001 return UTOPIA_STATUS_ERR_RESOURCE;
1002 }
1003
1004 pstMVOP_GET_BASE_ADD pMVOPArgs = (pstMVOP_GET_BASE_ADD) pArgs;
1005 psMVOPInstPri->fpMVOP_GetBaseAdd(pInstance, pMVOPArgs->u32YOffset, pMVOPArgs->u32UVOffset);
1006
1007 UtopiaResourceRelease(pResource);
1008 u32Return = UTOPIA_STATUS_SUCCESS;
1009 break;
1010 }
1011
1012
1013 case E_MVOP_CMD_SUB_INIT:
1014 {
1015 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1016 {
1017 printf("UtopiaResourceObtain fail\n");
1018 return UTOPIA_STATUS_ERR_RESOURCE;
1019 }
1020
1021 psMVOPInstPri->fpMVOP_SubInit(pInstance);
1022
1023 UtopiaResourceRelease(pResource);
1024 u32Return = UTOPIA_STATUS_SUCCESS;
1025 break;
1026 }
1027
1028
1029 case E_MVOP_CMD_SUB_EXIT:
1030 {
1031 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1032 {
1033 printf("UtopiaResourceObtain fail\n");
1034 return UTOPIA_STATUS_ERR_RESOURCE;
1035 }
1036
1037 psMVOPInstPri->fpMVOP_SubExit(pInstance);
1038
1039 UtopiaResourceRelease(pResource);
1040 u32Return = UTOPIA_STATUS_SUCCESS;
1041 break;
1042 }
1043
1044
1045 case E_MVOP_CMD_SUB_ENABLE:
1046 {
1047 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1048 {
1049 printf("UtopiaResourceObtain fail\n");
1050 return UTOPIA_STATUS_ERR_RESOURCE;
1051 }
1052
1053 pstMVOP_SUB_ENABLE pMVOPArgs = (pstMVOP_SUB_ENABLE) pArgs;
1054 psMVOPInstPri->fpMVOP_SubEnable(pInstance, pMVOPArgs->bEnable);
1055
1056 UtopiaResourceRelease(pResource);
1057 u32Return = UTOPIA_STATUS_SUCCESS;
1058 break;
1059 }
1060
1061
1062 case E_MVOP_CMD_SUB_SET_INPUTCFG:
1063 {
1064 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1065 {
1066 printf("UtopiaResourceObtain fail\n");
1067 return UTOPIA_STATUS_ERR_RESOURCE;
1068 }
1069
1070 pstMVOP_SUB_SET_INPUTCFG pMVOPArgs = (pstMVOP_SUB_SET_INPUTCFG) pArgs;
1071 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_SubSetInputCfg(pInstance, pMVOPArgs->in, pMVOPArgs->pCfg);
1072
1073 UtopiaResourceRelease(pResource);
1074 u32Return = UTOPIA_STATUS_SUCCESS;
1075 break;
1076 }
1077
1078
1079 case E_MVOP_CMD_SUB_SET_OTPUTCFG:
1080 {
1081 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1082 {
1083 printf("UtopiaResourceObtain fail\n");
1084 return UTOPIA_STATUS_ERR_RESOURCE;
1085 }
1086
1087 pstMVOP_SUB_SET_OTPUTCFG pMVOPArgs = (pstMVOP_SUB_SET_OTPUTCFG) pArgs;
1088 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_SubSetOutputCfg(pInstance, pMVOPArgs->pstVideoStatus, pMVOPArgs->bEnHDup);
1089
1090 UtopiaResourceRelease(pResource);
1091 u32Return = UTOPIA_STATUS_SUCCESS;
1092 break;
1093 }
1094
1095
1096 case E_MVOP_CMD_SUB_ENABLE_BLACK_BG:
1097 {
1098 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1099 {
1100 printf("UtopiaResourceObtain fail\n");
1101 return UTOPIA_STATUS_ERR_RESOURCE;
1102 }
1103
1104 psMVOPInstPri->fpMVOP_SubEnableBlackBG(pInstance);
1105
1106 UtopiaResourceRelease(pResource);
1107 u32Return = UTOPIA_STATUS_SUCCESS;
1108 break;
1109 }
1110
1111
1112 case E_MVOP_CMD_SUB_ENABLE_UV_SHIFT:
1113 {
1114 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1115 {
1116 printf("UtopiaResourceObtain fail\n");
1117 return UTOPIA_STATUS_ERR_RESOURCE;
1118 }
1119
1120 pstMVOP_SUB_ENABLE_UV_SHIFT pMVOPArgs = (pstMVOP_SUB_ENABLE_UV_SHIFT) pArgs;
1121 psMVOPInstPri->fpMVOP_SubEnableUVShift(pInstance, pMVOPArgs->bEnable);
1122
1123 UtopiaResourceRelease(pResource);
1124 u32Return = UTOPIA_STATUS_SUCCESS;
1125 break;
1126 }
1127
1128
1129 case E_MVOP_CMD_SUB_SET_MONO_MODE:
1130 {
1131 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1132 {
1133 printf("UtopiaResourceObtain fail\n");
1134 return UTOPIA_STATUS_ERR_RESOURCE;
1135 }
1136
1137 pstMVOP_SUB_SET_MONO_MODE pMVOPArgs = (pstMVOP_SUB_SET_MONO_MODE) pArgs;
1138 psMVOPInstPri->fpMVOP_SubSetMonoMode(pInstance, pMVOPArgs->bEnable);
1139
1140 UtopiaResourceRelease(pResource);
1141 u32Return = UTOPIA_STATUS_SUCCESS;
1142 break;
1143 }
1144
1145
1146 case E_MVOP_CMD_SUB_GET_HSIZE:
1147 {
1148 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1149 {
1150 printf("UtopiaResourceObtain fail\n");
1151 return UTOPIA_STATUS_ERR_RESOURCE;
1152 }
1153
1154 pstMVOP_SUB_GET_HSIZE pMVOPArgs = (pstMVOP_SUB_GET_HSIZE) pArgs;
1155 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_SubGetHSize(pInstance);
1156
1157 UtopiaResourceRelease(pResource);
1158 u32Return = UTOPIA_STATUS_SUCCESS;
1159 break;
1160 }
1161
1162
1163 case E_MVOP_CMD_SUB_GET_VSIZE:
1164 {
1165 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1166 {
1167 printf("UtopiaResourceObtain fail\n");
1168 return UTOPIA_STATUS_ERR_RESOURCE;
1169 }
1170
1171 pstMVOP_SUB_GET_VSIZE pMVOPArgs = (pstMVOP_SUB_GET_VSIZE) pArgs;
1172 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_SubGetVSize(pInstance);
1173
1174 UtopiaResourceRelease(pResource);
1175 u32Return = UTOPIA_STATUS_SUCCESS;
1176 break;
1177 }
1178
1179
1180 case E_MVOP_CMD_SUB_GET_HSTART:
1181 {
1182 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1183 {
1184 printf("UtopiaResourceObtain fail\n");
1185 return UTOPIA_STATUS_ERR_RESOURCE;
1186 }
1187
1188 pstMVOP_SUB_GET_HSTART pMVOPArgs = (pstMVOP_SUB_GET_HSTART) pArgs;
1189 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_SubGetHStart(pInstance);
1190
1191 UtopiaResourceRelease(pResource);
1192 u32Return = UTOPIA_STATUS_SUCCESS;
1193 break;
1194 }
1195
1196
1197 case E_MVOP_CMD_SUB_GET_VSTART:
1198 {
1199 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1200 {
1201 printf("UtopiaResourceObtain fail\n");
1202 return UTOPIA_STATUS_ERR_RESOURCE;
1203 }
1204
1205 pstMVOP_SUB_GET_VSTART pMVOPArgs = (pstMVOP_SUB_GET_VSTART) pArgs;
1206 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_SubGetVStart(pInstance);
1207
1208 UtopiaResourceRelease(pResource);
1209 u32Return = UTOPIA_STATUS_SUCCESS;
1210 break;
1211 }
1212
1213
1214 case E_MVOP_CMD_SUB_GET_IS_INTERLACE:
1215 {
1216 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1217 {
1218 printf("UtopiaResourceObtain fail\n");
1219 return UTOPIA_STATUS_ERR_RESOURCE;
1220 }
1221
1222 pstMVOP_SUB_GET_IS_INTERLACE pMVOPArgs = (pstMVOP_SUB_GET_IS_INTERLACE) pArgs;
1223 pMVOPArgs->bRet= psMVOPInstPri->fpMVOP_SubGetIsInterlace(pInstance);
1224
1225 UtopiaResourceRelease(pResource);
1226 u32Return = UTOPIA_STATUS_SUCCESS;
1227 break;
1228 }
1229
1230
1231 case E_MVOP_CMD_SUB_GET_IS_HDUPLICATE:
1232 {
1233 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1234 {
1235 printf("UtopiaResourceObtain fail\n");
1236 return UTOPIA_STATUS_ERR_RESOURCE;
1237 }
1238
1239 pstMVOP_SUB_GET_IS_HDUPLICATE pMVOPArgs = (pstMVOP_SUB_GET_IS_HDUPLICATE) pArgs;
1240 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SubGetIsHDuplicate(pInstance);
1241
1242 UtopiaResourceRelease(pResource);
1243 u32Return = UTOPIA_STATUS_SUCCESS;
1244 break;
1245 }
1246
1247
1248 case E_MVOP_CMD_SUB_GET_IS_ENABLE:
1249 {
1250 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1251 {
1252 printf("UtopiaResourceObtain fail\n");
1253 return UTOPIA_STATUS_ERR_RESOURCE;
1254 }
1255
1256 pstMVOP_SUB_GET_IS_ENABLE pMVOPArgs = (pstMVOP_SUB_GET_IS_ENABLE) pArgs;
1257 pMVOPArgs->eRet= psMVOPInstPri->fpMVOP_SubGetIsEnable(pInstance, pMVOPArgs->pbEnable);
1258
1259 UtopiaResourceRelease(pResource);
1260 u32Return = UTOPIA_STATUS_SUCCESS;
1261 break;
1262 }
1263
1264
1265 case E_MVOP_CMD_SUB_GET_OUTPUT_TIMING:
1266 {
1267 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1268 {
1269 printf("UtopiaResourceObtain fail\n");
1270 return UTOPIA_STATUS_ERR_RESOURCE;
1271 }
1272
1273 pstMVOP_SUB_GET_OUTPUT_TIMING pMVOPArgs = (pstMVOP_SUB_GET_OUTPUT_TIMING) pArgs;
1274 pMVOPArgs->eRet= psMVOPInstPri->fpMVOP_SubGetOutputTiming(pInstance, pMVOPArgs->pMVOPTiming);
1275
1276 UtopiaResourceRelease(pResource);
1277 u32Return = UTOPIA_STATUS_SUCCESS;
1278 break;
1279 }
1280
1281
1282 case E_MVOP_CMD_SUB_CHECK_CAPABILITY:
1283 {
1284 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1285 {
1286 printf("UtopiaResourceObtain fail\n");
1287 return UTOPIA_STATUS_ERR_RESOURCE;
1288 }
1289
1290 pstMVOP_SUB_CHECK_CAPABILITY pMVOPArgs = (pstMVOP_SUB_CHECK_CAPABILITY) pArgs;
1291 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SubCheckCapability(pInstance, pMVOPArgs->u16HSize, pMVOPArgs->u16VSize, pMVOPArgs->u16Fps);
1292
1293 UtopiaResourceRelease(pResource);
1294 u32Return = UTOPIA_STATUS_SUCCESS;
1295 break;
1296 }
1297
1298
1299 case E_MVOP_CMD_SUB_GET_MAXHOFFSET:
1300 {
1301 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1302 {
1303 printf("UtopiaResourceObtain fail\n");
1304 return UTOPIA_STATUS_ERR_RESOURCE;
1305 }
1306
1307 pstMVOP_SUB_GET_MAX_HOFFSET pMVOPArgs = (pstMVOP_SUB_GET_MAX_HOFFSET) pArgs;
1308 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_SubGetMaxHOffset(pInstance, pMVOPArgs->u16HSize, pMVOPArgs->u16VSize, pMVOPArgs->u16Fps);
1309
1310 UtopiaResourceRelease(pResource);
1311 u32Return = UTOPIA_STATUS_SUCCESS;
1312 break;
1313 }
1314
1315
1316 case E_MVOP_CMD_SUB_GET_MAXVOFFSET:
1317 {
1318 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1319 {
1320 printf("UtopiaResourceObtain fail\n");
1321 return UTOPIA_STATUS_ERR_RESOURCE;
1322 }
1323
1324 pstMVOP_SUB_GET_MAX_VOFFSET pMVOPArgs = (pstMVOP_SUB_GET_MAX_VOFFSET) pArgs;
1325 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_SubGetMaxVOffset(pInstance, pMVOPArgs->u16HSize, pMVOPArgs->u16VSize, pMVOPArgs->u16Fps);
1326
1327 UtopiaResourceRelease(pResource);
1328 u32Return = UTOPIA_STATUS_SUCCESS;
1329 break;
1330 }
1331
1332 case E_MVOP_CMD_SUB_SET_CLK:
1333 {
1334 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1335 {
1336 printf("UtopiaResourceObtain fail\n");
1337 return UTOPIA_STATUS_ERR_RESOURCE;
1338 }
1339
1340 pstMVOP_SUB_SET_CLK pMVOPArgs = (pstMVOP_SUB_SET_CLK) pArgs;
1341 psMVOPInstPri->fpMVOP_SubSetClk(pInstance, pMVOPArgs->bEnable);
1342
1343 UtopiaResourceRelease(pResource);
1344 u32Return = UTOPIA_STATUS_SUCCESS;
1345 break;
1346 }
1347
1348 case E_MVOP_CMD_SUB_SET_PATTERN:
1349 {
1350 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1351 {
1352 printf("UtopiaResourceObtain fail\n");
1353 return UTOPIA_STATUS_ERR_RESOURCE;
1354 }
1355
1356 pstMVOP_SUB_SET_PATTERN pMVOPArgs = (pstMVOP_SUB_SET_PATTERN) pArgs;
1357 psMVOPInstPri->fpMVOP_SubSetPattern(pInstance, pMVOPArgs->enMVOPPattern);
1358
1359 UtopiaResourceRelease(pResource);
1360 u32Return = UTOPIA_STATUS_SUCCESS;
1361 break;
1362 }
1363
1364
1365 case E_MVOP_CMD_SUB_SET_TILE_FORMAT:
1366 {
1367 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1368 {
1369 printf("UtopiaResourceObtain fail\n");
1370 return UTOPIA_STATUS_ERR_RESOURCE;
1371 }
1372
1373 pstMVOP_SUB_SET_TILE_FORMAT pMVOPArgs = (pstMVOP_SUB_SET_TILE_FORMAT) pArgs;
1374 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SubSetTileFormat(pInstance, pMVOPArgs->eTileFmt);
1375
1376 UtopiaResourceRelease(pResource);
1377 u32Return = UTOPIA_STATUS_SUCCESS;
1378 break;
1379 }
1380
1381
1382 case E_MVOP_CMD_SUB_GET_DST_INFO:
1383 {
1384 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1385 {
1386 printf("UtopiaResourceObtain fail\n");
1387 return UTOPIA_STATUS_ERR_RESOURCE;
1388 }
1389
1390 pstMVOP_SUB_GET_DST_INFO pMVOPArgs = (pstMVOP_SUB_GET_DST_INFO) pArgs;
1391 pMVOPArgs->bRet= psMVOPInstPri->fpMVOP_SubGetDstInfo(pInstance, pMVOPArgs->pDstInfo, pMVOPArgs->u32SizeofDstInfo);
1392
1393 UtopiaResourceRelease(pResource);
1394 u32Return = UTOPIA_STATUS_SUCCESS;
1395 break;
1396 }
1397
1398
1399 case E_MVOP_CMD_SUB_SET_FIXVTT:
1400 {
1401 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1402 {
1403 printf("UtopiaResourceObtain fail\n");
1404 return UTOPIA_STATUS_ERR_RESOURCE;
1405 }
1406
1407 pstMVOP_SUB_SET_FIXVTT pMVOPArgs = (pstMVOP_SUB_SET_FIXVTT) pArgs;
1408 pMVOPArgs->bRet= psMVOPInstPri->fpMVOP_SubSetFixVtt(pInstance, pMVOPArgs->u16FixVtt);
1409
1410 UtopiaResourceRelease(pResource);
1411 u32Return = UTOPIA_STATUS_SUCCESS;
1412 break;
1413 }
1414
1415
1416 case E_MVOP_CMD_SUB_SET_MMIO_MAPBASE:
1417 {
1418 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1419 {
1420 printf("UtopiaResourceObtain fail\n");
1421 return UTOPIA_STATUS_ERR_RESOURCE;
1422 }
1423
1424 pstMVOP_SUB_SET_MMIO_MAPBASE pMVOPArgs = (pstMVOP_SUB_SET_MMIO_MAPBASE) pArgs;
1425 pMVOPArgs->bRet= psMVOPInstPri->fpMVOP_SubSetMMIOMapBase(pInstance);
1426
1427 UtopiaResourceRelease(pResource);
1428 u32Return = UTOPIA_STATUS_SUCCESS;
1429 break;
1430 }
1431
1432
1433 case E_MVOP_CMD_SUB_MIU_SWITCH:
1434 {
1435 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1436 {
1437 printf("UtopiaResourceObtain fail\n");
1438 return UTOPIA_STATUS_ERR_RESOURCE;
1439 }
1440
1441 pstMVOP_SUB_MIU_SWITCH pMVOPArgs = (pstMVOP_SUB_MIU_SWITCH) pArgs;
1442 pMVOPArgs->eRet= psMVOPInstPri->fpMVOP_SubMiuSwitch(pInstance, pMVOPArgs->u8Miu);
1443
1444 UtopiaResourceRelease(pResource);
1445 u32Return = UTOPIA_STATUS_SUCCESS;
1446 break;
1447 }
1448
1449
1450 case E_MVOP_CMD_SUB_SET_BASEADD:
1451 {
1452 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1453 {
1454 printf("UtopiaResourceObtain fail\n");
1455 return UTOPIA_STATUS_ERR_RESOURCE;
1456 }
1457
1458 pstMVOP_SUB_SET_BASEADD pMVOPArgs = (pstMVOP_SUB_SET_BASEADD) pArgs;
1459 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SubSetBaseAdd(pInstance, pMVOPArgs->u32YOffset, pMVOPArgs->u32UVOffset, pMVOPArgs->bProgressive, pMVOPArgs->b422pack);
1460
1461 UtopiaResourceRelease(pResource);
1462 u32Return = UTOPIA_STATUS_SUCCESS;
1463 break;
1464 }
1465
1466
1467 case E_MVOP_CMD_SUB_SET_VOP_MIRRORMODE:
1468 {
1469 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1470 {
1471 printf("UtopiaResourceObtain fail\n");
1472 return UTOPIA_STATUS_ERR_RESOURCE;
1473 }
1474
1475 pstMVOP_SUB_SET_VOP_MIRROR_MODE pMVOPArgs = (pstMVOP_SUB_SET_VOP_MIRROR_MODE) pArgs;
1476 psMVOPInstPri->fpMVOP_SubSetVOPMirrorMode(pInstance, pMVOPArgs->bEnable, pMVOPArgs->eMirrorMode);
1477
1478 UtopiaResourceRelease(pResource);
1479 u32Return = UTOPIA_STATUS_SUCCESS;
1480 break;
1481 }
1482
1483
1484 case E_MVOP_CMD_SUB_ENABLE_FREERUN_MODE:
1485 {
1486 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1487 {
1488 printf("UtopiaResourceObtain fail\n");
1489 return UTOPIA_STATUS_ERR_RESOURCE;
1490 }
1491
1492 pstMVOP_SUB_ENABLE_FREERUN_MODE pMVOPArgs = (pstMVOP_SUB_ENABLE_FREERUN_MODE) pArgs;
1493 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SubEnableFreerunMode(pInstance, pMVOPArgs->bEnable);
1494
1495 UtopiaResourceRelease(pResource);
1496 u32Return = UTOPIA_STATUS_SUCCESS;
1497 break;
1498 }
1499
1500
1501 case E_MVOP_CMD_SUB_GET_BASEADD:
1502 {
1503 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1504 {
1505 printf("UtopiaResourceObtain fail\n");
1506 return UTOPIA_STATUS_ERR_RESOURCE;
1507 }
1508
1509 pstMVOP_SUB_GET_BASE_ADD pMVOPArgs = (pstMVOP_SUB_GET_BASE_ADD) pArgs;
1510 psMVOPInstPri->fpMVOP_SubGetBaseAdd(pInstance, pMVOPArgs->u32YOffset, pMVOPArgs->u32UVOffset);
1511
1512 UtopiaResourceRelease(pResource);
1513 u32Return = UTOPIA_STATUS_SUCCESS;
1514 break;
1515 }
1516
1517
1518 case E_MVOP_CMD_EX_INIT:
1519 {
1520 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1521 {
1522 printf("UtopiaResourceObtain fail\n");
1523 return UTOPIA_STATUS_ERR_RESOURCE;
1524 }
1525
1526 pstMVOP_EX_INIT pMVOPArgs = (pstMVOP_EX_INIT) pArgs;
1527 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExInit(pInstance, pMVOPArgs->eID, pMVOPArgs->u32InitParam);
1528
1529 UtopiaResourceRelease(pResource);
1530 u32Return = UTOPIA_STATUS_SUCCESS;
1531 break;
1532 }
1533
1534
1535 case E_MVOP_CMD_EX_EXIT:
1536 {
1537 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1538 {
1539 printf("UtopiaResourceObtain fail\n");
1540 return UTOPIA_STATUS_ERR_RESOURCE;
1541 }
1542
1543 pstMVOP_EX_EXIT pMVOPArgs = (pstMVOP_EX_EXIT) pArgs;
1544 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExExit(pInstance, pMVOPArgs->eID, pMVOPArgs->u32ExitParam);
1545
1546 UtopiaResourceRelease(pResource);
1547 u32Return = UTOPIA_STATUS_SUCCESS;
1548 break;
1549 }
1550
1551
1552 case E_MVOP_CMD_EX_ENABLE:
1553 {
1554 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1555 {
1556 printf("UtopiaResourceObtain fail\n");
1557 return UTOPIA_STATUS_ERR_RESOURCE;
1558 }
1559
1560 pstMVOP_EX_ENABLE pMVOPArgs = (pstMVOP_EX_ENABLE) pArgs;
1561 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExEnable(pInstance, pMVOPArgs->eID, pMVOPArgs->bEnable);
1562
1563 UtopiaResourceRelease(pResource);
1564 u32Return = UTOPIA_STATUS_SUCCESS;
1565 break;
1566 }
1567
1568
1569 case E_MVOP_CMD_EX_SET_INPUTCFG:
1570 {
1571 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1572 {
1573 printf("UtopiaResourceObtain fail\n");
1574 return UTOPIA_STATUS_ERR_RESOURCE;
1575 }
1576
1577 pstMVOP_EX_SET_INPUTCFG pMVOPArgs = (pstMVOP_EX_SET_INPUTCFG) pArgs;
1578 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExInputCfg(pInstance, pMVOPArgs->eID, pMVOPArgs->in, pMVOPArgs->pCfg);
1579
1580 UtopiaResourceRelease(pResource);
1581 u32Return = UTOPIA_STATUS_SUCCESS;
1582 break;
1583 }
1584
1585
1586 case E_MVOP_CMD_EX_SET_OTPUTCFG:
1587 {
1588 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1589 {
1590 printf("UtopiaResourceObtain fail\n");
1591 return UTOPIA_STATUS_ERR_RESOURCE;
1592 }
1593
1594 pstMVOP_EX_SET_OTPUTCFG pMVOPArgs = (pstMVOP_EX_SET_OTPUTCFG) pArgs;
1595 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExOutputCfg(pInstance, pMVOPArgs->eID, pMVOPArgs->pstVideoStatus, pMVOPArgs->bEnHDup);
1596
1597 UtopiaResourceRelease(pResource);
1598 u32Return = UTOPIA_STATUS_SUCCESS;
1599 break;
1600 }
1601
1602 case E_MVOP_CMD_EX_SET_CLK:
1603 {
1604 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1605 {
1606 printf("UtopiaResourceObtain fail\n");
1607 return UTOPIA_STATUS_ERR_RESOURCE;
1608 }
1609
1610 pstMVOP_EX_SET_CLK pMVOPArgs = (pstMVOP_EX_SET_CLK) pArgs;
1611 psMVOPInstPri->fpMVOP_ExSetClk(pInstance, pMVOPArgs->eID, pMVOPArgs->bEnable);
1612
1613 UtopiaResourceRelease(pResource);
1614 u32Return = UTOPIA_STATUS_SUCCESS;
1615 break;
1616 }
1617
1618 case E_MVOP_CMD_EX_SET_PATTERN:
1619 {
1620 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1621 {
1622 printf("UtopiaResourceObtain fail\n");
1623 return UTOPIA_STATUS_ERR_RESOURCE;
1624 }
1625
1626 pstMVOP_EX_SET_PATTERN pMVOPArgs = (pstMVOP_EX_SET_PATTERN) pArgs;
1627 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExSetPattern(pInstance, pMVOPArgs->eID, pMVOPArgs->enMVOPPattern);
1628
1629 UtopiaResourceRelease(pResource);
1630 u32Return = UTOPIA_STATUS_SUCCESS;
1631 break;
1632 }
1633
1634
1635 case E_MVOP_CMD_EX_SET_TILEFORMAT:
1636 {
1637 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1638 {
1639 printf("UtopiaResourceObtain fail\n");
1640 return UTOPIA_STATUS_ERR_RESOURCE;
1641 }
1642
1643 pstMVOP_EX_SET_TILE_FORMAT pMVOPArgs = (pstMVOP_EX_SET_TILE_FORMAT) pArgs;
1644 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExSetTileFormat(pInstance, pMVOPArgs->eID, pMVOPArgs->eTileFmt);
1645
1646 UtopiaResourceRelease(pResource);
1647 u32Return = UTOPIA_STATUS_SUCCESS;
1648 break;
1649 }
1650
1651
1652 case E_MVOP_CMD_EX_ENABLE_UV_SHIFT:
1653 {
1654 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1655 {
1656 printf("UtopiaResourceObtain fail\n");
1657 return UTOPIA_STATUS_ERR_RESOURCE;
1658 }
1659
1660 pstMVOP_EX_ENABLE_UV_SHIFT pMVOPArgs = (pstMVOP_EX_ENABLE_UV_SHIFT) pArgs;
1661 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExEnableUVShift(pInstance, pMVOPArgs->eID, pMVOPArgs->bEnable);
1662
1663 UtopiaResourceRelease(pResource);
1664 u32Return = UTOPIA_STATUS_SUCCESS;
1665 break;
1666 }
1667
1668
1669 case E_MVOP_CMD_EX_ENABLE_BLACK_BG:
1670 {
1671 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1672 {
1673 printf("UtopiaResourceObtain fail\n");
1674 return UTOPIA_STATUS_ERR_RESOURCE;
1675 }
1676
1677 pstMVOP_EX_ENABLE_BLACK_BG pMVOPArgs = (pstMVOP_EX_ENABLE_BLACK_BG) pArgs;
1678 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExEnableBlackBG(pInstance, pMVOPArgs->eID);
1679
1680 UtopiaResourceRelease(pResource);
1681 u32Return = UTOPIA_STATUS_SUCCESS;
1682 break;
1683 }
1684
1685
1686 case E_MVOP_CMD_EX_SET_MONO_MODE:
1687 {
1688 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1689 {
1690 printf("UtopiaResourceObtain fail\n");
1691 return UTOPIA_STATUS_ERR_RESOURCE;
1692 }
1693
1694 pstMVOP_EX_SET_MONO_MODE pMVOPArgs = (pstMVOP_EX_SET_MONO_MODE) pArgs;
1695 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExSetMonoMode(pInstance, pMVOPArgs->eID, pMVOPArgs->bEnable);
1696
1697 UtopiaResourceRelease(pResource);
1698 u32Return = UTOPIA_STATUS_SUCCESS;
1699 break;
1700 }
1701
1702
1703 case E_MVOP_CMD_EX_SET_FIXVTT:
1704 {
1705 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1706 {
1707 printf("UtopiaResourceObtain fail\n");
1708 return UTOPIA_STATUS_ERR_RESOURCE;
1709 }
1710
1711 pstMVOP_EX_SET_FIXVTT pMVOPArgs = (pstMVOP_EX_SET_FIXVTT) pArgs;
1712 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExSetFixVtt(pInstance, pMVOPArgs->eID, pMVOPArgs->u16FixVtt);
1713
1714 UtopiaResourceRelease(pResource);
1715 u32Return = UTOPIA_STATUS_SUCCESS;
1716 break;
1717 }
1718
1719
1720 case E_MVOP_CMD_EX_MIU_SWITCH:
1721 {
1722 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1723 {
1724 printf("UtopiaResourceObtain fail\n");
1725 return UTOPIA_STATUS_ERR_RESOURCE;
1726 }
1727
1728 pstMVOP_EX_MIU_SWITCH pMVOPArgs = (pstMVOP_EX_MIU_SWITCH) pArgs;
1729 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExMiuSwitch(pInstance, pMVOPArgs->eID, pMVOPArgs->u8Miu);
1730
1731 UtopiaResourceRelease(pResource);
1732 u32Return = UTOPIA_STATUS_SUCCESS;
1733 break;
1734 }
1735
1736
1737 case E_MVOP_CMD_EX_SET_VOP_MIRRORMODE:
1738 {
1739 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1740 {
1741 printf("UtopiaResourceObtain fail\n");
1742 return UTOPIA_STATUS_ERR_RESOURCE;
1743 }
1744
1745 pstMVOP_EX_SET_VOP_MIRROR_MODE pMVOPArgs = (pstMVOP_EX_SET_VOP_MIRROR_MODE) pArgs;
1746 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExSetVOPMirrorMode(pInstance, pMVOPArgs->eID, pMVOPArgs->bEnable, pMVOPArgs->eMirrorMode);
1747
1748 UtopiaResourceRelease(pResource);
1749 u32Return = UTOPIA_STATUS_SUCCESS;
1750 break;
1751 }
1752
1753
1754 case E_MVOP_CMD_EX_ENABLE_FREERUN_MODE:
1755 {
1756 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1757 {
1758 printf("UtopiaResourceObtain fail\n");
1759 return UTOPIA_STATUS_ERR_RESOURCE;
1760 }
1761
1762 pstMVOP_EX_ENABLE_FREERUN_MODE pMVOPArgs = (pstMVOP_EX_ENABLE_FREERUN_MODE) pArgs;
1763 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExEnableFreerunMode(pInstance, pMVOPArgs->eID, pMVOPArgs->bEnable);
1764
1765 UtopiaResourceRelease(pResource);
1766 u32Return = UTOPIA_STATUS_SUCCESS;
1767 break;
1768 }
1769
1770
1771 case E_MVOP_CMD_EX_GET_OUTPUT_TIMING:
1772 {
1773 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1774 {
1775 printf("UtopiaResourceObtain fail\n");
1776 return UTOPIA_STATUS_ERR_RESOURCE;
1777 }
1778
1779 pstMVOP_EX_GET_OUTPUT_TIMING pMVOPArgs = (pstMVOP_EX_GET_OUTPUT_TIMING) pArgs;
1780 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExGetOutputTiming(pInstance, pMVOPArgs->eID, pMVOPArgs->pMVOPTiming);
1781
1782 UtopiaResourceRelease(pResource);
1783 u32Return = UTOPIA_STATUS_SUCCESS;
1784 break;
1785 }
1786
1787
1788 case E_MVOP_CMD_EX_GET_IS_ENABLE:
1789 {
1790 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1791 {
1792 printf("UtopiaResourceObtain fail\n");
1793 return UTOPIA_STATUS_ERR_RESOURCE;
1794 }
1795
1796 pstMVOP_EX_GET_IS_ENABLE pMVOPArgs = (pstMVOP_EX_GET_IS_ENABLE) pArgs;
1797 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_ExGetIsEnable(pInstance, pMVOPArgs->eID, pMVOPArgs->pbEnable);
1798
1799 UtopiaResourceRelease(pResource);
1800 u32Return = UTOPIA_STATUS_SUCCESS;
1801 break;
1802 }
1803
1804
1805 case E_MVOP_CMD_EX_GET_HSIZE:
1806 {
1807 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1808 {
1809 printf("UtopiaResourceObtain fail\n");
1810 return UTOPIA_STATUS_ERR_RESOURCE;
1811 }
1812
1813 pstMVOP_EX_GET_HSIZE pMVOPArgs = (pstMVOP_EX_GET_HSIZE) pArgs;
1814 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_ExGetVStart(pInstance, pMVOPArgs->eID);
1815
1816 UtopiaResourceRelease(pResource);
1817 u32Return = UTOPIA_STATUS_SUCCESS;
1818 break;
1819 }
1820
1821
1822 case E_MVOP_CMD_EX_GET_VSIZE:
1823 {
1824 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1825 {
1826 printf("UtopiaResourceObtain fail\n");
1827 return UTOPIA_STATUS_ERR_RESOURCE;
1828 }
1829
1830 pstMVOP_EX_GET_VSIZE pMVOPArgs = (pstMVOP_EX_GET_VSIZE) pArgs;
1831 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_ExGetVStart(pInstance, pMVOPArgs->eID);
1832
1833
1834 UtopiaResourceRelease(pResource);
1835 u32Return = UTOPIA_STATUS_SUCCESS;
1836 break;
1837 }
1838
1839
1840 case E_MVOP_CMD_EX_GET_HSTART:
1841 {
1842 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1843 {
1844 printf("UtopiaResourceObtain fail\n");
1845 return UTOPIA_STATUS_ERR_RESOURCE;
1846 }
1847
1848 pstMVOP_EX_GET_HSTART pMVOPArgs = (pstMVOP_EX_GET_HSTART) pArgs;
1849 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_ExGetVStart(pInstance, pMVOPArgs->eID);
1850
1851 UtopiaResourceRelease(pResource);
1852 u32Return = UTOPIA_STATUS_SUCCESS;
1853 break;
1854 }
1855
1856
1857 case E_MVOP_CMD_EX_GET_VSTART:
1858 {
1859 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1860 {
1861 printf("UtopiaResourceObtain fail\n");
1862 return UTOPIA_STATUS_ERR_RESOURCE;
1863 }
1864
1865 pstMVOP_EX_GET_VSTART pMVOPArgs = (pstMVOP_EX_GET_VSTART) pArgs;
1866 pMVOPArgs->u16Ret = psMVOPInstPri->fpMVOP_ExGetVStart(pInstance, pMVOPArgs->eID);
1867
1868 UtopiaResourceRelease(pResource);
1869 u32Return = UTOPIA_STATUS_SUCCESS;
1870 break;
1871 }
1872
1873
1874 case E_MVOP_CMD_EX_GET_IS_INTERLACE:
1875 {
1876 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1877 {
1878 printf("UtopiaResourceObtain fail\n");
1879 return UTOPIA_STATUS_ERR_RESOURCE;
1880 }
1881
1882 pstMVOP_EX_GET_IS_INTERLACE pMVOPArgs = (pstMVOP_EX_GET_IS_INTERLACE) pArgs;
1883 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_ExGetIsInterlace(pInstance, pMVOPArgs->eID);
1884
1885 UtopiaResourceRelease(pResource);
1886 u32Return = UTOPIA_STATUS_SUCCESS;
1887 break;
1888 }
1889
1890
1891 case E_MVOP_CMD_EX_GET_IS_HDUPLICATE:
1892 {
1893 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1894 {
1895 printf("UtopiaResourceObtain fail\n");
1896 return UTOPIA_STATUS_ERR_RESOURCE;
1897 }
1898 pstMVOP_EX_GET_IS_HDUPLICATE pMVOPArgs = (pstMVOP_EX_GET_IS_HDUPLICATE) pArgs;
1899 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_ExGetIsHDuplicate(pInstance, pMVOPArgs->eID);
1900
1901 UtopiaResourceRelease(pResource);
1902 u32Return = UTOPIA_STATUS_SUCCESS;
1903 break;
1904 }
1905
1906
1907 case E_MVOP_CMD_EX_GET_STATUS:
1908 {
1909 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1910 {
1911 printf("UtopiaResourceObtain fail\n");
1912 return UTOPIA_STATUS_ERR_RESOURCE;
1913 }
1914
1915 pstMVOP_EX_GET_STATUS pMVOPArgs = (pstMVOP_EX_GET_STATUS) pArgs;
1916 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_ExGetStatus(pInstance, pMVOPArgs->eID, pMVOPArgs->pMVOPStat);
1917
1918 UtopiaResourceRelease(pResource);
1919 u32Return = UTOPIA_STATUS_SUCCESS;
1920 break;
1921 }
1922
1923
1924 case E_MVOP_CMD_EX_CHECK_CAPABILITY:
1925 {
1926 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1927 {
1928 printf("UtopiaResourceObtain fail\n");
1929 return UTOPIA_STATUS_ERR_RESOURCE;
1930 }
1931
1932 pstMVOP_EX_CHECK_CAPABILITY pMVOPArgs = (pstMVOP_EX_CHECK_CAPABILITY) pArgs;
1933 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_ExCheckCapability(pInstance, pMVOPArgs->eID, pMVOPArgs->u32InParam);
1934
1935 UtopiaResourceRelease(pResource);
1936 u32Return = UTOPIA_STATUS_SUCCESS;
1937 break;
1938 }
1939
1940
1941 case E_MVOP_CMD_EX_GET_DST_INFO:
1942 {
1943 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1944 {
1945 printf("UtopiaResourceObtain fail\n");
1946 return UTOPIA_STATUS_ERR_RESOURCE;
1947 }
1948
1949 pstMVOP_EX_GET_DST_INFO pMVOPArgs = (pstMVOP_EX_GET_DST_INFO) pArgs;
1950 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_ExGetDstInfo(pInstance, pMVOPArgs->eID, pMVOPArgs->pDstInfo, pMVOPArgs->u32SizeofDstInfo);
1951
1952 UtopiaResourceRelease(pResource);
1953 u32Return = UTOPIA_STATUS_SUCCESS;
1954 break;
1955 }
1956
1957 case E_MVOP_CMD_SEND_BLUE_SCREEN:
1958 {
1959 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1960 {
1961 printf("UtopiaResourceObtain fail\n");
1962 return UTOPIA_STATUS_ERR_RESOURCE;
1963 }
1964
1965 pstMVOP_SEND_BLUE_SCREEN pMVOPArgs = (pstMVOP_SEND_BLUE_SCREEN) pArgs;
1966 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_SendBlueScreen(pInstance, pMVOPArgs->u16Width, pMVOPArgs->u16Height);
1967
1968 UtopiaResourceRelease(pResource);
1969 u32Return = UTOPIA_STATUS_SUCCESS;
1970 break;
1971 }
1972
1973 case E_MVOP_CMD_SET_COMMAND:
1974 {
1975 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1976 {
1977 printf("UtopiaResourceObtain fail\n");
1978 return UTOPIA_STATUS_ERR_RESOURCE;
1979 }
1980
1981 pstMVOP_SET_COMMAND pMVOPArgs = (pstMVOP_SET_COMMAND) pArgs;
1982 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_SetCommand(pInstance, pMVOPArgs->stHd, pMVOPArgs->eCmd, pMVOPArgs->pPara);
1983
1984 UtopiaResourceRelease(pResource);
1985 u32Return = UTOPIA_STATUS_SUCCESS;
1986 break;
1987 }
1988
1989 case E_MVOP_CMD_GET_COMMAND:
1990 {
1991 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
1992 {
1993 printf("UtopiaResourceObtain fail\n");
1994 return UTOPIA_STATUS_ERR_RESOURCE;
1995 }
1996
1997 pstMVOP_GET_COMMAND pMVOPArgs = (pstMVOP_GET_COMMAND) pArgs;
1998 pMVOPArgs->eRet = psMVOPInstPri->fpMVOP_GetCommand(pInstance, pMVOPArgs->stHd, pMVOPArgs->eCmd, pMVOPArgs->pPara, pMVOPArgs->u32ParaSize);
1999
2000 UtopiaResourceRelease(pResource);
2001 u32Return = UTOPIA_STATUS_SUCCESS;
2002 break;
2003 }
2004
2005 case E_MVOP_CMD_SET_FREQUENCY:
2006 {
2007 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2008 {
2009 printf("UtopiaResourceObtain fail\n");
2010 return UTOPIA_STATUS_ERR_RESOURCE;
2011 }
2012
2013 pstMVOP_SET_FREQUENCY pMVOPArgs = (pstMVOP_SET_FREQUENCY) pArgs;
2014 psMVOPInstPri->fpMVOP_SetFrequency(pInstance, pMVOPArgs->eFreq);
2015
2016 UtopiaResourceRelease(pResource);
2017 u32Return = UTOPIA_STATUS_SUCCESS;
2018 break;
2019 }
2020
2021 case E_MVOP_CMD_ENABLE_INTERRUPT:
2022 {
2023 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2024 {
2025 printf("UtopiaResourceObtain fail\n");
2026 return UTOPIA_STATUS_ERR_RESOURCE;
2027 }
2028
2029 pstMVOP_ENABLE_INTERRUPT pMVOPArgs = (pstMVOP_ENABLE_INTERRUPT) pArgs;
2030 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_EnableInterrupt(pInstance, pMVOPArgs->eIntType);
2031
2032 UtopiaResourceRelease(pResource);
2033 u32Return = UTOPIA_STATUS_SUCCESS;
2034 break;
2035 }
2036
2037 case E_MVOP_CMD_GET_INT_STATUS:
2038 {
2039 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2040 {
2041 printf("UtopiaResourceObtain fail\n");
2042 return UTOPIA_STATUS_ERR_RESOURCE;
2043 }
2044
2045 pstMVOP_GET_INT_STATUS pMVOPArgs = (pstMVOP_GET_INT_STATUS) pArgs;
2046 pMVOPArgs->u8Ret= psMVOPInstPri->fpMVOP_GetIntStatus(pInstance);
2047
2048 UtopiaResourceRelease(pResource);
2049 u32Return = UTOPIA_STATUS_SUCCESS;
2050 break;
2051 }
2052
2053 case E_MVOP_CMD_SUB_ENABLE_INTERRUPT:
2054 {
2055 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2056 {
2057 printf("UtopiaResourceObtain fail\n");
2058 return UTOPIA_STATUS_ERR_RESOURCE;
2059 }
2060
2061 pstMVOP_SUB_ENABLE_INTERRUPT pMVOPArgs = (pstMVOP_SUB_ENABLE_INTERRUPT) pArgs;
2062 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_SubEnableInterrupt(pInstance, pMVOPArgs->eIntType);
2063
2064 UtopiaResourceRelease(pResource);
2065 u32Return = UTOPIA_STATUS_SUCCESS;
2066 break;
2067 }
2068
2069 case E_MVOP_CMD_SUB_GET_INT_STATUS:
2070 {
2071 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2072 {
2073 printf("UtopiaResourceObtain fail\n");
2074 return UTOPIA_STATUS_ERR_RESOURCE;
2075 }
2076
2077 pstMVOP_SUB_GET_INT_STATUS pMVOPArgs = (pstMVOP_SUB_GET_INT_STATUS) pArgs;
2078 pMVOPArgs->u8Ret= psMVOPInstPri->fpMVOP_SubGetIntStatus(pInstance);
2079
2080 UtopiaResourceRelease(pResource);
2081 u32Return = UTOPIA_STATUS_SUCCESS;
2082 break;
2083 }
2084
2085 case E_MVOP_CMD_EX_ENABLE_INTERRUPT:
2086 {
2087 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2088 {
2089 printf("UtopiaResourceObtain fail\n");
2090 return UTOPIA_STATUS_ERR_RESOURCE;
2091 }
2092
2093 pstMVOP_EX_ENABLE_INTERRUPT pMVOPArgs = (pstMVOP_EX_ENABLE_INTERRUPT) pArgs;
2094 pMVOPArgs->bRet = psMVOPInstPri->fpMVOP_ExEnableInterrupt(pInstance, pMVOPArgs->eID, pMVOPArgs->eIntType);
2095
2096 UtopiaResourceRelease(pResource);
2097 u32Return = UTOPIA_STATUS_SUCCESS;
2098 break;
2099 }
2100
2101 case E_MVOP_CMD_EX_GET_INT_STATUS:
2102 {
2103 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2104 {
2105 printf("UtopiaResourceObtain fail\n");
2106 return UTOPIA_STATUS_ERR_RESOURCE;
2107 }
2108
2109 pstMVOP_EX_GET_INT_STATUS pMVOPArgs = (pstMVOP_EX_GET_INT_STATUS) pArgs;
2110 pMVOPArgs->u8Ret= psMVOPInstPri->fpMVOP_ExGetIntStatus(pInstance, pMVOPArgs->eID);
2111
2112 UtopiaResourceRelease(pResource);
2113 u32Return = UTOPIA_STATUS_SUCCESS;
2114 break;
2115 }
2116 #if 1
2117 case E_MVOP_CMD_SET_POWERSTATE:
2118 {
2119 if(UtopiaResourceObtain(pModule, E_MVOP_POOL_ID_INTERNAL, &pResource) != 0)
2120 {
2121 printf("UtopiaResourceObtain fail\n");
2122 return UTOPIA_STATUS_ERR_RESOURCE;
2123 }
2124
2125 pstMVOP_SET_POWER_STATE pMVOPArgs = (pstMVOP_SET_POWER_STATE) pArgs;
2126 pMVOPArgs->u32Ret= psMVOPInstPri->fpMVOP_SetPowerState(pInstance, pMVOPArgs->u16PowerState);
2127
2128 UtopiaResourceRelease(pResource);
2129 u32Return = UTOPIA_STATUS_SUCCESS;
2130 break;
2131 }
2132
2133 #endif
2134
2135 // OBSOLETE command **END**, please avoid using these
2136
2137 case E_MVOP_CMD_MAX:
2138 default:
2139 {
2140 #if defined (__aarch64__)
2141 printf("Command %d is not existed\n",u32Cmd);
2142 #else
2143 printf("Command %d is not existed\n",(int)u32Cmd);
2144 #endif
2145 u32Return = UTOPIA_STATUS_ERR_INVALID_HANDLE;
2146 break;
2147 }
2148 }
2149 return u32Return;
2150 }
2151
MVOPClose(void * pInstance)2152 MS_U32 MVOPClose(void* pInstance)
2153 {
2154 UtopiaInstanceDelete(pInstance);
2155
2156 return TRUE;
2157 }
2158
2159
2160
2161