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!�L) 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 #define DRV_SC_MENULOAD_C
96
97 // Common Definition
98 #ifdef MSOS_TYPE_LINUX_KERNEL
99 #include <linux/string.h>
100 #else
101 #include <string.h>
102 #endif
103 #include "MsCommon.h"
104 #include "MsOS.h"
105 #include "mhal_xc_chip_config.h"
106 #ifndef CONFIG_MBOOT
107 #if (SUPPORT_KERNEL_MLOAD == 1)
108 #include "mdrv_xc_st.h"
109 #include "mdrv_xc_io.h"
110 #ifndef MSOS_TYPE_LINUX_KERNEL
111 #include <sys/ioctl.h>
112 #include <sys/types.h>
113 #include <sys/stat.h>
114 #include <fcntl.h>
115 #include <unistd.h>
116 #endif
117 #endif
118 #endif
119
120 #include "utopia.h"
121 #include "utopia_dapi.h"
122 //#include "Debug.h"
123 #include "xc_Analog_Reg.h"
124 #include "xc_hwreg_utility2.h"
125 #include "drvXC_IOPort.h"
126 #include "apiXC.h"
127 #include "apiXC_Adc.h"
128 #include "apiXC_Auto.h"
129 #include "drv_sc_display.h"
130 #include "drv_sc_isr.h"
131 #include "apiXC_PCMonitor.h"
132 #include "apiXC_ModeParse.h"
133 #include "drvXC_HDMI_if.h"
134 #include "mvideo_context.h"
135 #include "drv_sc_ip.h"
136 #if (LD_ENABLE==1)
137 #include "mdrv_ld.h"
138 #include "mdrv_ldalgo.h"
139 #endif
140 #include "mdrv_sc_3d.h"
141 #include "drv_sc_menuload.h"
142 #include "drvXC_ADC_Internal.h"
143 #include "mhal_sc.h"
144 #if FRC_INSIDE
145 #include "mdrv_frc.h"
146 #include "mhal_frc.h"
147 #endif
148 #include "XC_private.h"
149 #include "apiXC_v2.h"
150 #include "mhal_menuload.h"
151 #include "drvMIU.h"
152 #include "halCHIP.h"
153 #include "drv_sc_scaling.h"
154
155 #define MLDBG_WARN(x) x // open when debug time for serious issue.
156 #define MLDBG(x) //(printf("[MLOAD %d] ",__LINE__), x)
157 #define MLG(x) //(printf("[MLG] "), x)
158
159 #define _AlignTo(value, align) ( ((value) + ((align)-1)) & ~((align)-1) )
160
161
162
163 #if 0
164 void dumpcmd(void)
165 {
166 MS_U16 i, j;
167 MS_U8 *p = (MS_U8 *)MS_PA2KSEG1(pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr);
168
169 MLDBG(printf("dump cmd buffer: %d\n", pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint));
170 for (i = 0; i < pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint; i++)
171 {
172 printf("%06d: ", i);
173 for (j = 0; j < MS_MLOAD_CMD_LEN; j++)
174 {
175 printf("%02x", p[i*MS_MLOAD_CMD_LEN + j]);
176 }
177 printf(" \n");
178 }
179 }
180 #endif
181
182 #ifndef CONFIG_MBOOT
183 #if (SUPPORT_KERNEL_MLOAD == 1)
184 #ifdef MSOS_TYPE_LINUX_KERNEL
185 extern void KApi_XC_MLoad_Init(EN_MLOAD_CLIENT_TYPE _client_type,MS_U64 PhyAddr, MS_U32 u32BufByteLen);
186 extern void KApi_XC_MLoad_Enable(EN_MLOAD_CLIENT_TYPE _client_type,MS_BOOL bEnable);
187 extern EN_KDRV_MLOAD_TYPE KApi_XC_MLoad_GetStatus(EN_MLOAD_CLIENT_TYPE _client_type);
188 extern MS_BOOL KApi_XC_MLoad_WriteCmd(EN_MLOAD_CLIENT_TYPE _client_type,MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask);
189 extern MS_BOOL KApi_XC_MLoad_WriteCmd_NonXC(EN_MLOAD_CLIENT_TYPE _client_type,MS_U32 u32Bank,MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask);
190 extern MS_BOOL KApi_XC_MLoad_Fire(EN_MLOAD_CLIENT_TYPE _client_type,MS_BOOL bImmeidate);
191 extern MS_BOOL KDrv_XC_MLoad_set_IP_trig_p(EN_MLOAD_CLIENT_TYPE _client_type,MS_U16 u16train, MS_U16 u16disp);
192 extern MS_BOOL KDrv_XC_MLoad_get_IP_trig_p(EN_MLOAD_CLIENT_TYPE _client_type,MS_U16 *pu16Train, MS_U16 *pu16Disp);
193 extern void KDrv_XC_MLoad_set_trigger_sync(EN_MLOAD_CLIENT_TYPE _client_type,EN_MLOAD_TRIG_SYNC eTriggerSync);
194 #endif
195 #endif
196 #endif
197
198 static MS_BOOL _MDrv_XC_MLoad_WriteCmd_64Bits(void *pInstance, MS_U64 u64Cmd, MS_U16 u16Mask);
199 static MS_BOOL _MDrv_XC_MLoad_WriteCmd_32Bits(void *pInstance, MS_U32 u32Cmd, MS_U16 u16Mask);
200
_MDrv_XC_GetMloadMemOffset(void * pInstance,MS_U32 u32Index)201 static MS_U32 _MDrv_XC_GetMloadMemOffset(void *pInstance, MS_U32 u32Index)
202 {
203 MS_U32 u32Offset = 0;
204 MS_U32 u32CmdCntPerMIUBus = (MS_MLOAD_BUS_WIDTH/MS_MLOAD_CMD_LEN_64BITS);
205 u32Offset = (u32Index/u32CmdCntPerMIUBus)*MS_MLOAD_MEM_BASE_UNIT + (u32Index%u32CmdCntPerMIUBus)*MS_MLOAD_CMD_LEN_64BITS;
206 return u32Offset;
207 }
208
MDrv_XC_MLoad_Check_Done(void * pInstance)209 MS_BOOL MDrv_XC_MLoad_Check_Done(void *pInstance)
210 {
211 MS_BOOL bEn;
212
213 if(Hal_XC_MLoad_get_status(pInstance))
214 bEn = FALSE;
215 else
216 bEn = TRUE;
217 return bEn;
218 }
219
MDrv_XC_MLoad_Wait_HW_Done(void * pInstance)220 void MDrv_XC_MLoad_Wait_HW_Done(void *pInstance)
221 {
222 MS_U32 u32Delayms = 0;
223 while((MDrv_XC_MLoad_Check_Done(pInstance) == FALSE) && u32Delayms < 600)
224 {
225 MsOS_DelayTask(1);
226 u32Delayms++;
227 }
228 }
229
MDrv_XC_MLoad_Init(void * pInstance,MS_PHY phyAddr)230 void MDrv_XC_MLoad_Init(void *pInstance, MS_PHY phyAddr)
231 {
232 MS_PHY u32StartOffset;
233 MS_U8 u8MIUSel = 0;
234 MS_U16 u16Cmd;
235
236 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
237 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
238 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
239 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
240 MLDBG(printf("%s: 0x%llx\n", __FUNCTION__, phyAddr));
241 // remove the MIU offset
242 _phy_to_miu_offset(u8MIUSel, u32StartOffset, phyAddr);
243 UNUSED(u32StartOffset);
244 Hal_XC_MLoad_set_opm_arbiter_bypass(pInstance, TRUE);
245
246 //set command format
247 Hal_XC_MLoad_Command_Format_initial(pInstance);
248
249 //Hal_XC_MLoad_set_on_off(DISABLE);
250 Hal_XC_MLoad_set_trigger_timing(pInstance, TRIG_SRC_DELAY_LINE); //By REG_MLOAD_TRIG_DLY
251 Hal_XC_MLoad_set_trigger_delay(pInstance, 0x05);
252 Hal_XC_MLoad_set_trig_p(pInstance, 0x08, 0x0A);
253 Hal_XC_MLoad_get_trig_p(pInstance, &pXCResourcePrivate->sthal_SC.u16OldValue[E_STORE_VALUE_AUTO_TUNE_AREA_TRIG], &pXCResourcePrivate->sthal_SC.u16OldValue[E_STORE_VALUE_DISP_AREA_TRIG]);
254 #if (HW_DESIGN_4K2K_VER == 4)
255 // set ip trig as hw default value
256 MDrv_XC_MLoad_set_IP_trig_p(pInstance, 0x03, 0x05);
257 MDrv_XC_MLoad_get_IP_trig_p(pInstance, &pXCResourcePrivate->sthal_SC.u16OldValue[E_STORE_VALUE_IP_AUTO_TUNE_AREA_TRIG], &pXCResourcePrivate->sthal_SC.u16OldValue[E_STORE_VALUE_IP_DISP_AREA_TRIG]);
258 #endif
259 //Hal_XC_MLoad_set_miu_bus_sel(pInstance, MS_MLOAD_MIU_BUS_SEL);
260 Hal_XC_MLoad_set_miusel(pInstance, u8MIUSel);
261 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].u8XCMLoadMIUSel = u8MIUSel;
262
263 //***********watch dog***************
264 /*
265 **enable watch dog
266 */
267 Hal_XC_MLoad_enable_watch_dog(pInstance, TRUE);
268 /*
269 ** enlarge watch dog response time
270 */
271 Hal_XC_MLoad_set_watch_dog_time_delay(pInstance, 0x00F0);
272 /*
273 ** watch dog timer reset type 00: dma only, 01: miu, 11: all
274 */
275 Hal_XC_MLoad_enable_watch_dog_reset(pInstance, MLoad_WD_Timer_Reset_ALL);
276 //***********************************
277 /*
278 ** set bit mask enable
279 */
280 Hal_XC_MLoad_set_BitMask(pInstance,TRUE);
281 //***********************************
282
283 if (MDrv_XC_MLoad_GetCaps(pInstance))
284 {
285 for (u16Cmd = 0; u16Cmd < 32; u16Cmd++)
286 {
287 if(IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
288 {
289 if(ENABLE_64BITS_SPREAD_MODE)
290 {
291 //MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance,(MS_U64)MS_MLOAD_NULL_CMD_SPREAD_MODE, 0xFFFF);
292 _MDrv_XC_MLoad_WriteCmd_64Bits(pInstance,(MS_U64)MS_MLOAD_NULL_CMD_SPREAD_MODE, 0xFFFF);
293 }
294 else
295 {
296 //MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance,(MS_U64)MS_MLOAD_NULL_CMD, 0xFFFF);
297 _MDrv_XC_MLoad_WriteCmd_64Bits(pInstance,(MS_U64)MS_MLOAD_NULL_CMD, 0xFFFF);
298 }
299 }
300 else
301 {
302 //MDrv_XC_MLoad_Add_32Bits_Cmd(pInstance,(MS_U32)MS_MLOAD_NULL_CMD, 0xFFFF);
303 _MDrv_XC_MLoad_WriteCmd_32Bits(pInstance,(MS_U32)MS_MLOAD_NULL_CMD, 0xFFFF);
304 }
305 }
306
307 MDrv_XC_MLoad_AddNull(pInstance);
308 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint - 1;
309
310 // when system is power on, the read count of MLoad may be not 0.
311 // If we enable MLoad RIU_En, the garbage data in fifo will over-write
312 // unexpected register.
313 // Hence, add below code before Kickoff to avoid it.
314
315 Hal_XC_MLoad_set_riu_cs(pInstance, TRUE);
316 MsOS_DelayTask(1);
317
318 Hal_XC_MLoad_Set_riu(pInstance, 1);
319
320 MDrv_WriteByte(0x102F00, 0xFF);
321
322 Hal_XC_MLoad_set_riu_cs(pInstance, FALSE);
323
324 MsOS_DelayTask(1);
325
326 MDrv_XC_MLoad_KickOff(pInstance);
327 }
328 }
329
MDrv_XC_MLoad_GetCaps(void * pInstance)330 MS_BOOL MDrv_XC_MLoad_GetCaps(void *pInstance)
331 {
332 return Hal_XC_MLoad_GetCaps(pInstance);
333 }
334
MDrv_XC_MLoad_Trigger(void * pInstance,MS_PHY startAddr,MS_U16 u16CmdCnt)335 void MDrv_XC_MLoad_Trigger(void *pInstance, MS_PHY startAddr, MS_U16 u16CmdCnt)
336 {
337 MS_PHY u32StartOffset = 0;
338 MS_U8 u8MIUSel = 0;
339 MLDBG(printf("%s 0x%llx, %u\n\n",__FUNCTION__, startAddr, u16CmdCnt));
340
341 //dumpcmd();
342 #if 1
343 _phy_to_miu_offset(u8MIUSel, u32StartOffset, startAddr);
344 UNUSED(u8MIUSel);
345 Hal_XC_MLoad_set_base_addr(pInstance, u32StartOffset);
346 Hal_XC_MLoad_set_depth(pInstance, u16CmdCnt);
347 Hal_XC_MLoad_set_len(pInstance, MS_MLOAD_REG_LEN);//length of DMA request
348 Hal_XC_MLoad_set_on_off(pInstance, ENABLE);
349 MsOS_DelayTaskUs(3);
350 Hal_XC_MLoad_Set_riu(pInstance, ENABLE);
351
352 #else
353 Hal_XC_MLoad_trigger(startAddr, MS_MLOAD_REG_LEN, (MS_U8)u16CmdCnt);
354 #endif
355 }
356
MDrv_XC_MLoad_AddCmd(void * pInstance,MS_U32 u32Cmd)357 void MDrv_XC_MLoad_AddCmd(void *pInstance, MS_U32 u32Cmd)
358 {
359 MS_U32 *pu32Addr = NULL;
360 MS_PHY DstAddr;
361 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
362 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
363 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
364 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
365
366 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint * MS_MLOAD_CMD_LEN;
367 pu32Addr = (MS_U32 *)MS_PA2KSEG1(DstAddr);
368 *pu32Addr = u32Cmd;
369 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint++;
370 }
371
MDrv_XC_MLoad_SetCmd(MS_PHY DstAddr,MS_U32 u32Cmd)372 void MDrv_XC_MLoad_SetCmd(MS_PHY DstAddr, MS_U32 u32Cmd)
373 {
374 MS_U32 *pu32Addr = NULL;
375
376 pu32Addr = (MS_U32 *)MS_PA2KSEG1(DstAddr);
377 *pu32Addr = u32Cmd;
378 }
379
MDrv_XC_MLoad_SetCmd_64Bits(MS_PHY DstAddr,MS_U64 u64Cmd)380 void MDrv_XC_MLoad_SetCmd_64Bits(MS_PHY DstAddr, MS_U64 u64Cmd)
381 {
382 MS_U64 *pu64Addr = NULL;
383
384 pu64Addr = (MS_U64 *)MS_PA2KSEG1(DstAddr);
385 *pu64Addr = u64Cmd;
386 }
387
MDrv_XC_MLoad_GetCmd(MS_PHY DstAddr)388 MS_U32 MDrv_XC_MLoad_GetCmd(MS_PHY DstAddr)
389 {
390 MS_VIRT u32Addr;
391
392 u32Addr = MS_PA2KSEG1(DstAddr);
393 return (MS_U32)(*(MS_U32 *)u32Addr);
394 }
395
MDrv_XC_MLoad_GetCmd_64Bits(MS_PHY DstAddr)396 MS_U64 MDrv_XC_MLoad_GetCmd_64Bits(MS_PHY DstAddr)
397 {
398 MS_VIRT u32Addr;
399
400 u32Addr = MS_PA2KSEG1(DstAddr);
401 return (MS_U64)(*(MS_U64 *)u32Addr);
402 }
403
MDrv_XC_MLoad_BufferEmpty(void * pInstance)404 MS_BOOL MDrv_XC_MLoad_BufferEmpty(void *pInstance)
405 {
406 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
407 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
408 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
409 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
410 if(MDrv_XC_MLoad_Check_Done(pInstance) &&
411 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint) &&
412 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint+1))
413 return TRUE;
414 else
415 return FALSE;
416 }
417
418 //-------------------------------------------------------------------------------------------------
419 /// Write command to the Menuload buffer
420 /// @param u32Cmd \b IN: the command to write into the buffer
421 /// @return TRUE if succeed, FALSE if failed
422 //-------------------------------------------------------------------------------------------------
_MDrv_XC_MLoad_WriteCmd_32Bits(void * pInstance,MS_U32 u32Cmd,MS_U16 u16Mask)423 static MS_BOOL _MDrv_XC_MLoad_WriteCmd_32Bits(void *pInstance, MS_U32 u32Cmd, MS_U16 u16Mask)
424 {
425 MS_BOOL bRet;
426 MS_U16 u16DummyCmdIdx;
427 MS_U16 u16QueueCmd;
428 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
429 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
430 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
431 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
432 #ifdef ENABLE_SCALING_WO_MUTE
433 if ((pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint) &&
434 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint+1))
435 {
436 MDrv_XC_MLoad_Wait_HW_Done(pInstance);
437 }
438 #endif
439
440 if( MDrv_XC_MLoad_BufferEmpty(pInstance) )
441 {
442 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
443 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
444 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
445 MDrv_XC_MLoad_Add_32Bits_Cmd(pInstance, u32Cmd, u16Mask);
446 bRet = TRUE;
447 }
448 else
449 {
450 u16DummyCmdIdx = _AlignTo(pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint+1 + 16 , 4);
451
452 if (u16DummyCmdIdx == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint+1)
453 {
454 u16DummyCmdIdx = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint+1+MS_MLOAD_CMD_ALIGN;
455 }
456
457 if(u16DummyCmdIdx < pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt)
458 {
459 u16QueueCmd = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint - pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint + 1;
460
461 if(u16QueueCmd == MS_MLOAD_MAX_CMD_CNT - 1) //max cmd depth is MS_MLOAD_MAX_CMD_CNT
462 {
463 MDrv_XC_MLoad_Add_32Bits_Cmd(pInstance, MS_MLOAD_NULL_CMD, 0xFFFF);
464 }
465 MDrv_XC_MLoad_Add_32Bits_Cmd(pInstance, u32Cmd, u16Mask);
466
467 bRet = TRUE;
468 }
469 else
470 {
471 MLDBG(printf("WPoint=%x, MaxCnt=%x, DummyIdx=%x\n"
472 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint
473 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt
474 , u16DummyCmdIdx));
475 bRet = FALSE;
476 }
477 }
478
479 return bRet;
480 }
481
482 //-------------------------------------------------------------------------------------------------
483 /// Write command to the Menuload buffer
484 /// @param u64Cmd \b IN: the command to write into the buffer
485 /// @return TRUE if succeed, FALSE if failed
486 //-------------------------------------------------------------------------------------------------
_MDrv_XC_MLoad_WriteCmd_64Bits(void * pInstance,MS_U64 u64Cmd,MS_U16 u16Mask)487 static MS_BOOL _MDrv_XC_MLoad_WriteCmd_64Bits(void *pInstance, MS_U64 u64Cmd, MS_U16 u16Mask)
488 {
489 MS_BOOL bRet;
490 MS_U16 u16DummyCmdIdx;
491 MS_U16 u16QueueCmd;
492 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
493 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
494 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
495 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
496 #ifdef ENABLE_SCALING_WO_MUTE
497 if ((pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint) &&
498 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint+1))
499 {
500 MDrv_XC_MLoad_Wait_HW_Done(pInstance);
501 }
502 #endif
503
504 if( MDrv_XC_MLoad_BufferEmpty(pInstance) )
505 {
506 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
507 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
508 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
509 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance, u64Cmd, u16Mask);
510 bRet = TRUE;
511 }
512 else
513 {
514 u16DummyCmdIdx = _AlignTo(pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint+1 + 16 , 4);
515
516 if (u16DummyCmdIdx == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint+1)
517 {
518 u16DummyCmdIdx = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint+1+MS_MLOAD_CMD_ALIGN;
519 }
520
521 if(u16DummyCmdIdx < pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt)
522 {
523 u16QueueCmd = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint - pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint + 1;
524
525 if(u16QueueCmd == MS_MLOAD_MAX_CMD_CNT - 1) //max cmd depth is MS_MLOAD_MAX_CMD_CNT
526 {
527 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance, MS_MLOAD_NULL_CMD_SPREAD_MODE, 0xFFFF);
528 }
529 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance, u64Cmd, u16Mask);
530
531 bRet = TRUE;
532 }
533 else
534 {
535 MLDBG(printf("WPoint=%x, MaxCnt=%x, DummyIdx=%x\n"
536 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint
537 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt
538 , u16DummyCmdIdx));
539 bRet = FALSE;
540 }
541 }
542
543 return bRet;
544 }
545
MDrv_XC_MLoad_KickOff(void * pInstance)546 MS_BOOL MDrv_XC_MLoad_KickOff(void *pInstance)
547 {
548 //MS_MLOAD_END_CMD use instance, does not remove this
549 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
550 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
551 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
552 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
553 MS_BOOL bRet;
554 MS_U16 u16CmdCnt;
555 MS_U16 u16QueueCmd, u16FireIdx;
556 MS_PHY CmdBufAddr;
557
558 MLDBG(printf("%s\n",__FUNCTION__));
559 if(MDrv_XC_MLoad_Check_Done(pInstance) && pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint)
560 {
561 if(pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint > pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint)
562 {
563 u16QueueCmd = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint - pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint;
564
565 if(u16QueueCmd > MS_MLOAD_MAX_CMD_CNT)
566 {
567 MLDBG_WARN(printf("Queue Too Many !!!!!!!!!!!!!!!!!\n"));
568 MLDBG_WARN(printf("WPoint=%d, FirePoint=%d, RPoint=%d\n"
569 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint
570 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint
571 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint));
572 }
573
574 u16FireIdx = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint;
575 MLDBG(printf("u16QueueCmd= %u, u16FireIdx= %u\n", u16QueueCmd, u16FireIdx));
576
577 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
578 {
579 MS_U64 u64EndCmd;
580 //MS_U32 u32FireMemShift = 0;
581 //MS_U32 u32ReadMemShift = 0;
582 MS_PHY u32FireMemShift = 0;
583 MS_PHY u32ReadMemShift = 0;
584
585 #if ENABLE_64BITS_SPREAD_MODE
586 if((pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint % 2) != 0)
587 {
588 u32FireMemShift = (MS_PHY)_MDrv_XC_GetMloadMemOffset(pInstance, u16FireIdx);
589 }
590
591 //check the last command to see whether it is null command
592 //CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u16FireIdx * MS_MLOAD_CMD_LEN_64BITS;
593 CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u32FireMemShift;
594
595
596 u64EndCmd = MDrv_XC_MLoad_GetCmd_64Bits(CmdBufAddr);
597 if(u64EndCmd != MS_MLOAD_NULL_CMD_SPREAD_MODE)
598 {
599 MLDBG_WARN(printf("WPoint=%d, FirePoint=%d, RPoint=%d\n"
600 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint
601 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint
602 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint));
603 MLDBG_WARN(printf("KickOff: Non Null Cmd. Trigger is not executed!!\n"));
604 MS_ASSERT(0);
605 bRet = FALSE;
606 }
607 else
608 {
609 u16CmdCnt = u16FireIdx - pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint + 1;
610 u16CmdCnt = Hal_XC_MLoad_Get_Depth(pInstance, u16CmdCnt);
611 if (psXCInstPri->u32DeviceID == 0)
612 {
613 u64EndCmd = MS_MLOAD_END_CMD_SPREAD_MODE(((MS_U64)u16CmdCnt));
614 }
615 else
616 {
617 u64EndCmd = MS_MLOAD_END_CMD_DEV1_SPREAD_MODE(((MS_U64)u16CmdCnt));
618 }
619
620 MDrv_XC_MLoad_SetCmd_64Bits(CmdBufAddr, u64EndCmd);
621
622 MsOS_FlushMemory();
623
624 u32FireMemShift = (MS_PHY)_MDrv_XC_GetMloadMemOffset(pInstance, pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint);
625
626 //CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint * MS_MLOAD_CMD_LEN_64BITS;
627 CmdBufAddr = (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u32ReadMemShift);
628 MLDBG(printf("CmdBufAddr = 0x%llx, u16CmdCnt = 0x%x\n", CmdBufAddr, u16CmdCnt));
629
630 MDrv_XC_MLoad_Trigger(pInstance, CmdBufAddr, u16CmdCnt);
631 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = u16FireIdx + 1;
632 bRet = TRUE;
633 MLDBG(printf("after fire u16WPoint=%u u16RPoint=%u u16FPoint=%u\n",
634 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
635 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
636 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
637 }
638 #else
639 //check the last command to see whether it is null command
640 CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u16FireIdx * MS_MLOAD_CMD_LEN_64BITS;
641 u64EndCmd = MDrv_XC_MLoad_GetCmd_64Bits(CmdBufAddr);
642 if(u64EndCmd != MS_MLOAD_NULL_CMD)
643 {
644 MLDBG_WARN(printf("WPoint=%d, FirePoint=%d, RPoint=%d\n"
645 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint
646 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint
647 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint));
648 MLDBG_WARN(printf("KickOff: Non Null Cmd. Trigger is not executed!!\n"));
649 MS_ASSERT(0);
650 bRet = FALSE;
651 }
652 else
653 {
654 u16CmdCnt = u16FireIdx - pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint + 1;
655 u16CmdCnt = Hal_XC_MLoad_Get_Depth(pInstance, u16CmdCnt);
656 u64EndCmd = (MS_U64) MS_MLOAD_END_CMD(((MS_U32)u16CmdCnt));
657
658 MDrv_XC_MLoad_SetCmd_64Bits(CmdBufAddr, u64EndCmd);
659
660 MsOS_FlushMemory();
661
662 CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint * MS_MLOAD_CMD_LEN_64BITS;
663 MLDBG(printf("CmdBufAddr = 0x%lx, u16CmdCnt = 0x%lx\n", CmdBufAddr, u16CmdCnt));
664
665 MDrv_XC_MLoad_Trigger(pInstance, CmdBufAddr, u16CmdCnt);
666 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = u16FireIdx + 1;
667 bRet = TRUE;
668 MLDBG(printf("after fire u16WPoint=%u u16RPoint=%u u16FPoint=%u\n",
669 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
670 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
671 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
672 }
673 #endif
674 }
675 else
676 {
677 MS_U32 u32EndCmd;
678
679 //check the last command to see whether it is null command
680 CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u16FireIdx * MS_MLOAD_CMD_LEN;
681 u32EndCmd = MDrv_XC_MLoad_GetCmd(CmdBufAddr);
682 if(u32EndCmd != MS_MLOAD_NULL_CMD)
683 {
684 MLDBG_WARN(printf("WPoint=%d, FirePoint=%d, RPoint=%d\n"
685 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint
686 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint
687 , pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint));
688 MLDBG_WARN(printf("KickOff: Non Null Cmd. Trigger is not executed!!\n"));
689 MS_ASSERT(0);
690 bRet = FALSE;
691 }
692 else
693 {
694 u16CmdCnt = u16FireIdx - pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint + 1;
695
696 u32EndCmd = MS_MLOAD_END_CMD(((MS_U32)u16CmdCnt));
697 MLDBG(printf("CmdBufAddr = 0x%llx, u32EndCmd = 0x%x\n", CmdBufAddr, u32EndCmd));
698 MDrv_XC_MLoad_SetCmd(CmdBufAddr, u32EndCmd);
699
700 MsOS_FlushMemory();
701
702 CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint * MS_MLOAD_CMD_LEN;
703 MLDBG(printf("CmdBufAddr = 0x%llx, u16CmdCnt = 0x%x\n", CmdBufAddr, u16CmdCnt));
704 MDrv_XC_MLoad_Trigger(pInstance, CmdBufAddr, u16CmdCnt);
705 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = u16FireIdx + 1;
706 bRet = TRUE;
707 MLDBG(printf("after fire u16WPoint=%u u16RPoint=%u u16FPoint=%u\n",
708 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
709 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
710 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
711 }
712 }
713
714 }
715 else if(pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint &&
716 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint-1)
717 {
718 bRet = TRUE;
719 }
720 else
721 {
722 MLDBG(printf("MenuLoad: WPoint=%u, FPoint=%u, RPoint=%u !!\n",
723 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
724 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint,
725 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint));
726 bRet = FALSE;
727 }
728 }
729 else
730 {
731 bRet = TRUE;
732 }
733 return bRet;
734 }
735
MDrv_XC_MLoad_AddNull(void * pInstance)736 void MDrv_XC_MLoad_AddNull(void *pInstance)
737 {
738 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
739 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
740 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
741 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
742 MLDBG(printf("%s\n",__FUNCTION__));
743 do
744 // coverity[loop_top]
745 {
746 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
747 {
748 if(ENABLE_64BITS_SPREAD_MODE)
749 {
750 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance,(MS_U64)MS_MLOAD_NULL_CMD_SPREAD_MODE, 0xFFFF);
751 }
752 else
753 {
754 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance,(MS_U64)MS_MLOAD_NULL_CMD, 0xFFFF);
755 }
756 }
757 else
758 {
759 MDrv_XC_MLoad_Add_32Bits_Cmd(pInstance,(MS_U32)MS_MLOAD_NULL_CMD, 0xFFFF);
760 }
761
762 }while (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint%MS_MLOAD_CMD_ALIGN != 0);
763 }
764
765 //-------------------------------------------------------------------------------------------------
766 /// Initialize the Menuload
767 /// @param PhyAddr \b IN: the physical address for the menuload
768 /// @param u32BufByteLen \b IN: the buffer length of the menu load commands
769 //-------------------------------------------------------------------------------------------------
MApi_XC_MLoad_Init_U2(void * pInstance,MS_PHY PhyAddr,MS_U32 u32BufByteLen)770 void MApi_XC_MLoad_Init_U2(void* pInstance, MS_PHY PhyAddr, MS_U32 u32BufByteLen)
771 {
772 char word[] = {"_MLOAD_MUTEX"};
773 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
774 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
775 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
776 MLDBG(printf("%s: 0x%llx, 0x%x\n", __FUNCTION__, PhyAddr, u32BufByteLen));
777 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
778 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
779 //menuload init just once except dc on
780 if(pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].g_bMLoadInitted)
781 {
782 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
783 return;
784 }
785 else
786 {
787 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].g_bMLoadInitted = TRUE;
788 }
789 #ifndef CONFIG_MBOOT
790 #if (SUPPORT_KERNEL_MLOAD == 1)
791 pXCResourcePrivate->stdrvXC_MVideo_Context.g_u32MLoadPhyAddr_Suspend = PhyAddr;
792 pXCResourcePrivate->stdrvXC_MVideo_Context.g_u32MLoadBufByteLen_Suspend = u32BufByteLen;
793 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
794 #ifdef MSOS_TYPE_LINUX_KERNEL
795 EN_MLOAD_CLIENT_TYPE client_type;
796 if(psXCInstPri->u32DeviceID == 0)
797 client_type = E_CLIENT_MAIN_XC;
798 else
799 client_type = E_CLIENT_SUB_XC;
800 KApi_XC_MLoad_Init(client_type,PhyAddr,u32BufByteLen);
801 return;
802 #else
803 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
804 int fd = -1;
805 fd = open("/dev/scaler", O_RDWR);
806 if (-1 == fd)
807 {
808 printf("\nUnable to open /dev/scaler\n");
809 return ;
810 }
811 else
812 {
813 ST_KDRV_MLOAD_INIT k_mload_init;
814 if(psXCInstPri->u32DeviceID == 0)
815 k_mload_init._client_type = E_CLIENT_MAIN_XC;
816 else
817 k_mload_init._client_type = E_CLIENT_SUB_XC;
818 k_mload_init.PhyAddr = PhyAddr;
819 k_mload_init.u32BufByteLen = u32BufByteLen;
820 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_INIT,&k_mload_init))
821 {
822 perror("ioctl");
823 close(fd);
824 return;
825 }
826 close(fd);
827 return ;
828 }
829 #endif
830 #endif
831 #endif
832 #endif
833 if(MDrv_XC_MLoad_GetCaps(pInstance))
834 {
835 if (_MLOAD_MUTEX == -1)
836 {
837 _MLOAD_MUTEX = MsOS_CreateMutex(E_MSOS_FIFO, word, MSOS_PROCESS_SHARED);
838 if (_MLOAD_MUTEX == -1)
839 {
840 MLDBG(printf("[MAPI MLOAD][%06d] create mutex fail\n", __LINE__));
841 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
842 return;
843 }
844 }
845
846 _MLOAD_ENTRY(pInstance);
847 #ifdef MSOS_TYPE_LINUX_KERNEL
848 //error check for mapping error
849 MS_PHY u32StartOffset;
850 MS_U8 u8MIUSel = 0;
851 MS_U16 u16Cmd;
852 MS_PHY phyTempPhyAddr = PhyAddr;
853 _phy_to_miu_offset(u8MIUSel, u32StartOffset, phyTempPhyAddr);
854 MS_VIRT u32tmpaddr = MS_PA2KSEG1(PhyAddr);
855 if (u32tmpaddr == 0)
856 {
857 printf("[%s] Mapping error!!!!!!\n",__FUNCTION__);
858 MsOS_MPool_Mapping(u8MIUSel, PhyAddr, u32BufByteLen, TRUE);
859 u32tmpaddr = MS_PA2KSEG1(PhyAddr);
860 printf("\n MIU %d, u32ML_Addr_PA = 0x%tx, u32ML_Size_PA = 0x%tx \n", u8MIUSel, (ptrdiff_t)PhyAddr, (ptrdiff_t)u32BufByteLen);
861 printf("\n u32tmpaddr = 0x%tx \n", (ptrdiff_t)u32tmpaddr);
862 }
863 memset((MS_VIRT *)u32tmpaddr, 0, u32BufByteLen);
864 #else
865 memset((MS_VIRT *)MS_PA2KSEG1(PhyAddr), 0, u32BufByteLen);
866 #endif
867 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.bEnable = FALSE;
868 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
869 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
870 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
871 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
872 {
873 if ((u32BufByteLen / MS_MLOAD_CMD_LEN_64BITS) < 0x3FFFC)
874 {
875 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt = (MS_U16)(u32BufByteLen / MS_MLOAD_CMD_LEN_64BITS);
876 }
877 else
878 {
879 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt = 0xFFFF;
880 MLDBG_WARN(printf("Too Large menuload u32BufByteLen. u16MaxCmdCnt might overflow!\n"));
881 }
882 }
883 else
884 {
885 if ((u32BufByteLen / MS_MLOAD_CMD_LEN) < 0xFFFF)
886 {
887 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt = (MS_U16)(u32BufByteLen / MS_MLOAD_CMD_LEN);
888 }
889 else
890 {
891 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16MaxCmdCnt = 0xFFFF;
892 MLDBG_WARN(printf("Too Large menuload u32BufByteLen. u16MaxCmdCnt might overflow!\n"));
893 }
894 }
895 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr = PhyAddr;
896
897 pXCResourcePrivate->stdrvXC_MVideo_Context.g_u32MLoadPhyAddr_Suspend = PhyAddr;
898 pXCResourcePrivate->stdrvXC_MVideo_Context.g_u32MLoadBufByteLen_Suspend = u32BufByteLen;
899 MDrv_XC_MLoad_Init(pInstance, PhyAddr);
900
901 _MLOAD_RETURN(pInstance);
902 }
903 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
904 }
905
MApi_XC_MLoad_Init(MS_PHY PhyAddr,MS_U32 u32BufByteLen)906 void MApi_XC_MLoad_Init(MS_PHY PhyAddr, MS_U32 u32BufByteLen)
907 {
908 if (pu32XCInst == NULL)
909 {
910 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
911 return;
912 }
913
914 stXC_MLOAD_INIT XCArgs;
915 XCArgs.PhyAddr = PhyAddr;
916 XCArgs.u32BufByteLen = u32BufByteLen;
917
918 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
919 {
920 printf("Obtain XC engine fail\n");
921 return;
922 }
923 else
924 {
925 return;
926 }
927 }
MApi_XC_MLoad_Cus_Init_U2(void * pInstance,EN_MLOAD_CLIENT_SELECT eMloadSelect,MS_PHY PhyAddr,MS_U32 u32BufByteLen)928 void MApi_XC_MLoad_Cus_Init_U2(void* pInstance, EN_MLOAD_CLIENT_SELECT eMloadSelect, MS_PHY PhyAddr, MS_U32 u32BufByteLen)
929 {
930 //char word[] = {"_MLOAD_MUTEX"};
931 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
932 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
933 MLDBG(printf("%s: %u,0x%llx, 0x%x\n", __FUNCTION__, eMloadSelect, PhyAddr, u32BufByteLen));
934 #ifndef CONFIG_MBOOT
935 #if (SUPPORT_KERNEL_MLOAD == 1)
936 #ifdef MSOS_TYPE_LINUX_KERNEL
937 KApi_XC_MLoad_Init(E_CLIENT_MAIN_HDR,PhyAddr,u32BufByteLen);
938 return;
939 #else
940 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
941 int fd = -1;
942 fd = open("/dev/scaler", O_RDWR);
943 if (-1 == fd)
944 {
945 printf("\nUnable to open /dev/scaler\n");
946 return ;
947 }
948 else
949 {
950 ST_KDRV_MLOAD_INIT k_mload_init;
951 k_mload_init._client_type = E_CLIENT_MAIN_HDR;
952 k_mload_init.PhyAddr = PhyAddr;
953 k_mload_init.u32BufByteLen = u32BufByteLen;
954 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_INIT,&k_mload_init))
955 {
956 perror("ioctl");
957 close(fd);
958 return;
959 }
960 close(fd);
961 return ;
962 }
963 #endif
964 #endif
965 #endif
966 #endif
967 }
968
MApi_XC_MLoad_Cus_Init(EN_MLOAD_CLIENT_SELECT eMloadSelect,MS_PHY PhyAddr,MS_U32 u32BufByteLen)969 void MApi_XC_MLoad_Cus_Init(EN_MLOAD_CLIENT_SELECT eMloadSelect, MS_PHY PhyAddr, MS_U32 u32BufByteLen)
970 {
971 if (pu32XCInst == NULL)
972 {
973 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
974 return;
975 }
976
977 stXC_MLOAD_CUS_INIT XCArgs;
978 XCArgs.eMloadSelect = eMloadSelect;
979 XCArgs.PhyAddr = PhyAddr;
980 XCArgs.u32BufByteLen = u32BufByteLen;
981
982 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_CUS_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
983 {
984 printf("Obtain XC engine fail\n");
985 return;
986 }
987 else
988 {
989 return;
990 }
991 }
992 //-------------------------------------------------------------------------------------------------
993 /// Enable/Disable the MLoad
994 /// @return void
995 //-------------------------------------------------------------------------------------------------
MDrv_XC_MLoad_Enable(void * pInstance,MS_BOOL bEnable)996 void MDrv_XC_MLoad_Enable(void *pInstance, MS_BOOL bEnable)
997 {
998 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
999 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1000 #ifndef CONFIG_MBOOT
1001 #if (SUPPORT_KERNEL_MLOAD == 1)
1002 #ifdef MSOS_TYPE_LINUX_KERNEL
1003 EN_MLOAD_CLIENT_TYPE client_type;
1004 if(psXCInstPri->u32DeviceID == 0)
1005 client_type = E_CLIENT_MAIN_XC;
1006 else
1007 client_type = E_CLIENT_SUB_XC;
1008 KApi_XC_MLoad_Enable(client_type,bEnable);
1009 return;
1010 #else
1011 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1012 int fd = -1;
1013 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1014 if (-1 == fd)
1015 {
1016 printf("\nUnable to open /dev/scaler\n");
1017 return ;
1018 }
1019 else
1020 {
1021 ST_KDRV_MLOAD_ENABLE k_mload_enable;
1022 if(psXCInstPri->u32DeviceID == 0)
1023 k_mload_enable._client_type = E_CLIENT_MAIN_XC;
1024 else
1025 k_mload_enable._client_type = E_CLIENT_SUB_XC;
1026 k_mload_enable.bEnable = bEnable;
1027 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_ENABLE,&k_mload_enable))
1028 {
1029 perror("ioctl");
1030 close(fd);
1031 return;
1032 }
1033 close(fd);
1034 return ;
1035 }
1036 #endif
1037 #endif
1038 #endif
1039 #endif
1040 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1041 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1042 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1043 if( pXCResourcePrivate->stdrvXC_MVideo_Context.g_u32MLoadPhyAddr_Suspend != 0)
1044 #endif
1045 {
1046 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.bEnable = bEnable;
1047 }
1048 }
1049
MApi_XC_MLoad_Enable_U2(void * pInstance,MS_BOOL bEnable)1050 void MApi_XC_MLoad_Enable_U2(void* pInstance, MS_BOOL bEnable)
1051 {
1052 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1053 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1054 #ifndef CONFIG_MBOOT
1055 #if (SUPPORT_KERNEL_MLOAD == 1)
1056 #ifdef MSOS_TYPE_LINUX_KERNEL
1057 EN_MLOAD_CLIENT_TYPE client_type;
1058 if(psXCInstPri->u32DeviceID == 0)
1059 client_type = E_CLIENT_MAIN_XC;
1060 else
1061 client_type = E_CLIENT_SUB_XC;
1062 KApi_XC_MLoad_Enable(client_type,bEnable);
1063 return;
1064 #else
1065 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1066 int fd = -1;
1067 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1068 if (-1 == fd)
1069 {
1070 printf("\nUnable to open /dev/scaler\n");
1071 return ;
1072 }
1073 else
1074 {
1075 ST_KDRV_MLOAD_ENABLE k_mload_enable;
1076 if(psXCInstPri->u32DeviceID == 0)
1077 k_mload_enable._client_type = E_CLIENT_MAIN_XC;
1078 else
1079 k_mload_enable._client_type = E_CLIENT_SUB_XC;
1080 k_mload_enable.bEnable = bEnable;
1081 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_ENABLE,&k_mload_enable))
1082 {
1083 perror("ioctl");
1084 close(fd);
1085 return;
1086 }
1087 close(fd);
1088 return ;
1089 }
1090 #endif
1091 #endif
1092 #endif
1093 #endif
1094 _MLOAD_ENTRY(pInstance);
1095 MDrv_XC_MLoad_Enable(pInstance,bEnable);
1096 _MLOAD_RETURN(pInstance);
1097 }
1098
MApi_XC_MLoad_Enable(MS_BOOL bEnable)1099 void MApi_XC_MLoad_Enable(MS_BOOL bEnable)
1100 {
1101 if (pu32XCInst == NULL)
1102 {
1103 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1104 return;
1105 }
1106
1107 stXC_MLOAD_ENABLE XCArgs;
1108 XCArgs.bEnable = bEnable;
1109
1110 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1111 {
1112 printf("Obtain XC engine fail\n");
1113 return;
1114 }
1115 else
1116 {
1117 return;
1118 }
1119 }
1120
MApi_XC_MLoad_Cus_Enable_U2(void * pInstance,EN_MLOAD_CLIENT_SELECT eMloadSelect,MS_BOOL bEnable)1121 void MApi_XC_MLoad_Cus_Enable_U2(void* pInstance, EN_MLOAD_CLIENT_SELECT eMloadSelect, MS_BOOL bEnable)
1122 {
1123 #ifndef CONFIG_MBOOT
1124 #if (SUPPORT_KERNEL_MLOAD == 1)
1125 #ifdef MSOS_TYPE_LINUX_KERNEL
1126 KApi_XC_MLoad_Enable(E_CLIENT_MAIN_HDR,bEnable);
1127 return;
1128 #else
1129 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1130 int fd = -1;
1131 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1132 if (-1 == fd)
1133 {
1134 printf("\nUnable to open /dev/scaler\n");
1135 return ;
1136 }
1137 else
1138 {
1139 ST_KDRV_MLOAD_ENABLE k_mload_enable;
1140 k_mload_enable._client_type = E_CLIENT_MAIN_HDR;
1141 k_mload_enable.bEnable = bEnable;
1142 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_ENABLE,&k_mload_enable))
1143 {
1144 perror("ioctl");
1145 close(fd);
1146 return;
1147 }
1148 close(fd);
1149 return ;
1150 }
1151 #endif
1152 #endif
1153 #endif
1154 #endif
1155 }
1156
MApi_XC_MLoad_Cus_Enable(EN_MLOAD_CLIENT_SELECT eMloadSelect,MS_BOOL bEnable)1157 void MApi_XC_MLoad_Cus_Enable(EN_MLOAD_CLIENT_SELECT eMloadSelect, MS_BOOL bEnable)
1158 {
1159 if (pu32XCInst == NULL)
1160 {
1161 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1162 return;
1163 }
1164
1165 stXC_MLOAD_CUS_ENABLE XCArgs;
1166 XCArgs.eMloadSelect = eMloadSelect;
1167 XCArgs.bEnable = bEnable;
1168
1169 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_CUS_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1170 {
1171 printf("Obtain XC engine fail\n");
1172 return;
1173 }
1174 else
1175 {
1176 return;
1177 }
1178 }
1179
1180 //-------------------------------------------------------------------------------------------------
1181 /// Get the status of MLoad
1182 /// @return MLOAD_TYPE
1183 //-------------------------------------------------------------------------------------------------
MDrv_XC_MLoad_GetStatus(void * pInstance)1184 MLOAD_TYPE MDrv_XC_MLoad_GetStatus(void *pInstance)
1185 {
1186 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1187 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1188 #ifndef CONFIG_MBOOT
1189 #if (SUPPORT_KERNEL_MLOAD == 1)
1190 #ifdef MSOS_TYPE_LINUX_KERNEL
1191 EN_MLOAD_CLIENT_TYPE client_type;
1192 if(psXCInstPri->u32DeviceID == 0)
1193 client_type = E_CLIENT_MAIN_XC;
1194 else
1195 client_type = E_CLIENT_SUB_XC;
1196 return KApi_XC_MLoad_GetStatus(client_type);
1197 #else
1198 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1199 int fd = -1;
1200 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1201 if (-1 == fd)
1202 {
1203 printf("\nUnable to open /dev/scaler\n");
1204 return E_MLOAD_UNSUPPORTED;
1205 }
1206 else
1207 {
1208 ST_KDRV_MLOAD_GETSTATUS k_mload_getstatus;
1209 k_mload_getstatus._client_type = E_CLIENT_MAIN_XC;
1210 k_mload_getstatus.eReturn = E_KDRV_MLOAD_DISABLED;
1211 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_GETSTATUS,&k_mload_getstatus))
1212 {
1213 perror("ioctl");
1214 close(fd);
1215 return k_mload_getstatus.eReturn;
1216 }
1217 close(fd);
1218 return k_mload_getstatus.eReturn;
1219 }
1220 #endif
1221 #endif
1222 #endif
1223 #endif
1224 MLOAD_TYPE type = E_MLOAD_UNSUPPORTED;
1225 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1226 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1227
1228 if (MDrv_XC_MLoad_GetCaps(pInstance))
1229 {
1230 if (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.bEnable)
1231 {
1232 type = E_MLOAD_ENABLED;
1233 }
1234 else
1235 {
1236 type = E_MLOAD_DISABLED;
1237 }
1238 }
1239 return type;
1240 }
1241
MApi_XC_MLoad_GetStatus_U2(void * pInstance)1242 MLOAD_TYPE MApi_XC_MLoad_GetStatus_U2(void* pInstance)
1243 {
1244 MLOAD_TYPE eMode = E_MLOAD_UNSUPPORTED;
1245
1246 eMode = MDrv_XC_MLoad_GetStatus(pInstance);
1247
1248 return eMode;
1249 }
1250
MApi_XC_MLoad_GetStatus(void)1251 MLOAD_TYPE MApi_XC_MLoad_GetStatus(void)
1252 {
1253 if (pu32XCInst == NULL)
1254 {
1255 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1256 return E_MLOAD_UNSUPPORTED;
1257 }
1258
1259 stXC_MLOAD_GETSTATUS XCArgs;
1260 XCArgs.eReturnValue = E_MLOAD_UNSUPPORTED;
1261
1262 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_GETSTATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1263 {
1264 printf("Obtain XC engine fail\n");
1265 return E_MLOAD_UNSUPPORTED;
1266 }
1267 else
1268 {
1269 return XCArgs.eReturnValue;
1270 }
1271 }
1272
1273 //-------------------------------------------------------------------------------------------------
1274 /// Fire the Menuload commands
1275 /// @return TRUE if succeed, FALSE if failed
1276 //-------------------------------------------------------------------------------------------------
MApi_XC_MLoad_Fire(void * pInstance,MS_BOOL bImmediate)1277 MS_BOOL MApi_XC_MLoad_Fire(void *pInstance, MS_BOOL bImmediate)
1278 {
1279 MS_BOOL bReturn = FALSE;
1280 #ifndef CONFIG_MBOOT
1281 #if (SUPPORT_KERNEL_MLOAD == 1)
1282 #ifdef MSOS_TYPE_LINUX_KERNEL
1283 KDrv_XC_MLoad_set_trigger_sync(E_CLIENT_MAIN_XC,E_MLOAD_TRIGGER_BY_OP_SYNC);
1284 bReturn = KApi_XC_MLoad_Fire(E_CLIENT_MAIN_XC,bImmediate);
1285 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1286 KDrv_XC_MLoad_set_trigger_sync(E_CLIENT_SUB_XC,E_MLOAD_TRIGGER_BY_OP_SYNC);
1287 return KApi_XC_MLoad_Fire(E_CLIENT_SUB_XC,bImmediate);
1288 #else
1289 return bReturn;
1290 #endif
1291 #else
1292 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1293 int fd = -1;
1294 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1295 if (-1 == fd)
1296 {
1297 printf("\nUnable to open /dev/scaler\n");
1298 return FALSE;
1299 }
1300 else
1301 {
1302 //*************************Set Vsync**************************
1303 ST_KDRV_MLOAD_SET_TRIG_SYNC k_mload_set_trigger_sync;
1304 k_mload_set_trigger_sync._client_type = E_CLIENT_MAIN_XC;
1305 k_mload_set_trigger_sync.eTriggerSync = E_MLOAD_TRIGGER_BY_OP_SYNC;
1306 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_SET_TRIG_SYNC,&k_mload_set_trigger_sync))
1307 {
1308 perror("ioctl");
1309 close(fd);
1310 return FALSE;
1311 }
1312 //************************************************************
1313 ST_KDRV_MLOAD_FIRE k_mload_fire;
1314 k_mload_fire._client_type = E_CLIENT_MAIN_XC;
1315 k_mload_fire.bImmeidate = bImmediate;
1316 k_mload_fire.bReturn = FALSE;
1317 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_FIRE,&k_mload_fire))
1318 {
1319 perror("ioctl");
1320 close(fd);
1321 return FALSE;
1322 }
1323 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1324 else
1325 {
1326 //*************************Set Vsync**************************
1327 //ST_KDRV_MLOAD_SET_TRIG_SYNC k_mload_set_trigger_sync;
1328 k_mload_set_trigger_sync._client_type = E_CLIENT_SUB_XC;
1329 k_mload_set_trigger_sync.eTriggerSync = E_MLOAD_TRIGGER_BY_OP_SYNC;
1330 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_SET_TRIG_SYNC,&k_mload_set_trigger_sync))
1331 {
1332 perror("ioctl");
1333 close(fd);
1334 return FALSE;
1335 }
1336 //************************************************************
1337 //ST_KDRV_MLOAD_FIRE k_mload_fire;
1338 k_mload_fire._client_type = E_CLIENT_SUB_XC;
1339 k_mload_fire.bImmeidate = bImmediate;
1340 k_mload_fire.bReturn = FALSE;
1341 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_FIRE,&k_mload_fire))
1342 {
1343 perror("ioctl");
1344 close(fd);
1345 return FALSE;
1346 }
1347 }
1348 #endif
1349 close(fd);
1350 return k_mload_fire.bReturn;
1351 }
1352 #endif
1353 #endif
1354 #endif
1355 #endif
1356 _MLOAD_ENTRY(pInstance);
1357 bReturn = MDrv_XC_MLoad_Fire(pInstance, bImmediate);
1358 _MLOAD_RETURN(pInstance);
1359 return bReturn;
1360 }
1361
MDrv_XC_MLoad_Fire(void * pInstance,MS_BOOL bImmediate)1362 MS_BOOL MDrv_XC_MLoad_Fire(void *pInstance, MS_BOOL bImmediate)
1363 {
1364 #ifndef CONFIG_MBOOT
1365 #if (SUPPORT_KERNEL_MLOAD == 1)
1366 #ifdef MSOS_TYPE_LINUX_KERNEL
1367 MS_BOOL bReturn;
1368 KDrv_XC_MLoad_set_trigger_sync(E_CLIENT_MAIN_XC,E_MLOAD_TRIGGER_BY_OP_SYNC);
1369 bReturn = KApi_XC_MLoad_Fire(E_CLIENT_MAIN_XC,bImmediate);
1370 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1371 KDrv_XC_MLoad_set_trigger_sync(E_CLIENT_SUB_XC,E_MLOAD_TRIGGER_BY_OP_SYNC);
1372 return KApi_XC_MLoad_Fire(E_CLIENT_SUB_XC,bImmediate);
1373 #else
1374 return bReturn;
1375 #endif
1376 #else
1377 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1378 int fd = -1;
1379 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1380 if (-1 == fd)
1381 {
1382 printf("\nUnable to open /dev/scaler\n");
1383 return FALSE;
1384 }
1385 else
1386 {
1387 //*************************Set Vsync**************************
1388 ST_KDRV_MLOAD_SET_TRIG_SYNC k_mload_set_trigger_sync;
1389 k_mload_set_trigger_sync._client_type = E_CLIENT_MAIN_XC;
1390 k_mload_set_trigger_sync.eTriggerSync = E_MLOAD_TRIGGER_BY_OP_SYNC;
1391 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_SET_TRIG_SYNC,&k_mload_set_trigger_sync))
1392 {
1393 perror("ioctl");
1394 close(fd);
1395 return FALSE;
1396 }
1397 //************************************************************
1398 ST_KDRV_MLOAD_FIRE k_mload_fire;
1399 k_mload_fire._client_type = E_CLIENT_MAIN_XC;
1400 k_mload_fire.bImmeidate = bImmediate;
1401 k_mload_fire.bReturn = FALSE;
1402 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_FIRE,&k_mload_fire))
1403 {
1404 perror("ioctl");
1405 close(fd);
1406 return FALSE;
1407 }
1408 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1409 else
1410 {
1411 //*************************Set Vsync**************************
1412 //ST_KDRV_MLOAD_SET_TRIG_SYNC k_mload_set_trigger_sync;
1413 k_mload_set_trigger_sync._client_type = E_CLIENT_SUB_XC;
1414 k_mload_set_trigger_sync.eTriggerSync = E_MLOAD_TRIGGER_BY_OP_SYNC;
1415 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_SET_TRIG_SYNC,&k_mload_set_trigger_sync))
1416 {
1417 perror("ioctl");
1418 close(fd);
1419 return FALSE;
1420 }
1421 //************************************************************
1422 //ST_KDRV_MLOAD_FIRE k_mload_fire;
1423 k_mload_fire._client_type = E_CLIENT_SUB_XC;
1424 k_mload_fire.bImmeidate = bImmediate;
1425 k_mload_fire.bReturn = FALSE;
1426 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_FIRE,&k_mload_fire))
1427 {
1428 perror("ioctl");
1429 close(fd);
1430 return FALSE;
1431 }
1432
1433 }
1434 #endif
1435 close(fd);
1436 return k_mload_fire.bReturn;
1437 }
1438 #endif
1439 #endif
1440 #endif
1441 #endif
1442 MS_BOOL bRet = FALSE;
1443 MS_U32 u32Delayms = 0;
1444 MS_U16 u16Boundary = 16, i = 0;
1445
1446 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1447 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1448 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1449 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1450
1451 CHECK_XC_SWDS_ENABLE
1452 // SC1 mload may not enable
1453 if (E_MLOAD_ENABLED != MDrv_XC_MLoad_GetStatus(pInstance))
1454 {
1455 return bRet;
1456 }
1457 MLDBG(printf("%s, u16WPoint=%u u16RPoint=%u u16FPoint=%u\n", __FUNCTION__,
1458 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
1459 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
1460 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
1461
1462 // this code to protect mload not done,then to fire reg again,it will incorrect
1463 // such as, init mload will be used after 20ms, but user using within 20ms, here we need check that mload has done before
1464 while((MDrv_XC_MLoad_Check_Done(pInstance) == FALSE) && u32Delayms < 600)
1465 {
1466 MsOS_DelayTask(1);
1467 u32Delayms++;
1468 }
1469 if(MDrv_XC_MLoad_Check_Done(pInstance) == FALSE)
1470 {
1471 MLDBG_WARN(printf("Wait MLoad Done TimeOut!\n"));
1472 Hal_XC_MLoad_set_on_off(pInstance, DISABLE);
1473 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
1474 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
1475 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
1476 return FALSE;
1477 }
1478 u32Delayms = 0;
1479
1480 if (MDrv_XC_MLoad_BufferEmpty(pInstance))
1481 {
1482 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
1483 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
1484 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
1485 MLDBG(printf("%s MLoad buffer is empty, Skip menuload fire.\n", __FUNCTION__));
1486 bRet = TRUE;
1487 }
1488 else
1489 {
1490 // 16 entry as boundary for menuload to prevent cmd sent unpredictable.
1491 for (i = 0 ; i < u16Boundary ; i++)
1492 {
1493
1494
1495 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
1496 {
1497 if(ENABLE_64BITS_SPREAD_MODE)
1498 {
1499 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance,(MS_U64)MS_MLOAD_NULL_CMD_SPREAD_MODE, 0xFFFF);
1500 }
1501 else
1502 {
1503 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstance,(MS_U64)MS_MLOAD_NULL_CMD, 0xFFFF);
1504 }
1505 }
1506 else
1507 {
1508 MDrv_XC_MLoad_Add_32Bits_Cmd(pInstance,(MS_U32)MS_MLOAD_NULL_CMD, 0xFFFF);
1509 }
1510
1511 }
1512
1513 MDrv_XC_MLoad_AddNull(pInstance);
1514
1515 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint - 1;
1516
1517 MLDBG(printf("u16WPoint=%u u16RPoint=%u u16FPoint=%u\n",
1518 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
1519 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
1520 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
1521
1522 MDrv_XC_MLoad_KickOff(pInstance);
1523
1524 if(bImmediate)
1525 { // we need to make sure the value is
1526 u32Delayms = 0;
1527 while((MDrv_XC_MLoad_Check_Done(pInstance) == FALSE) && u32Delayms < 600)
1528 {
1529 MsOS_DelayTask(1);
1530 u32Delayms++;
1531 }
1532
1533 // Patch HW outpu Vsync plus width too short and cause MLoad missing.
1534 // T3 U06 will fix it.
1535 if(MDrv_XC_MLoad_Check_Done(pInstance) == FALSE)
1536 {
1537 MLDBG_WARN(printf("MLoad, TimeOut\n"));
1538 Hal_XC_MLoad_set_on_off(pInstance, DISABLE);
1539 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
1540 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
1541 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
1542 bRet = FALSE;
1543 }
1544 else
1545 {
1546 bRet = TRUE;
1547 }
1548 }
1549 else
1550 {
1551 bRet = TRUE;
1552 }
1553
1554 }
1555 /// for another device
1556 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1557 if (bRet)
1558 {
1559 void *pInstanceTmp = NULL;
1560 if (psXCInstPri->u32DeviceID == 0)
1561 {
1562 CHECK_DEVICE1_INSTANCE();
1563 pInstanceTmp = g_pDevice1Instance;
1564 }
1565 else
1566 {
1567 CHECK_DEVICE0_INSTANCE();
1568 pInstanceTmp = g_pDevice0Instance;
1569 }
1570 if (E_MLOAD_ENABLED == MDrv_XC_MLoad_GetStatus(pInstanceTmp))
1571 {
1572 UtopiaInstanceGetPrivate(pInstanceTmp, (void**)&psXCInstPri);
1573 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1574
1575 MLDBG(printf("%s, u16WPoint=%u u16RPoint=%u u16FPoint=%u\n", __FUNCTION__,
1576 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
1577 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
1578 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
1579 if (MDrv_XC_MLoad_BufferEmpty(pInstanceTmp))
1580 {
1581 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
1582 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
1583 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
1584 MLDBG(printf("%s MLoad buffer is empty, Skip menuload fire.\n", __FUNCTION__));
1585 bRet = TRUE;
1586 }
1587 else
1588 {
1589 // 16 entry as boundary for menuload to prevent cmd sent unpredictable.
1590 for (i = 0 ; i < u16Boundary ; i++)
1591 {
1592 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
1593 {
1594 if(ENABLE_64BITS_SPREAD_MODE)
1595 {
1596 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstanceTmp,(MS_U64)MS_MLOAD_NULL_CMD_SPREAD_MODE, 0xFFFF);
1597 }
1598 else
1599 {
1600 MDrv_XC_MLoad_Add_64Bits_Cmd(pInstanceTmp,(MS_U64)MS_MLOAD_NULL_CMD, 0xFFFF);
1601 }
1602 }
1603 else
1604 {
1605 MDrv_XC_MLoad_Add_32Bits_Cmd(pInstanceTmp,(MS_U32)MS_MLOAD_NULL_CMD, 0xFFFF);
1606 }
1607
1608 }
1609
1610 MDrv_XC_MLoad_AddNull(pInstanceTmp);
1611
1612 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint - 1;
1613
1614 MLDBG(printf("u16WPoint=%u u16RPoint=%u u16FPoint=%u\n",
1615 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint,
1616 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint,
1617 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint));
1618
1619 MDrv_XC_MLoad_KickOff(pInstanceTmp);
1620
1621 if(bImmediate)
1622 {
1623 // we need to make sure the value is
1624 u32Delayms = 0;
1625 while((MDrv_XC_MLoad_Check_Done(pInstanceTmp) == FALSE) && u32Delayms < 600)
1626 {
1627 MsOS_DelayTask(1);
1628 u32Delayms++;
1629 }
1630
1631 // Patch HW outpu Vsync plus width too short and cause MLoad missing.
1632 // T3 U06 will fix it.
1633 if(MDrv_XC_MLoad_Check_Done(pInstanceTmp) == FALSE)
1634 {
1635 MLDBG_WARN(printf("MLoad, TimeOut\n"));
1636 Hal_XC_MLoad_set_on_off(pInstanceTmp, DISABLE);
1637 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint = 0;
1638 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint = 0;
1639 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16FPoint = 0;
1640 bRet = FALSE;
1641 }
1642 else
1643 {
1644 bRet = TRUE;
1645 }
1646 }
1647 else
1648 {
1649 bRet = TRUE;
1650 }
1651 }
1652 }
1653 }
1654 #endif
1655 return bRet;
1656 }
1657
1658 //-------------------------------------------------------------------------------------------------
1659 /// Write command to the Menuload buffer by WORD
1660 /// @param u32Addr \b IN: the address (sub-bank + 8-bit address)
1661 /// @param u16Data \b IN: the data
1662 /// @param u16Mask \b IN: the mask
1663 /// @return TRUE if succeed, FALSE if failed
1664 //-------------------------------------------------------------------------------------------------
MApi_XC_MLoad_WriteCmd(void * pInstance,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)1665 MS_BOOL MApi_XC_MLoad_WriteCmd(void *pInstance, MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
1666 {
1667 #ifndef CONFIG_MBOOT
1668 #if (SUPPORT_KERNEL_MLOAD == 1)
1669 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1670 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1671 #ifdef MSOS_TYPE_LINUX_KERNEL
1672 EN_MLOAD_CLIENT_TYPE _client_type;
1673 if(psXCInstPri->u32DeviceID == 0)
1674 _client_type = E_CLIENT_MAIN_XC;
1675 else
1676 _client_type = E_CLIENT_SUB_XC;
1677 return KApi_XC_MLoad_WriteCmd(_client_type,u32Addr,u16Data, u16Mask);
1678 #else
1679 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1680 int fd = -1;
1681 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1682 if (-1 == fd)
1683 {
1684 printf("\nUnable to open /dev/scaler\n");
1685 return FALSE;
1686 }
1687 else
1688 {
1689 ST_KDRV_MLOAD_WRT_CMD k_mload_wcmd;
1690 if(psXCInstPri->u32DeviceID == 0)
1691 k_mload_wcmd._client_type = E_CLIENT_MAIN_XC;
1692 else
1693 k_mload_wcmd._client_type = E_CLIENT_SUB_XC;
1694 k_mload_wcmd.u32Addr = u32Addr;
1695 k_mload_wcmd.u16Data = u16Data;
1696 k_mload_wcmd.u16Mask = u16Mask;
1697 k_mload_wcmd.bReturn = FALSE;
1698 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_WRT_CMD,&k_mload_wcmd))
1699 {
1700 perror("ioctl");
1701 close(fd);
1702 return FALSE;
1703 }
1704 close(fd);
1705 return k_mload_wcmd.bReturn;
1706 }
1707 #endif
1708 #endif
1709 #endif
1710 #endif
1711 MS_BOOL bReturn = FALSE;
1712 _MLOAD_ENTRY(pInstance);
1713 bReturn = MDrv_XC_MLoad_WriteCmd(pInstance, u32Addr, u16Data, u16Mask);
1714 _MLOAD_RETURN(pInstance);
1715 return bReturn;
1716 }
1717
MDrv_XC_MLoad_WriteCmd(void * pInstance,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)1718 MS_BOOL MDrv_XC_MLoad_WriteCmd(void *pInstance, MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
1719 {
1720 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1721 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1722 #ifndef CONFIG_MBOOT
1723 #if (SUPPORT_KERNEL_MLOAD == 1)
1724 #ifdef MSOS_TYPE_LINUX_KERNEL
1725 EN_MLOAD_CLIENT_TYPE _client_type;
1726 if(psXCInstPri->u32DeviceID == 0)
1727 _client_type = E_CLIENT_MAIN_XC;
1728 else
1729 _client_type = E_CLIENT_SUB_XC;
1730 return KApi_XC_MLoad_WriteCmd(_client_type, u32Addr, u16Data, u16Mask);
1731 #else
1732 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1733 int fd = -1;
1734 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
1735 if (-1 == fd)
1736 {
1737 printf("\nUnable to open /dev/scaler and fd = %x\n",fd);
1738 return FALSE;
1739 }
1740 else
1741 {
1742 ST_KDRV_MLOAD_WRT_CMD k_mload_wcmd;
1743 if(psXCInstPri->u32DeviceID == 0)
1744 k_mload_wcmd._client_type = E_CLIENT_MAIN_XC;
1745 else
1746 k_mload_wcmd._client_type = E_CLIENT_SUB_XC;
1747 k_mload_wcmd.u32Addr = u32Addr;
1748 k_mload_wcmd.u16Data = u16Data;
1749 k_mload_wcmd.u16Mask = u16Mask;
1750 k_mload_wcmd.bReturn = FALSE;
1751 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_WRT_CMD,&k_mload_wcmd))
1752 {
1753 perror("ioctl");
1754 close(fd);
1755 return FALSE;
1756 }
1757 close(fd);
1758 return k_mload_wcmd.bReturn;
1759 }
1760 #endif
1761 #endif
1762 #endif
1763 #endif
1764 MS_BOOL bRet;
1765 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1766 MS_U8 u8Bank;
1767 MS_BOOL bNeedChangeInstance = FALSE;
1768 void *pInstanceTmp = NULL;
1769 u8Bank = ((u32Addr >> 8) & 0xFF);
1770 // check device according to bank
1771 if (u8Bank >= _XC_Device_Offset[1]) // device 1 bank
1772 {
1773 if (psXCInstPri->u32DeviceID != 1)
1774 {
1775 pInstanceTmp = pInstance; // store instance 0
1776 pInstance = g_pDevice1Instance; //switch to instance 1
1777 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1778 bNeedChangeInstance = TRUE; // mark instance had change
1779 }
1780 u32Addr -= (_XC_Device_Offset[1] << 8);
1781 }
1782 #endif
1783 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1784 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1785
1786 CHECK_XC_SWDS_ENABLE
1787 #ifdef A3_MLG // need to refine later, test the capibility first
1788 MS_U8 u8MLoadMIUSel = Hal_XC_MLoad_get_miusel();
1789
1790 if (u8MLoadMIUSel != pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].u8XCMLoadMIUSel)
1791 Hal_XC_MLoad_set_miusel(pInstance, pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].u8XCMLoadMIUSel);
1792 #endif
1793 MS_BOOL bReturn;
1794 bReturn = MDrv_XC_MLoad_WriteCommand(pInstance,u32Addr, u16Data, u16Mask);
1795 if(bReturn == TRUE)
1796 {
1797 bRet = TRUE;
1798 }
1799 else
1800 {
1801 MLDBG(printf("Fail: %x %04x %04x \n", u32Addr, u16Data, u16Mask));
1802 bRet = FALSE;
1803 }
1804 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1805 if (bNeedChangeInstance)
1806 {
1807 pInstance = pInstanceTmp; // restore instance 0
1808 }
1809 #endif
1810 return bRet;
1811 }
1812
MApi_XC_MLoad_WriteCmd_And_Fire_U2(void * pInstance,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)1813 MS_BOOL MApi_XC_MLoad_WriteCmd_And_Fire_U2(void* pInstance, MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
1814 {
1815 MS_BOOL bRet = TRUE;
1816 _MLOAD_ENTRY(pInstance);
1817
1818 if (!MDrv_XC_MLoad_WriteCmd(pInstance, u32Addr, u16Data, u16Mask))
1819 {
1820 bRet = FALSE;
1821 MLDBG(printf("Fail: Cmd %x %x %x \n", u32Addr, u16Data, u16Mask));
1822 }
1823 else
1824 {
1825 if (!MDrv_XC_MLoad_Fire(pInstance, TRUE))
1826 {
1827 bRet = FALSE;
1828 MLDBG(printf("Fire Error!!!!\n "));
1829 }
1830 }
1831 _MLOAD_RETURN(pInstance);
1832 return bRet;
1833 }
1834
MApi_XC_MLoad_WriteCmd_And_Fire(MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)1835 MS_BOOL MApi_XC_MLoad_WriteCmd_And_Fire(MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
1836 {
1837 if (pu32XCInst == NULL)
1838 {
1839 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1840 return FALSE;
1841 }
1842
1843 stXC_MLOAD_WRITE_CMD_AND_FIRE XCArgs;
1844 XCArgs.u32Addr = u32Addr;
1845 XCArgs.u16Data = u16Data;
1846 XCArgs.u16Mask = u16Mask;
1847 XCArgs.bReturnValue = FALSE;
1848
1849 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_WRITE_CMD_AND_FIRE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1850 {
1851 printf("Obtain XC engine fail\n");
1852 return FALSE;
1853 }
1854 else
1855 {
1856 return XCArgs.bReturnValue;
1857 }
1858 }
1859
MApi_XC_MLoad_WriteCmds_And_Fire_U2(void * pInstance,MS_U32 * pu32Addr,MS_U16 * pu16Data,MS_U16 * pu16Mask,MS_U16 u16CmdCnt)1860 MS_BOOL MApi_XC_MLoad_WriteCmds_And_Fire_U2(void* pInstance, MS_U32 *pu32Addr, MS_U16 *pu16Data, MS_U16 *pu16Mask, MS_U16 u16CmdCnt)
1861 {
1862 MS_BOOL bRet = TRUE;
1863 MS_U16 i = 0, j = 0;
1864 _MLOAD_ENTRY(pInstance);
1865
1866 //Note: If there are some same regs in the Mload cmd queue,
1867 // MLoad will use the value of the last reg address to fire. others same regs will be ignore.
1868 // So we handle this situation here, to combine every same reg's setting value to the same.
1869 for(i=0; i<u16CmdCnt; i++)
1870 {
1871 for(j=i+1; j<u16CmdCnt; j++)
1872 {
1873 if(pu32Addr[i] == pu32Addr[j])
1874 {
1875 pu16Mask[i] |= pu16Mask[j];
1876 pu16Data[i] |= pu16Data[j];
1877 pu16Mask[j] = pu16Mask[i];
1878 pu16Data[j] = pu16Data[i];
1879 }
1880 }
1881 }
1882
1883 for(i=0; i<u16CmdCnt; i++)
1884 {
1885 if ( (!MDrv_SC_CheckMuteStatusByRegister(pInstance, MAIN_WINDOW))
1886 ||(!MDrv_SC_CheckMuteStatusByRegister(pInstance, SUB_WINDOW)))
1887 {
1888 if (!MDrv_XC_MLoad_WriteCmd(pInstance, pu32Addr[i], pu16Data[i], pu16Mask[i]))
1889 {
1890 bRet = FALSE;
1891 MLDBG(printf("Fail: Cmd %x %x %x \n", pu32Addr[i], pu16Data[i], pu16Mask[i]));
1892 }
1893 }
1894 else
1895 {
1896 SC_W2BYTEMSK(0, pu32Addr[i], pu16Data[i], pu16Mask[i]);
1897 }
1898 }
1899
1900 if ( (!MDrv_SC_CheckMuteStatusByRegister(pInstance, MAIN_WINDOW))
1901 ||(!MDrv_SC_CheckMuteStatusByRegister(pInstance, SUB_WINDOW)))
1902 {
1903 if (!MDrv_XC_MLoad_Fire(pInstance, TRUE))
1904 {
1905 bRet = FALSE;
1906 MLDBG(printf("Fire Error!!!!\n "));
1907 }
1908 }
1909
1910 _MLOAD_RETURN(pInstance);
1911 return bRet;
1912 }
1913
MApi_XC_MLoad_WriteCmds_And_Fire(MS_U32 * pu32Addr,MS_U16 * pu16Data,MS_U16 * pu16Mask,MS_U16 u16CmdCnt)1914 MS_BOOL MApi_XC_MLoad_WriteCmds_And_Fire(MS_U32 *pu32Addr, MS_U16 *pu16Data, MS_U16 *pu16Mask, MS_U16 u16CmdCnt)
1915 {
1916 if (pu32XCInst == NULL)
1917 {
1918 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1919 return FALSE;
1920 }
1921
1922 stXC_MLOAD_WRITE_CMDS_AND_FIRE XCArgs;
1923 XCArgs.pu32Addr = pu32Addr;
1924 XCArgs.pu16Data = pu16Data;
1925 XCArgs.pu16Mask = pu16Mask;
1926 XCArgs.u16CmdCnt = u16CmdCnt;
1927 XCArgs.bReturnValue = FALSE;
1928
1929 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLOAD_WRITE_CMDS_AND_FIRE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1930 {
1931 printf("Obtain XC engine fail\n");
1932 return FALSE;
1933 }
1934 else
1935 {
1936 return XCArgs.bReturnValue;
1937 }
1938 }
1939
MDrv_XC_MLG_Init(void * pInstance,MS_PHY phyAddr)1940 static void MDrv_XC_MLG_Init(void *pInstance, MS_PHY phyAddr)
1941 {
1942 MS_U32 u32StartOffset = 0;
1943 MS_U8 u8MIUSel = 0;
1944 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1945 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1946 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1947 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1948
1949 MLG(printf("%s\n",__FUNCTION__));
1950
1951 // remove the MIU offset
1952 _phy_to_miu_offset(u8MIUSel, u32StartOffset, phyAddr);
1953 UNUSED(u32StartOffset);
1954 MLG(printf("u8MIUSel = %d\n", u8MIUSel));
1955 if (Hal_XC_MLG_GetCaps(pInstance))
1956 {
1957 //Hal_XC_MLG_set_trigger_timing(TRIG_SRC_FE_VSYNC); //output VSync falling edge
1958 Hal_XC_MLG_set_trigger_timing(pInstance, TRIG_SRC_FE_VFDE); //output VDE falling edge
1959 Hal_XC_MLG_set_trigger_delay(pInstance, 0x01);
1960 Hal_XC_MLG_set_len(pInstance, MS_MLG_REG_LEN);//length of DMA request
1961
1962 Hal_XC_MLoad_set_miusel(pInstance, u8MIUSel);
1963 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].u8XCMLoadMIUSel = u8MIUSel;
1964 }
1965
1966 }
1967
MDrv_XC_MLG_Trigger(void * pInstance,MS_PHY startAddr,MS_U16 u16CmdCnt)1968 static void MDrv_XC_MLG_Trigger(void *pInstance, MS_PHY startAddr, MS_U16 u16CmdCnt)
1969 {
1970 MS_PHY u32StartOffset;
1971 MS_U8 u8MIUSel = 0;
1972
1973 MLG(printf("%s 0x%lx, %u\n",__FUNCTION__, startAddr, u16CmdCnt));
1974
1975 _phy_to_miu_offset(u8MIUSel, u32StartOffset, startAddr);
1976 UNUSED(u8MIUSel);
1977 Hal_XC_MLG_set_base_addr(pInstance, u32StartOffset);
1978 Hal_XC_MLG_set_depth(pInstance, u16CmdCnt);
1979 Hal_XC_MLG_set_on_off(pInstance, ENABLE);
1980 MsOS_DelayTaskUs(3);
1981 }
1982 #ifdef A3_MLG // need to refine later, test the capibility first
1983 /////////////////////////////////////////////////////////////////////////////
1984 //arrary[]=
1985 // 0x00,0x00,0x01,0x00,0x02,0x03,0x00,0x04,0x05, //DATA in format
1986 //-------------------------------------------------------------------------//
1987 // Menuload Gamma command (12 bit content)
1988 //
1989 // One MIU Word
1990 // A3,A5 support this function
1991 // [A3,A5]
1992 // ______________________________________________________________________________
1993 // Byte | 0 1 2 3 4 5 6
1994 // [ gamma table B content] [ gamma table G content] [ gamma table R content] [B enable] [G enable] [R enable]
1995 // 35:0 71:36 72:107 144:144 145:145 146:146
1996 //
1997 //For example of 256 entry:
1998 //R_in[35:0](0) = { 12��h0, WR_R[11:0](0), 12��h0} for 256 entry
1999 //R_in[35:0](1) = { 12��h0, WR_R[11:0](1), WR_R[11:0](0)} for 256 entry
2000 //R_in[35:0](2) = { 12��h0, WR_R[11:0](2), WR_R[11:0](1)} for 256 entry
2001 /////////////////////////////////////////////////////////////////////////////
MDrv_XC_MLG_WriteCmd(void * pInstance,MS_U8 * pR,MS_U8 * pG,MS_U8 * pB,MS_U16 u16Count,MS_U16 * pMaxGammaValue)2002 static void MDrv_XC_MLG_WriteCmd(void *pInstance, MS_U8 *pR, MS_U8 *pG, MS_U8 *pB, MS_U16 u16Count, MS_U16 *pMaxGammaValue)
2003 {
2004 MS_SC_MLG_TBL *pMLG_Addr;
2005 MS_PHY DstAddr;
2006 MS_U16 i,j;
2007 MS_U16 u16Temp,u16Temp_R,u16Temp_G,u16Temp_B;
2008 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2009 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2010 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2011 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2012
2013 MLG(printf("%s,u16Count=%u.\n",__FUNCTION__,u16Count));
2014 if((Hal_XC_MLG_get_status(pInstance) == 0) &&
2015 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint))
2016 {
2017 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint = 0;
2018 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint = 0;
2019 }
2020 pMaxGammaValue[0] = pMaxGammaValue [1] = pMaxGammaValue [2] = 0;
2021
2022 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint * MS_MLG_CMD_LEN;
2023 pMLG_Addr = (MS_SC_MLG_TBL *)MS_PA2KSEG1(DstAddr);
2024
2025 if ((pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint + u16Count) <= pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16MaxCmdCnt)
2026 {
2027 pMLG_Addr[0].RData0 = 0;
2028 pMLG_Addr[0].GData0 = 0;
2029 pMLG_Addr[0].BData0 = 0;
2030 //Decode from Gamma table
2031 for (i = 0, j = 0; i < u16Count; i+=2 , j+=3)
2032 {
2033 //���줸�C��m��//for 12 bit(8~11),��m��arrary[i-1];i=1
2034 u16Temp_B = 0;
2035 u16Temp_B = ((pB[j] & 0x0F) << 8) | (pB[j+1]);
2036 u16Temp_B = (u16Temp_B << 4);
2037 //printf("[MLG],[%u]-B1 , u16Temp_B=0x%x.\n",i,u16Temp_B);
2038 pMLG_Addr[i].BData1_L = (u16Temp_B & 0x000F);
2039 pMLG_Addr[i].BData1 = (u16Temp_B >> 4);;
2040 // ______________________________________________________________________________
2041 u16Temp_G = 0;
2042 u16Temp_G = ((pG[j] & 0x0F) << 8) | (pG[j+1]);
2043 u16Temp_G = (u16Temp_G << 4);
2044 //printf("[MLG],[%u]-G1 , u16Temp_G=0x%x.\n",i,u16Temp_G);
2045 pMLG_Addr[i].GData1 = (u16Temp_G & 0x00FF);
2046 pMLG_Addr[i].GData1_H = (u16Temp_G >> 8);
2047 // ______________________________________________________________________________
2048 u16Temp_R = 0;
2049 u16Temp_R = ((pR[j] & 0x0F) << 8) | (pR[j+1]);
2050 u16Temp_R = (u16Temp_R << 4);
2051 //printf("[MLG],[%u]-R1 , u16Temp_R=0x%x.\n",i,u16Temp_R);
2052 pMLG_Addr[i].RData1_L= (u16Temp_R & 0x000F);
2053 pMLG_Addr[i].RData1 = (u16Temp_R >> 4);
2054 // =====================================================================
2055 u16Temp = 0;
2056 u16Temp = ((pB[j] & 0x0F) << 8) | (pB[j+1]);
2057 u16Temp = (u16Temp << 4);
2058 //printf("[MLG],[%u]-B0 , B_u16Temp-0=0x%x.\n",i+1,u16Temp);
2059 pMLG_Addr[i+1].BData0 = (u16Temp & 0x00FF);
2060 pMLG_Addr[i+1].BData0_H = (u16Temp >> 8);
2061 // ______________________________________________________________________________
2062 u16Temp = 0;
2063 u16Temp = ((pG[j] & 0x0F) << 8) | (pG[j+1]);
2064 u16Temp = (u16Temp << 4);
2065 //printf("[MLG],[%u]-G0 , G_u16Temp-0=0x%x.\n",i+1,u16Temp);
2066 pMLG_Addr[i+1].GData0_L = (u16Temp & 0x000F);
2067 pMLG_Addr[i+1].GData0 = (u16Temp >> 4);
2068 // ______________________________________________________________________________
2069 u16Temp = 0;
2070 u16Temp = ((pR[j] & 0x0F) << 8) | (pR[j+1]);
2071 u16Temp = (u16Temp << 4);
2072 //printf("[MLG],[%u]-R0 , R_u16Temp=0x%x.\n",i+1,u16Temp);
2073 pMLG_Addr[i+1].RData0 = (u16Temp & 0x00FF);
2074 pMLG_Addr[i+1].RData0_H = (u16Temp >> 8);
2075 // =====================================================================
2076
2077 pMLG_Addr[i].REnable = pMLG_Addr[i].GEnable = pMLG_Addr[i].BEnable = TRUE;
2078 pMLG_Addr[i].Dummy0 = pMLG_Addr[i].Dummy1 = pMLG_Addr[i].Dummy2 = pMLG_Addr[i].Dummy3 = 0;
2079 pMLG_Addr[i].RData2 = pMLG_Addr[i].GData2 = pMLG_Addr[i].BData2 = 0;
2080 pMLG_Addr[i].RData2_H = pMLG_Addr[i].GData2_L = pMLG_Addr[i].BData2_H = 0;
2081
2082 if(pMaxGammaValue[0] < (u16Temp_R>>4))
2083 {
2084 pMaxGammaValue[0] = (u16Temp_R>>4);
2085 }
2086 if(pMaxGammaValue[1] < (u16Temp_G>>4))
2087 {
2088 pMaxGammaValue[1] = (u16Temp_G>>4);
2089 }
2090 if(pMaxGammaValue[2] < (u16Temp_B>>4))
2091 {
2092 pMaxGammaValue[2] = (u16Temp_B>>4);
2093 }
2094
2095 // 0x00,0x00,0x01,0x00,0x02,0x03,0x00,0x04,0x05, //DATA in format
2096 //���줸����m��//for 12 bit(8~11),��m��arrary[i+1];i=2
2097 u16Temp_B= 0;
2098 u16Temp_B = ((pB[j] & 0xF0) << 4) | (pB[j+2]);;
2099 u16Temp_B = (u16Temp_B << 4);
2100 //printf("[MLG],[%u]-B1 , u16Temp_B =0x%x.\n",i+1,u16Temp_B);
2101 pMLG_Addr[i+1].BData1_L = (u16Temp_B & 0x000F);
2102 pMLG_Addr[i+1].BData1 = (u16Temp_B >> 4);
2103 // ______________________________________________________________________________
2104 u16Temp_G = 0;
2105 u16Temp_G = ((pG[j] & 0xF0) << 4) | (pG[j+2]);;
2106 u16Temp_G = (u16Temp_G << 4);
2107 //printf("[MLG],[%u]-G1 , u16Temp_G = 0x%x.\n",i+1,u16Temp_G);
2108 pMLG_Addr[i+1].GData1 = (u16Temp_G & 0x00FF);
2109 pMLG_Addr[i+1].GData1_H = (u16Temp_G >> 8);
2110 // ______________________________________________________________________________
2111 u16Temp_R = 0;
2112 u16Temp_R = ((pR[j] & 0xF0) << 4) | (pR[j+2]);;
2113 u16Temp_R = (u16Temp_R << 4);
2114 //printf("[MLG],[%u]-R1 , u16Temp_R=0x%x.\n",i+1,u16Temp_R);
2115 pMLG_Addr[i+1].RData1_L = (u16Temp_R & 0x000F);
2116 pMLG_Addr[i+1].RData1 = (u16Temp_R >> 4);
2117 // =====================================================================
2118 u16Temp = 0;
2119 u16Temp = ((pB[j] & 0xF0) << 4) | (pB[j+2]);;
2120 u16Temp = (u16Temp << 4);
2121 //printf("[MLG],[%u]-B0 , G_u16Temp-0=0x%x.\n",i+2,u16Temp);
2122 pMLG_Addr[i+2].BData0 = (u16Temp & 0x00FF);
2123 pMLG_Addr[i+2].BData0_H = (u16Temp >> 8);
2124 // ______________________________________________________________________________
2125 u16Temp = 0;
2126 u16Temp = ((pG[j] & 0xF0) << 4) | (pG[j+2]);;
2127 u16Temp = (u16Temp << 4);
2128 //printf("[MLG],[%u]-G0 , G_u16Temp-0=0x%x.\n",i+2,u16Temp);
2129 pMLG_Addr[i+2].GData0_L = (u16Temp & 0x000F);
2130 pMLG_Addr[i+2].GData0 = (u16Temp >> 4);
2131 // ______________________________________________________________________________
2132 u16Temp = 0;
2133 u16Temp = ((pR[j] & 0xF0) << 4) | (pR[j+2]);;
2134 u16Temp = (u16Temp << 4);
2135 //printf("[MLG],[%u]-R0 , G_u16Temp-0=0x%x.\n\n",i+2,u16Temp);
2136 pMLG_Addr[i+2].RData0 = (u16Temp & 0x00FF);
2137 pMLG_Addr[i+2].RData0_H = (u16Temp >> 8);
2138 // =====================================================================
2139
2140 pMLG_Addr[i+1].REnable = pMLG_Addr[i+1].GEnable = pMLG_Addr[i+1].BEnable = TRUE;
2141 pMLG_Addr[i+1].Dummy0 = pMLG_Addr[i+1].Dummy1 =pMLG_Addr[i+1].Dummy2 =pMLG_Addr[i+1].Dummy3 =0;
2142 pMLG_Addr[i+1].RData2 = pMLG_Addr[i+1].GData2 = pMLG_Addr[i+1].BData2 = 0;
2143 pMLG_Addr[i+1].RData2_H = pMLG_Addr[i+1].GData2_L = pMLG_Addr[i+1].BData2_H = 0;
2144
2145 if(pMaxGammaValue[0] < (u16Temp_R>>4))
2146 {
2147 pMaxGammaValue[0] = (u16Temp_R>>4);
2148 }
2149 if(pMaxGammaValue[1] < (u16Temp_G>>4))
2150 {
2151 pMaxGammaValue[1] = (u16Temp_G>>4);
2152 }
2153 if(pMaxGammaValue[2] < (u16Temp_B>>4))
2154 {
2155 pMaxGammaValue[2] = (u16Temp_B>>4);
2156 }
2157 }
2158
2159 pMaxGammaValue[0] = pMaxGammaValue[0]|0xF00;
2160 pMaxGammaValue[1] = pMaxGammaValue[1]|0xF00;
2161 pMaxGammaValue[2] = pMaxGammaValue[2]|0xF00;
2162
2163 MLG(printf("[MLG]Red MaxGammaValue = 0x%x\n",pMaxGammaValue[0]));
2164 MLG(printf("[MLG]Green MaxGammaValue = 0x%x\n",pMaxGammaValue[1]));
2165 MLG(printf("[MLG]Blue MaxGammaValue =0x%x\n",pMaxGammaValue[2]));
2166
2167 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint +=u16Count;
2168 }
2169 else
2170 {
2171 printf("Size is not enough, Cmd Too Many !!!!!!!!!!!!!!!!!\n");
2172 }
2173
2174 MLG(printf("stMLGInfo.u16WPoint = %d\n",pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint));
2175 }
2176 #else
2177 #ifdef MLG_1024
2178 /////////////////////////////////////////////////////////////////////////////
2179 //arrary[]=
2180 // 0x00,0x00,0x01,0x00,0x02,0x03,0x00,0x04,0x05, //DATA in format
2181 //-------------------------------------------------------------------------//
2182 // Menuload Gamma command (12 bit content)
2183 //
2184 // One MIU Word
2185 // A3,A5 support this function
2186 // [A3,A5]
2187 // ______________________________________________________________________________
2188 // Byte | 0 1 2 3 4 5 6
2189 // [ gamma table B content] [ gamma table G content] [ gamma table R content] [B enable] [G enable] [R enable]
2190 // 35:0 71:36 72:107 144:144 145:145 146:146 ....255
2191 //
2192 //B0[11:0] : B_ref[11:0]
2193 //{B2[11:0], B1[11:0]} : {{3'b0, B_delta3[4:0]}, {3'b0, B_delta2[4:0]}, {3'b0, B_delta1[4:0]}}
2194 // ===> {B2[11:0], B1[11:0], B0[11:0]} : {3'b0, B_delta3[4:0], 3'b0, B_delta2[4:0], 3'b0, B_delta1[4:0], B_ref[11:0]}
MDrv_XC_MLG_WriteCmd(void * pInstance,MS_U8 * pR,MS_U8 * pG,MS_U8 * pB,MS_U16 u16Count,MS_U16 * pMaxGammaValue)2195 static void MDrv_XC_MLG_WriteCmd(void *pInstance, MS_U8 *pR, MS_U8 *pG, MS_U8 *pB, MS_U16 u16Count, MS_U16 *pMaxGammaValue)
2196 {
2197 MS_SC_MLG_TBL *pMLG_Addr;
2198 MS_PHY DstAddr;
2199 MS_U16 i,j;
2200 MS_U16 u16Temp,u16Temp_R,u16Temp_G,u16Temp_B, u16GammaDeltaR, u16GammaDeltaG, u16GammaDeltaB;
2201 MS_U16 u16CmdCount = 0;
2202 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2203 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2204 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2205 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2206
2207 MLG(printf("%s,u16Count=%u.\n",__FUNCTION__,u16Count));
2208 if((Hal_XC_MLG_get_status(pInstance) == 0) &&
2209 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint))
2210 {
2211 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint = 0;
2212 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint = 0;
2213 }
2214 pMaxGammaValue[0] = pMaxGammaValue [1] = pMaxGammaValue [2] = 0;
2215
2216 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint * MS_MLG_CMD_LEN;
2217 pMLG_Addr = (MS_SC_MLG_TBL *)MS_PA2KSEG1(DstAddr);
2218
2219 if (u16Count == 1024)//For 1024 Entry Mode
2220 u16CmdCount = u16Count/4;
2221 else //For 256 Entry Mode
2222 u16CmdCount = u16Count;
2223
2224 if ((pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint + u16CmdCount) <= pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16MaxCmdCnt)
2225 {
2226 if (u16Count == 1024)//For 1024 Entry Mode
2227 {
2228 MLG(printf("\033[0;31m [%s][%d] 1024 entry \033[0m\n", __FUNCTION__, __LINE__));
2229 MS_U16 u16Delta1, u16Delta2, u16Delta3;
2230 //Decode from Gamma table
2231 for (i = 0, j = 0; i < u16Count/4; i+=1 , j+=6)
2232 {
2233 // For index i B0 data
2234 u16Temp_B = (pB[j] & 0x0F) | (pB[j+1] << 4);
2235 MLG(printf("[%u]-B1 , u16Temp_B=0x%x.\n",i,u16Temp_B));
2236 pMLG_Addr[i].BData0 = (MS_U64)u16Temp_B;
2237
2238 // For B delta
2239 u16Delta1 = (((pB[j] & 0xF0) >> 4) | (pB[j+2] << 4)) - pMLG_Addr[i].BData0;
2240 u16Delta2 = ((pB[j+3] & 0x0F) | (pB[j+4] << 4)) - (((pB[j] & 0xF0) >> 4) | (pB[j+2] << 4));
2241 u16Delta3 = (((pB[j+3] & 0xF0) >> 4) | (pB[j+5] << 4)) - ((pB[j+3] & 0x0F) | (pB[j+4] << 4));
2242 //{B2[11:0], B1[11:0]} : {{3'b0, B_delta3[4:0]}, {3'b0, B_delta2[4:0]}, {3'b0, B_delta1[4:0]}}
2243 pMLG_Addr[i].BData1 = ((MS_U64)(u16Delta2 & 0x0F) << 8) | (u16Delta1 & 0x1F);
2244 pMLG_Addr[i].BData2 = ((MS_U64)(u16Delta3 & 0x1F) << 4) | ((u16Delta2 & 0x10) >> 4);
2245
2246 // For index i G0 data
2247 u16Temp_G = (pG[j] & 0x0F) | (pG[j+1] << 4);
2248 MLG(printf("[%u]-G1 , u16Temp_G=0x%x.\n",i,u16Temp_G));
2249 pMLG_Addr[i].GData0 = (MS_U64)u16Temp_G;
2250
2251 // For G delta
2252 u16Delta1 = (((pG[j] & 0xF0) >> 4) | (pG[j+2] << 4)) - pMLG_Addr[i].GData0;
2253 u16Delta2 = ((pG[j+3] & 0x0F) | (pG[j+4] << 4)) - (((pG[j] & 0xF0) >> 4) | (pG[j+2] << 4));
2254 u16Delta3 = (((pG[j+3] & 0xF0) >> 4) | (pG[j+5] << 4)) - ((pG[j+3] & 0x0F) | (pG[j+4] << 4));
2255 //{B2[11:0], B1[11:0]} : {{3'b0, B_delta3[4:0]}, {3'b0, B_delta2[4:0]}, {3'b0, B_delta1[4:0]}}
2256 pMLG_Addr[i].GData1 = ((MS_U64)(u16Delta2 & 0x0F) << 8) | (u16Delta1 & 0x1F);
2257 pMLG_Addr[i].GData2_L = ((MS_U64)(u16Delta2 & 0x10) >> 4);
2258 pMLG_Addr[i].GData2_H = (MS_U64)(u16Delta3 & 0x1F);
2259
2260 // For index i R0 data
2261 u16Temp_R = (pR[j] & 0x0F) | (pR[j+1] << 4);
2262 MLG(printf("[%u]-R1 , u16Temp_R=0x%x.\n",i,u16Temp_R));
2263 pMLG_Addr[i].RData0 = (MS_U64)u16Temp_R;
2264
2265 // For R delta
2266 u16Delta1 = (((pR[j] & 0xF0) >> 4) | (pR[j+2] << 4)) - pMLG_Addr[i].RData0;
2267 u16Delta2 = ((pR[j+3] & 0x0F) | (pR[j+4] << 4)) - (((pR[j] & 0xF0) >> 4) | (pR[j+2] << 4));
2268 u16Delta3 = (((pR[j+3] & 0xF0) >> 4) | (pR[j+5] << 4)) - ((pR[j+3] & 0x0F) | (pR[j+4] << 4));
2269 //{B2[11:0], B1[11:0]} : {{3'b0, B_delta3[4:0]}, {3'b0, B_delta2[4:0]}, {3'b0, B_delta1[4:0]}}
2270 pMLG_Addr[i].RData1 = ((MS_U64)(u16Delta2 & 0x0F) << 8) | (u16Delta1 & 0x1F);
2271 pMLG_Addr[i].RData2 = ((MS_U64)(u16Delta3 & 0x1F) << 4) | ((u16Delta2 & 0x10) >> 4);
2272
2273 // =============== fill index i 's info here ============================
2274 pMLG_Addr[i].REnable = pMLG_Addr[i].GEnable = pMLG_Addr[i].BEnable = TRUE;
2275 pMLG_Addr[i].Dummy0 = pMLG_Addr[i].Dummy1 = pMLG_Addr[i].Dummy2 = pMLG_Addr[i].Dummy3 = 0;
2276
2277 if(pMaxGammaValue[0] < (u16Temp_R >> 4))
2278 {
2279 pMaxGammaValue[0] = (u16Temp_R >> 4);
2280 }
2281 if(pMaxGammaValue[1] < (u16Temp_G >> 4))
2282 {
2283 pMaxGammaValue[1] = (u16Temp_G >> 4);
2284 }
2285 if(pMaxGammaValue[2] < (u16Temp_B >> 4))
2286 {
2287 pMaxGammaValue[2] = (u16Temp_B >> 4);
2288 }
2289
2290 }
2291 }
2292 else //For 256 Entry Mode
2293 {
2294 MLG(printf("\033[0;31m [%s][%d] 256 entry \033[0m\n", __FUNCTION__, __LINE__));
2295 //Decode from Gamma table
2296 for (i = 0, j = 0; i < u16Count; i+=2 , j+=3)
2297 {
2298 // For index i B0/G0/R0 data
2299 u16Temp_B = (pB[j] & 0x0F) | (pB[j+1] << 4);
2300 MLG(printf("[%u]-B1 , u16Temp_B=0x%x.\n",i,u16Temp_B));
2301 pMLG_Addr[i].BData0 = (MS_U64)u16Temp_B;
2302
2303 u16Temp_G = (pG[j] & 0x0F) | (pG[j+1] << 4);
2304 MLG(printf("[%u]-G1 , u16Temp_G=0x%x.\n",i,u16Temp_G));
2305 pMLG_Addr[i].GData0 = (MS_U64)u16Temp_G;
2306
2307 u16Temp_R = (pR[j] & 0x0F) | (pR[j+1] << 4);
2308 MLG(printf("[%u]-R1 , u16Temp_R=0x%x.\n",i,u16Temp_R));
2309 pMLG_Addr[i].RData0 = (MS_U64)u16Temp_R;
2310
2311 if(pMaxGammaValue[0] < (u16Temp_R >> 4))
2312 {
2313 pMaxGammaValue[0] = (u16Temp_R >> 4);
2314 }
2315 if(pMaxGammaValue[1] < (u16Temp_G >> 4))
2316 {
2317 pMaxGammaValue[1] = (u16Temp_G >> 4);
2318 }
2319 if(pMaxGammaValue[2] < (u16Temp_B >> 4))
2320 {
2321 pMaxGammaValue[2] = (u16Temp_B >> 4);
2322 }
2323
2324 // For index i+1 B0/G0/R0 data
2325 u16Temp_B = ((pB[j] & 0xF0) >> 4) | (pB[j+2] << 4);
2326 MLG(printf("[%u]-B0 , B_u16Temp-0=0x%x.\n",i+1,u16Temp_B));
2327 pMLG_Addr[i+1].BData0 = (MS_U64)u16Temp_B;
2328
2329 u16Temp_G = ((pG[j] & 0xF0) >> 4) | (pG[j+2] << 4);
2330 MLG(printf("[%u]-G0 , G_u16Temp-0=0x%x.\n",i+1,u16Temp_G));
2331 pMLG_Addr[i+1].GData0 = (MS_U64)u16Temp_G;
2332
2333 u16Temp_R = ((pR[j] & 0xF0) >> 4) | (pR[j+2] << 4);
2334 MLG(printf("[%u]-R0 , R_u16Temp=0x%x.\n",i+1,u16Temp_R));
2335 pMLG_Addr[i+1].RData0 = (MS_U64)u16Temp_R;
2336
2337 if(pMaxGammaValue[0] < (u16Temp_R >> 4))
2338 {
2339 pMaxGammaValue[0] = (u16Temp_R >> 4);
2340 }
2341 if(pMaxGammaValue[1] < (u16Temp_G >> 4))
2342 {
2343 pMaxGammaValue[1] = (u16Temp_G >> 4);
2344 }
2345 if(pMaxGammaValue[2] < (u16Temp_B >> 4))
2346 {
2347 pMaxGammaValue[2] = (u16Temp_B >> 4);
2348 }
2349
2350 // cal delta vaule
2351 u16GammaDeltaB = (pMLG_Addr[i+1].BData0 - pMLG_Addr[i].BData0) /4;
2352 u16GammaDeltaG = (pMLG_Addr[i+1].GData0 - pMLG_Addr[i].GData0) /4;
2353 u16GammaDeltaR = (pMLG_Addr[i+1].RData0 - pMLG_Addr[i].RData0) /4;
2354
2355 //{B2[11:0], B1[11:0]} : {{3'b0, B_delta3[4:0]}, {3'b0, B_delta2[4:0]}, {3'b0, B_delta1[4:0]}}
2356 pMLG_Addr[i].BData1 = ((MS_U64)(u16GammaDeltaB & 0x0F) << 8) | (u16GammaDeltaB & 0x1F);
2357 pMLG_Addr[i].BData2 = ((MS_U64)(u16GammaDeltaB & 0x1F) << 4) | ((u16GammaDeltaB & 0x10) >> 4);
2358
2359 pMLG_Addr[i].GData1 = ((MS_U64)(u16GammaDeltaG & 0x0F) << 8) | (u16GammaDeltaG & 0x1F);
2360 pMLG_Addr[i].GData2_L = ((MS_U64)(u16GammaDeltaG & 0x10) >> 4);
2361 pMLG_Addr[i].GData2_H = (MS_U64)(u16GammaDeltaG & 0x1F);
2362
2363 pMLG_Addr[i].RData1 = ((MS_U64)(u16GammaDeltaR & 0x0F) << 8) | (u16GammaDeltaR & 0x1F);
2364 pMLG_Addr[i].RData2 = ((MS_U64)(u16GammaDeltaR & 0x1F) << 4) | ((u16GammaDeltaR & 0x10) >> 4);
2365
2366 // =============== fill index i 's info here ============================
2367 pMLG_Addr[i].REnable = pMLG_Addr[i].GEnable = pMLG_Addr[i].BEnable = TRUE;
2368 pMLG_Addr[i].Dummy0 = pMLG_Addr[i].Dummy1 = pMLG_Addr[i].Dummy2 = pMLG_Addr[i].Dummy3 = 0;
2369
2370
2371 // For index i+2 B0/G0/R0 data, just in order to get index (i+1) ~ (i+2) 's delta
2372 u16Temp = (pB[j+3] & 0x0F) | (pB[j+4] << 4);
2373 MLG(printf("[%u]-B0 , G_u16Temp-0=0x%x.\n",i+2,u16Temp));
2374 pMLG_Addr[i+2].BData0 = (MS_U64)u16Temp;
2375
2376 u16Temp = (pG[j+3] & 0x0F) | (pG[j+4] << 4);
2377 MLG(printf("[%u]-G0 , G_u16Temp-0=0x%x.\n",i+2,u16Temp));
2378 pMLG_Addr[i+2].GData0 = (MS_U64)u16Temp;
2379
2380 u16Temp = (pR[j+3] & 0x0F) | (pR[j+4] << 4);
2381 MLG(printf("[%u]-R0 , G_u16Temp-0=0x%x.\n\n",i+2,u16Temp));
2382 pMLG_Addr[i+2].RData0 = (MS_U64)u16Temp;
2383
2384 // cal delta vaule
2385 u16GammaDeltaB = (pMLG_Addr[i+2].BData0 - pMLG_Addr[i+1].BData0) /4;
2386 u16GammaDeltaG = (pMLG_Addr[i+2].GData0 - pMLG_Addr[i+1].GData0) /4;
2387 u16GammaDeltaR = (pMLG_Addr[i+2].RData0 - pMLG_Addr[i+1].RData0) /4;
2388
2389 //{B2[11:0], B1[11:0]} : {{3'b0, B_delta3[4:0]}, {3'b0, B_delta2[4:0]}, {3'b0, B_delta1[4:0]}}
2390 pMLG_Addr[i+1].BData1 = ((MS_U64)(u16GammaDeltaB & 0x0F) << 8) | (u16GammaDeltaB & 0x1F);
2391 pMLG_Addr[i+1].BData2 = ((MS_U64)(u16GammaDeltaB & 0x1F) << 4) | ((u16GammaDeltaB & 0x10) >> 4);
2392
2393 pMLG_Addr[i+1].GData1 = ((MS_U64)(u16GammaDeltaG & 0x0F) << 8) | (u16GammaDeltaG & 0x1F);
2394 pMLG_Addr[i+1].GData2_L = (MS_U64)(u16GammaDeltaG & 0x10) >> 4;
2395 pMLG_Addr[i+1].GData2_H = (MS_U64)(u16GammaDeltaG & 0x1F);
2396
2397 pMLG_Addr[i+1].RData1 = ((MS_U64)(u16GammaDeltaR & 0x0F) << 8) | (u16GammaDeltaR & 0x1F);
2398 pMLG_Addr[i+1].RData2 = ((MS_U64)(u16GammaDeltaR & 0x1F) << 4) | ((u16GammaDeltaR & 0x10) >> 4);
2399
2400 // =============== fill index i+1 's info here ============================
2401 pMLG_Addr[i+1].REnable = pMLG_Addr[i+1].GEnable = pMLG_Addr[i+1].BEnable = TRUE;
2402 pMLG_Addr[i+1].Dummy0 = pMLG_Addr[i+1].Dummy1 = pMLG_Addr[i+1].Dummy2 = pMLG_Addr[i+1].Dummy3 = 0;
2403
2404 }
2405 }
2406
2407
2408 pMaxGammaValue[0] = pMaxGammaValue[0]|0xF00;
2409 pMaxGammaValue[1] = pMaxGammaValue[1]|0xF00;
2410 pMaxGammaValue[2] = pMaxGammaValue[2]|0xF00;
2411
2412 MLG(printf("[MLG]Red MaxGammaValue = 0x%x\n",pMaxGammaValue[0]));
2413 MLG(printf("[MLG]Green MaxGammaValue = 0x%x\n",pMaxGammaValue[1]));
2414 MLG(printf("[MLG]Blue MaxGammaValue =0x%x\n",pMaxGammaValue[2]));
2415
2416 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint +=u16CmdCount;
2417 }
2418 else
2419 {
2420 printf("Size is not enough, Cmd Too Many !!!!!!!!!!!!!!!!!\n");
2421 }
2422
2423 MLG(printf("stMLGInfo.u16WPoint = %d\n",pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint));
2424 }
2425 #else // MLG_256 or not support MLG case
2426 /////////////////////////////////////////////////////////////////////////////
2427 // Menuload Gamma command (12 bit content)
2428 //
2429 // One MIU Word
2430 // T8, T11, T12 support this function
2431 // [T8, T12] 128 Bit = 16 Bytess
2432 // ______________________________________________________________________________
2433 // Byte | 0 1 2 3 4 5 6
2434 // [ gamma table B content] [ gamma table G content] [ gamma table R content] [B enable] [G enable] [R enable]
2435 // 11:0 27:16 43:32 48:48 49:49 50:50
2436 //
MDrv_XC_MLG_WriteCmd(void * pInstance,MS_U8 * pR,MS_U8 * pG,MS_U8 * pB,MS_U16 u16Count,MS_U16 * pMaxGammaValue)2437 static void MDrv_XC_MLG_WriteCmd(void *pInstance, MS_U8 *pR, MS_U8 *pG, MS_U8 *pB, MS_U16 u16Count, MS_U16 *pMaxGammaValue)
2438 {
2439 MS_SC_MLG_TBL *pMLG_Addr;
2440 MS_PHY DstAddr;
2441 MS_U16 i,j;
2442 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2443 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2444 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2445 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2446
2447 MLG(printf("%s\n",__FUNCTION__));
2448 if((Hal_XC_MLG_get_status(pInstance) == 0) &&
2449 (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint == pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint))
2450 {
2451 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint = 0;
2452 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint = 0;
2453 }
2454 pMaxGammaValue[0] = pMaxGammaValue [1] = pMaxGammaValue [2] = 0;
2455
2456 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint * MS_MLG_CMD_LEN;
2457 pMLG_Addr = (MS_SC_MLG_TBL *)MS_PA2KSEG1(DstAddr);
2458
2459 if ((pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint + u16Count) <= pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16MaxCmdCnt)
2460 {
2461
2462 for (i = 0, j = 0; i < u16Count; i+=2 , j+=3)
2463 {
2464 pMLG_Addr[i].u16R = (pR[j] & 0x0F) | (pR[j+1] << 4);
2465 pMLG_Addr[i].u16G = (pG[j] & 0x0F) | (pG[j+1] << 4);
2466 pMLG_Addr[i].u16B = (pB[j] & 0x0F) | (pB[j+1] << 4);
2467 pMLG_Addr[i].u16Enable = BIT(0) | BIT(1) | BIT(2);
2468
2469 MLG(printf("MLG_Addr[%d].u16R = 0x%x\n",i, pMLG_Addr[i].u16R));
2470 MLG(printf("MLG_Addr[%d].u16G = 0x%x\n",i, pMLG_Addr[i].u16G));
2471 MLG(printf("MLG_Addr[%d].u16B = 0x%x\n",i, pMLG_Addr[i].u16B));
2472 if(pMaxGammaValue[0] < pMLG_Addr[i].u16R)
2473 {
2474 pMaxGammaValue[0] = pMLG_Addr[i].u16R;
2475 }
2476 if(pMaxGammaValue[1] < pMLG_Addr[i].u16G)
2477 {
2478 pMaxGammaValue[1] = pMLG_Addr[i].u16G;
2479 }
2480 if(pMaxGammaValue[2] < pMLG_Addr[i].u16B)
2481 {
2482 pMaxGammaValue[2] = pMLG_Addr[i].u16B;
2483 }
2484
2485 pMLG_Addr[i+1].u16R = (pR[j] >>4) | (pR[j+2] << 4);
2486 pMLG_Addr[i+1].u16G = (pG[j] >>4) | (pG[j+2] << 4);
2487 pMLG_Addr[i+1].u16B = (pB[j] >>4) | (pB[j+2] << 4);
2488 pMLG_Addr[i+1].u16Enable = BIT(0) | BIT(1) | BIT(2);
2489
2490 MLG(printf("MLG_Addr[%d].u16R = 0x%x\n",i+1, pMLG_Addr[i+1].u16R));
2491 MLG(printf("MLG_Addr[%d].u16G = 0x%x\n",i+1, pMLG_Addr[i+1].u16G));
2492 MLG(printf("MLG_Addr[%d].u16B = 0x%x\n",i+1, pMLG_Addr[i+1].u16B));
2493 if(pMaxGammaValue[0] < pMLG_Addr[i+1].u16R)
2494 {
2495 pMaxGammaValue[0] = pMLG_Addr[i+1].u16R;
2496 }
2497 if(pMaxGammaValue[1] < pMLG_Addr[i+1].u16G)
2498 {
2499 pMaxGammaValue[1] = pMLG_Addr[i+1].u16G;
2500 }
2501 if(pMaxGammaValue[2] < pMLG_Addr[i+1].u16B)
2502 {
2503 pMaxGammaValue[2] = pMLG_Addr[i+1].u16B;
2504 }
2505 MLG(printf("Red MaxGammaValue = 0x%x\n",pMaxGammaValue[0]));
2506 MLG(printf("Green MaxGammaValue = 0x%x\n",pMaxGammaValue[1]));
2507 MLG(printf("Blue MaxGammaValue =0x%x\n",pMaxGammaValue[2]));
2508 }
2509
2510 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint +=u16Count;
2511 }
2512 else
2513 {
2514 MLDBG(printf("Size is not enough, Cmd Too Many !!!!!!!!!!!!!!!!!\n"));
2515 }
2516 MLG(printf("stMLGInfo.u16WPoint = %d\n",pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint));
2517 }
2518 #endif
2519 #endif
2520 //-------------------------------------------------------------------------------------------------
2521 /// Initialize the Menuload Gamma
2522 /// @param PhyAddr \b IN: the physical address for the menuload
2523 /// @param u32BufByteLen \b IN: the buffer length of the menu load commands
2524 /// @return void
2525 //-------------------------------------------------------------------------------------------------
MApi_XC_MLG_Init_U2(void * pInstance,MS_PHY PhyAddr,MS_U32 u32BufByteLen)2526 void MApi_XC_MLG_Init_U2(void* pInstance, MS_PHY PhyAddr, MS_U32 u32BufByteLen)
2527 {
2528 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2529 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2530 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2531 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2532
2533 MLG(printf("%s: 0x%lx, 0x%lx\n", __FUNCTION__, PhyAddr, u32BufByteLen));
2534
2535 if(Hal_XC_MLG_GetCaps(pInstance))
2536 {
2537
2538 memset((void *)MS_PA2KSEG1(PhyAddr), 0, u32BufByteLen);
2539
2540 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.bEnable = FALSE;
2541 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint = 0;
2542 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint = 0;
2543 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16MaxCmdCnt = (MS_U16)(u32BufByteLen / MS_MLG_CMD_LEN);
2544 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.PhyAddr = PhyAddr;
2545
2546 MDrv_XC_MLG_Init(pInstance, PhyAddr);
2547 MLG(printf("Cmd max number = %d\n",pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16MaxCmdCnt));
2548 }
2549
2550 }
2551
MApi_XC_MLG_Init(MS_PHY PhyAddr,MS_U32 u32BufByteLen)2552 void MApi_XC_MLG_Init(MS_PHY PhyAddr, MS_U32 u32BufByteLen)
2553 {
2554 if (pu32XCInst == NULL)
2555 {
2556 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2557 return;
2558 }
2559
2560 stXC_MLG_INIT XCArgs;
2561 XCArgs.PhyAddr = PhyAddr;
2562 XCArgs.u32BufByteLen = u32BufByteLen;
2563
2564 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLG_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2565 {
2566 printf("Obtain XC engine fail\n");
2567 return;
2568 }
2569 else
2570 {
2571 return;
2572 }
2573 }
2574
2575 //-------------------------------------------------------------------------------------------------
2576 /// Enable/Disable the Menuload Gamma
2577 /// @return void
2578 //-------------------------------------------------------------------------------------------------
MApi_XC_MLG_Enable_U2(void * pInstance,MS_BOOL bEnable)2579 void MApi_XC_MLG_Enable_U2(void* pInstance, MS_BOOL bEnable)
2580 {
2581 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2582 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2583 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2584 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2585
2586 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.bEnable = bEnable;
2587 }
2588
MApi_XC_MLG_Enable(MS_BOOL bEnable)2589 void MApi_XC_MLG_Enable(MS_BOOL bEnable)
2590 {
2591 if (pu32XCInst == NULL)
2592 {
2593 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2594 return;
2595 }
2596
2597 stXC_MLG_ENABLE XCArgs;
2598 XCArgs.bEnable = bEnable;
2599
2600 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLG_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2601 {
2602 printf("Obtain XC engine fail\n");
2603 return;
2604 }
2605 else
2606 {
2607 return;
2608 }
2609 }
2610
2611 //-------------------------------------------------------------------------------------------------
2612 /// Get the caps of Menuload Gamma
2613 /// @return TRUE if succeed, FALSE if failed
2614 //-------------------------------------------------------------------------------------------------
MApi_XC_MLG_GetCaps_U2(void * pInstance)2615 MS_BOOL MApi_XC_MLG_GetCaps_U2(void* pInstance)
2616 {
2617 return Hal_XC_MLG_GetCaps(pInstance);
2618 }
2619
MApi_XC_MLG_GetCaps(void)2620 MS_BOOL MApi_XC_MLG_GetCaps(void)
2621 {
2622 if (pu32XCInst == NULL)
2623 {
2624 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2625 return FALSE;
2626 }
2627
2628 stXC_MLG_GET_CAPS XCArgs;
2629 XCArgs.bReturnValue = FALSE;
2630
2631 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLG_GET_CAPS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2632 {
2633 printf("Obtain XC engine fail\n");
2634 return FALSE;
2635 }
2636 else
2637 {
2638 return XCArgs.bReturnValue;
2639 }
2640 }
2641
2642 //-------------------------------------------------------------------------------------------------
2643 /// Get the status of Menuload Gamma
2644 /// @return MLG_TYPE
2645 //-------------------------------------------------------------------------------------------------
MApi_XC_MLG_GetStatus_U2(void * pInstance)2646 MLG_TYPE MApi_XC_MLG_GetStatus_U2(void* pInstance)
2647 {
2648 MLG_TYPE type = E_MLG_UNSUPPORTED;
2649 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2650 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2651 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2652 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2653 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2654
2655 if (Hal_XC_MLG_GetCaps(pInstance))
2656 {
2657 if (pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.bEnable)
2658 {
2659 type = E_MLG_ENABLED;
2660 }
2661 else
2662 {
2663 type = E_MLG_DISABLED;
2664 }
2665 }
2666 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2667 return type;
2668 }
2669
MApi_XC_MLG_GetStatus(void)2670 MLG_TYPE MApi_XC_MLG_GetStatus(void)
2671 {
2672 if (pu32XCInst == NULL)
2673 {
2674 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2675 return E_MLG_UNSUPPORTED;
2676 }
2677
2678 stXC_MLG_GETSTATUS XCArgs;
2679 XCArgs.eReturnValue = E_MLG_UNSUPPORTED;
2680
2681 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_MLG_GETSTATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2682 {
2683 printf("Obtain XC engine fail\n");
2684 return E_MLG_UNSUPPORTED;
2685 }
2686 else
2687 {
2688 return XCArgs.eReturnValue;
2689 }
2690 }
2691
2692 //-------------------------------------------------------------------------------------------------
2693 /// Fire the Menuload gamma commands
2694 /// @return TRUE if succeed, FALSE if failed
2695 //-------------------------------------------------------------------------------------------------
MApi_XC_MLG_Fire(MS_U8 * pR,MS_U8 * pG,MS_U8 * pB,MS_U16 u16Count,MS_U16 * pMaxGammaValue)2696 void MApi_XC_MLG_Fire(MS_U8 *pR, MS_U8 *pG, MS_U8 *pB, MS_U16 u16Count, MS_U16 *pMaxGammaValue)
2697 {
2698 void* pInstance = pu32XCInst_private;
2699 MS_U32 u32Delayms = 0;
2700 #define BUSY 1
2701 #define AVAILABLE 0
2702 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2703 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2704 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2705 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2706
2707 _MLOAD_ENTRY(pInstance);
2708
2709 #if 0
2710 MS_U8 u8MLoadMIUSel = Hal_XC_MLoad_get_miusel();
2711
2712 // Before MLG, set miu as MLG status
2713 if (u8MLoadMIUSel != u8XCMLoadMIUSel)
2714 {
2715 MLG(printf("\033[0;36m [%s][%d] Before MLG, set miu as MLG status \033[0m\n", __FUNCTION__, __LINE__));
2716 Hal_XC_MLoad_set_miusel(u8XCMLoadMIUSel);
2717 }
2718 #endif
2719
2720 MS_U16 u16CmdCount = 0;
2721 if (u16Count == 1024)//For 1024 Entry Mode
2722 u16CmdCount = u16Count/4;
2723 else //For 256 Entry Mode
2724 u16CmdCount = u16Count;
2725
2726 //intf("[MLG]%s,Hal_XC_MLG_GetCaps()=%u,Hal_XC_MLG_get_status()=%u.\n",__FUNCTION__,Hal_XC_MLG_GetCaps(),Hal_XC_MLG_get_status());
2727 if(Hal_XC_MLG_GetCaps(pInstance) && (Hal_XC_MLG_get_status(pInstance) == AVAILABLE))
2728 {
2729 MS_PHY CmdBufAddr;
2730 MDrv_XC_MLG_WriteCmd(pInstance, pR, pG, pB, u16Count, pMaxGammaValue);
2731 MsOS_FlushMemory();
2732 CmdBufAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint * MS_MLG_CMD_LEN;
2733 MDrv_XC_MLG_Trigger(pInstance, CmdBufAddr, u16CmdCount);
2734 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint += u16CmdCount;
2735
2736 while((Hal_XC_MLG_get_status(pInstance) == BUSY) && u32Delayms < 600)
2737 {
2738 MsOS_DelayTask(1);
2739 u32Delayms++;
2740 }
2741
2742 // Patch HW outpu Vsync plus width too short and cause MLoad missing.
2743 // T3 U06 will fix it.
2744 //intf("[MLG]%s,Hal_XC_MLG_get_status()=%u.\n",__FUNCTION__,Hal_XC_MLG_get_status());
2745 if(Hal_XC_MLG_get_status(pInstance) == BUSY)
2746 {
2747 MLDBG_WARN(printf("[Gamma]MLoad, TimeOut\n"));
2748 //Hal_XC_MLG_set_on_off(DISABLE);
2749 // add reset??
2750 //MDrv_XC_SoftwareReset(REST_CLK, MAIN_WINDOW);
2751 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16RPoint = 0;
2752 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16WPoint = 0;
2753 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLGInfo.u16FPoint = 0;
2754 }
2755 }
2756
2757 #if 0
2758 // after MLG, set miu as original status
2759 if (u8MLoadMIUSel != u8XCMLoadMIUSel)
2760 {
2761 MLG(printf("\033[0;36m [%s][%d] after MLG, set miu as original status \033[0m\n", __FUNCTION__, __LINE__));
2762 Hal_XC_MLoad_set_miusel(u8MLoadMIUSel);
2763 }
2764 #endif
2765
2766 _MLOAD_RETURN(pInstance);
2767 }
2768
2769 //___|T_________________........__|T____ VSync
2770 //__________|T__________________ ATP(refer the size befor memory to cal the pip sub and main length)
2771 //_________________|T___________ Disp
2772
2773 //Generate TRAIN_TRIG_P from delayed line of Vsync(Setting the delay line for Auto tune area)(monaco ip DI point add trig engine)
2774 //Generate DISP_TRIG_P from delayed line of Vsync(Setting the delay line for Display area)(monaco ip DI point add trig engine)
MDrv_XC_MLoad_set_IP_trig_p(void * pInstance,MS_U16 u16train,MS_U16 u16disp)2775 MS_BOOL MDrv_XC_MLoad_set_IP_trig_p(void *pInstance, MS_U16 u16train, MS_U16 u16disp)
2776 {
2777 #if (HW_DESIGN_4K2K_VER == 4)
2778 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2779 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2780 #ifndef CONFIG_MBOOT
2781 #if (SUPPORT_KERNEL_MLOAD == 1)
2782 #ifdef MSOS_TYPE_LINUX_KERNEL
2783 EN_MLOAD_CLIENT_TYPE _client_type;
2784 if(psXCInstPri->u32DeviceID == 0)
2785 _client_type = E_CLIENT_MAIN_XC;
2786 else
2787 _client_type = E_CLIENT_SUB_XC;
2788 return KDrv_XC_MLoad_set_IP_trig_p( _client_type, u16train, u16disp);
2789 #else
2790 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
2791 int fd = -1;
2792 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
2793 if (-1 == fd)
2794 {
2795 printf("\nUnable to open /dev/scaler\n");
2796 return FALSE;
2797 }
2798 else
2799 {
2800 ST_KDRV_MLOAD_SET_IP_TRIG_P k_mload_set_trog_p;
2801 if(psXCInstPri->u32DeviceID == 0)
2802 k_mload_set_trog_p._client_type = E_CLIENT_MAIN_XC;
2803 else
2804 k_mload_set_trog_p._client_type = E_CLIENT_SUB_XC;
2805 k_mload_set_trog_p.u16train = u16train;
2806 k_mload_set_trog_p.u16disp = u16disp;
2807 k_mload_set_trog_p.bReturn = FALSE;
2808 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_SET_IP_TRIG_P,&k_mload_set_trog_p))
2809 {
2810 perror("ioctl");
2811 close(fd);
2812 return FALSE;
2813 }
2814 close(fd);
2815 return k_mload_set_trog_p.bReturn;
2816 }
2817 #endif
2818 #endif
2819 #endif
2820 #endif
2821 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK57_1A_L, u16train, 0x0FFF);
2822 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK57_1B_L, u16disp, 0x0FFF);
2823 #endif
2824 return TRUE;
2825 }
2826
2827 //Get the delay line for Auto tune area
2828 //Get the delay line for Display area
MDrv_XC_MLoad_get_IP_trig_p(void * pInstance,MS_U16 * pu16Train,MS_U16 * pu16Disp)2829 MS_BOOL MDrv_XC_MLoad_get_IP_trig_p(void *pInstance, MS_U16 *pu16Train, MS_U16 *pu16Disp)
2830 {
2831 #if (HW_DESIGN_4K2K_VER == 4)
2832 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2833 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2834 #ifndef CONFIG_MBOOT
2835 #if (SUPPORT_KERNEL_MLOAD == 1)
2836 #ifdef MSOS_TYPE_LINUX_KERNEL
2837 EN_MLOAD_CLIENT_TYPE _client_type;
2838 if(psXCInstPri->u32DeviceID == 0)
2839 _client_type = E_CLIENT_MAIN_XC;
2840 else
2841 _client_type = E_CLIENT_SUB_XC;
2842 return KDrv_XC_MLoad_get_IP_trig_p(_client_type, pu16Train, pu16Disp);
2843 #else
2844 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
2845 int fd = -1;
2846 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
2847 if (-1 == fd)
2848 {
2849 printf("\nUnable to open /dev/scaler\n");
2850 return FALSE;
2851 }
2852 else
2853 {
2854 ST_KDRV_MLOAD_GET_IP_TRIG_P k_mload_get_trog_p;
2855 if(psXCInstPri->u32DeviceID == 0)
2856 k_mload_get_trog_p._client_type = E_CLIENT_MAIN_XC;
2857 else
2858 k_mload_get_trog_p._client_type = E_CLIENT_SUB_XC;
2859 k_mload_get_trog_p.pu16Train = pu16Train;
2860 k_mload_get_trog_p.pu16Disp = pu16Disp;
2861 k_mload_get_trog_p.bReturn = FALSE;
2862 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_GET_IP_TRIG_P,&k_mload_get_trog_p))
2863 {
2864 perror("ioctl");
2865 close(fd);
2866 return FALSE;
2867 }
2868 close(fd);
2869 return k_mload_get_trog_p.bReturn;
2870 }
2871 #endif
2872 #endif
2873 #endif
2874 #endif
2875 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2876 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2877 *pu16Train = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK57_1A_L, 0x0FFF);
2878 *pu16Disp = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK57_1B_L, 0x0FFF);
2879 #endif
2880 return TRUE;
2881 }
2882
MDrv_XC_MLoad_Add_32Bits_Cmd(void * pInstance,MS_U32 u32Cmd,MS_U16 u16Mask)2883 void MDrv_XC_MLoad_Add_32Bits_Cmd(void *pInstance,MS_U32 u32Cmd, MS_U16 u16Mask)
2884 {
2885 MS_U32 *pu32Addr = NULL;
2886 MS_PHY DstAddr;
2887 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2888 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2889 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2890 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2891
2892 if ( (ENABLE_MLOAD_SAME_REG_COMBINE == 1)
2893 &&(u32Cmd != MS_MLOAD_NULL_CMD))
2894 {
2895 MS_U16 u16WPoint = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint;
2896 MS_U16 u16CmdIndex = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint;
2897 MS_U32 u32CurrentAddr = 0;
2898 MS_U16 u16CurrentData = 0;
2899 MS_U32 u32OldAddr = 0;
2900 MS_U16 u16OldData = 0;
2901 for (u16CmdIndex = 0; u16CmdIndex < u16WPoint; u16CmdIndex++)
2902 {
2903 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u16CmdIndex * MS_MLOAD_CMD_LEN;
2904 pu32Addr = (MS_U32 *)MS_PA2KSEG1(DstAddr);
2905 Hal_XC_MLoad_parsing_32bits_subBankMode(pInstance, u32Cmd, &u32CurrentAddr, &u16CurrentData);
2906 Hal_XC_MLoad_parsing_32bits_subBankMode(pInstance, *pu32Addr, &u32OldAddr, &u16OldData);
2907 if (u32OldAddr == u32CurrentAddr)
2908 {
2909 if (u16OldData != u16CurrentData)
2910 {
2911 MS_U16 u16NewData = 0;
2912 u16NewData = (u16OldData & ~u16Mask) | (u16CurrentData & u16Mask);
2913 MLDBG(printf("[Mload] [%s][line %d] Old Cmd=%x \n",__FUNCTION__, __LINE__, u32Cmd));
2914 u32Cmd = Hal_XC_MLoad_Gen_32bits_subBankMode(pInstance, u32OldAddr, u16NewData, 0xFFFF);
2915 MLDBG(printf("[Mload] [%s][line %d] Old Cmd=%x \n",__FUNCTION__, __LINE__, u32Cmd));
2916 *pu32Addr = u32Cmd;
2917 }
2918
2919 return;
2920 }
2921 }
2922 }
2923 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint * MS_MLOAD_CMD_LEN;
2924 pu32Addr = (MS_U32 *)MS_PA2KSEG1(DstAddr);
2925 *pu32Addr = u32Cmd;
2926 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint++;
2927 }
2928
MDrv_XC_MLoad_Add_64Bits_Cmd(void * pInstance,MS_U64 u64Cmd,MS_U16 u16Mask)2929 void MDrv_XC_MLoad_Add_64Bits_Cmd(void *pInstance,MS_U64 u64Cmd, MS_U16 u16Mask)
2930 {
2931 MS_U64 *pu64Addr = NULL;
2932 MS_PHY DstAddr;
2933 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2934 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2935 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2936 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2937
2938 MS_U32 u32WriteMemShift = 0;
2939
2940 if ( (ENABLE_MLOAD_SAME_REG_COMBINE == 1)
2941 &&(u64Cmd != MS_MLOAD_NULL_CMD_SPREAD_MODE))
2942 {
2943 MS_U16 u16CmdIndex = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16RPoint;
2944 MS_U16 u16WPoint = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint;
2945
2946 for (; u16CmdIndex < u16WPoint; u16CmdIndex++)
2947 {
2948 u32WriteMemShift = _MDrv_XC_GetMloadMemOffset(pInstance, u16CmdIndex);
2949 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u32WriteMemShift;
2950 pu64Addr = (MS_U64 *)MS_PA2KSEG1(DstAddr);
2951 MS_U32 u32CurrentAddr = 0;
2952 MS_U16 u16CurrentData = 0;
2953 MS_U32 u32OldAddr = 0;
2954 MS_U16 u16OldData = 0;
2955 Hal_XC_MLoad_parsing_64bits_spreadMode_NonXC(pInstance, *pu64Addr, &u32OldAddr, &u16OldData);
2956 Hal_XC_MLoad_parsing_64bits_spreadMode_NonXC(pInstance, u64Cmd, &u32CurrentAddr, &u16CurrentData);
2957 #if defined(PATCH_HW_VTT_LIMITATION)
2958 if(MDrv_ReadByte(REG_CHIP_REVISION) >= HW_VTT_LIMITATION_CHIPREV)
2959 #endif
2960 {
2961 if ( (u32OldAddr == u32CurrentAddr)
2962 &&((u32CurrentAddr®_SCALER_BASE) == REG_SCALER_BASE)) //only xc reg check
2963 {
2964 if (u16OldData != u16CurrentData)
2965 {
2966 MS_U16 u16NewData = 0;
2967 u16NewData = (u16OldData & ~u16Mask) | (u16CurrentData & u16Mask);
2968 MLDBG(printf("[Mload] [%s][line %d] Old Cmd=%llx \n",__FUNCTION__, __LINE__, u64Cmd));
2969 u64Cmd = Hal_XC_MLoad_Gen_64bits_spreadMode_NonXC(pInstance, (u32CurrentAddr>>8)&0xFFFF, u32CurrentAddr&0xFF, u16NewData, 0xFFFF);
2970 MLDBG(printf("[Mload] [%s][line %d] New Cmd=%llx \n",__FUNCTION__, __LINE__, u64Cmd));
2971 *pu64Addr = u64Cmd;
2972 }
2973 return;
2974 }
2975 }
2976 }
2977 }
2978
2979 u32WriteMemShift = _MDrv_XC_GetMloadMemOffset(pInstance, pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint);
2980 //DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint * MS_MLOAD_CMD_LEN_64BITS;
2981 DstAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.PhyAddr + u32WriteMemShift;
2982 pu64Addr = (MS_U64 *)MS_PA2KSEG1(DstAddr);
2983 *pu64Addr = u64Cmd;
2984 pXCResourcePrivate->stdrvXC_MVideo_Context.stdrvXC_Menuload[psXCInstPri->u32DeviceID].stMLoadInfo.u16WPoint++;
2985 }
2986
MDrv_XC_MLoad_WriteCommand(void * pInstance,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)2987 MS_BOOL MDrv_XC_MLoad_WriteCommand(void *pInstance,MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
2988 {
2989 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2990 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2991 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2992 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2993
2994 MS_BOOL bReturn = FALSE;
2995 // SC1 mload may not enable
2996 if (E_MLOAD_ENABLED != MDrv_XC_MLoad_GetStatus(pInstance))
2997 {
2998 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Addr, u16Data, u16Mask);
2999 }
3000 else
3001 {
3002 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
3003 {
3004 MS_U64 u64Command = 0;
3005 if(ENABLE_64BITS_SPREAD_MODE)//64 bits spread mode
3006 {
3007 u64Command = Hal_XC_MLoad_Gen_64bits_spreadMode(pInstance,u32Addr,u16Data,u16Mask);
3008 }
3009 else//64 bits sub-bank mode
3010 {
3011 u64Command = Hal_XC_MLoad_Gen_64bits_subBankMode(pInstance,u32Addr,u16Data,u16Mask);
3012 }
3013
3014 if(_MDrv_XC_MLoad_WriteCmd_64Bits(pInstance, u64Command, u16Mask))
3015 {
3016 bReturn = TRUE;
3017 }
3018 else
3019 {
3020 MLDBG(printf("Fail: %x %04x %04x \n", u32Addr, u16Data, u16Mask));
3021 bReturn = FALSE;
3022 }
3023 }
3024 else//32 bits sub-bank mode
3025 {
3026 MS_U32 u32Command = 0;
3027 u32Command = Hal_XC_MLoad_Gen_32bits_subBankMode(pInstance,u32Addr,u16Data,u16Mask);
3028
3029 if(_MDrv_XC_MLoad_WriteCmd_32Bits(pInstance, u32Command, u16Mask))
3030 {
3031 bReturn = TRUE;
3032 }
3033 else
3034 {
3035 MLDBG(printf("Fail: %x %04x %04x \n", u32Addr, u16Data, u16Mask));
3036 bReturn = FALSE;
3037 }
3038 }
3039 }
3040 return bReturn;
3041 }
3042
3043 //-------------------------------------------------------------------------------------------------
3044 /// Write command to the Menuload buffer by WORD
3045 /// @param u32Bank \b IN: the address (direct-bank)
3046 /// @param u32Addr \b IN: the address (8-bit address)
3047 /// @param u16Data \b IN: the data
3048 /// @param u16Mask \b IN: the mask
3049 /// @return TRUE if succeed, FALSE if failed
3050
3051 // This function can support write non xc registers with menuload.
3052 // If you want to write xc registers,you should use MApi_XC_MLoad_WriteCmd.
3053
3054 //-------------------------------------------------------------------------------------------------
MApi_XC_MLoad_WriteCmd_NonXC(void * pInstance,MS_U32 u32Bank,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)3055 MS_BOOL MApi_XC_MLoad_WriteCmd_NonXC(void *pInstance,MS_U32 u32Bank,MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
3056 {
3057 #ifndef CONFIG_MBOOT
3058 #if (SUPPORT_KERNEL_MLOAD == 1)
3059 #ifdef MSOS_TYPE_LINUX_KERNEL
3060 return KApi_XC_MLoad_WriteCmd_NonXC(E_CLIENT_MAIN_XC, u32Bank, u32Addr, u16Data, u16Mask);
3061 #else
3062 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
3063 int fd = -1;
3064 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
3065 if (-1 == fd)
3066 {
3067 printf("\nUnable to open /dev/scaler\n");
3068 return FALSE;
3069 }
3070 else
3071 {
3072 ST_KDRV_MLOAD_WRT_CMD_NONXC k_mload_wcmd_nonxc;
3073 k_mload_wcmd_nonxc._client_type = E_CLIENT_MAIN_XC;
3074 k_mload_wcmd_nonxc.u32Bank = u32Bank;
3075 k_mload_wcmd_nonxc.u32Addr = u32Addr;
3076 k_mload_wcmd_nonxc.u16Data = u16Data;
3077 k_mload_wcmd_nonxc.u16Mask = u16Mask;
3078 k_mload_wcmd_nonxc.bReturn = FALSE;
3079 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_WRT_CMD_NONXC,&k_mload_wcmd_nonxc))
3080 {
3081 perror("ioctl");
3082 close(fd);
3083 return FALSE;
3084 }
3085 close(fd);
3086 return k_mload_wcmd_nonxc.bReturn;
3087 }
3088 #endif
3089 #endif
3090 #endif
3091 #endif
3092 MS_BOOL bReturn = FALSE;
3093 _MLOAD_ENTRY(pInstance);
3094 bReturn = MDrv_XC_MLoad_WriteCommand_NonXC(pInstance,u32Bank,u32Addr, u16Data, u16Mask);
3095 _MLOAD_RETURN(pInstance);
3096 return bReturn;
3097 }
3098
MDrv_XC_MLoad_WriteCommand_NonXC(void * pInstance,MS_U32 u32Bank,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)3099 MS_BOOL MDrv_XC_MLoad_WriteCommand_NonXC(void *pInstance,MS_U32 u32Bank,MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
3100 {
3101 #ifndef CONFIG_MBOOT
3102 #if (SUPPORT_KERNEL_MLOAD == 1)
3103 #ifdef MSOS_TYPE_LINUX_KERNEL
3104 return KApi_XC_MLoad_WriteCmd_NonXC(E_CLIENT_MAIN_XC, u32Bank, u32Addr, u16Data, u16Mask);
3105 #else
3106 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
3107 int fd = -1;
3108 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
3109 if (-1 == fd)
3110 {
3111 printf("\nUnable to open /dev/scaler\n");
3112 return FALSE;
3113 }
3114 else
3115 {
3116 ST_KDRV_MLOAD_WRT_CMD_NONXC k_mload_wcmd_nonxc;
3117 k_mload_wcmd_nonxc._client_type = E_CLIENT_MAIN_XC;
3118 k_mload_wcmd_nonxc.u32Bank = u32Bank;
3119 k_mload_wcmd_nonxc.u32Addr = u32Addr;
3120 k_mload_wcmd_nonxc.u16Data = u16Data;
3121 k_mload_wcmd_nonxc.u16Mask = u16Mask;
3122 k_mload_wcmd_nonxc.bReturn = FALSE;
3123 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_WRT_CMD_NONXC,&k_mload_wcmd_nonxc))
3124 {
3125 perror("ioctl");
3126 close(fd);
3127 return FALSE;
3128 }
3129 close(fd);
3130 return k_mload_wcmd_nonxc.bReturn;
3131 }
3132 #endif
3133 #endif
3134 #endif
3135 #endif
3136 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3137 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3138
3139 MS_BOOL bReturn;
3140
3141 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
3142 {
3143 MS_U64 u64Command = 0;
3144
3145 #if(ENABLE_64BITS_SPREAD_MODE)//64 bits spread mode
3146 u64Command = Hal_XC_MLoad_Gen_64bits_spreadMode_NonXC(pInstance,u32Bank,u32Addr,u16Data,u16Mask);
3147 #else//64 bits sub-bank mode
3148 printf("Not support sub bank mode for non xc bank!");
3149 #endif
3150
3151 if(_MDrv_XC_MLoad_WriteCmd_64Bits(pInstance,u64Command, u16Mask))
3152 {
3153 bReturn = TRUE;
3154 }
3155 else
3156 {
3157 MLDBG(printf("Fail: %x %04x %04x \n", u32Addr, u16Data, u16Mask));
3158 bReturn = FALSE;
3159 }
3160 }
3161 else //32 bits sub-bank mode
3162 {
3163 printf("Not support sub bank mode for non xc bank!");
3164 bReturn = FALSE;
3165 }
3166
3167 return bReturn;
3168 }
3169
MDrv_XC_MLoad_set_trigger_sync(void * pInstance,MLoad_Trigger_Sync eTriggerSync)3170 void MDrv_XC_MLoad_set_trigger_sync(void *pInstance, MLoad_Trigger_Sync eTriggerSync)
3171 {
3172 #ifndef CONFIG_MBOOT
3173 #if (SUPPORT_KERNEL_MLOAD == 1)
3174 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3175 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3176 #ifdef MSOS_TYPE_LINUX_KERNEL
3177 EN_MLOAD_CLIENT_TYPE _client_type;
3178 if(psXCInstPri->u32DeviceID == 0)
3179 _client_type = E_CLIENT_MAIN_XC;
3180 else
3181 _client_type = E_CLIENT_SUB_XC;
3182 KDrv_XC_MLoad_set_trigger_sync(_client_type,eTriggerSync);
3183 return;
3184 #else
3185 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
3186 int fd = -1;
3187 fd = open("/dev/scaler", O_WRONLY | O_NDELAY);
3188 if (-1 == fd)
3189 {
3190 printf("\nUnable to open /dev/scaler\n");
3191 return ;
3192 }
3193 else
3194 {
3195 ST_KDRV_MLOAD_SET_TRIG_SYNC k_mload_set_trigger_sync;
3196 if(psXCInstPri->u32DeviceID == 0)
3197 k_mload_set_trigger_sync._client_type = E_CLIENT_MAIN_XC;
3198 else
3199 k_mload_set_trigger_sync._client_type = E_CLIENT_SUB_XC;
3200 k_mload_set_trigger_sync.eTriggerSync = eTriggerSync;
3201 if (-1 == ioctl(fd, MDRV_XC_IOC_MLOAD_SET_TRIG_SYNC,&k_mload_set_trigger_sync))
3202 {
3203 perror("ioctl");
3204 close(fd);
3205 return ;
3206 }
3207 close(fd);
3208 return ;
3209 }
3210 #endif
3211 #endif
3212 #endif
3213 #endif
3214 Hal_XC_MLoad_set_trigger_sync(pInstance,eTriggerSync);
3215 }
3216