1 #ifndef _API_XC_PANEL_V2_C_
2 #define _API_XC_PANEL_V2_C_
3
4 #include "MsTypes.h"
5 #ifndef MSOS_TYPE_LINUX_KERNEL
6 #include <stdio.h>
7 #include <string.h>
8 #endif
9 #include "MsCommon.h"
10 #include "utopia_dapi.h"
11 #include "apiPNL.h"
12 #include "apiPNL_v2.h"
13 #include "drvPNL.h"
14 #include "PNL_private.h"
15 #include "utopia.h"
16
17 #ifdef MSOS_TYPE_LINUX_KERNEL
18 void *pInstancePNLStr = NULL;
PNLStr(MS_U32 u32PowerState,void * pModule)19 MS_U32 PNLStr(MS_U32 u32PowerState, void* pModule)
20 {
21 MS_U32 u32Return=UTOPIA_STATUS_FAIL;
22 stPNL_SetPowerState PNLArgs;
23
24 switch(u32PowerState)
25 {
26 case E_POWER_SUSPEND:
27 if (pInstancePNLStr == NULL)
28 {
29 if(UtopiaOpen(MODULE_PNL, &pInstancePNLStr, 0, NULL) != UTOPIA_STATUS_SUCCESS)
30 {
31 printf("UtopiaOpen PNL failed\n");
32 return UTOPIA_STATUS_FAIL;
33 }
34 }
35 PNLArgs.ePowerState = u32PowerState;
36 PNLArgs.u32Return = UTOPIA_STATUS_FAIL;
37 if(UtopiaIoctl(pInstancePNLStr, E_PNL_CMD_SETPOWERSTATE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
38 {
39 printf("Obtain PNL engine fail\n");
40 return UTOPIA_STATUS_FAIL;
41 }
42 u32Return=PNLArgs.u32Return;
43 break;
44 case E_POWER_RESUME:
45 if (pInstancePNLStr == NULL)
46 {
47 if(UtopiaOpen(MODULE_PNL, &pInstancePNLStr, 0, NULL) != UTOPIA_STATUS_SUCCESS)
48 {
49 printf("UtopiaOpen PNL failed\n");
50 return UTOPIA_STATUS_FAIL;
51 }
52 }
53 PNLArgs.ePowerState = u32PowerState;
54 PNLArgs.u32Return = UTOPIA_STATUS_FAIL;
55 if(UtopiaIoctl(pInstancePNLStr, E_PNL_CMD_SETPOWERSTATE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
56 {
57 printf("Obtain PNL engine fail\n");
58 return UTOPIA_STATUS_FAIL;
59 }
60 u32Return=PNLArgs.u32Return;
61 break;
62 default:
63 printf("[%s][%d] PowerState:%lx not Implement now!!!\n",__FUNCTION__,__LINE__,u32PowerState);
64 break;
65 }
66 return u32Return;
67 }
68 #endif
69 // ========== Global definition ==========
70 void* pModulePNL = NULL;
71
PNLRegisterToUtopia(FUtopiaOpen ModuleType)72 void PNLRegisterToUtopia(FUtopiaOpen ModuleType)
73 {
74 MS_U32 u32ResourceStatusCheck[E_PNL_POOL_ID_MAX] = {UTOPIA_STATUS_FAIL};
75 // 1. deal with module
76 UtopiaModuleCreate(MODULE_PNL, 0, &pModulePNL);
77 UtopiaModuleRegister(pModulePNL);
78 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
79 UtopiaModuleSetupFunctionPtr(pModulePNL, (FUtopiaOpen)PNLOpen, (FUtopiaClose)PNLClose, (FUtopiaIOctl)PNLIoctl);
80
81 // 2. deal with resource , PNL may need 2 resources, one is readonly, the other is XC resource
82 void* psResource = NULL;
83 void* psResource1 = NULL;
84 #if defined(MSOS_TYPE_LINUX_KERNEL)
85 UtopiaModuleSetupSTRFunctionPtr(pModulePNL, (FUtopiaSTR)PNLStr);
86 UtopiaModuleSetSTRPrivate(pModulePNL, sizeof(PNL_REGS_SAVE_AREA));
87 #endif
88 // 3. resource can allocate private for internal use
89 MS_U32 u32MaxDeviceNum = _XC_PNL_GET_DEVICE_NUM();
90 MS_U32 i = 0;
91 for(i = 0 ; i < u32MaxDeviceNum ;i++)
92 {
93 // need refine
94 if(i == 0)
95 {
96 UtopiaModuleAddResourceStart(pModulePNL, E_PNL_POOL_ID_INTERNAL);
97 u32ResourceStatusCheck[E_PNL_POOL_ID_INTERNAL] = UtopiaResourceCreate("PNL_VARIABLE", sizeof(PNL_RESOURCE_PRIVATE), &psResource);
98 UtopiaResourceRegister(pModulePNL, psResource, E_PNL_POOL_ID_INTERNAL);
99 UtopiaModuleAddResourceEnd(pModulePNL, E_PNL_POOL_ID_INTERNAL);
100 }
101 else
102 {
103 UtopiaModuleAddResourceStart(pModulePNL, E_PNL_POOL_ID_INTERNAL1);
104 u32ResourceStatusCheck[E_PNL_POOL_ID_INTERNAL1] = UtopiaResourceCreate("PNL_VARIABLE1", sizeof(PNL_RESOURCE_PRIVATE), &psResource1);
105 UtopiaResourceRegister(pModulePNL, psResource1, E_PNL_POOL_ID_INTERNAL1);
106 UtopiaModuleAddResourceEnd(pModulePNL, E_PNL_POOL_ID_INTERNAL1);
107 }
108 }
109
110 //4. init resource private members here (aka, global variable)
111 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
112 UtopiaResourceGetPrivate(psResource,(void**)(&pPNLResourcePrivate));
113
114 if (u32ResourceStatusCheck[E_PNL_POOL_ID_INTERNAL] == UTOPIA_STATUS_SHM_EXIST)
115 {
116 // do nothing, since it is already inited
117 }
118 else
119 {
120 // Init flow control related variables here. Other global variable should be
121 // inited in each of its init function relatively.
122 pPNLResourcePrivate->bResourceRegistered = TRUE;
123
124 // apiPNL.c
125 pPNLResourcePrivate->stapiPNL._bSkipTimingChange = FALSE;
126 pPNLResourcePrivate->stapiPNL._cstPnlInfo.eSupportGammaType = E_APIPNL_GAMMA_ALL;
127 memset(pPNLResourcePrivate->stapiPNL._pu8GammaTab[0], 0 ,sizeof(MS_U8)*GammaTblSize);
128 memset(pPNLResourcePrivate->stapiPNL._pu8GammaTab[1], 0 ,sizeof(MS_U8)*GammaTblSize);
129 memset(pPNLResourcePrivate->stapiPNL._pu8GammaTab[2], 0 ,sizeof(MS_U8)*GammaTblSize);
130 pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized = FALSE;
131 pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Enabled = FALSE;
132 pPNLResourcePrivate->stapiPNL._u16PanelDCLK = 0;
133 pPNLResourcePrivate->stapiPNL._bForceSetDCLKEnable = DISABLE;
134 pPNLResourcePrivate->stapiPNL._u16PanelHStart = 0;
135 pPNLResourcePrivate->stapiPNL._bForceSetHStartEnable = DISABLE;
136 pPNLResourcePrivate->stapiPNL.ePrevPowerState = E_POWER_MECHANICAL;
137
138 // halPNL.c
139 pPNLResourcePrivate->sthalPNL._u16PnlDefault_SwingLevel = 250;
140 pPNLResourcePrivate->sthalPNL._eDrvPnlInitOptions = E_PNL_OUTPUT_CLK_DATA;
141 pPNLResourcePrivate->sthalPNL._u8MOD_CALI_TARGET = 1; // 00:250mv, 01:350mv, 10:300mv, 11:200mv
142 pPNLResourcePrivate->sthalPNL._u8MOD_CALI_PAIR_SEL = 0x01;
143 pPNLResourcePrivate->sthalPNL._usMOD_CALI_OFFSET = 0;
144 pPNLResourcePrivate->sthalPNL._u8MOD_CALI_VALUE = 0x1F; // 250mv:2'h15, 350mv:2'h1F, 300mv:2'h1A, 200mv:2'h10
145 pPNLResourcePrivate->sthalPNL._u8MOD_LVDS_Pair_Shift = 0;
146 pPNLResourcePrivate->sthalPNL._u8MOD_LVDS_Pair_Type = 0;
147 pPNLResourcePrivate->sthalPNL._u8PnlDiffSwingLevel = 0x63;
148 pPNLResourcePrivate->sthalPNL._bPVDD_2V5 = FALSE;
149
150 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8OutputOrderType = 0; // default
151 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder0_3 = 0x5410;
152 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder4_7 = 0x5410;
153 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder8_11 = 0x0000;
154 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder12_13 = 0x0000;
155 }
156
157 if (psResource1 != NULL)
158 {
159 UtopiaResourceGetPrivate(psResource1,(void**)(&pPNLResourcePrivate));
160
161 if (u32ResourceStatusCheck[E_PNL_POOL_ID_INTERNAL1] == UTOPIA_STATUS_SHM_EXIST)
162 {
163 // do nothing, since it is already inited
164 }
165 else
166 {
167 // Init flow control related variables here. Other global variable should be
168 // inited in each of its init function relatively.
169 pPNLResourcePrivate->bResourceRegistered = TRUE;
170
171 // apiPNL.c
172 pPNLResourcePrivate->stapiPNL._bSkipTimingChange = FALSE;
173 pPNLResourcePrivate->stapiPNL._cstPnlInfo.eSupportGammaType = E_APIPNL_GAMMA_ALL;
174 pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized = FALSE;
175 pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Enabled = FALSE;
176 pPNLResourcePrivate->stapiPNL._u16PanelDCLK = 0;
177 pPNLResourcePrivate->stapiPNL._bForceSetDCLKEnable = DISABLE;
178 pPNLResourcePrivate->stapiPNL._u16PanelHStart = 0;
179 pPNLResourcePrivate->stapiPNL._bForceSetHStartEnable = DISABLE;
180 pPNLResourcePrivate->stapiPNL.ePrevPowerState = E_POWER_MECHANICAL;
181
182 // halPNL.c
183 pPNLResourcePrivate->sthalPNL._u16PnlDefault_SwingLevel = 250;
184 pPNLResourcePrivate->sthalPNL._eDrvPnlInitOptions = E_PNL_OUTPUT_CLK_DATA;
185 pPNLResourcePrivate->sthalPNL._u8MOD_CALI_TARGET = 0;
186 pPNLResourcePrivate->sthalPNL._u8MOD_CALI_PAIR_SEL = 0x01;
187 pPNLResourcePrivate->sthalPNL._usMOD_CALI_OFFSET = 0;
188 pPNLResourcePrivate->sthalPNL._u8MOD_CALI_VALUE = 0x15;
189 pPNLResourcePrivate->sthalPNL._u8MOD_LVDS_Pair_Shift = 0;
190 pPNLResourcePrivate->sthalPNL._u8MOD_LVDS_Pair_Type = 0;
191 pPNLResourcePrivate->sthalPNL._u8PnlDiffSwingLevel = 0x63;
192 pPNLResourcePrivate->sthalPNL._bPVDD_2V5 = FALSE;
193
194 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8OutputOrderType = 0; // default
195 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder0_3 = 0x5410;
196 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder4_7 = 0x5410;
197 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder8_11 = 0x0000;
198 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder12_13 = 0x0000;
199 }
200 }
201 }
202
PNLOpen(void ** ppInstance,const void * const pAttribute)203 MS_U32 PNLOpen(void** ppInstance, const void* const pAttribute)
204 {
205 PNL_INSTANCE_PRIVATE *psPNLInstPri = NULL;
206 UtopiaInstanceCreate(sizeof(PNL_INSTANCE_PRIVATE), ppInstance);
207 UtopiaInstanceGetPrivate(*ppInstance, (void**)&psPNLInstPri);
208
209 psPNLInstPri->u32DeviceID = 0;
210 if(pAttribute != NULL)
211 {
212 MS_U32* pID = (MS_U32*)pAttribute;
213 psPNLInstPri->u32DeviceID = *pID;
214 }
215 #ifdef UTOPIA_20
216 psPNLInstPri->fpPNL_GetLibVer = MApi_PNL_GetLibVer_U2;
217 psPNLInstPri->fpPNL_GetInfo = MApi_PNL_GetInfo_U2;
218 psPNLInstPri->fpPNL_GetStatus = MApi_PNL_GetStatus_U2;
219 psPNLInstPri->fpPNL_GetStatusEx = MApi_PNL_GetStatusEx_U2;
220 psPNLInstPri->fpPNL_SetDbgLevel = MApi_PNL_SetDbgLevel_U2;
221 psPNLInstPri->fpPNL_IOMapBaseInit = MApi_PNL_IOMapBaseInit_U2;
222 psPNLInstPri->fpPNL_PreInit = MApi_PNL_PreInit_U2;
223 psPNLInstPri->fpPNL_Init = MApi_PNL_Init_U2;
224 psPNLInstPri->fpPNL_Init_Ex = MApi_PNL_Init_Ex_U2;
225 psPNLInstPri->fpPNL_GetConfig = MApi_PNL_GetConfig_U2;
226 psPNLInstPri->fpPNL_SetOutput = MApi_PNL_SetOutput_U2;
227 psPNLInstPri->fpPNL_ChangePanelType = MApi_PNL_ChangePanelType_U2;
228 psPNLInstPri->fpPNL_TCONMAP_DumpTable = MApi_PNL_TCONMAP_DumpTable_U2;
229 psPNLInstPri->fpPNL_TCONMAP_Power_Sequence = MApi_PNL_TCONMAP_Power_Sequence_U2;
230 psPNLInstPri->fpPNL_TCON_Count_Reset = MApi_PNL_TCON_Count_Reset_U2;
231 psPNLInstPri->fpPNL_TCON_Init = MApi_PNL_TCON_Init_U2;
232 psPNLInstPri->fpPNL_GetDstInfo = MApi_PNL_GetDstInfo_U2;
233 psPNLInstPri->fpPNL_Control_Out_Swing = MApi_PNL_Control_Out_Swing_U2;
234 psPNLInstPri->fpPNL_SetOutputPattern = MApi_PNL_SetOutputPattern_U2;
235 psPNLInstPri->fpPNL_Mod_Calibration_Setting = MApi_Mod_Calibration_Setting_U2;
236 psPNLInstPri->fpPNL_Mod_Do_Calibration = MApi_Mod_Do_Calibration_U2;
237 psPNLInstPri->fpPNL_BD_LVDS_Output_Type = MApi_BD_LVDS_Output_Type_U2;
238 psPNLInstPri->fpPNL_SetLPLLTypeExt = MApi_PNL_SetLPLLTypeExt_U2;
239 psPNLInstPri->fpPNL_Init_MISC = MApi_PNL_Init_MISC_U2;
240 psPNLInstPri->fpPNL_Get_MISC_Status = MApi_PNL_GetMiscStatus_U2;
241 psPNLInstPri->fpPNL_MOD_OutputConfig_User = MApi_PNL_MOD_OutputConfig_User_U2;
242 psPNLInstPri->fpPNL_MOD_OutputChannelOrder = MApi_PNL_MOD_OutputChannelOrder_U2;
243 psPNLInstPri->fpPNL_HWLVDSReservedtoLRFlag = MApi_PNL_HWLVDSReservedtoLRFlag_U2;
244 psPNLInstPri->fpPNL_MOD_PVDD_Power_Setting = MApi_MOD_PVDD_Power_Setting_U2;
245 psPNLInstPri->fpPNL_SetSSC_En = MApi_PNL_SetSSC_En_U2;
246 psPNLInstPri->fpPNL_SetSSC_Fmodulation = MApi_PNL_SetSSC_Fmodulation_U2;
247 psPNLInstPri->fpPNL_SetSSC_Rdeviation = MApi_PNL_SetSSC_Rdeviation_U2;
248 psPNLInstPri->fpPNL_SetOSDSSC_En = MApi_PNL_SetOSDSSC_En_U2;
249 psPNLInstPri->fpPNL_SetOSDSSC_Fmodulation = MApi_PNL_SetOSDSSC_Fmodulation_U2;
250 psPNLInstPri->fpPNL_SetOSDSSC_Rdeviation = MApi_PNL_SetOSDSSC_Rdeviation_U2;
251 psPNLInstPri->fpPNL_SkipTimingChange = MApi_PNL_SkipTimingChange_U2;
252 psPNLInstPri->fpPNL_PreSetModeOn = MApi_PNL_PreSetModeOn_U2;
253 psPNLInstPri->fpPNL_OverDriver_Init = MApi_PNL_OverDriver_Init_U2;
254 psPNLInstPri->fpPNL_OverDriver_Enable = MApi_PNL_OverDriver_Enable_U2;
255 psPNLInstPri->fpPNL_Get_LPLL_Type = MApi_Pnl_Get_LPLL_Type_U2;
256 psPNLInstPri->fpPNL_Get_TCON_Capability = MApi_PNL_Get_TCON_Capability_U2;
257 psPNLInstPri->fpPNL_SetPairSwap = MApi_PNL_SetPairSwap_U2;
258 psPNLInstPri->fpPNL_SetExt_LPLL_Type = MApi_PNL_SetExt_LPLL_Type_U2;
259 psPNLInstPri->fpPNL_CalExtLPLLSETbyDClk = MApi_PNL_CalExtLPLLSETbyDClk_U2;
260 psPNLInstPri->fpPNL_SetDiffSwingLevel = MApi_PNL_SetDiffSwingLevel_U2;
261 psPNLInstPri->fpPNL_SetPowerState = MApi_PNL_SetPowerState_U2;
262 psPNLInstPri->fpPNL_ForceSetPanelDCLK = MApi_PNL_ForceSetPanelDCLK_U2;
263 psPNLInstPri->fpPNL_ForceSetPanelHStart = MApi_PNL_ForceSetPanelHStart_U2;
264 psPNLInstPri->fpPNL_EnableInternalTermination = MApi_PNL_EnableInternalTermination_U2;
265 psPNLInstPri->fpPNL_OutputDeviceHandshake = MApi_PNL_OutputDeviceHandshake_U2;
266 psPNLInstPri->fpPNL_OutputDeviceOCHandshake = MApi_PNL_OutputDeviceOCHandshake_U2;
267 psPNLInstPri->fpPNL_SetOutputInterlaceTiming = MApi_PNL_SetOutputInterlaceTiming_U2;
268 psPNLInstPri->fpPNL_GetOutputInterlaceTiming = MApi_PNL_GetOutputInterlaceTiming_U2;
269 psPNLInstPri->fpPNL_GetPanelData = MApi_PNL_GetPanelData_U2;
270 psPNLInstPri->fpPNL_DumpPanelData = MApi_PNL_DumpPanelData_U2;
271 psPNLInstPri->fpPNL_SetSSC = MApi_PNL_SetSSC_U2;
272 psPNLInstPri->fpPNL_GetPanelOnTiming = MApi_PNL_GetPanelOnTiming_U2;
273 psPNLInstPri->fpPNL_GetPanelOffTiming = MApi_PNL_GetPanelOffTiming_U2;
274 psPNLInstPri->fpPNL_GetPanelDimCtrl = MApi_PNL_GetPanelDimCtrl_U2;
275 psPNLInstPri->fpPNL_GetAllGammaTbl = MApi_PNL_GetAllGammaTbl_U2;
276 psPNLInstPri->fpPNL_EnablePanel = MApi_PNL_EnablePanel_U2;
277 psPNLInstPri->fpPNL_SetGammaTbl = MApi_PNL_SetGammaTbl_U2;
278 psPNLInstPri->fpPNL_GetGammaTbl = MApi_PNL_GetGammaTbl_U2;
279 psPNLInstPri->fpPNL_SetGammaValue = MApi_PNL_SetGammaValue_U2;
280 psPNLInstPri->fpPNL_GetLPLLMode = MApi_PNL_GetLPLLMode_U2;
281 psPNLInstPri->fpPNL_GetDefVFreq = MApi_PNL_GetDefVFreq_U2;
282 psPNLInstPri->fpPNL_GetPanelName = MApi_PNL_GetName_U2;
283 psPNLInstPri->fpPNL_GetHStart = MAPI_PNL_GetPNLHstart_U2;
284 psPNLInstPri->fpPNL_GetVStart = MAPI_PNL_GetPNLVstart_U2;
285 psPNLInstPri->fpPNL_GetWidth = MAPI_PNL_GetPNLWidth_U2;
286 psPNLInstPri->fpPNL_GetHeight = MAPI_PNL_GetPNLHeight_U2;
287 psPNLInstPri->fpPNL_GetHtotal = MAPI_PNL_GetPNLHtotal_U2;
288 psPNLInstPri->fpPNL_GetVtotal = MAPI_PNL_GetPNLVtotal_U2;
289 psPNLInstPri->fpPNL_GetHsyncwidth = MAPI_PNL_GetPNLHsyncWidth_U2;
290 psPNLInstPri->fpPNL_GetHsyncBackPorch = MAPI_PNL_GetPNLHsyncBackPorch_U2;
291 psPNLInstPri->fpPNL_GetVsyncBackPorch = MAPI_PNL_GetPNLVsyncBackPorch_U2;
292 psPNLInstPri->fpPNL_GetLPLLType = MApi_PNL_GetLPLLType_U2;
293 psPNLInstPri->fpPNL_GetARC = MApi_PNL_GetARC_U2;
294 psPNLInstPri->fpPNL_GetMinSET = MApi_PNL_GetMinSET_U2;
295 psPNLInstPri->fpPNL_GetMaxSET = MApi_PNL_GetMaxSET_U2;
296 psPNLInstPri->fpPNL_GetOutTimingMode = MApi_PNL_GetOutTimingMode_U2;
297 psPNLInstPri->fpPNL_CheckVBY1HandshakeStatus = MApi_PNL_Check_VBY1_Handshake_Status_U2;
298 psPNLInstPri->fpPNL_SetVideoHWTraining = MApi_PNL_SetVideoHWTraining_U2;
299 psPNLInstPri->fpPNL_SetOSDHWTraining = MApi_PNL_SetOSDHWTraining_U2;
300 psPNLInstPri->fpPNL_GetVideoHWTraining_Status = MApi_PNL_GetVideoHWTraining_Status_U2;
301 psPNLInstPri->fpPNL_GetOSDHWTraining_Status = MApi_PNL_GetOSDHWTraining_Status_U2;
302 psPNLInstPri->fpPNL_Setting = MApi_PNL_Setting_U2;
303 #endif
304 return UTOPIA_STATUS_SUCCESS;
305 }
306
307
PNLIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)308 MS_U32 PNLIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
309 {
310 #ifdef UTOPIA_20
311 void* pModule = NULL;
312 PNL_INSTANCE_PRIVATE* psPNLInstPri = NULL;
313 UtopiaInstanceGetPrivate(pInstance, (void*)&psPNLInstPri);
314 UtopiaInstanceGetModule(pInstance, &pModule);
315 //printf("[%s,%5d] u32Cmd type = %ld\n",__FUNCTION__,__LINE__,u32Cmd);
316 pu32PNLInst_private = pInstance;
317 switch(u32Cmd)
318 {
319 case E_PNL_CMD_GETLIBVER:
320 {
321 pstPNL_GetLibVer pPNLArgs = (pstPNL_GetLibVer)pArgs;
322 pPNLArgs->eResult = psPNLInstPri->fpPNL_GetLibVer(pInstance, pPNLArgs->ppVersion);
323
324 return UTOPIA_STATUS_SUCCESS;
325 }
326
327 case E_PNL_CMD_GETINFO:
328 {
329 pstPNL_GetInfo pPNLArgs = (pstPNL_GetInfo)pArgs;
330 pPNLArgs->pApiInfo = psPNLInstPri->fpPNL_GetInfo(pInstance);
331
332 return UTOPIA_STATUS_SUCCESS;
333 }
334
335 case E_PNL_CMD_GETSTATUS:
336 {
337 pstPNL_GetStatus pPNLArgs = (pstPNL_GetStatus)pArgs;
338 pPNLArgs->bReturn = psPNLInstPri->fpPNL_GetStatus(pInstance, pPNLArgs->pPnlStatus);
339
340 return UTOPIA_STATUS_SUCCESS;
341 }
342
343 case E_PNL_CMD_GETSTATUSEX:
344 {
345 pstPNL_GetStatusEx pPNLArgs = (pstPNL_GetStatusEx)pArgs;
346 pPNLArgs->bReturn = psPNLInstPri->fpPNL_GetStatusEx(pInstance, pPNLArgs->pPnlExtStatus);
347
348 return UTOPIA_STATUS_SUCCESS;
349 }
350
351 case E_PNL_CMD_SETDBGLEVEL:
352 {
353 pstPNL_SetDbgLevel pPNLArgs = (pstPNL_SetDbgLevel)pArgs;
354 pPNLArgs->bReturn = psPNLInstPri->fpPNL_SetDbgLevel(pInstance, pPNLArgs->u16DbgSwitch);
355
356 return UTOPIA_STATUS_SUCCESS;
357 }
358
359 case E_PNL_CMD_IOMAPBASEINIT:
360 {
361 pstPNL_IOMapBaseInit pPNLArgs = (pstPNL_IOMapBaseInit)pArgs;
362 pPNLArgs->bReturn = psPNLInstPri->fpPNL_IOMapBaseInit(pInstance);
363
364 return UTOPIA_STATUS_SUCCESS;
365 }
366
367 case E_PNL_CMD_PREINIT:
368 {
369 pstPNL_PreInit pPNLArgs = (pstPNL_PreInit)pArgs;
370 pPNLArgs->bReturn = psPNLInstPri->fpPNL_PreInit(pInstance, pPNLArgs->eInitParam);
371
372 return UTOPIA_STATUS_SUCCESS;
373 }
374
375 case E_PNL_CMD_INIT:
376 {
377 pstPNL_Init pPNLArgs = (pstPNL_Init)pArgs;
378 pPNLArgs->bReturn = psPNLInstPri->fpPNL_Init(pInstance, pPNLArgs->pSelPanelType);
379
380 return UTOPIA_STATUS_SUCCESS;
381 }
382
383 case E_PNL_CMD_INIT_EX:
384 {
385 pstPNL_Init_Ex pPNLArgs = (pstPNL_Init_Ex)pArgs;
386 pPNLArgs->bReturn = psPNLInstPri->fpPNL_Init_Ex(pInstance, pPNLArgs->pSelPanelType, pPNLArgs->LIBVER);
387
388 return UTOPIA_STATUS_SUCCESS;
389 }
390
391 case E_PNL_CMD_GET_CONFIG:
392 {
393 pstPNL_GetConfig pPNLArgs = (pstPNL_GetConfig) pArgs;
394 pPNLArgs->eReturn = psPNLInstPri->fpPNL_GetConfig(pInstance,pPNLArgs->pSelPanelType);
395
396 return UTOPIA_STATUS_SUCCESS;
397 }
398
399 case E_PNL_CMD_SETOUTPUT:
400 {
401 pstPNL_SetOutput pPNLArgs = (pstPNL_SetOutput)pArgs;
402 psPNLInstPri->fpPNL_SetOutput(pInstance, pPNLArgs->eOutputMode);
403
404 return UTOPIA_STATUS_SUCCESS;
405 }
406
407 case E_PNL_CMD_CHANGEPANELTYPE:
408 {
409 pstPNL_ChangePanelType pPNLArgs = (pstPNL_ChangePanelType)pArgs;
410 pPNLArgs->bReturn = psPNLInstPri->fpPNL_ChangePanelType(pInstance, pPNLArgs->pSelPanelType);
411
412 return UTOPIA_STATUS_SUCCESS;
413 }
414
415 case E_PNL_CMD_TCONMAP_DUMPTABLE:
416 {
417 pstPNL_TCONMAP_DumpTable pPNLArgs = (pstPNL_TCONMAP_DumpTable)pArgs;
418 pPNLArgs->bReturn = psPNLInstPri->fpPNL_TCONMAP_DumpTable(pInstance, pPNLArgs->pTCONTable, pPNLArgs->u8Tcontype);
419
420 return UTOPIA_STATUS_SUCCESS;
421 }
422
423 case E_PNL_CMD_TCONMAP_POWER_SEQUENCE:
424 {
425 pstPNL_TCONMAP_Power_Sequence pPNLArgs = (pstPNL_TCONMAP_Power_Sequence)pArgs;
426 pPNLArgs->bReturn = psPNLInstPri->fpPNL_TCONMAP_Power_Sequence(pInstance, pPNLArgs->pTCONTable, pPNLArgs->bEnable);
427
428 return UTOPIA_STATUS_SUCCESS;
429 }
430
431 case E_PNL_CMD_TCON_COUNT_RESET:
432 {
433 pstPNL_TCON_Count_Reset pPNLArgs = (pstPNL_TCON_Count_Reset)pArgs;
434 psPNLInstPri->fpPNL_TCON_Count_Reset(pInstance, pPNLArgs->bEnable);
435
436 return UTOPIA_STATUS_SUCCESS;
437 }
438
439 case E_PNL_CMD_TCON_INIT:
440 {
441 psPNLInstPri->fpPNL_TCON_Init(pInstance);
442
443 return UTOPIA_STATUS_SUCCESS;
444 }
445
446 case E_PNL_CMD_GETDSTINFO:
447 {
448 pstPNL_GetDstInfo pPNLArgs = (pstPNL_GetDstInfo)pArgs;
449 pPNLArgs->bReturn = psPNLInstPri->fpPNL_GetDstInfo(pInstance, pPNLArgs->pDstInfo, pPNLArgs->u32SizeofDstInfo);
450
451 return UTOPIA_STATUS_SUCCESS;
452 }
453
454 case E_PNL_CMD_CONTROL_OUT_SWING:
455 {
456 pstPNL_Control_Out_Swing pPNLArgs = (pstPNL_Control_Out_Swing)pArgs;
457 pPNLArgs->bReturn = psPNLInstPri->fpPNL_Control_Out_Swing(pInstance, pPNLArgs->u16Swing_Level);
458
459 return UTOPIA_STATUS_SUCCESS;
460 }
461
462 case E_PNL_CMD_SET_OUTPUT_PATTERN:
463 {
464 pstPNL_SetOutputPattern pPNLArgs = (pstPNL_SetOutputPattern)pArgs;
465 psPNLInstPri->fpPNL_SetOutputPattern(pInstance, pPNLArgs->bEnable, pPNLArgs->u16Red, pPNLArgs->u16Green, pPNLArgs->u16Blue);
466
467 return UTOPIA_STATUS_SUCCESS;
468 }
469
470 case E_PNL_CMD_MOD_CALIBRATION_SETTING:
471 {
472 pstPNL_Mod_Calibration_Setting pPNLArgs = (pstPNL_Mod_Calibration_Setting)pArgs;
473 pPNLArgs->bReturn = psPNLInstPri->fpPNL_Mod_Calibration_Setting(pInstance, pPNLArgs->pstModCaliInfo);
474
475 return UTOPIA_STATUS_SUCCESS;
476 }
477
478 case E_PNL_CMD_MOD_DO_CALIBRATION:
479 {
480 pstPNL_Mod_Do_Calibration pPNLArgs = (pstPNL_Mod_Do_Calibration)pArgs;
481 pPNLArgs->bReturn= psPNLInstPri->fpPNL_Mod_Do_Calibration(pInstance);
482
483 return UTOPIA_STATUS_SUCCESS;
484 }
485
486 case E_PNL_CMD_BD_LVDS_OUTPUT_TYPE:
487 {
488 pstPNL_BD_LVDS_Output_Type pPNLArgs = (pstPNL_BD_LVDS_Output_Type)pArgs;
489 psPNLInstPri->fpPNL_BD_LVDS_Output_Type(pInstance, pPNLArgs->Type);
490
491 return UTOPIA_STATUS_SUCCESS;
492 }
493
494 case E_PNL_CMD_SETLPLLTYPEEXT:
495 {
496 pstPNL_SetLPLLTypeExt pPNLArgs = (pstPNL_SetLPLLTypeExt)pArgs;
497 psPNLInstPri->fpPNL_SetLPLLTypeExt(pInstance, pPNLArgs->eLPLL_TypeExt);
498
499 return UTOPIA_STATUS_SUCCESS;
500 }
501
502 case E_PNL_CMD_INIT_MISC:
503 {
504 pstPNL_Init_MISC pPNLArgs = (pstPNL_Init_MISC)pArgs;
505 psPNLInstPri->fpPNL_Init_MISC(pInstance, pPNLArgs->ePNL_MISC);
506
507 return UTOPIA_STATUS_SUCCESS;
508 }
509
510 case E_PNL_CMD_GET_MISC_STATUS:
511 {
512 pstPNL_Get_MISC_Status pPNLArgs = (pstPNL_Get_MISC_Status)pArgs;
513 pPNLArgs->u32Status = psPNLInstPri->fpPNL_Get_MISC_Status(pInstance);
514
515 return UTOPIA_STATUS_SUCCESS;
516 }
517
518 case E_PNL_CMD_MOD_OUTPUTCONFIG_USER:
519 {
520 pstPNL_MOD_OutputConfig_User pPNLArgs = (pstPNL_MOD_OutputConfig_User)pArgs;
521 psPNLInstPri->fpPNL_MOD_OutputConfig_User(pInstance, pPNLArgs->u32OutputCFG0_7, pPNLArgs->u32OutputCFG8_15, pPNLArgs->u32OutputCFG16_21);
522
523 return UTOPIA_STATUS_SUCCESS;
524 }
525
526 case E_PNL_CMD_MOD_OUTPUT_CHANNEL_ORDER:
527 {
528 pstPNL_MOD_OutputChannelOrder pPNLArgs = (pstPNL_MOD_OutputChannelOrder)pArgs;
529 psPNLInstPri->fpPNL_MOD_OutputChannelOrder(pInstance,
530 pPNLArgs->u8OutputOrderType,
531 pPNLArgs->u16OutputOrder0_3,
532 pPNLArgs->u16OutputOrder4_7,
533 pPNLArgs->u16OutputOrder8_11,
534 pPNLArgs->u16OutputOrder12_13);
535
536 return UTOPIA_STATUS_SUCCESS;
537 }
538
539 case E_PNL_CMD_HWLVDSRESERVEDTOLRFLAG:
540 {
541 pstPNL_HWLVDSReservedtoLRFlag pPNLArgs = (pstPNL_HWLVDSReservedtoLRFlag)pArgs;
542 psPNLInstPri->fpPNL_HWLVDSReservedtoLRFlag(pInstance, pPNLArgs->lvdsresinfo);
543
544 return UTOPIA_STATUS_SUCCESS;
545 }
546
547 case E_PNL_CMD_MOD_PVDD_POWER_SETTING:
548 {
549 pstPNL_MOD_PVDD_Power_Setting pPNLArgs = (pstPNL_MOD_PVDD_Power_Setting)pArgs;
550 psPNLInstPri->fpPNL_MOD_PVDD_Power_Setting(pInstance, pPNLArgs->bIs2p5);
551
552 return UTOPIA_STATUS_SUCCESS;
553 }
554
555 case E_PNL_CMD_SETSSC_EN:
556 {
557 pstPNL_SetSSC_En pPNLArgs = (pstPNL_SetSSC_En)pArgs;
558 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetSSC_En(pInstance, pPNLArgs->bEnable);
559
560 return UTOPIA_STATUS_SUCCESS;
561 }
562
563 case E_PNL_CMD_SETSSC_FMODULATION:
564 {
565 pstPNL_SetSSC_Fmodulation pPNLArgs = (pstPNL_SetSSC_Fmodulation)pArgs;
566 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetSSC_Fmodulation(pInstance, pPNLArgs->u16Fmodulation);
567
568 return UTOPIA_STATUS_SUCCESS;
569 }
570
571 case E_PNL_CMD_SETSSC_RDEVIATION:
572 {
573 pstPNL_SetSSC_Rdeviation pPNLArgs = (pstPNL_SetSSC_Rdeviation)pArgs;
574 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetSSC_Rdeviation(pInstance, pPNLArgs->u16Rdeviation);
575
576 return UTOPIA_STATUS_SUCCESS;
577 }
578
579 case E_PNL_CMD_SETOSDSSC_EN:
580 {
581 pstPNL_SetOSDSSC_En pPNLArgs = (pstPNL_SetOSDSSC_En)pArgs;
582 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetOSDSSC_En(pInstance, pPNLArgs->bEnable);
583
584 return UTOPIA_STATUS_SUCCESS;
585 }
586
587 case E_PNL_CMD_SETOSDSSC_FMODULATION:
588 {
589 pstPNL_SetOSDSSC_Fmodulation pPNLArgs = (pstPNL_SetOSDSSC_Fmodulation)pArgs;
590 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetOSDSSC_Fmodulation(pInstance, pPNLArgs->u16Fmodulation);
591
592 return UTOPIA_STATUS_SUCCESS;
593 }
594
595 case E_PNL_CMD_SETOSDSSC_RDEVIATION:
596 {
597 pstPNL_SetOSDSSC_Rdeviation pPNLArgs = (pstPNL_SetOSDSSC_Rdeviation)pArgs;
598 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetOSDSSC_Rdeviation(pInstance, pPNLArgs->u16Rdeviation);
599
600 return UTOPIA_STATUS_SUCCESS;
601 }
602
603 case E_PNL_CMD_SKIPTIMINGCHANGE:
604 {
605 pstPNL_SkipTimingChange pPNLArgs = (pstPNL_SkipTimingChange)pArgs;
606 pPNLArgs->eResult = psPNLInstPri->fpPNL_SkipTimingChange(pInstance, pPNLArgs->bFlag);
607
608 return UTOPIA_STATUS_SUCCESS;
609 }
610
611 case E_PNL_CMD_PRE_SET_MODE_ON:
612 {
613 pstPNL_PreSetModeOn pPNLArgs = (pstPNL_PreSetModeOn)pArgs;
614 pPNLArgs->eResult = psPNLInstPri->fpPNL_PreSetModeOn(pInstance, pPNLArgs->bSetMode);
615
616 return UTOPIA_STATUS_SUCCESS;
617 }
618
619 case E_PNL_CMD_OVERDRIVER_INIT:
620 {
621 pstPNL_OverDriver_Init pPNLArgs = (pstPNL_OverDriver_Init)pArgs;
622 pPNLArgs->eResult = psPNLInstPri->fpPNL_OverDriver_Init(pInstance, pPNLArgs->pPNL_ODInitData, pPNLArgs->u32ODInitDataLen);
623
624 return UTOPIA_STATUS_SUCCESS;
625 }
626
627 case E_PNL_CMD_OVERDRIVER_ENABLE:
628 {
629 pstPNL_OverDriver_Enable pPNLArgs = (pstPNL_OverDriver_Enable)pArgs;
630 pPNLArgs->eResult = psPNLInstPri->fpPNL_OverDriver_Enable(pInstance, pPNLArgs->bEnable);
631
632 return UTOPIA_STATUS_SUCCESS;
633 }
634
635 case E_PNL_CMD_GET_LPLL_TYPE:
636 {
637 pstPNL_Get_LPLL_Type pPNLArgs = (pstPNL_Get_LPLL_Type)pArgs;
638 pPNLArgs->u8Return = psPNLInstPri->fpPNL_Get_LPLL_Type(pInstance);
639
640 return UTOPIA_STATUS_SUCCESS;
641 }
642
643 case E_PNL_CMD_GET_TCON_CAPABILITY:
644 {
645 pstPNL_Get_TCON_Capability pPNLArgs = (pstPNL_Get_TCON_Capability)pArgs;
646 pPNLArgs->bReturn = psPNLInstPri->fpPNL_Get_TCON_Capability(pInstance);
647
648 return UTOPIA_STATUS_SUCCESS;
649 }
650
651 case E_PNL_CMD_SETPAIRSWAP:
652 {
653 pstPNL_SetPairSwap pPNLArgs = (pstPNL_SetPairSwap)pArgs;
654 psPNLInstPri->fpPNL_SetPairSwap(pInstance, pPNLArgs->u32Polarity);
655
656 return UTOPIA_STATUS_SUCCESS;
657 }
658
659 case E_PNL_CMD_SET_EXT_LPLL_TYPE:
660 {
661 pstPNL_SetExt_LPLL_Type pPNLArgs = (pstPNL_SetExt_LPLL_Type)pArgs;
662 psPNLInstPri->fpPNL_SetExt_LPLL_Type(pInstance, pPNLArgs->u16Ext_lpll_type);
663
664 return UTOPIA_STATUS_SUCCESS;
665 }
666
667 case E_PNL_CMD_CALEXTLPLLSETBYDCLK:
668 {
669 pstPNL_CalExtLPLLSETbyDClk pPNLArgs = (pstPNL_CalExtLPLLSETbyDClk)pArgs;
670 psPNLInstPri->fpPNL_CalExtLPLLSETbyDClk(pInstance, pPNLArgs->ldHz);
671
672 return UTOPIA_STATUS_SUCCESS;
673 }
674
675 case E_PNL_CMD_SETDIFFSWINGLEVEL:
676 {
677 pstPNL_SetDiffSwingLevel pPNLArgs = (pstPNL_SetDiffSwingLevel)pArgs;
678 pPNLArgs->bReturn = psPNLInstPri->fpPNL_SetDiffSwingLevel(pInstance, pPNLArgs->u8Swing_Level);
679
680 return UTOPIA_STATUS_SUCCESS;
681 }
682
683 case E_PNL_CMD_SETPOWERSTATE:
684 {
685 pstPNL_SetPowerState pPNLArgs = (pstPNL_SetPowerState)pArgs;
686 pPNLArgs->u32Return = psPNLInstPri->fpPNL_SetPowerState(pInstance, pPNLArgs->ePowerState);
687
688 return UTOPIA_STATUS_SUCCESS;
689 }
690
691 case E_PNL_CMD_FORCESETPANELDCLK:
692 {
693 pstPNL_ForceSetPanelDCLK pPNLArgs = (pstPNL_ForceSetPanelDCLK)pArgs;
694 pPNLArgs->bReturn = psPNLInstPri->fpPNL_ForceSetPanelDCLK(pInstance, pPNLArgs->u16PanelDCLK, pPNLArgs->bSetDCLKEnable);
695
696 return UTOPIA_STATUS_SUCCESS;
697 }
698
699 case E_PNL_CMD_FORCESETPANELHSTART:
700 {
701 pstPNL_ForceSetPanelHStart pPNLArgs = (pstPNL_ForceSetPanelHStart)pArgs;
702 pPNLArgs->bReturn = psPNLInstPri->fpPNL_ForceSetPanelHStart(pInstance, pPNLArgs->u16PanelHStart, pPNLArgs->bSetHStartEnable);
703
704 return UTOPIA_STATUS_SUCCESS;
705 }
706
707 case E_PNL_CMD_ENABLEINTERNALTERMINATION:
708 {
709 pstPNL_EnableInternalTermination pPNLArgs = (pstPNL_EnableInternalTermination)pArgs;
710 pPNLArgs->bReturn = psPNLInstPri->fpPNL_EnableInternalTermination(pInstance, pPNLArgs->bEnable);
711
712 return UTOPIA_STATUS_SUCCESS;
713 }
714
715 case E_PNL_CMD_OUTPUTDEVICEHANDSHAKE:
716 {
717 pstPNL_OutputDeviceHandshake pPNLArgs = (pstPNL_OutputDeviceHandshake)pArgs;
718 pPNLArgs->bReturn = psPNLInstPri->fpPNL_OutputDeviceHandshake(pInstance);
719
720 return UTOPIA_STATUS_SUCCESS;
721 }
722
723 case E_PNL_CMD_OUTPUTDEVICEOCHANDSHAKE:
724 {
725 pstPNL_OutputDeviceOCHandshake pPNLArgs = (pstPNL_OutputDeviceOCHandshake)pArgs;
726 pPNLArgs->bReturn = psPNLInstPri->fpPNL_OutputDeviceOCHandshake(pInstance);
727
728 return UTOPIA_STATUS_SUCCESS;
729 }
730
731 case E_PNL_CMD_SETOUTPUTINTERLACETIMING:
732 {
733 pstPNL_SetOutputInterlaceTiming pPNLArgs = (pstPNL_SetOutputInterlaceTiming)pArgs;
734 pPNLArgs->eReturn = psPNLInstPri->fpPNL_SetOutputInterlaceTiming(pInstance, pPNLArgs->bEnable);
735
736 return UTOPIA_STATUS_SUCCESS;
737 }
738
739 case E_PNL_CMD_GETOUTPUTINTERLACETIMING:
740 {
741 pstPNL_GetOutputInterlaceTiming pPNLArgs = (pstPNL_GetOutputInterlaceTiming)pArgs;
742 pPNLArgs->bReturn = psPNLInstPri->fpPNL_GetOutputInterlaceTiming(pInstance);
743
744 return UTOPIA_STATUS_SUCCESS;
745 }
746
747 case E_PNL_CMD_GETPANELDATA:
748 {
749 pstPNL_GetPanelData pPNLArgs = (pstPNL_GetPanelData)pArgs;
750 psPNLInstPri->fpPNL_GetPanelData(pInstance, pPNLArgs->pstPNLData);
751
752 return UTOPIA_STATUS_SUCCESS;
753 }
754
755 case E_PNL_CMD_DUMPPANELDATA:
756 {
757 psPNLInstPri->fpPNL_DumpPanelData(pInstance);
758
759 return UTOPIA_STATUS_SUCCESS;
760 }
761
762 case E_PNL_CMD_SETSSC:
763 {
764 pstPNL_SetSSC pPNLArgs = (pstPNL_SetSSC)pArgs;
765 psPNLInstPri->fpPNL_SetSSC(pInstance, pPNLArgs->u16Fmodulation, pPNLArgs->u16Rdeviation, pPNLArgs->bEnable);
766
767 return UTOPIA_STATUS_SUCCESS;
768 }
769
770 case E_PNL_CMD_GETPANELONTIMING:
771 {
772 pstPNL_GetPanelOnTiming pPNLArgs = (pstPNL_GetPanelOnTiming)pArgs;
773 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetPanelOnTiming(pInstance, pPNLArgs->seq);
774
775 return UTOPIA_STATUS_SUCCESS;
776 }
777
778 case E_PNL_CMD_GETPANELOFFTIMING:
779 {
780 pstPNL_GetPanelOffTiming pPNLArgs = (pstPNL_GetPanelOffTiming)pArgs;
781 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetPanelOffTiming(pInstance, pPNLArgs->seq);
782
783 return UTOPIA_STATUS_SUCCESS;
784 }
785
786 case E_PNL_CMD_GETPANELDIMCTRL:
787 {
788 pstPNL_GetPanelDimCtrl pPNLArgs = (pstPNL_GetPanelDimCtrl)pArgs;
789 pPNLArgs->u8Return = psPNLInstPri->fpPNL_GetPanelDimCtrl(pInstance, pPNLArgs->dim_type);
790
791 return UTOPIA_STATUS_SUCCESS;
792 }
793
794 case E_PNL_CMD_GETALLGAMMATBL:
795 {
796 pstPNL_GetAllGammaTbl pPNLArgs = (pstPNL_GetAllGammaTbl)pArgs;
797 pPNLArgs->ppu8Return = psPNLInstPri->fpPNL_GetAllGammaTbl(pInstance);
798
799 return UTOPIA_STATUS_SUCCESS;
800 }
801
802 case E_PNL_CMD_ENABLEPANEL:
803 {
804 pstPNL_EnablePanel pPNLArgs = (pstPNL_EnablePanel)pArgs;
805 pPNLArgs->bReturn = psPNLInstPri->fpPNL_EnablePanel(pInstance, pPNLArgs->bPanelOn);
806
807 return UTOPIA_STATUS_SUCCESS;
808 }
809
810 case E_PNL_CMD_SETGAMMATBL:
811 {
812 pstPNL_SetGammaTbl pPNLArgs = (pstPNL_SetGammaTbl)pArgs;
813 pPNLArgs->bReturn = psPNLInstPri->fpPNL_SetGammaTbl(pInstance, pPNLArgs->eGammaType, pPNLArgs->pu8GammaTab, pPNLArgs->Gamma_Map_Mode);
814
815 return UTOPIA_STATUS_SUCCESS;
816 }
817
818 case E_PNL_CMD_GETGAMMATBL:
819 {
820 pstPNL_GetGammaTbl pPNLArgs = (pstPNL_GetGammaTbl)pArgs;
821 pPNLArgs->bReturn = psPNLInstPri->fpPNL_GetGammaTbl(pInstance, pPNLArgs->eGammaType, pPNLArgs->pu8GammaTab, pPNLArgs->Gamma_Map_Mode);
822
823 return UTOPIA_STATUS_SUCCESS;
824 }
825
826 case E_PNL_CMD_SETGAMMAVALUE:
827 {
828 pstPNL_SetGammaValue pPNLArgs = (pstPNL_SetGammaValue)pArgs;
829 pPNLArgs->bReturn = psPNLInstPri->fpPNL_SetGammaValue(pInstance, pPNLArgs->u8Channel, pPNLArgs->u16Offset, pPNLArgs->u16GammaValue);
830
831 return UTOPIA_STATUS_SUCCESS;
832 }
833
834 case E_PNL_CMD_GETLPLLMODE:
835 {
836 pstPNL_GetLPLLMode pPNLArgs = (pstPNL_GetLPLLMode)pArgs;
837 pPNLArgs->u8Return = psPNLInstPri->fpPNL_GetLPLLMode(pInstance);
838
839 return UTOPIA_STATUS_SUCCESS;
840 }
841
842 case E_PNL_CMD_GETDEFVFREQ:
843 {
844 pstPNL_GetDefVFreq pPNLArgs = (pstPNL_GetDefVFreq)pArgs;
845 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetDefVFreq(pInstance);
846
847 return UTOPIA_STATUS_SUCCESS;
848 }
849
850 case E_PNL_CMD_GETPANELNAME:
851 {
852 pstPNL_GetName pPNLArgs = (pstPNL_GetName)pArgs;
853 pPNLArgs->pPNLName = psPNLInstPri->fpPNL_GetPanelName(pInstance);
854
855 return UTOPIA_STATUS_SUCCESS;
856 }
857
858 case E_PNL_CMD_GETHSTART:
859 {
860 pstPNL_GetHstart pPNLArgs = (pstPNL_GetHstart)pArgs;
861 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetHStart(pInstance);
862
863 return UTOPIA_STATUS_SUCCESS;
864 }
865
866 case E_PNL_CMD_GETVSTART:
867 {
868 pstPNL_GetVstart pPNLArgs = (pstPNL_GetVstart)pArgs;
869 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetVStart(pInstance);
870
871 return UTOPIA_STATUS_SUCCESS;
872 }
873
874 case E_PNL_CMD_GETWIDTH:
875 {
876 pstPNL_GetWidth pPNLArgs = (pstPNL_GetWidth)pArgs;
877 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetWidth(pInstance);
878
879 return UTOPIA_STATUS_SUCCESS;
880 }
881
882 case E_PNL_CMD_GETHEIGHT:
883 {
884 pstPNL_GetWidth pPNLArgs = (pstPNL_GetWidth)pArgs;
885 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetHeight(pInstance);
886
887 return UTOPIA_STATUS_SUCCESS;
888 }
889
890 case E_PNL_CMD_GETHTOTAL:
891 {
892 pstPNL_GetHtotal pPNLArgs = (pstPNL_GetHtotal)pArgs;
893 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetHtotal(pInstance);
894
895 return UTOPIA_STATUS_SUCCESS;
896 }
897
898 case E_PNL_CMD_GETVTOTAL:
899 {
900 pstPNL_GetVtotal pPNLArgs = (pstPNL_GetVtotal)pArgs;
901 pPNLArgs->u16Return = psPNLInstPri->fpPNL_GetVtotal(pInstance);
902
903 return UTOPIA_STATUS_SUCCESS;
904 }
905
906 case E_PNL_CMD_GETHSYNCWIDTH:
907 {
908 pstPNL_GetHsyncWidth pPNLArgs = (pstPNL_GetHsyncWidth)pArgs;
909 pPNLArgs->u8Return = psPNLInstPri->fpPNL_GetHsyncwidth(pInstance);
910
911 return UTOPIA_STATUS_SUCCESS;
912 }
913
914 case E_PNL_CMD_GETHSYNCBACKPORCH:
915 {
916 pstPNL_GetHsyncBackPorch pPNLArgs = (pstPNL_GetHsyncBackPorch)pArgs;
917 pPNLArgs->u8Return = psPNLInstPri->fpPNL_GetHsyncBackPorch(pInstance);
918
919 return UTOPIA_STATUS_SUCCESS;
920 }
921
922 case E_PNL_CMD_GETVSYNCBACKPORCH:
923 {
924 pstPNL_GetVsyncBackPorch pPNLArgs = (pstPNL_GetVsyncBackPorch)pArgs;
925 pPNLArgs->u8Return = psPNLInstPri->fpPNL_GetVsyncBackPorch(pInstance);
926
927 return UTOPIA_STATUS_SUCCESS;
928 }
929
930 case E_PNL_CMD_GETLPLLTYPE:
931 {
932 pstPNL_GetLPLLType pPNLArgs = (pstPNL_GetLPLLType)pArgs;
933 pPNLArgs->u8Return = psPNLInstPri->fpPNL_GetLPLLType(pInstance);
934
935 return UTOPIA_STATUS_SUCCESS;
936 }
937
938 case E_PNL_CMD_GETARC:
939 {
940 pstPNL_GetARC pPNLArgs = (pstPNL_GetARC)pArgs;
941 pPNLArgs->ePanelAspectRatio= psPNLInstPri->fpPNL_GetARC(pInstance);
942
943 return UTOPIA_STATUS_SUCCESS;
944 }
945
946 case E_PNL_CMD_GETMINSET:
947 {
948 pstPNL_GetMinSET pPNLArgs = (pstPNL_GetMinSET)pArgs;
949 pPNLArgs->u32Return = psPNLInstPri->fpPNL_GetMinSET(pInstance);
950
951 return UTOPIA_STATUS_SUCCESS;
952 }
953
954 case E_PNL_CMD_GETMAXSET:
955 {
956 pstPNL_GetMaxSET pPNLArgs = (pstPNL_GetMaxSET)pArgs;
957 pPNLArgs->u32Return = psPNLInstPri->fpPNL_GetMaxSET(pInstance);
958
959 return UTOPIA_STATUS_SUCCESS;
960 }
961
962 case E_PNL_CMD_GETOUTTIMINGMODE:
963 {
964 pstPNL_GetOutTimingMode pPNLArgs = (pstPNL_GetOutTimingMode)pArgs;
965 pPNLArgs->ePanelOutTimingMode= psPNLInstPri->fpPNL_GetOutTimingMode(pInstance);
966
967 return UTOPIA_STATUS_SUCCESS;
968 }
969
970 case E_PNL_CMD_CHECKVBY1HANDSHAKESTATUS:
971 {
972 pstPNL_CheckVBY1HandshakeStatus pPNLArgs = (pstPNL_CheckVBY1HandshakeStatus)pArgs;
973 pPNLArgs->bResult = psPNLInstPri->fpPNL_CheckVBY1HandshakeStatus(pInstance);
974
975 return UTOPIA_STATUS_SUCCESS;
976 }
977
978 case E_PNL_CMD_SET_VIDEOHWTRAINING_MODE:
979 {
980 pstPNL_MOD_Video_HWTrainingMode pPNLArgs = (pstPNL_MOD_Video_HWTrainingMode)pArgs;
981 psPNLInstPri->fpPNL_SetVideoHWTraining(pInstance, pPNLArgs->bEnable);
982
983 return UTOPIA_STATUS_SUCCESS;
984 }
985
986 case E_PNL_CMD_SET_OSDHWTRAINING_MODE:
987 {
988 pstPNL_MOD_OSD_HWTrainingMode pPNLArgs = (pstPNL_MOD_OSD_HWTrainingMode)pArgs;
989 psPNLInstPri->fpPNL_SetOSDHWTraining(pInstance, pPNLArgs->bEnable);
990
991 return UTOPIA_STATUS_SUCCESS;
992 }
993
994 case E_PNL_CMD_GET_VIDEOHWTRAINING_MODE:
995 {
996 pstPNL_GetVideoHWTraining_status pPNLArgs = (pstPNL_GetVideoHWTraining_status)pArgs;
997 pPNLArgs->bStatus= psPNLInstPri->fpPNL_GetVideoHWTraining_Status(pInstance);
998
999 return UTOPIA_STATUS_SUCCESS;
1000 }
1001
1002 case E_PNL_CMD_GET_OSDHWTRAINING_MODE:
1003 {
1004 pstPNL_GetOSDHWTraining_status pPNLArgs = (pstPNL_GetOSDHWTraining_status)pArgs;
1005 pPNLArgs->bStatus = psPNLInstPri->fpPNL_GetOSDHWTraining_Status(pInstance);
1006
1007 return UTOPIA_STATUS_SUCCESS;
1008 }
1009 case E_PNL_CMD_Setting:
1010 {
1011 pstPNL_Setting pPNLArgs = (pstPNL_Setting)pArgs;
1012 pPNLArgs->eReturnValue = psPNLInstPri->fpPNL_Setting(pInstance, pPNLArgs->u32Cmd, pPNLArgs->pCmdArgs, pPNLArgs->u32CmdArgsSize);
1013
1014 return UTOPIA_STATUS_SUCCESS;
1015 }
1016 default:
1017 printf("Error Command = %td\n", (ptrdiff_t)u32Cmd);
1018 break;
1019 }
1020
1021 return UTOPIA_STATUS_FAIL;
1022 #else
1023 return UTOPIA_STATUS_SUCCESS;
1024 #endif
1025 }
1026
PNLClose(void * pInstance)1027 MS_U32 PNLClose(void* pInstance)
1028 {
1029 UtopiaInstanceDelete(pInstance);
1030
1031 return UTOPIA_STATUS_SUCCESS;
1032 }
1033
1034 #endif
1035