1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94 #define MHAL_ACE_C
95
96
97 //-------------------------------------------------------------------------------------------------
98 // Include Files
99 //-------------------------------------------------------------------------------------------------
100 // Common Definition
101 #include "MsCommon.h"
102 #include "MsOS.h"
103
104 // Internal Definition
105 #include "apiXC_Ace.h"
106 #include "mhal_ace.h"
107 #include "ace_hwreg_utility2.h"
108 #include "drvACE.h"
109 #include "hwreg_ace.h"
110 #ifdef MSOS_TYPE_LINUX_KERNEL
111 #include <linux/string.h>
112 #else
113 #include <string.h>
114 #endif
115
116 //-------------------------------------------------------------------------------------------------
117 // Driver Compiler Options
118 //-------------------------------------------------------------------------------------------------
119
120
121 //-------------------------------------------------------------------------------------------------
122 // Local Defines
123 //-------------------------------------------------------------------------------------------------
124
125 #define MAIN_WINDOW 0
126 #define SUB_WINDOW 1
127
128 //-------------------------------------------------------------------------------------------------
129 // Local Structures
130 //-------------------------------------------------------------------------------------------------
131 #include "ACE_private.h"
132
133 #include "utopia_dapi.h"
134 #include "utopia.h"
135
136 extern void* pu32ACEInst;
137 extern void* pu32ACERes[E_ACE_POOL_ID_MAX];
138
139
140 //-------------------------------------------------------------------------------------------------
141 // Global Variables
142 //-------------------------------------------------------------------------------------------------
143
144 static MS_BOOL bMainWinSkipWaitVsyn = 0, bSubWinSkipWaitVsyn = 0;
145
146 //-------------------------------------------------------------------------------------------------
147 // Local Variables
148 //-------------------------------------------------------------------------------------------------
149
150
151 //-------------------------------------------------------------------------------------------------
152 // Debug Functions
153 //-------------------------------------------------------------------------------------------------
154
155
156 //-------------------------------------------------------------------------------------------------
157 // Local Functions
158 //-------------------------------------------------------------------------------------------------
159
160 //-------------------------------------------------------------------------------------------------
161 // Global Functions
162 //-------------------------------------------------------------------------------------------------
163
Hal_ACE_DMS(void * pInstance,MS_BOOL bScalerWin,MS_BOOL bisATV)164 void Hal_ACE_DMS( void* pInstance, MS_BOOL bScalerWin, MS_BOOL bisATV )
165 {
166 if(bisATV)
167 {
168 if(bScalerWin == MAIN_WINDOW)
169 {
170 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x01, 0x01);
171 SC_W2BYTEMSK(0,REG_SC_BK18_71_L, 0x20, LBMASK);
172 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x06, LBMASK);
173 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x01 <<8, HBMASK);
174
175 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x01, 0x01);
176 SC_W2BYTEMSK(0,REG_SC_BK19_7C_L, 0x20, LBMASK);
177 SC_W2BYTEMSK(0,REG_SC_BK19_7D_L, 0x06, LBMASK);
178 }
179 else
180 {
181 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x10, 0x10);
182 SC_W2BYTEMSK(0,REG_SC_BK18_73_L, 0x20, LBMASK);
183 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x06, LBMASK);
184 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x01 <<8, HBMASK);
185
186 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x10, 0x10);
187 SC_W2BYTEMSK(0,REG_SC_BK19_7E_L, 0x20, LBMASK);
188 SC_W2BYTEMSK(0,REG_SC_BK19_7F_L, 0x06, LBMASK);
189 }
190 }
191 else
192 {
193 if(bScalerWin == MAIN_WINDOW)
194 {
195 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x00, 0x01);
196 SC_W2BYTEMSK(0,REG_SC_BK18_71_L, 0x00, LBMASK);
197 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x00, LBMASK);
198 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x00 <<8, HBMASK);
199
200 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00, 0x01);
201 SC_W2BYTEMSK(0,REG_SC_BK19_7C_L, 0x00, LBMASK);
202 SC_W2BYTEMSK(0,REG_SC_BK19_7D_L, 0x00, LBMASK);
203 }
204 else
205 {
206 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x00, 0x10);
207 SC_W2BYTEMSK(0,REG_SC_BK18_73_L, 0x00, LBMASK);
208 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x00, LBMASK);
209 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x00 <<8, HBMASK);
210
211 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00, 0x10);
212 SC_W2BYTEMSK(0,REG_SC_BK19_7E_L, 0x00, LBMASK);
213 SC_W2BYTEMSK(0,REG_SC_BK19_7F_L, 0x00, LBMASK);
214 }
215 }
216 }
217
218 MS_VIRT _ACE_RIU_BASE;
219
220 // Put this function here because hwreg_utility2 only for hal.
Hal_ACE_init_riu_base(MS_VIRT ptr_riu_base)221 void Hal_ACE_init_riu_base(MS_VIRT ptr_riu_base)
222 {
223 _ACE_RIU_BASE = ptr_riu_base;
224 }
225
226 extern void* pu32ACE_XCInst;
227 extern void* pu32ACE_XCInst_1;
228 #define _ACE_SELECT_XC_INST(ACEID) \
229 (u32deviceID == 0)? pu32ACE_XCInst : pu32ACE_XCInst_1
230
Hal_ACE_SetSharpness(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8Sharpness)231 void Hal_ACE_SetSharpness( void* pInstance, MS_BOOL bScalerWin, MS_U8 u8Sharpness)
232 {
233 if((MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED) && (!Hal_ACE_GetSkipWaitVsync(pInstance, bScalerWin)))
234 {
235
236 if(bScalerWin == MAIN_WINDOW)
237 {
238 MApi_XC_MLoad_WriteCmd(pInstance, REG_SC_BK19_13_L, (u8Sharpness)<<8, 0x7F00); // 7 bit sharpness!
239 }
240 else
241 {
242 MApi_XC_MLoad_WriteCmd(pInstance, REG_SC_BK19_17_L, (u8Sharpness)<<8, 0x7F00);
243 }
244 MApi_XC_MLoad_Fire(pInstance, TRUE);
245
246 }
247 else
248 {
249 if(bScalerWin == MAIN_WINDOW)
250 {
251 SC_W2BYTEMSK(0, REG_SC_BK19_13_L, (u8Sharpness)<<8, 0x7F00); // 7 bit sharpness!
252 }
253 else
254 {
255 SC_W2BYTEMSK(0, REG_SC_BK19_17_L, (u8Sharpness)<<8, 0x7F00);
256 }
257 }
258 }
259
Hal_ACE_SetBrightness(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8RedBrightness,MS_U8 u8GreenBrightness,MS_U8 u8BlueBrightness)260 void Hal_ACE_SetBrightness( void* pInstance, MS_BOOL bScalerWin, MS_U8 u8RedBrightness, MS_U8 u8GreenBrightness, MS_U8 u8BlueBrightness )
261 {
262 ACE_INSTANCE_PRIVATE *psACEInstPri = NULL;
263 UtopiaInstanceGetPrivate(pInstance, (void**)&psACEInstPri);
264 MS_U32 u32deviceID = psACEInstPri->u32DeviceID;
265
266 // Y adhust(2's complement)
267 if(u8GreenBrightness >= 128)
268 {
269 u8GreenBrightness = u8GreenBrightness - 128;
270 }
271 else
272 {
273 u8GreenBrightness = (u8GreenBrightness) + BIT(7);
274 }
275
276 MS_BOOL bUseMenuload = FALSE;
277 if((!Hal_ACE_GetSkipWaitVsync(pInstance, bScalerWin)))
278 {
279 if(MApi_XC_MLoad_GetStatus_U2(_ACE_SELECT_XC_INST(u32deviceID)) == E_MLOAD_ENABLED)
280 {
281 bUseMenuload = TRUE;
282 }
283 }
284
285 if(bUseMenuload)
286 {
287 if(bScalerWin == MAIN_WINDOW)
288 {
289 MApi_XC_MLoad_WriteCmd(_ACE_SELECT_XC_INST(u32deviceID), REG_SC_BK2F_7A_L, ((MS_U16)u8GreenBrightness), 0xFF);
290 }
291 else
292 {
293 MApi_XC_MLoad_WriteCmd(_ACE_SELECT_XC_INST(u32deviceID), REG_SC_BK63_5A_L, ((MS_U16)u8GreenBrightness), 0xFF);
294 }
295
296 MApi_XC_MLoad_Fire(_ACE_SELECT_XC_INST(u32deviceID),TRUE);
297 }
298 else
299 {
300 if(bScalerWin == MAIN_WINDOW)
301 {
302 SC_W2BYTEMSK(u32deviceID,REG_SC_BK2F_7A_L, ((MS_U16)u8GreenBrightness), 0xFF);
303 }
304 else
305 {
306 SC_W2BYTEMSK(u32deviceID,REG_SC_BK63_5A_L, ((MS_U16)u8GreenBrightness), 0xFF);
307 }
308 }
309
310 }
311
Hal_ACE_SetBrightnessPrecise(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedBrightness,MS_U16 u16GreenBrightness,MS_U16 u16BlueBrightness)312 void Hal_ACE_SetBrightnessPrecise(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16RedBrightness, MS_U16 u16GreenBrightness, MS_U16 u16BlueBrightness)
313 {
314 ACE_INSTANCE_PRIVATE *psACEInstPri = NULL;
315 UtopiaInstanceGetPrivate(pInstance, (void**)&psACEInstPri);
316 MS_U32 u32deviceID = psACEInstPri->u32DeviceID;
317
318
319 MS_U8 u8GreenBrightness = (MS_U8)u16GreenBrightness;
320
321 // Y adhust(2's complement)
322 if(u8GreenBrightness >= 128)
323 {
324 u8GreenBrightness = u8GreenBrightness - 128;
325 }
326 else
327 {
328 u8GreenBrightness = (u8GreenBrightness) + BIT(7);
329 }
330
331 if(MApi_XC_MLoad_GetStatus_U2(_ACE_SELECT_XC_INST(u32deviceID)) == E_MLOAD_ENABLED)
332 {
333
334 if(bScalerWin == MAIN_WINDOW)
335 {
336 MApi_XC_MLoad_WriteCmd(_ACE_SELECT_XC_INST(u32deviceID), REG_SC_BK2F_7A_L, ((MS_U16)u8GreenBrightness), 0xFF);
337 }
338 else
339 {
340 MApi_XC_MLoad_WriteCmd(_ACE_SELECT_XC_INST(u32deviceID), REG_SC_BK63_5A_L, ((MS_U16)u8GreenBrightness), 0xFF);
341 }
342
343 MApi_XC_MLoad_Fire(_ACE_SELECT_XC_INST(u32deviceID),TRUE);
344
345 }
346 else
347 {
348 if(bScalerWin == MAIN_WINDOW)
349 {
350 SC_W2BYTEMSK(u32deviceID,REG_SC_BK2F_7A_L, ((MS_U16)u8GreenBrightness), 0xFF);
351 }
352 else
353 {
354 SC_W2BYTEMSK(u32deviceID,REG_SC_BK63_5A_L, ((MS_U16)u8GreenBrightness), 0xFF);
355 }
356 }
357 }
358
Hal_ACE_GetBrightness(void * pInstance,MS_BOOL bScalerWin,MS_U8 * u8RedBrightness,MS_U8 * u8GreenBrightness,MS_U8 * u8BlueBrightness)359 void Hal_ACE_GetBrightness(void* pInstance, MS_BOOL bScalerWin, MS_U8* u8RedBrightness, MS_U8* u8GreenBrightness, MS_U8* u8BlueBrightness )
360 {
361 ACE_INSTANCE_PRIVATE *psACEInstPri = NULL;
362 UtopiaInstanceGetPrivate(pInstance, (void**)&psACEInstPri);
363 MS_U32 u32deviceID = psACEInstPri->u32DeviceID;
364
365 *u8RedBrightness = 0;
366 *u8GreenBrightness = 0;
367 *u8BlueBrightness = 0;
368
369 if(bScalerWin == MAIN_WINDOW)
370 {
371 *u8GreenBrightness = SC_R2BYTE(u32deviceID,REG_SC_BK2F_7A_L) & 0xFF;
372 }
373 else
374 {
375 *u8GreenBrightness = SC_R2BYTE(u32deviceID,REG_SC_BK63_5A_L) & 0xFF;
376 }
377
378 if (*u8GreenBrightness & BIT(7))
379 {
380 *u8GreenBrightness = *u8GreenBrightness - BIT(7);
381 }
382 else
383 {
384 *u8GreenBrightness = *u8GreenBrightness + 128;
385 }
386 }
387
388
Hal_ACE_SetPostRGBGain(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedGain,MS_U16 u16GreenGain,MS_U16 u16BlueGain)389 void Hal_ACE_SetPostRGBGain(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16RedGain, MS_U16 u16GreenGain, MS_U16 u16BlueGain)
390 {
391 return;
392 }
393
Hal_ACE_SetPostRGBOffset(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedOffset,MS_U16 u16GreenOffset,MS_U16 u16BlueOffset)394 void Hal_ACE_SetPostRGBOffset(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16RedOffset, MS_U16 u16GreenOffset, MS_U16 u16BlueOffset)
395 {
396 return;
397 }
398
Hal_ACE_SetPostRGBGainOffsetTogether(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedGain,MS_U16 u16GreenGain,MS_U16 u16BlueGain,MS_U16 u16RedOffset,MS_U16 u16GreenOffset,MS_U16 u16BlueOffset)399 void Hal_ACE_SetPostRGBGainOffsetTogether(void* pInstance, MS_BOOL bScalerWin,
400 MS_U16 u16RedGain, MS_U16 u16GreenGain, MS_U16 u16BlueGain,
401 MS_U16 u16RedOffset, MS_U16 u16GreenOffset, MS_U16 u16BlueOffset)
402 {
403 return;
404 }
405
Hal_ACE_GetColorMatrix(void * pInstance,MS_BOOL bScalerWin,MS_U16 * pu16Matrix)406 void Hal_ACE_GetColorMatrix( void* pInstance, MS_BOOL bScalerWin, MS_U16* pu16Matrix)
407 {
408 MS_U8 i;
409
410 if(bScalerWin == MAIN_WINDOW)
411 {
412 for (i=0; i<9; i++)
413 {
414 *pu16Matrix = SC_R2BYTE(0,(REG_SC_BK2F_71_L + (2 * i)));
415 pu16Matrix++;
416 }
417 }
418 else
419 {
420 for (i=0; i<9; i++)
421 {
422 *pu16Matrix = SC_R2BYTE(0,(REG_SC_BK2F_71_L + (2 * i)));
423 pu16Matrix++;
424 }
425 }
426 }
427
Hal_ACE_SetColorMatrix(void * pInstance,MS_BOOL bScalerWin,MS_U16 * pu16Matrix)428 void Hal_ACE_SetColorMatrix( void* pInstance, MS_BOOL bScalerWin, MS_U16* pu16Matrix)
429 {
430 MS_U8 i;
431
432 if(bScalerWin == MAIN_WINDOW)
433 {
434 for (i=0; i<9; i++)
435 {
436 SC_W2BYTE(0, (REG_SC_BK2F_71_L+(2 * i)), *pu16Matrix);
437 pu16Matrix++;
438 }
439 }
440 else
441 {
442 for (i=0; i<9; i++)
443 {
444 SC_W2BYTE(0, (REG_SC_BK2F_71_L+(2 * i)), *pu16Matrix);
445 pu16Matrix++;
446 }
447 }
448 }
449
Hal_ACE_SetIHC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IHC_COLOR_TYPE eIHC,MS_U8 u8Val)450 MS_BOOL Hal_ACE_SetIHC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IHC_COLOR_TYPE eIHC, MS_U8 u8Val)
451 {
452 return TRUE;
453 }
454
Hal_ACE_GetIHC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IHC_COLOR_TYPE eIHC,MS_U8 * pu8Val)455 MS_BOOL Hal_ACE_GetIHC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IHC_COLOR_TYPE eIHC, MS_U8* pu8Val)
456 {
457 return TRUE;
458 }
459
Hal_ACE_SetICC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_ICC_COLOR_TYPE eICC,MS_U8 u8Val)460 MS_BOOL Hal_ACE_SetICC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_ICC_COLOR_TYPE eICC, MS_U8 u8Val)
461 {
462 return TRUE;
463 }
464
Hal_ACE_GetICC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_ICC_COLOR_TYPE eICC,MS_U8 * pu8Val)465 MS_BOOL Hal_ACE_GetICC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_ICC_COLOR_TYPE eICC, MS_U8* pu8Val)
466 {
467 return TRUE;
468 }
469
Hal_ACE_SetIBC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IBC_COLOR_TYPE eIBC,MS_U8 u8Val)470 MS_BOOL Hal_ACE_SetIBC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IBC_COLOR_TYPE eIBC, MS_U8 u8Val)
471 {
472 return TRUE;
473 }
474
Hal_ACE_GetIBC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IBC_COLOR_TYPE eIBC,MS_U8 * pu8Val)475 MS_BOOL Hal_ACE_GetIBC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IBC_COLOR_TYPE eIBC, MS_U8* pu8Val)
476 {
477 return TRUE;
478 }
479
Hal_ACE_PatchDTGColorChecker(void * pInstance,MS_U8 u8Mode)480 void Hal_ACE_PatchDTGColorChecker(void* pInstance, MS_U8 u8Mode)
481 {
482 static MS_U8 u8Red, u8Green, u8Blue;
483 static MS_U8 u8VOP_50L, u8XVYCC_01L, u8VOP_16H;
484
485 if(u8Mode)
486 {
487 // specific settings for MHEG5
488 u8Red = SC_R2BYTEMSK(0,REG_SC_BK10_17_L, LBMASK);
489 u8Green = SC_R2BYTEMSK(0,REG_SC_BK10_17_L, HBMASK);
490 u8Blue = SC_R2BYTEMSK(0,REG_SC_BK10_18_L, LBMASK);
491 u8VOP_50L = SC_R2BYTEMSK(0,REG_SC_BK10_50_L, LBMASK);
492
493 u8XVYCC_01L= SC_R2BYTEMSK(0,REG_SC_BK25_01_L, LBMASK);
494 u8VOP_16H = SC_R2BYTEMSK(0,REG_SC_BK10_16_L, HBMASK);
495
496 SC_W2BYTEMSK(0,REG_SC_BK10_16_L, 0x0000, 0x0100);
497 SC_W2BYTEMSK(0,REG_SC_BK25_01_L, 0x0000, 0x00F0);
498
499 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, 0x80, LBMASK);
500 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, 0x80 <<8, HBMASK);
501 SC_W2BYTEMSK(0,REG_SC_BK10_50_L, 0x00, LBMASK);
502
503 // add from YT
504 SC_W2BYTE(0,REG_SC_BK18_41_L, 0x080C);
505 SC_W2BYTE(0,REG_SC_BK18_42_L, 0x0808);
506 SC_W2BYTE(0,REG_SC_BK18_43_L, 0x1008);
507 }
508 else
509 {
510 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, u8Red, LBMASK);
511 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, ((MS_U16)u8Green) <<8, HBMASK);
512 SC_W2BYTEMSK(0,REG_SC_BK10_18_L, u8Blue, LBMASK);
513 SC_W2BYTEMSK(0,REG_SC_BK10_50_L, u8VOP_50L, LBMASK);
514
515 SC_W2BYTEMSK(0,REG_SC_BK25_01_L, u8XVYCC_01L, LBMASK);
516 SC_W2BYTEMSK(0,REG_SC_BK10_16_L, ((MS_U16)u8VOP_16H)<<8, HBMASK);
517 }
518 }
519
Hal_ACE_SetSlopValue(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8SlopValue)520 void Hal_ACE_SetSlopValue( void* pInstance, MS_BOOL bScalerWin, MS_U8 u8SlopValue)
521 {
522 if(bScalerWin == MAIN_WINDOW)
523 {
524 SC_W2BYTEMSK(0,REG_SC_BK1A_10_L, ((MS_U16)u8SlopValue) <<8, HBMASK);
525 }
526 else
527 {
528 SC_W2BYTEMSK(0,REG_SC_BK1A_12_L, ((MS_U16)u8SlopValue) <<8, HBMASK);
529 }
530 }
531
Hal_ACE_SetFCC_En(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8Reg,MS_BOOL bEn)532 void Hal_ACE_SetFCC_En( void* pInstance, MS_BOOL bScalerWin, MS_U8 u8Reg, MS_BOOL bEn)
533 {
534 MS_U16 u16value;
535
536 if(u8Reg > 7)
537 u8Reg = 7;
538
539 if (bEn)
540 {
541 if(bScalerWin == MAIN_WINDOW)
542 u16value = (SC_R2BYTE(0,REG_SC_BK18_10_L) & 0x000F) | (1 << u8Reg);
543 else
544 u16value = (SC_R2BYTE(0,REG_SC_BK18_11_L) & 0x000F) | (1 << u8Reg);
545 }
546 else
547 {
548 if(bScalerWin == MAIN_WINDOW)
549 u16value = (SC_R2BYTE(0,REG_SC_BK18_10_L) & 0x000F) & ~(1 << u8Reg);
550 else
551 u16value = (SC_R2BYTE(0,REG_SC_BK18_11_L) & 0x000F) & ~(1 << u8Reg);
552 }
553
554 SC_W2BYTEMSK(0,REG_SC_BK18_10_L, u16value, 0x000F);
555 }
556
557
Hal_ACE_SetFCC_Cb(void * pInstance,MS_U8 u8Reg,MS_U8 u8value)558 void Hal_ACE_SetFCC_Cb(void* pInstance, MS_U8 u8Reg, MS_U8 u8value)
559 {
560 MS_U32 u32reg_addr;
561
562 if(u8Reg > 7)
563 u8Reg = 7;
564
565 u32reg_addr = REG_SC_BK18_18_L + u8Reg * 2;
566 SC_W2BYTEMSK(0,u32reg_addr, (MS_U16)u8value, LBMASK);
567 }
568
Hal_ACE_Set_IHC_SRAM(void * pInstance,MS_U16 * pBuf,MS_U8 u8SRAM_Idx,MS_U16 u16Cnt)569 void Hal_ACE_Set_IHC_SRAM(void* pInstance, MS_U16 *pBuf, MS_U8 u8SRAM_Idx, MS_U16 u16Cnt)
570 {
571 MS_U16 i;
572
573 if(u8SRAM_Idx > 3)
574 {
575 u8SRAM_Idx = 0;
576 }
577
578 SC_W2BYTEMSK(0,REG_SC_BK18_7C_L, BIT(0), BIT(0)); // io_en disable
579 SC_W2BYTEMSK(0,REG_SC_BK18_7C_L, u8SRAM_Idx<<1, BIT(2)|BIT(1)); // sram select
580
581 for(i=0; i<u16Cnt; i++)
582 {
583 while (SC_R2BYTE(0,REG_SC_BK18_7E_L) & BIT(8));
584
585 SC_W2BYTEMSK(0,REG_SC_BK18_7D_L, i, 0x00FF); // address
586 SC_W2BYTEMSK(0,REG_SC_BK18_7E_L, pBuf[i], 0x00FF); //data
587
588 SC_W2BYTEMSK(0,REG_SC_BK18_7E_L, BIT(8), BIT(8)); // io_w enable
589 }
590
591 SC_W2BYTEMSK(0,REG_SC_BK18_7C_L, 0, BIT(0)); // io_en enable
592 }
593
Hal_ACE_Set_ICC_SRAM(void * pInstance,MS_U16 * pBuf,MS_U16 u16Cnt)594 void Hal_ACE_Set_ICC_SRAM(void* pInstance, MS_U16 *pBuf, MS_U16 u16Cnt)
595 {
596 MS_U16 i;
597 SC_W2BYTEMSK(0,REG_SC_BK18_78_L, BIT(0), BIT(0)); // io_en disable
598
599 for(i=0; i<u16Cnt; i++)
600 {
601 while (SC_R2BYTE(0,REG_SC_BK18_7A_L) & BIT(8));
602
603 SC_W2BYTEMSK(0,REG_SC_BK18_79_L, i, 0x00FF); // address
604 SC_W2BYTEMSK(0,REG_SC_BK18_7A_L, (pBuf[i] & 0xFF), 0x00FF); //data
605 SC_W2BYTEMSK(0,REG_SC_BK18_7B_L, ((pBuf[i] & 0x100)<<4), 0x1000); //sign data
606
607 SC_W2BYTEMSK(0,REG_SC_BK18_7A_L, BIT(8), BIT(8)); // io_w enable
608 }
609
610 SC_W2BYTEMSK(0,REG_SC_BK18_78_L, 0, BIT(0)); // io_en enable
611 }
612
613 ////////////////////////////////////////////////////////////////////////////////
614 //
615 // MWE start
616 //
617 ////////////////////////////////////////////////////////////////////////////////
MHal_SC_SetMWEQuality(void * pInstance)618 void MHal_SC_SetMWEQuality(void* pInstance)
619 {
620 MS_U16 value ;
621
622 //////////////////////////////////////
623 /// Copy main window setting
624 //////////////////////////////////////
625 // Copy H-Peak
626 value = SC_R2BYTE(0,REG_SC_BK19_10_L);
627 SC_W2BYTE(0,REG_SC_BK19_14_L, value);
628 value = SC_R2BYTE(0,REG_SC_BK19_11_L);
629 SC_W2BYTE(0,REG_SC_BK19_15_L, value );
630 value = SC_R2BYTE(0,REG_SC_BK19_12_L);
631 SC_W2BYTE(0,REG_SC_BK19_16_L, value );
632 value = SC_R2BYTE(0,REG_SC_BK19_13_L);
633 SC_W2BYTE(0,REG_SC_BK19_17_L, value );
634 value = SC_R2BYTE(0,REG_SC_BK19_18_L);
635 SC_W2BYTE(0,REG_SC_BK19_28_L, value );
636 value = SC_R2BYTE(0,REG_SC_BK19_19_L);
637 SC_W2BYTE(0,REG_SC_BK19_29_L, value );
638 value = SC_R2BYTE(0,REG_SC_BK19_1A_L);
639 SC_W2BYTE(0,REG_SC_BK19_2A_L, value );
640 value = SC_R2BYTE(0,REG_SC_BK19_1B_L);
641 SC_W2BYTE(0,REG_SC_BK19_2B_L, value );
642 value = SC_R2BYTE(0,REG_SC_BK19_1C_L);
643 SC_W2BYTE(0,REG_SC_BK19_2C_L, value );
644 value = SC_R2BYTE(0,REG_SC_BK19_1D_L);
645 SC_W2BYTE(0,REG_SC_BK19_2D_L, value );
646 value = SC_R2BYTE(0,REG_SC_BK19_1E_L);
647 SC_W2BYTE(0,REG_SC_BK19_2E_L, value );
648 value = SC_R2BYTE(0,REG_SC_BK19_1F_L);
649 SC_W2BYTE(0,REG_SC_BK19_2F_L, value );
650
651
652 // Copy FCC from main window
653 value = SC_R2BYTE(0,REG_SC_BK18_10_L);
654 SC_W2BYTE(0,REG_SC_BK18_11_L, value);
655
656 // Copy ICC
657 value = SC_R2BYTE(0,REG_SC_BK18_30_L) ;
658 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, value >> 4, (BIT(2)|BIT(3)));
659 value = SC_R2BYTE(0,REG_SC_BK18_31_L);
660 SC_W2BYTEMSK(0,REG_SC_BK18_31_L, (value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)|BIT(12)|BIT(13)|BIT(14)|BIT(15)));
661 value = SC_R2BYTE(0,REG_SC_BK18_32_L);
662 SC_W2BYTEMSK(0,REG_SC_BK18_32_L, ( value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)|BIT(12)|BIT(13)|BIT(14)|BIT(15)));
663 value = SC_R2BYTE(0,REG_SC_BK18_33_L);
664 SC_W2BYTEMSK(0,REG_SC_BK18_33_L, ( value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)|BIT(12)|BIT(13)|BIT(14)|BIT(15)));
665 value = SC_R2BYTE(0,REG_SC_BK18_34_L);
666 SC_W2BYTEMSK(0,REG_SC_BK18_34_L, (value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)));
667 value = SC_R2BYTE(0,REG_SC_BK18_35_L);
668 SC_W2BYTEMSK(0,REG_SC_BK18_35_L, (value << 8), 0xFF00);
669
670 // IBC
671 value = SC_R2BYTE(0,REG_SC_BK18_40_L);
672 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, value >> 1, BIT(6));
673 value = SC_R2BYTE(0,REG_SC_BK18_41_L);
674 SC_W2BYTE(0,REG_SC_BK18_45_L, value );
675 value = SC_R2BYTE(0,REG_SC_BK18_42_L);
676 SC_W2BYTE(0,REG_SC_BK18_46_L, value );
677 value = SC_R2BYTE(0,REG_SC_BK18_43_L);
678 SC_W2BYTE(0,REG_SC_BK18_47_L, value );
679 value = SC_R2BYTE(0,REG_SC_BK18_44_L);
680 SC_W2BYTEMSK(0,REG_SC_BK18_48_L, value ,(BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4)|BIT(5)));
681
682 // Y/C noise masking
683 value = SC_R2BYTE(0,REG_SC_BK18_55_L);
684 SC_W2BYTEMSK(0,REG_SC_BK18_5D_L, value ,(BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4)|BIT(5)|BIT(7)|BIT(8)|BIT(9)|BIT(10)|BIT(11)|BIT(12)|BIT(13)|BIT(15)));
685
686 // IHC
687 value = SC_R2BYTE(0,REG_SC_BK18_60_L);
688 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, value >> 1, BIT(6));
689 // YC-Coring
690 value = SC_R2BYTE(0,REG_SC_BK18_50_L);
691 SC_W2BYTE(0,REG_SC_BK18_58_L, value );
692 value = SC_R2BYTE(0,REG_SC_BK18_51_L);
693 SC_W2BYTE(0,REG_SC_BK18_59_L, value);
694 value = SC_R2BYTE(0,REG_SC_BK18_52_L);
695 SC_W2BYTE(0,REG_SC_BK18_5A_L, value);
696 value = SC_R2BYTE(0,REG_SC_BK18_53_L);
697 SC_W2BYTE(0,REG_SC_BK18_5B_L, value);
698 value = SC_R2BYTE(0,REG_SC_BK18_54_L);
699 SC_W2BYTE(0,REG_SC_BK18_5C_L, value);
700
701 // copy Y-Adjust
702 value = SC_R2BYTE(0,REG_SC_BK1A_0E_L);
703 SC_W2BYTEMSK(0,REG_SC_BK1A_0E_L, (value << 8), BIT(8) | BIT(9));
704 value = SC_R2BYTE(0,REG_SC_BK1A_0F_L);
705 SC_W2BYTEMSK(0,REG_SC_BK1A_0F_L, (value << 8), 0xFF00);
706
707 // copy BLE
708 value = SC_R2BYTE(0,REG_SC_BK1A_10_L);
709 SC_W2BYTE(0,REG_SC_BK1A_12_L, value );
710 // copy WLE
711 value = SC_R2BYTE(0,REG_SC_BK1A_11_L);
712 SC_W2BYTE(0,REG_SC_BK1A_13_L, value );
713 // copy Y/C gain control
714 value = SC_R2BYTE(0,REG_SC_BK1A_14_L);
715 SC_W2BYTE(0,REG_SC_BK1A_15_L, value );
716 // Histogram data
717 value = SC_R2BYTE(0,REG_SC_BK1A_01_L);
718 SC_W2BYTE(0,REG_SC_BK1A_03_L, value );
719
720 // Copy DLC table
721 value = SC_R2BYTE(0,REG_SC_BK1A_30_L);
722 SC_W2BYTE(0,REG_SC_BK1A_38_L, value);
723 value = SC_R2BYTE(0,REG_SC_BK1A_31_L);
724 SC_W2BYTE(0,REG_SC_BK1A_39_L, value );
725 value = SC_R2BYTE(0,REG_SC_BK1A_32_L);
726 SC_W2BYTE(0,REG_SC_BK1A_3A_L, value );
727 value = SC_R2BYTE(0,REG_SC_BK1A_33_L);
728 SC_W2BYTE(0,REG_SC_BK1A_3B_L, value );
729 value = SC_R2BYTE(0,REG_SC_BK1A_34_L);
730 SC_W2BYTE(0,REG_SC_BK1A_3C_L, value );
731 value = SC_R2BYTE(0,REG_SC_BK1A_35_L);
732 SC_W2BYTE(0,REG_SC_BK1A_3D_L, value);
733 value = SC_R2BYTE(0,REG_SC_BK1A_36_L);
734 SC_W2BYTE(0,REG_SC_BK1A_3E_L, value );
735 value = SC_R2BYTE(0,REG_SC_BK1A_37_L);
736 SC_W2BYTE(0,REG_SC_BK1A_3F_L, value);
737
738 // Copy Statistic
739 value = SC_R2BYTE(0,REG_SC_BK1A_04_L);
740 SC_W2BYTEMSK(0,REG_SC_BK1A_04_L, value >> 1 , BIT(0));
741
742 // Copy Luma curve
743 value = SC_R2BYTE(0,REG_SC_BK1A_04_L);
744 SC_W2BYTEMSK(0,REG_SC_BK1A_04_L, value >> 1 , BIT(6));
745 // Read Brightness setting from main window
746 value = SC_R2BYTE(0,REG_SC_BK0F_36_L);
747 SC_W2BYTE(0,REG_SC_BK0F_39_L, value );
748 value = SC_R2BYTE(0,REG_SC_BK0F_37_L);
749 SC_W2BYTE(0,REG_SC_BK0F_3A_L, value );
750 value = SC_R2BYTE(0,REG_SC_BK0F_38_L);
751 SC_W2BYTE(0,REG_SC_BK0F_3B_L, value );
752
753 // copy Post Scaling filter selection from main to sub
754 value = SC_R2BYTE(0,REG_SC_BK23_0B_L);
755 SC_W2BYTE(0,REG_SC_BK23_2B_L, value );
756
757 // color matrix
758
759 {
760
761 value = SC_R2BYTE(0,REG_SC_BK2F_71_L);
762 SC_W2BYTE(0,REG_SC_BK2F_71_L, value );
763
764 value = SC_R2BYTE(0,REG_SC_BK2F_72_L);
765 SC_W2BYTE(0,REG_SC_BK2F_72_L, value );
766
767 value = SC_R2BYTE(0,REG_SC_BK2F_73_L);
768 SC_W2BYTE(0,REG_SC_BK2F_73_L, value );
769
770 value = SC_R2BYTE(0,REG_SC_BK2F_74_L);
771 SC_W2BYTE(0,REG_SC_BK2F_74_L, value );
772
773 value = SC_R2BYTE(0,REG_SC_BK2F_75_L);
774 SC_W2BYTE(0,REG_SC_BK2F_75_L, value );
775
776 value = SC_R2BYTE(0,REG_SC_BK2F_76_L);
777 SC_W2BYTE(0,REG_SC_BK2F_76_L,value);
778
779 value = SC_R2BYTE(0,REG_SC_BK2F_77_L);
780 SC_W2BYTE(0,REG_SC_BK2F_77_L, value );
781
782 value = SC_R2BYTE(0,REG_SC_BK2F_78_L);
783 SC_W2BYTE(0,REG_SC_BK2F_78_L,value );
784
785 value = SC_R2BYTE(0,REG_SC_BK2F_79_L);
786 SC_W2BYTE(0,REG_SC_BK2F_79_L,value );
787
788 value = SC_R2BYTE(0,REG_SC_BK2F_7A_L);
789 SC_W2BYTE(0,REG_SC_BK2F_7A_L,value);
790
791 }
792
793 //////////////////////////////////////
794 /// Disable
795 //////////////////////////////////////
796 //disable ICC
797
798 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, 0x00 ,BIT(2));
799 //disable IBC
800 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, 0x00 ,BIT(6));
801 //disable IHC
802 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, 0x00 ,BIT(6));
803 //disable DLC ( fresh contrast )
804 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, 0x00 ,BIT(6));
805
806 // main window DLC
807 //REG_WI(REG_SC_DLC(0x04), 1, BIT(7));
808
809 }
810
Hal_ACE_MWESetWin(void * pInstance,MS_U16 u16hstart,MS_U16 u16hend,MS_U16 u16vstart,MS_U16 u16vend)811 void Hal_ACE_MWESetWin(void* pInstance, MS_U16 u16hstart, MS_U16 u16hend, MS_U16 u16vstart, MS_U16 u16vend)
812 {
813 if(MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED)
814 {
815
816 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_07_L, u16hstart, 0x1FFF);
817 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_08_L, u16hend, 0x1FFF);
818 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_09_L, u16vstart, 0xFFF);
819 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_0A_L, u16vend, 0xFFF);
820
821 MApi_XC_MLoad_Fire(pInstance,TRUE);
822
823 }
824 else
825 {
826 SC_W2BYTEMSK(0,REG_SC_BK0F_07_L, u16hstart, 0x1FFF);
827 SC_W2BYTEMSK(0,REG_SC_BK0F_08_L, u16hend, 0x1FFF);
828 SC_W2BYTEMSK(0,REG_SC_BK0F_09_L, u16vstart, 0xFFF);
829 SC_W2BYTEMSK(0,REG_SC_BK0F_0A_L, u16vend, 0xFFF);
830 }
831 }
832
Hal_ACE_MWECloneVisualEffect(void * pInstance)833 void Hal_ACE_MWECloneVisualEffect(void* pInstance)
834 {
835 MS_U16 value ;
836
837 //////////////////////////////////////
838 /// Clone Main Window
839 //////////////////////////////////////
840
841 // copy brightness enable flag
842 value = SC_R2BYTE(0,REG_SC_BK10_16_L);
843 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, 0xFD00);
844 // copy color table enable flag
845 value = SC_R2BYTE(0,REG_SC_BK10_2F_L);
846 SC_W2BYTEMSK(0,REG_SC_BK0F_26_L, value, 0x0037);
847 //clone ICC
848 value = SC_R2BYTE(0,REG_SC_BK18_30_L);
849 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, value >> 4, BIT(2));
850 //clone IBC
851 value = SC_R2BYTE(0,REG_SC_BK18_40_L);
852 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, value >> 1, BIT(6));
853 //clone IHC
854 value = SC_R2BYTE(0,REG_SC_BK18_60_L);
855 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, value >> 1, BIT(6));
856 }
857
Hal_ACE_3DClonePQMap(void * pInstance,XC_ACE_WEAVETYPE enWeaveType)858 void Hal_ACE_3DClonePQMap(void* pInstance, XC_ACE_WEAVETYPE enWeaveType)
859 {
860 MS_U16 value = 0;
861
862 //if(!bHWeaveOut && !bVWeaveOut)
863 {
864 SC_W2BYTEMSK(0,REG_SC_BK19_10_L, 0x8F00 ,0xFF00);
865 SC_W2BYTE(0,REG_SC_BK19_12_L, 0x0000);
866 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, 0x00, 0x00FF);
867 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, 0x00, BIT(4));
868 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00, BIT(0));
869 }
870
871 //FCC
872 {
873 value = SC_R2BYTE(0,REG_SC_BK18_10_L);
874 SC_W2BYTE(0,REG_SC_BK18_11_L, value);
875 }
876
877 //Y/C noise masking
878 {
879 value = SC_R2BYTE(0,REG_SC_BK18_55_L);
880 SC_W2BYTEMSK(0,REG_SC_BK18_5D_L, value ,(BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4)|BIT(5)|BIT(7)|BIT(8)|BIT(9)|BIT(10)|BIT(11)|BIT(12)|BIT(13)|BIT(15)));
881 }
882
883 //YC-Coring
884 {
885 value = SC_R2BYTE(0,REG_SC_BK18_50_L);
886 SC_W2BYTE(0,REG_SC_BK18_58_L, value );
887 value = SC_R2BYTE(0,REG_SC_BK18_51_L);
888 SC_W2BYTE(0,REG_SC_BK18_59_L, value);
889 value = SC_R2BYTE(0,REG_SC_BK18_52_L);
890 SC_W2BYTE(0,REG_SC_BK18_5A_L, value);
891 value = SC_R2BYTE(0,REG_SC_BK18_53_L);
892 SC_W2BYTE(0,REG_SC_BK18_5B_L, value);
893 value = SC_R2BYTE(0,REG_SC_BK18_54_L);
894 SC_W2BYTE(0,REG_SC_BK18_5C_L, value);
895 }
896
897 //Y-Adjust
898 {
899 value = SC_R2BYTE(0,REG_SC_BK1A_0E_L);
900 SC_W2BYTEMSK(0,REG_SC_BK1A_0E_L, (value << 8), BIT(8) | BIT(9));
901 value = SC_R2BYTE(0,REG_SC_BK1A_0F_L);
902 SC_W2BYTEMSK(0,REG_SC_BK1A_0F_L, (value << 8), 0xFF00);
903 }
904
905 //Histogram data
906 {
907 value = SC_R2BYTE(0,REG_SC_BK1A_01_L);
908 SC_W2BYTE(0,REG_SC_BK1A_03_L, value );
909 }
910
911 //DLC table
912 {
913 value = SC_R2BYTE(0,REG_SC_BK1A_30_L);
914 SC_W2BYTE(0,REG_SC_BK1A_38_L, value);
915 value = SC_R2BYTE(0,REG_SC_BK1A_31_L);
916 SC_W2BYTE(0,REG_SC_BK1A_39_L, value );
917 value = SC_R2BYTE(0,REG_SC_BK1A_32_L);
918 SC_W2BYTE(0,REG_SC_BK1A_3A_L, value );
919 value = SC_R2BYTE(0,REG_SC_BK1A_33_L);
920 SC_W2BYTE(0,REG_SC_BK1A_3B_L, value );
921 value = SC_R2BYTE(0,REG_SC_BK1A_34_L);
922 SC_W2BYTE(0,REG_SC_BK1A_3C_L, value );
923 value = SC_R2BYTE(0,REG_SC_BK1A_35_L);
924 SC_W2BYTE(0,REG_SC_BK1A_3D_L, value);
925 value = SC_R2BYTE(0,REG_SC_BK1A_36_L);
926 SC_W2BYTE(0,REG_SC_BK1A_3E_L, value );
927 value = SC_R2BYTE(0,REG_SC_BK1A_37_L);
928 SC_W2BYTE(0,REG_SC_BK1A_3F_L, value);
929 }
930
931 //CTI
932 {
933 value = SC_R2BYTE(0,REG_SC_BK23_60_L);
934 SC_W2BYTE(0,REG_SC_BK23_70_L, value );
935
936 value = SC_R2BYTE(0,REG_SC_BK23_61_L);
937 SC_W2BYTE(0,REG_SC_BK23_71_L, value );
938
939 value = SC_R2BYTE(0,REG_SC_BK23_62_L);
940 SC_W2BYTE(0,REG_SC_BK23_72_L, value );
941
942 value = SC_R2BYTE(0,REG_SC_BK23_63_L);
943 SC_W2BYTE(0,REG_SC_BK23_73_L, value );
944
945 value = SC_R2BYTE(0,REG_SC_BK23_64_L);
946 SC_W2BYTE(0,REG_SC_BK23_74_L, value );
947
948 value = SC_R2BYTE(0,REG_SC_BK23_65_L);
949 SC_W2BYTE(0,REG_SC_BK23_75_L, value );
950
951 value = SC_R2BYTE(0,REG_SC_BK23_66_L);
952 SC_W2BYTE(0,REG_SC_BK23_76_L, value );
953
954 value = SC_R2BYTE(0,REG_SC_BK23_67_L);
955 SC_W2BYTE(0,REG_SC_BK23_77_L, value );
956 }
957
958
959 //rgb2yuv enable flag
960 {
961 value = SC_R2BYTE(0,REG_SC_BK18_6E_L);
962 SC_W2BYTEMSK(0,REG_SC_BK18_6E_L, value << 4, BIT(4));
963 value = SC_R2BYTE(0,REG_SC_BK18_6F_L);
964 SC_W2BYTEMSK(0,REG_SC_BK18_6F_L, value << 4, BIT(4) | BIT(5));
965 }
966
967 //color matrix
968 {
969 value = SC_R2BYTE(0,REG_SC_BK2F_71_L);
970 SC_W2BYTE(0,REG_SC_BK2F_71_L, value );
971
972 value = SC_R2BYTE(0,REG_SC_BK2F_72_L);
973 SC_W2BYTE(0,REG_SC_BK2F_72_L, value );
974
975 value = SC_R2BYTE(0,REG_SC_BK2F_73_L);
976 SC_W2BYTE(0,REG_SC_BK2F_73_L, value );
977
978 value = SC_R2BYTE(0,REG_SC_BK2F_74_L);
979 SC_W2BYTE(0,REG_SC_BK2F_74_L, value );
980
981 value = SC_R2BYTE(0,REG_SC_BK2F_75_L);
982 SC_W2BYTE(0,REG_SC_BK2F_75_L, value );
983
984 value = SC_R2BYTE(0,REG_SC_BK2F_76_L);
985 SC_W2BYTE(0,REG_SC_BK2F_76_L,value);
986
987 value = SC_R2BYTE(0,REG_SC_BK2F_77_L);
988 SC_W2BYTE(0,REG_SC_BK2F_77_L, value );
989
990 value = SC_R2BYTE(0,REG_SC_BK2F_78_L);
991 SC_W2BYTE(0,REG_SC_BK2F_78_L,value );
992
993 value = SC_R2BYTE(0,REG_SC_BK2F_79_L);
994 SC_W2BYTE(0,REG_SC_BK2F_79_L,value );
995
996 value = SC_R2BYTE(0,REG_SC_BK2F_7A_L);
997 SC_W2BYTE(0,REG_SC_BK2F_7A_L,value);
998 }
999
1000 //DNR
1001 {
1002 value = SC_R2BYTE(0,REG_SC_BK06_21_L);
1003 SC_W2BYTE(0,REG_SC_BK06_01_L,value);
1004
1005 value = SC_R2BYTE(0,REG_SC_BK06_26_L);
1006 SC_W2BYTEMSK(0,REG_SC_BK06_06_L, value, 0x00FF);
1007
1008 value = SC_R2BYTE(0,REG_SC_BK06_27_L);
1009 SC_W2BYTE(0,REG_SC_BK06_07_L,value);
1010 }
1011
1012 //DBK
1013 {
1014 value = SC_R2BYTE(0,REG_SC_BK0C_10_L);
1015 SC_W2BYTEMSK(0,REG_SC_BK0C_10_L, value<<4, BIT(6) | BIT(5) | BIT(4));
1016
1017 value = SC_R2BYTE(0,REG_SC_BK0C_11_L);
1018 SC_W2BYTEMSK(0,REG_SC_BK0C_11_L, value<<8, 0xFF00);
1019
1020 value = SC_R2BYTE(0,REG_SC_BK0C_39_L);
1021 SC_W2BYTE(0,REG_SC_BK0C_3B_L,value);
1022
1023 value = SC_R2BYTE(0,REG_SC_BK0C_3A_L);
1024 SC_W2BYTEMSK(0,REG_SC_BK0C_3C_L,value,0x00FF);
1025
1026 value = SC_R2BYTE(0,REG_SC_BK0C_40_L);
1027 SC_W2BYTE(0,REG_SC_BK0C_43_L,value);
1028
1029 value = SC_R2BYTE(0,REG_SC_BK0C_41_L);
1030 SC_W2BYTE(0,REG_SC_BK0C_44_L,value);
1031
1032 value = SC_R2BYTE(0,REG_SC_BK0C_42_L);
1033 SC_W2BYTE(0,REG_SC_BK0C_46_L,value);
1034 }
1035
1036 //SNR
1037 {
1038 value = SC_R2BYTE(0,REG_SC_BK0C_30_L);
1039 SC_W2BYTEMSK(0,REG_SC_BK0C_30_L, value<<4, BIT(6) | BIT(5) | BIT(4));
1040
1041 value = SC_R2BYTE(0,REG_SC_BK0C_31_L);
1042 SC_W2BYTEMSK(0,REG_SC_BK0C_31_L, value<<8, 0x0F00);
1043 }
1044
1045 //NMR
1046 {
1047 value = SC_R2BYTE(0,REG_SC_BK0C_50_L);
1048 SC_W2BYTEMSK(0,REG_SC_BK0C_50_L, value<<4, BIT(5) | BIT(4));
1049
1050 value = SC_R2BYTE(0,REG_SC_BK0C_54_L);
1051 SC_W2BYTEMSK(0,REG_SC_BK0C_54_L, value<<8, 0xFF00);
1052 }
1053
1054 //HSP, VSP
1055 {
1056 value = SC_R2BYTE(0,REG_SC_BK23_0B_L);
1057 SC_W2BYTE(0,REG_SC_BK23_2B_L,value);
1058 }
1059
1060 //MemFormat
1061 {
1062 value = SC_R2BYTE(0,REG_SC_BK12_01_L);
1063 SC_W2BYTE(0,REG_SC_BK12_41_L, value);
1064
1065 value = SC_R2BYTE(0,REG_SC_BK12_02_L);
1066 SC_W2BYTE(0,REG_SC_BK12_42_L, value);
1067
1068 value = SC_R2BYTE(0,REG_SC_BK12_03_L);
1069 SC_W2BYTEMSK(0,REG_SC_BK12_43_L, value, 0x00FF);
1070
1071 value = SC_R2BYTE(0,REG_SC_BK23_0C_L);
1072 SC_W2BYTEMSK(0,REG_SC_BK23_2C_L, value, 0x00FF);
1073 }
1074
1075 //Peaking
1076 {
1077 value = SC_R2BYTE(0,REG_SC_BK19_10_L);
1078 SC_W2BYTE(0,REG_SC_BK19_14_L,value);
1079
1080 value = SC_R2BYTE(0,REG_SC_BK19_11_L);
1081 SC_W2BYTE(0,REG_SC_BK19_15_L,value);
1082
1083 value = SC_R2BYTE(0,REG_SC_BK19_12_L);
1084 SC_W2BYTE(0,REG_SC_BK19_16_L,value);
1085
1086 value = SC_R2BYTE(0,REG_SC_BK19_13_L);
1087 SC_W2BYTE(0,REG_SC_BK19_17_L,value);
1088 }
1089
1090 //Sharpness
1091 {
1092 value = SC_R2BYTE(0,REG_SC_BK19_18_L);
1093 SC_W2BYTE(0,REG_SC_BK19_28_L,value);
1094
1095 value = SC_R2BYTE(0,REG_SC_BK19_19_L);
1096 SC_W2BYTE(0,REG_SC_BK19_29_L,value);
1097
1098 value = SC_R2BYTE(0,REG_SC_BK19_1A_L);
1099 SC_W2BYTE(0,REG_SC_BK19_2A_L,value);
1100
1101 value = SC_R2BYTE(0,REG_SC_BK19_1B_L);
1102 SC_W2BYTE(0,REG_SC_BK19_2B_L,value);
1103
1104 value = SC_R2BYTE(0,REG_SC_BK19_1C_L);
1105 SC_W2BYTE(0,REG_SC_BK19_2C_L,value);
1106
1107 value = SC_R2BYTE(0,REG_SC_BK19_1D_L);
1108 SC_W2BYTE(0,REG_SC_BK19_2D_L,value);
1109
1110 value = SC_R2BYTE(0,REG_SC_BK19_1E_L);
1111 SC_W2BYTE(0,REG_SC_BK19_2E_L,value);
1112
1113 value = SC_R2BYTE(0,REG_SC_BK19_1F_L);
1114 SC_W2BYTE(0,REG_SC_BK19_2F_L,value);
1115 }
1116
1117 //ICC
1118 {
1119 value = SC_R2BYTE(0,REG_SC_BK18_30_L) ;
1120 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, value >> 4, (BIT(2)|BIT(3)));
1121 value = SC_R2BYTE(0,REG_SC_BK18_31_L);
1122 SC_W2BYTEMSK(0,REG_SC_BK18_31_L, (value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)|BIT(12)|BIT(13)|BIT(14)|BIT(15)));
1123 value = SC_R2BYTE(0,REG_SC_BK18_32_L);
1124 SC_W2BYTEMSK(0,REG_SC_BK18_32_L, ( value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)|BIT(12)|BIT(13)|BIT(14)|BIT(15)));
1125 value = SC_R2BYTE(0,REG_SC_BK18_33_L);
1126 SC_W2BYTEMSK(0,REG_SC_BK18_33_L, ( value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)|BIT(12)|BIT(13)|BIT(14)|BIT(15)));
1127 value = SC_R2BYTE(0,REG_SC_BK18_34_L);
1128 SC_W2BYTEMSK(0,REG_SC_BK18_34_L, (value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)));
1129 value = SC_R2BYTE(0,REG_SC_BK18_35_L);
1130 SC_W2BYTEMSK(0,REG_SC_BK18_35_L, (value << 8), 0xFF00);
1131 value = SC_R2BYTE(0,REG_SC_BK27_30_L) ;
1132 SC_W2BYTEMSK(0,REG_SC_BK27_30_L, value >> 1, (BIT(6)|BIT(0)));
1133 }
1134
1135 //IBC
1136 {
1137 value = SC_R2BYTE(0,REG_SC_BK18_40_L);
1138 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, value >> 1, BIT(6));
1139 value = SC_R2BYTE(0,REG_SC_BK18_41_L);
1140 SC_W2BYTE(0,REG_SC_BK18_45_L, value );
1141 value = SC_R2BYTE(0,REG_SC_BK18_42_L);
1142 SC_W2BYTE(0,REG_SC_BK18_46_L, value );
1143 value = SC_R2BYTE(0,REG_SC_BK18_43_L);
1144 SC_W2BYTE(0,REG_SC_BK18_47_L, value );
1145 value = SC_R2BYTE(0,REG_SC_BK18_44_L);
1146 SC_W2BYTEMSK(0,REG_SC_BK18_48_L, value ,(BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4)|BIT(5)));
1147 }
1148
1149 //IHC
1150 {
1151 value = SC_R2BYTE(0,REG_SC_BK18_60_L);
1152 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, value >> 1, BIT(6));
1153 value = SC_R2BYTE(0,REG_SC_BK18_61_L);
1154 SC_W2BYTE(0,REG_SC_BK18_65_L, value );
1155 value = SC_R2BYTE(0,REG_SC_BK18_62_L);
1156 SC_W2BYTE(0,REG_SC_BK18_66_L, value );
1157 value = SC_R2BYTE(0,REG_SC_BK18_63_L);
1158 SC_W2BYTE(0,REG_SC_BK18_67_L, value );
1159 value = SC_R2BYTE(0,REG_SC_BK18_64_L);
1160 SC_W2BYTEMSK(0,REG_SC_BK18_68_L, value, 0x00FF);
1161 }
1162
1163 //ACK
1164 {
1165 value = SC_R2BYTE(0,REG_SC_BK18_38_L);
1166 SC_W2BYTEMSK(0,REG_SC_BK18_38_L, value>>4, BIT(3) | BIT(2));
1167 }
1168
1169 //Y offset
1170 {
1171 value = SC_R2BYTE(0,REG_SC_BK1A_0F_L);
1172 SC_W2BYTEMSK(0,REG_SC_BK1A_0F_L, value<<8, 0xFF00);
1173 }
1174
1175 //Y/C gain
1176 {
1177 value = SC_R2BYTE(0,REG_SC_BK1A_14_L);
1178 SC_W2BYTE(0,REG_SC_BK1A_15_L,value);
1179
1180 value = SC_R2BYTE(0,REG_SC_BK1A_16_L);
1181 SC_W2BYTEMSK(0,REG_SC_BK1A_16_L, value<<8, 0xFF00);
1182 }
1183
1184 //DMS
1185 {
1186 value = SC_R2BYTE(0,REG_SC_BK26_10_L);
1187 SC_W2BYTE(0,REG_SC_BK26_14_L,value);
1188
1189 value = SC_R2BYTE(0,REG_SC_BK26_11_L);
1190 SC_W2BYTE(0,REG_SC_BK26_15_L,value);
1191
1192 value = SC_R2BYTE(0,REG_SC_BK26_12_L);
1193 SC_W2BYTE(0,REG_SC_BK26_16_L,value);
1194
1195 value = SC_R2BYTE(0,REG_SC_BK26_13_L);
1196 SC_W2BYTE(0,REG_SC_BK26_17_L,value);
1197
1198 value = SC_R2BYTE(0,REG_SC_BK26_18_L);
1199 SC_W2BYTE(0,REG_SC_BK26_1B_L,value);
1200 }
1201
1202 //Spike NR
1203 {
1204 value = SC_R2BYTE(0,REG_SC_BK26_50_L);
1205 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, value<<4, 0X00F0);
1206 }
1207
1208 //Bri
1209 {
1210 value = SC_R2BYTE(0,REG_SC_BK10_16_L);
1211 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, BIT(8));
1212
1213 value = SC_R2BYTE(0,REG_SC_BK0F_36_L);
1214 SC_W2BYTE(0,REG_SC_BK0F_39_L, value );
1215
1216 value = SC_R2BYTE(0,REG_SC_BK0F_37_L);
1217 SC_W2BYTE(0,REG_SC_BK0F_3A_L, value );
1218
1219 value = SC_R2BYTE(0,REG_SC_BK0F_38_L);
1220 SC_W2BYTE(0,REG_SC_BK0F_3B_L, value );
1221 }
1222
1223 //Gamma
1224 {
1225 value = SC_R2BYTE(0,REG_SC_BK10_50_L);
1226 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, BIT(0));
1227 }
1228
1229 //DLC
1230 {
1231 value = SC_R2BYTE(0,REG_SC_BK1A_04_L);
1232 SC_W2BYTEMSK(0,REG_SC_BK1A_04_L, value >> 1 , BIT(0) | BIT(6));
1233 }
1234
1235 //BLE&WLE
1236 {
1237 // copy BLE
1238 value = SC_R2BYTE(0,REG_SC_BK1A_10_L);
1239 SC_W2BYTE(0,REG_SC_BK1A_12_L, value );
1240 // copy WLE
1241 value = SC_R2BYTE(0,REG_SC_BK1A_11_L);
1242 SC_W2BYTE(0,REG_SC_BK1A_13_L, value );
1243 }
1244
1245 //HBC
1246 {
1247 value = SC_R2BYTE(0,REG_SC_BK10_16_L);
1248 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, 0xFF00);
1249 }
1250
1251 //Color temp
1252 {
1253 value = SC_R2BYTE(0,REG_SC_BK25_21_L);
1254 SC_W2BYTEMSK(0,REG_SC_BK25_27_L, value, 0x07ff);
1255 value = SC_R2BYTE(0,REG_SC_BK25_22_L);
1256 SC_W2BYTEMSK(0,REG_SC_BK25_28_L, value, 0x07ff);
1257 value = SC_R2BYTE(0,REG_SC_BK25_23_L);
1258 SC_W2BYTEMSK(0,REG_SC_BK25_29_L, value, 0x07ff);
1259
1260 value = SC_R2BYTE(0,REG_SC_BK25_24_L);
1261 SC_W2BYTEMSK(0,REG_SC_BK25_2A_L, value, 0x0fff);
1262 value = SC_R2BYTE(0,REG_SC_BK25_25_L);
1263 SC_W2BYTEMSK(0,REG_SC_BK25_2B_L, value, 0x0fff);
1264 value = SC_R2BYTE(0,REG_SC_BK25_26_L);
1265 SC_W2BYTEMSK(0,REG_SC_BK25_2C_L, value, 0x0fff);
1266 value = SC_R2BYTE(0,REG_SC_BK25_01_L);
1267 SC_W2BYTEMSK(0,REG_SC_BK25_11_L, value, 0x00ff);
1268 }
1269
1270 if(enWeaveType & E_ACE_WEAVETYPE_H)
1271 {
1272 SC_W2BYTEMSK(0,REG_SC_BK23_54_L, 0x00 ,0x80);//disable HDSDD
1273 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, 0x00 ,0xFF);//disable snr_vertical vertical c low pass and spike NR
1274 SC_W2BYTEMSK(0,REG_SC_BK0C_70_L, 0x01 ,0x01);//SPF off
1275 SC_W2BYTEMSK(0,REG_SC_BK0C_10_L, 0x00 ,0x17);//disable SPF DBK
1276 SC_W2BYTE(0,REG_SC_BK0C_30_L, 0x0000);//disable SPF SNR
1277 SC_W2BYTE(0,REG_SC_BK0C_50_L, 0x0000);//disable SPF NMR
1278 SC_W2BYTE(0,REG_SC_BK26_10_L, 0x0000);//disable SPF DMS
1279 SC_W2BYTEMSK(0,REG_SC_BK23_0B_L, 0x00 ,0xFF00);//disable vsp filter
1280 SC_W2BYTEMSK(0,REG_SC_BK23_0C_L, 0x00 ,0x0C00);//disable VSP CoRing
1281 SC_W2BYTEMSK(0,REG_SC_BK23_11_L, 0x00 ,0x80);//disable VSP DeRing
1282 SC_W2BYTEMSK(0,REG_SC_BK23_13_L, 0x00 ,0x08);//disable VSP PreVBound
1283 SC_W2BYTE(0,REG_SC_BK19_12_L, 0x0000);//disable VNMR and VLPF
1284 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00 ,0x01);//disable VNMR Y lowY
1285 SC_W2BYTEMSK(0,REG_SC_BK19_10_L, 0x00 ,0x7000);//disable vertical peaking band
1286 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, 0x00 ,0x10);//disable vertical adaptive peaking band
1287 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, 0x00 ,0x01);//disable Post SNR
1288 }
1289 if(enWeaveType & E_ACE_WEAVETYPE_V)
1290 {
1291 SC_W2BYTEMSK(0,REG_SC_BK22_08_L, 0x00 ,0xFF00);
1292 // diable H scaling filter
1293 SC_W2BYTEMSK(0,REG_SC_BK23_0B_L, 0x00 ,0x00FF);
1294 // RGB 8bits
1295 SC_W2BYTEMSK(0,REG_SC_BK12_01_L, 0x10 ,0x00FF);
1296 SC_W2BYTEMSK(0,REG_SC_BK12_02_L, 0x00 ,0xFF00);
1297 // disable 422To444
1298 SC_W2BYTEMSK(0,REG_SC_BK23_0C_L, 0x40 ,0x00FF);
1299 // disable 444To422
1300 SC_W2BYTEMSK(0,REG_SC_BK02_0A_L, 0x00 ,0x00FF);
1301 // disable DNR
1302 SC_W2BYTEMSK(0,REG_SC_BK06_21_L, 0x10 ,0x00FF);
1303 // disable 2D peaking
1304 SC_W2BYTEMSK(0,REG_SC_BK19_10_L, 0x80 ,0x00FF);
1305 // disable Precti
1306 SC_W2BYTE(0,REG_SC_BK23_60_L, 0x00);
1307 SC_W2BYTE(0,REG_SC_BK23_61_L, 0x00);
1308 // disable Postcti
1309 SC_W2BYTE(0,REG_SC_BK27_20_L, 0x00);
1310 SC_W2BYTE(0,REG_SC_BK27_21_L, 0x00);
1311 SC_W2BYTE(0,REG_SC_BK18_50_L, 0x00);
1312 }
1313 }
1314
1315
Hal_ACE_MWEEnable(void * pInstance,MS_BOOL ben,MS_BOOL bLoadFromTable)1316 void Hal_ACE_MWEEnable(void* pInstance, MS_BOOL ben, MS_BOOL bLoadFromTable)
1317 {
1318 if (ben)
1319 {
1320 if(!bLoadFromTable)
1321 {
1322 MHal_SC_SetMWEQuality(pInstance);
1323 }
1324 if(MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED)
1325 {
1326
1327 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK20_10_L, BIT(1) | BIT(2) , BIT(1) | BIT(2) );
1328 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK2F_20_L, 0x00, BIT(2));
1329 MApi_XC_MLoad_Fire(pInstance,TRUE);
1330
1331 }
1332 else
1333 {
1334 SC_W2BYTEMSK(0,REG_SC_BK20_10_L, BIT(1) | BIT(2) , BIT(1) | BIT(2) );
1335 SC_W2BYTEMSK(0,REG_SC_BK2F_20_L, 0x00, BIT(2));
1336 }
1337 }
1338 else
1339 {
1340 if(MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED)
1341 {
1342
1343 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK20_10_L, 0x00, BIT(1) | BIT(2) );
1344 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK2F_20_L, BIT(2), BIT(2));
1345 MApi_XC_MLoad_Fire(pInstance,TRUE);
1346
1347 }
1348 else
1349 {
1350 SC_W2BYTEMSK(0,REG_SC_BK20_10_L, 0x00, BIT(1) | BIT(2) );
1351 SC_W2BYTEMSK(0,REG_SC_BK2F_20_L, BIT(2), BIT(2));
1352 }
1353 }
1354 }
1355
Hal_ACE_MWESetBorder(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16color,MS_U16 u16_l,MS_U16 u16_r,MS_U16 u16_t,MS_U16 u16_d)1356 void Hal_ACE_MWESetBorder( void* pInstance, MS_BOOL bScalerWin, MS_U16 u16color, MS_U16 u16_l, MS_U16 u16_r, MS_U16 u16_t, MS_U16 u16_d)
1357 {
1358 if(bScalerWin == MAIN_WINDOW)
1359 {
1360 SC_W2BYTEMSK(0,REG_SC_BK10_24_L, ((u16color & 0xFF) <<8), HBMASK);
1361 SC_W2BYTEMSK(0,REG_SC_BK0F_02_L, ((u16_l & 0xFF) <<8), HBMASK);
1362 SC_W2BYTEMSK(0,REG_SC_BK0F_03_L, ((u16_r & 0xFF) <<8), HBMASK);
1363 SC_W2BYTEMSK(0,REG_SC_BK0F_04_L, ((u16_t & 0xFF) <<8), HBMASK);
1364 SC_W2BYTEMSK(0,REG_SC_BK0F_05_L, ((u16_d & 0xFF) <<8), HBMASK);
1365 }
1366 else
1367 {
1368 SC_W2BYTEMSK(0,REG_SC_BK0F_17_L, u16color & 0xFF, LBMASK);
1369 SC_W2BYTEMSK(0,REG_SC_BK0F_02_L, u16_l & 0xFF, LBMASK);
1370 SC_W2BYTEMSK(0,REG_SC_BK0F_03_L, u16_r & 0xFF, LBMASK);
1371 SC_W2BYTEMSK(0,REG_SC_BK0F_04_L, u16_t & 0xFF, LBMASK);
1372 SC_W2BYTEMSK(0,REG_SC_BK0F_05_L, u16_d & 0xFF, LBMASK);
1373 }
1374 }
1375 ////////////////////////////////////////////////////////////////////////////////
1376 //
1377 // MWE end
1378 //
1379 ////////////////////////////////////////////////////////////////////////////////
1380
1381
1382 ////////////////////////////////////////////////////////////////////////////////
1383 //
1384 // DynamicNR start
1385 //
1386 ////////////////////////////////////////////////////////////////////////////////
1387
Hal_ACE_DNR_GetMotion(void * pInstance)1388 MS_U8 Hal_ACE_DNR_GetMotion(void* pInstance)
1389 {
1390 MS_U8 u8motion = (MS_U8)(SC_R2BYTE(0,REG_SC_BK0A_1A_L) & 0x007F);
1391 return u8motion;
1392 }
1393
Hal_ACE_DNR_GetCoringThreshold(void * pInstance,MS_BOOL bScalerWin)1394 MS_U8 Hal_ACE_DNR_GetCoringThreshold(void* pInstance, MS_BOOL bScalerWin)
1395 {
1396 MS_U8 u8val;
1397
1398 if(bScalerWin == MAIN_WINDOW)
1399 {
1400 u8val = SC_R2BYTE(0,REG_SC_BK19_13_L) & 0xFF;
1401 }
1402 else
1403 {
1404 u8val = SC_R2BYTE(0,REG_SC_BK19_17_L) & 0xFF;
1405 }
1406
1407 return u8val;
1408 }
1409
Hal_ACE_DNR_GetSharpnessAdjust(void * pInstance,MS_BOOL bScalerWin)1410 MS_U8 Hal_ACE_DNR_GetSharpnessAdjust(void* pInstance, MS_BOOL bScalerWin)
1411 {
1412 MS_U8 u8val;
1413
1414 if(bScalerWin == MAIN_WINDOW)
1415 {
1416 u8val = ((SC_R2BYTE(0,REG_SC_BK19_13_L) & 0xFF00)>>8);
1417 }
1418 else
1419 {
1420 u8val = ((SC_R2BYTE(0,REG_SC_BK19_17_L) & 0xFF00)>>8);
1421 }
1422
1423 return u8val;
1424 }
1425
Hal_ACE_DNR_GetGuassin_SNR_Threshold(void * pInstance,MS_BOOL bScalerWin)1426 MS_U8 Hal_ACE_DNR_GetGuassin_SNR_Threshold(void* pInstance, MS_BOOL bScalerWin)
1427 {
1428 MS_U8 u8val;
1429
1430 if(bScalerWin == MAIN_WINDOW)
1431 {
1432 u8val = ((SC_R2BYTE(0,REG_SC_BK19_60_L) & 0xFF00)>>8);
1433 }
1434 else
1435 {
1436 u8val = ((SC_R2BYTE(0,REG_SC_BK19_61_L) & 0xFF00)>>8);
1437 }
1438
1439 return u8val;
1440 }
1441
Hal_ACE_DNR_SetCoringThreshold(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1442 void Hal_ACE_DNR_SetCoringThreshold(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1443 {
1444 if(bScalerWin == MAIN_WINDOW)
1445 {
1446 SC_W2BYTEMSK(0,REG_SC_BK19_13_L, u16val, 0x00FF);
1447 }
1448 else
1449 {
1450 SC_W2BYTEMSK(0,REG_SC_BK19_17_L, u16val, 0x00FF);
1451 }
1452 }
1453
Hal_ACE_DNR_SetSharpnessAdjust(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1454 void Hal_ACE_DNR_SetSharpnessAdjust(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1455 {
1456 if(bScalerWin == MAIN_WINDOW)
1457 {
1458 SC_W2BYTEMSK(0,REG_SC_BK19_13_L, (u16val<<8), 0xFF00);
1459 }
1460 else
1461 {
1462 SC_W2BYTEMSK(0,REG_SC_BK19_17_L, (u16val<<8), 0xFF00);
1463 }
1464 }
1465
Hal_ACE_DNR_SetNM_V(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1466 void Hal_ACE_DNR_SetNM_V(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1467 {
1468 if(bScalerWin == MAIN_WINDOW)
1469 {
1470 SC_W2BYTEMSK(0,REG_SC_BK19_12_L, u16val, 0x00FF);
1471 }
1472 else
1473 {
1474 SC_W2BYTEMSK(0,REG_SC_BK19_16_L, u16val, 0x00FF);
1475 }
1476 }
1477
Hal_ACE_DNR_SetGNR_0(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1478 void Hal_ACE_DNR_SetGNR_0(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1479 {
1480 if(bScalerWin == MAIN_WINDOW)
1481 {
1482 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, u16val, 0x00FF);
1483 }
1484 else
1485 {
1486 SC_W2BYTEMSK(0,REG_SC_BK19_61_L, u16val, 0x00FF);
1487 }
1488 }
1489
Hal_ACE_DNR_SetGNR_1(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1490 void Hal_ACE_DNR_SetGNR_1(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1491 {
1492 if(bScalerWin == MAIN_WINDOW)
1493 {
1494 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, (u16val<<8), 0xFF00);
1495 }
1496 else
1497 {
1498 SC_W2BYTEMSK(0,REG_SC_BK19_61_L, (u16val<<8), 0xFF00);
1499 }
1500 }
1501
Hal_ACE_DNR_SetCP(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1502 void Hal_ACE_DNR_SetCP(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1503 {
1504 if(bScalerWin == MAIN_WINDOW)
1505 {
1506 SC_W2BYTEMSK(0,REG_SC_BK19_30_L, u16val, 0x00C1); // BIT(0), BIT(1) are reserved.
1507 }
1508 else
1509 {
1510 SC_W2BYTEMSK(0,REG_SC_BK19_30_L, u16val, 0x000E); // BIT(0), BIT(1) are reserved.
1511 }
1512 }
1513
Hal_ACE_DNR_SetDP(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1514 void Hal_ACE_DNR_SetDP(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1515 {
1516 if(bScalerWin == MAIN_WINDOW)
1517 {
1518 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, u16val, 0x00FF);
1519 }
1520 else
1521 {
1522 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, (u16val<<8), 0xFF00);
1523 }
1524 }
1525
Hal_ACE_DNR_SetNM_H_0(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1526 void Hal_ACE_DNR_SetNM_H_0(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1527 {
1528 if(bScalerWin == MAIN_WINDOW)
1529 {
1530 SC_W2BYTEMSK(0,REG_SC_BK18_55_L, u16val, 0x00FF);
1531 }
1532 else
1533 {
1534 SC_W2BYTEMSK(0,REG_SC_BK18_5D_L, u16val, 0x00FF);
1535 }
1536 }
1537
Hal_ACE_DNR_SetNM_H_1(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1538 void Hal_ACE_DNR_SetNM_H_1(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1539 {
1540 if(bScalerWin == MAIN_WINDOW)
1541 {
1542 SC_W2BYTEMSK(0,REG_SC_BK18_55_L, (u16val<<8), 0xFF00);
1543 }
1544 else
1545 {
1546 SC_W2BYTEMSK(0,REG_SC_BK18_5D_L, (u16val<<8), 0xFF00);
1547 }
1548 }
1549
Hal_ACE_DNR_SetGray_Ground_Gain(void * pInstance,MS_U16 u16val)1550 void Hal_ACE_DNR_SetGray_Ground_Gain(void* pInstance, MS_U16 u16val)
1551 {
1552 SC_W2BYTEMSK(0,REG_SC_BK18_21_L, (u16val<<8), 0xF000);
1553 }
1554
Hal_ACE_DNR_SetGray_Ground_En(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1555 void Hal_ACE_DNR_SetGray_Ground_En(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1556 {
1557 if(bScalerWin == MAIN_WINDOW)
1558 {
1559 SC_W2BYTEMSK(0,REG_SC_BK18_10_L, (u16val?(BIT(7)):(0)), 0x0080);
1560 }
1561 else
1562 {
1563 SC_W2BYTEMSK(0,REG_SC_BK18_11_L, (u16val?(BIT(7)):(0)), 0x0080);
1564 }
1565 }
1566
Hal_ACE_DNR_SetSC_Coring(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1567 void Hal_ACE_DNR_SetSC_Coring(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1568 {
1569 if(bScalerWin == MAIN_WINDOW)
1570 {
1571 SC_W2BYTEMSK(0,REG_SC_BK23_0D_L, (u16val<<8), 0xFF00); // BK23_1B (8bit address)
1572 }
1573 else
1574 {
1575 SC_W2BYTEMSK(0,REG_SC_BK23_2D_L, (u16val<<8), 0xFF00);
1576 }
1577 }
1578
Hal_ACE_DNR_SetSpikeNR_0(void * pInstance,MS_U16 u16val)1579 void Hal_ACE_DNR_SetSpikeNR_0(void* pInstance, MS_U16 u16val)
1580 {
1581 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, u16val, 0x0001);
1582 }
1583
Hal_ACE_DNR_SetSpikeNR_1(void * pInstance,MS_U16 u16val)1584 void Hal_ACE_DNR_SetSpikeNR_1(void* pInstance, MS_U16 u16val)
1585 {
1586 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, (u16val<<8), 0x0F00); //BK26_A0 (8bit address)
1587 SC_W2BYTEMSK(0,REG_SC_BK26_53_L, (u16val>>5), 0x0007); //BK26_A6 (8bit address)
1588 }
1589
Hal_ACE_DNR_SetSNR_NM(void * pInstance,MS_U16 u16val)1590 void Hal_ACE_DNR_SetSNR_NM(void* pInstance, MS_U16 u16val)
1591 {
1592 SC_W2BYTEMSK(0,REG_SC_BK0C_54_L, u16val, 0x00FF);
1593 }
1594
Hal_ACE_DNR_SetBank_Coring(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1595 void Hal_ACE_DNR_SetBank_Coring(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1596 {
1597 if(bScalerWin == MAIN_WINDOW)
1598 {
1599 SC_W2BYTE(0,REG_SC_BK19_33_L, u16val);
1600 SC_W2BYTE(0,REG_SC_BK19_34_L, u16val);
1601 }
1602 else
1603 {
1604 SC_W2BYTE(0,REG_SC_BK19_35_L, u16val);
1605 SC_W2BYTE(0,REG_SC_BK19_36_L, u16val);
1606 }
1607 }
1608
1609
Hal_ACE_DNR_SetGuassin_SNR_Threshold(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1610 void Hal_ACE_DNR_SetGuassin_SNR_Threshold(void* pInstance, MS_BOOL bScalerWin, MS_U16 u16val)
1611 {
1612 if(bScalerWin == MAIN_WINDOW)
1613 {
1614 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, (u16val<<8), 0xFF00);
1615 }
1616 else
1617 {
1618 SC_W2BYTEMSK(0,REG_SC_BK19_61_L, (u16val<<8), 0xFF00);
1619 }
1620 }
1621
Hal_ACE_DNR_SetNRTbl_Y(void * pInstance,MS_U8 u8Idx,MS_U16 u16val)1622 void Hal_ACE_DNR_SetNRTbl_Y(void* pInstance, MS_U8 u8Idx, MS_U16 u16val)
1623 {
1624 SC_W2BYTE(0,(REG_SC_BK06_40_L+u8Idx), u16val);
1625 }
1626
Hal_ACE_DNR_SetNRTbl_C(void * pInstance,MS_U8 u8Idx,MS_U16 u16val)1627 void Hal_ACE_DNR_SetNRTbl_C(void* pInstance, MS_U8 u8Idx, MS_U16 u16val)
1628 {
1629 SC_W2BYTE(0,(REG_SC_BK06_44_L+u8Idx), u16val);
1630 }
1631
1632 // Write command by Menuload
Hal_ACE_Write_Color_Matrix_Burst(void * pInstance,MS_BOOL bWindow,MS_U16 * psMatrix)1633 void Hal_ACE_Write_Color_Matrix_Burst( void* pInstance, MS_BOOL bWindow, MS_U16* psMatrix )
1634 {
1635 MS_U8 i,j;
1636 MS_U32 ucAddr;
1637 MS_S16 sTmp;
1638 //DECLARA_BANK_VARIABLE
1639
1640 //BACKUP_SC_BANK
1641 if( bWindow == MAIN_WINDOW )
1642 {
1643 //SET_SC_BANK(BANK_CM_MAIN);
1644 ucAddr = REG_SC_BK2F_71_L;
1645 }
1646 else
1647 {
1648 //SET_SC_BANK(BANK_CM_SUB);
1649 ucAddr = REG_SC_BK63_51_L;
1650
1651 }
1652
1653 for(i=0; i!=3; i++)
1654 {
1655 for(j=0; j!=3; j++)
1656 {
1657 sTmp = psMatrix[i*3+j];
1658 if( sTmp >= 0 )
1659 {
1660 if( sTmp > 0xfff )
1661 {
1662 sTmp = 0xfff;
1663 }
1664
1665 }
1666 else
1667 {
1668 sTmp = sTmp * -1;
1669 if( sTmp > 0xfff )
1670 {
1671 sTmp = 0xfff;
1672 }
1673 sTmp |= 0x1000;
1674
1675 }
1676 MApi_XC_MLoad_WriteCmd(pInstance, ucAddr, sTmp , 0x1FFF);
1677
1678 ucAddr += 2;
1679 } // for
1680 } // for
1681 MApi_XC_MLoad_Fire(pInstance,TRUE);
1682
1683
1684
1685 }
1686
1687 // Write command by Menuload
Hal_ACE_Is_Support_MLoad(void * pInstance)1688 MS_BOOL Hal_ACE_Is_Support_MLoad( void* pInstance )
1689 {
1690 if (MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED)
1691 return TRUE;
1692 else
1693 return FALSE;
1694 }
1695
1696 //-------------------------------------------------------------------------------------------------
1697 // Skip Wait Vsync
1698 // @param eWindow \b IN: Indicates the window where the ACE function applies to.
1699 // @param Skip wait Vsync \b IN: Disable wait Vsync
1700 //-------------------------------------------------------------------------------------------------
Hal_ACE_SetSkipWaitVsync(void * pInstance,MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)1701 void Hal_ACE_SetSkipWaitVsync( void* pInstance, MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)
1702 {
1703
1704 if(eWindow == MAIN_WINDOW )
1705 {
1706 bMainWinSkipWaitVsyn= bIsSkipWaitVsyn;
1707 }
1708 else
1709 {
1710 bSubWinSkipWaitVsyn = bIsSkipWaitVsyn;
1711 }
1712 }
1713
Hal_ACE_GetSkipWaitVsync(void * pInstance,MS_BOOL bScalerWin)1714 MS_BOOL Hal_ACE_GetSkipWaitVsync( void* pInstance, MS_BOOL bScalerWin)
1715 {
1716 if(bScalerWin == MAIN_WINDOW)
1717 {
1718 return bMainWinSkipWaitVsyn;
1719 }
1720 else
1721 {
1722 return bSubWinSkipWaitVsyn;
1723 }
1724 }
1725
HAL_ACE_Set_RBChannelOffset(void * pInstance,MS_BOOL bScalerWin,MS_BOOL bEnable)1726 void HAL_ACE_Set_RBChannelOffset(void* pInstance, MS_BOOL bScalerWin, MS_BOOL bEnable)
1727 {
1728 ACE_INSTANCE_PRIVATE *psACEInstPri = NULL;
1729 UtopiaInstanceGetPrivate(pInstance, (void**)&psACEInstPri);
1730 MS_U32 u32deviceID = psACEInstPri->u32DeviceID;
1731
1732 if(bEnable)
1733 {
1734 if(bScalerWin == MAIN_WINDOW)
1735 {
1736 SC_W2BYTE(u32deviceID, REG_SC_BK0F_36_L, 0x600);
1737 SC_W2BYTE(u32deviceID, REG_SC_BK0F_38_L, 0x600);
1738 }
1739 else
1740 {
1741 SC_W2BYTE(u32deviceID, REG_SC_BK0F_39_L, 0x600);
1742 SC_W2BYTE(u32deviceID, REG_SC_BK0F_3B_L, 0x600);
1743 }
1744 }
1745 else
1746 {
1747 if(bScalerWin == MAIN_WINDOW)
1748 {
1749 SC_W2BYTE(u32deviceID, REG_SC_BK0F_36_L, 0x400);
1750 SC_W2BYTE(u32deviceID, REG_SC_BK0F_38_L, 0x400);
1751 }
1752 else
1753 {
1754 SC_W2BYTE(u32deviceID, REG_SC_BK0F_39_L, 0x400);
1755 SC_W2BYTE(u32deviceID, REG_SC_BK0F_3B_L, 0x400);
1756 }
1757 }
1758 }
1759
Hal_ACE_Set_Device_Bank_Offset(void)1760 void Hal_ACE_Set_Device_Bank_Offset(void)
1761 {
1762 memset(u32XCDeviceBankOffset, 0, sizeof(MS_U32)*XC_ACE_SUPPORT_DEVICE_NUM);
1763 u32XCDeviceBankOffset[XC_ACE_DEVICE0] = E_HALACE_DEVICE0_XC_BANK_OFFSET; // Set SC0 reg bank offset
1764 u32XCDeviceBankOffset[XC_ACE_DEVICE1] = E_HALACE_DEVICE1_XC_BANK_OFFSET; // Set SC1 reg bank offset
1765 }
1766
1767
1768 ////////////////////////////////////////////////////////////////////////////////
1769 //
1770 // DynamicNR end
1771 //
1772 ////////////////////////////////////////////////////////////////////////////////
1773
1774 #undef MHAL_ACE_C
1775
1776