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 #include <string.h>
104
105 // Internal Definition
106 #include "apiXC_Ace.h"
107 #include "mhal_ace.h"
108 #include "ace_hwreg_utility2.h"
109 #include "drvACE.h"
110 #include "hwreg_ace.h"
111 //-------------------------------------------------------------------------------------------------
112 // Driver Compiler Options
113 //-------------------------------------------------------------------------------------------------
114
115
116 //-------------------------------------------------------------------------------------------------
117 // Local Defines
118 //-------------------------------------------------------------------------------------------------
119
120 #define MAIN_WINDOW 0
121 #define SUB_WINDOW 1
122
123 //-------------------------------------------------------------------------------------------------
124 // Local Structures
125 //-------------------------------------------------------------------------------------------------
126
127
128 //-------------------------------------------------------------------------------------------------
129 // Global Variables
130 //-------------------------------------------------------------------------------------------------
131
132 static MS_BOOL bMainWinSkipWaitVsyn = 0, bSubWinSkipWaitVsyn = 0;
133
134 //-------------------------------------------------------------------------------------------------
135 // Local Variables
136 //-------------------------------------------------------------------------------------------------
137
138
139 //-------------------------------------------------------------------------------------------------
140 // Debug Functions
141 //-------------------------------------------------------------------------------------------------
142
143
144 //-------------------------------------------------------------------------------------------------
145 // Local Functions
146 //-------------------------------------------------------------------------------------------------
147
148 //-------------------------------------------------------------------------------------------------
149 // Global Functions
150 //-------------------------------------------------------------------------------------------------
151
Hal_ACE_DMS(void * pInstance,MS_BOOL bScalerWin,MS_BOOL bisATV)152 void Hal_ACE_DMS(void* pInstance, MS_BOOL bScalerWin, MS_BOOL bisATV )
153 {
154 if(bisATV)
155 {
156 if(bScalerWin == MAIN_WINDOW)
157 {
158 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x01, 0x01);
159 SC_W2BYTEMSK(0,REG_SC_BK18_71_L, 0x20, LBMASK);
160 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x06, LBMASK);
161 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x01 <<8, HBMASK);
162
163 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x01, 0x01);
164 SC_W2BYTEMSK(0,REG_SC_BK19_7C_L, 0x20, LBMASK);
165 SC_W2BYTEMSK(0,REG_SC_BK19_7D_L, 0x06, LBMASK);
166 }
167 else
168 {
169 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x10, 0x10);
170 SC_W2BYTEMSK(0,REG_SC_BK18_73_L, 0x20, LBMASK);
171 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x06, LBMASK);
172 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x01 <<8, HBMASK);
173
174 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x10, 0x10);
175 SC_W2BYTEMSK(0,REG_SC_BK19_7E_L, 0x20, LBMASK);
176 SC_W2BYTEMSK(0,REG_SC_BK19_7F_L, 0x06, LBMASK);
177 }
178 }
179 else
180 {
181 if(bScalerWin == MAIN_WINDOW)
182 {
183 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x00, 0x01);
184 SC_W2BYTEMSK(0,REG_SC_BK18_71_L, 0x00, LBMASK);
185 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x00, LBMASK);
186 SC_W2BYTEMSK(0,REG_SC_BK18_72_L, 0x00 <<8, HBMASK);
187
188 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00, 0x01);
189 SC_W2BYTEMSK(0,REG_SC_BK19_7C_L, 0x00, LBMASK);
190 SC_W2BYTEMSK(0,REG_SC_BK19_7D_L, 0x00, LBMASK);
191 }
192 else
193 {
194 SC_W2BYTEMSK(0,REG_SC_BK18_70_L, 0x00, 0x10);
195 SC_W2BYTEMSK(0,REG_SC_BK18_73_L, 0x00, LBMASK);
196 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x00, LBMASK);
197 SC_W2BYTEMSK(0,REG_SC_BK18_74_L, 0x00 <<8, HBMASK);
198
199 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00, 0x10);
200 SC_W2BYTEMSK(0,REG_SC_BK19_7E_L, 0x00, LBMASK);
201 SC_W2BYTEMSK(0,REG_SC_BK19_7F_L, 0x00, LBMASK);
202 }
203 }
204 }
205
206 MS_U32 _ACE_RIU_BASE;
207
208 // Put this function here because hwreg_utility2 only for hal.
Hal_ACE_init_riu_base(MS_U32 u32riu_base)209 void Hal_ACE_init_riu_base(MS_U32 u32riu_base)
210 {
211 _ACE_RIU_BASE = u32riu_base;
212 }
213
Hal_ACE_SetSharpness(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8Sharpness)214 void Hal_ACE_SetSharpness(void* pInstance, MS_BOOL bScalerWin, MS_U8 u8Sharpness)
215 {
216 if((MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED) && (!Hal_ACE_GetSkipWaitVsync(pInstance, bScalerWin)))
217 {
218
219
220 if(bScalerWin == MAIN_WINDOW)
221 {
222 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK19_13_L, (u8Sharpness)<<8, 0x7F00); // 7 bit sharpness!
223 }
224 else
225 {
226 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK19_17_L, (u8Sharpness)<<8, 0x7F00);
227 }
228 MApi_XC_MLoad_Fire(pInstance,TRUE);
229
230 }
231 else
232 {
233 if(bScalerWin == MAIN_WINDOW)
234 {
235 SC_W2BYTEMSK(0,REG_SC_BK19_13_L, (u8Sharpness)<<8, 0x7F00); // 7 bit sharpness!
236 }
237 else
238 {
239 SC_W2BYTEMSK(0,REG_SC_BK19_17_L, (u8Sharpness)<<8, 0x7F00);
240 }
241 }
242 }
243
Hal_ACE_SetBrightness(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8RedBrightness,MS_U8 u8GreenBrightness,MS_U8 u8BlueBrightness)244 void Hal_ACE_SetBrightness(void* pInstance, MS_BOOL bScalerWin, MS_U8 u8RedBrightness, MS_U8 u8GreenBrightness, MS_U8 u8BlueBrightness )
245 {
246 if((MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED) && (!Hal_ACE_GetSkipWaitVsync(pInstance, bScalerWin)))
247 {
248
249 if(bScalerWin == MAIN_WINDOW)
250 {
251 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_36_L, ((MS_U16)u8RedBrightness<<3), 0xFFFF );
252 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_37_L, ((MS_U16)u8GreenBrightness<<3), 0xFFFF );
253 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_38_L, ((MS_U16)u8BlueBrightness<<3), 0xFFFF );
254 }
255 else
256 {
257 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_39_L, ((MS_U16)u8RedBrightness<<3), 0xFFFF );
258 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_3A_L, ((MS_U16)u8GreenBrightness<<3), 0xFFFF );
259 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_3B_L, ((MS_U16)u8BlueBrightness<<3), 0xFFFF );
260 }
261 MApi_XC_MLoad_Fire(pInstance,TRUE);
262
263
264 }
265 else
266 {
267 if(bScalerWin == MAIN_WINDOW)
268 {
269 SC_W2BYTE(0,REG_SC_BK0F_36_L, ((MS_U16)u8RedBrightness<<3) );
270 SC_W2BYTE(0,REG_SC_BK0F_37_L, ((MS_U16)u8GreenBrightness<<3) );
271 SC_W2BYTE(0,REG_SC_BK0F_38_L, ((MS_U16)u8BlueBrightness<<3) );
272 }
273 else
274 {
275 SC_W2BYTE(0,REG_SC_BK0F_39_L, ((MS_U16)u8RedBrightness<<3) );
276 SC_W2BYTE(0,REG_SC_BK0F_3A_L, ((MS_U16)u8GreenBrightness<<3) );
277 SC_W2BYTE(0,REG_SC_BK0F_3B_L, ((MS_U16)u8BlueBrightness<<3) );
278 }
279 }
280 }
281
Hal_ACE_SetBrightnessPrecise(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedBrightness,MS_U16 u16GreenBrightness,MS_U16 u16BlueBrightness)282 void Hal_ACE_SetBrightnessPrecise(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16RedBrightness, MS_U16 u16GreenBrightness, MS_U16 u16BlueBrightness)
283 {
284 if(MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED)
285 {
286
287 if(bScalerWin == MAIN_WINDOW)
288 {
289 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_36_L, u16RedBrightness, 0xFFFF);
290 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_37_L, u16GreenBrightness, 0xFFFF);
291 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_38_L, u16BlueBrightness, 0xFFFF);
292 }
293 else
294 {
295 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_39_L, u16RedBrightness, 0xFFFF);
296 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_3A_L, u16GreenBrightness, 0xFFFF);
297 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_3B_L, u16BlueBrightness, 0xFFFF);
298 }
299
300 MApi_XC_MLoad_Fire(pInstance,TRUE);
301
302 }
303 else
304 {
305 if(bScalerWin == MAIN_WINDOW)
306 {
307 SC_W2BYTE(0,REG_SC_BK0F_36_L, u16RedBrightness);
308 SC_W2BYTE(0,REG_SC_BK0F_37_L, u16GreenBrightness);
309 SC_W2BYTE(0,REG_SC_BK0F_38_L, u16BlueBrightness);
310 }
311 else
312 {
313 SC_W2BYTE(0,REG_SC_BK0F_39_L, u16RedBrightness);
314 SC_W2BYTE(0,REG_SC_BK0F_3A_L, u16GreenBrightness);
315 SC_W2BYTE(0,REG_SC_BK0F_3B_L, u16BlueBrightness);
316 }
317 }
318 }
319
Hal_ACE_SetPostRGBGain(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedGain,MS_U16 u16GreenGain,MS_U16 u16BlueGain)320 void Hal_ACE_SetPostRGBGain(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16RedGain, MS_U16 u16GreenGain, MS_U16 u16BlueGain)
321 {
322 if(MAIN_WINDOW == bScalerWin)
323 {
324 SC_W2BYTE(0,REG_SC_BK25_24_L, u16RedGain);
325 SC_W2BYTE(0,REG_SC_BK25_25_L, u16GreenGain);
326 SC_W2BYTE(0,REG_SC_BK25_26_L, u16BlueGain);
327 SC_W2BYTEMSK(0,REG_SC_BK25_01_L, BIT(6) | BIT(5) | BIT(4), BIT(6) | BIT(5) | BIT(4));
328 }
329 else
330 {
331 SC_W2BYTE(0,REG_SC_BK25_2A_L, u16RedGain);
332 SC_W2BYTE(0,REG_SC_BK25_2B_L, u16GreenGain);
333 SC_W2BYTE(0,REG_SC_BK25_2C_L, u16BlueGain);
334 SC_W2BYTEMSK(0,REG_SC_BK25_11_L, BIT(6) | BIT(5) | BIT(4), BIT(6) | BIT(5) | BIT(4));
335 }
336 }
337
Hal_ACE_SetPostRGBOffset(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16RedOffset,MS_U16 u16GreenOffset,MS_U16 u16BlueOffset)338 void Hal_ACE_SetPostRGBOffset(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16RedOffset, MS_U16 u16GreenOffset, MS_U16 u16BlueOffset)
339 {
340 if(MAIN_WINDOW == bScalerWin)
341 {
342 SC_W2BYTE(0,REG_SC_BK25_21_L, u16RedOffset);
343 SC_W2BYTE(0,REG_SC_BK25_22_L, u16GreenOffset);
344 SC_W2BYTE(0,REG_SC_BK25_23_L, u16BlueOffset);
345 SC_W2BYTEMSK(0,REG_SC_BK25_01_L, BIT(6) | BIT(5) | BIT(4), BIT(6) | BIT(5) | BIT(4));
346 }
347 else
348 {
349 SC_W2BYTE(0,REG_SC_BK25_27_L, u16RedOffset);
350 SC_W2BYTE(0,REG_SC_BK25_28_L, u16GreenOffset);
351 SC_W2BYTE(0,REG_SC_BK25_29_L, u16BlueOffset);
352 SC_W2BYTEMSK(0,REG_SC_BK25_11_L, BIT(6) | BIT(5) | BIT(4), BIT(6) | BIT(5) | BIT(4));
353 }
354 }
355
Hal_ACE_GetColorMatrix(void * pInstance,MS_BOOL bScalerWin,MS_U16 * pu16Matrix)356 void Hal_ACE_GetColorMatrix(void* pInstance, MS_BOOL bScalerWin, MS_U16* pu16Matrix)
357 {
358 MS_U8 i;
359
360 if(bScalerWin == MAIN_WINDOW)
361 {
362 for (i=0; i<9; i++)
363 {
364 *pu16Matrix = SC_R2BYTE(0,(REG_SC_BK10_26_L + (2 * i)));
365 pu16Matrix++;
366 }
367 }
368 else
369 {
370 for (i=0; i<9; i++)
371 {
372 *pu16Matrix = SC_R2BYTE(0,(REG_SC_BK0F_1D_L + (2 * i)));
373 pu16Matrix++;
374 }
375 }
376 }
377
Hal_ACE_SetColorMatrix(void * pInstance,MS_BOOL bScalerWin,MS_U16 * pu16Matrix)378 void Hal_ACE_SetColorMatrix(void* pInstance, MS_BOOL bScalerWin, MS_U16* pu16Matrix)
379 {
380 MS_U8 i;
381
382 if(bScalerWin == MAIN_WINDOW)
383 {
384 for (i=0; i<9; i++)
385 {
386 SC_W2BYTE(0, (REG_SC_BK10_26_L+(2 * i)), *pu16Matrix);
387 pu16Matrix++;
388 }
389 }
390 else
391 {
392 for (i=0; i<9; i++)
393 {
394 SC_W2BYTE(0, (REG_SC_BK0F_1D_L+(2 * i)), *pu16Matrix);
395 pu16Matrix++;
396 }
397 }
398 }
399
Hal_ACE_SetIHC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IHC_COLOR_TYPE eIHC,MS_U8 u8Val)400 MS_BOOL Hal_ACE_SetIHC(void* pInstance,MS_BOOL bScalerWin, XC_ACE_IHC_COLOR_TYPE eIHC, MS_U8 u8Val)
401 {
402 MS_U16 u16Valtmp = (u8Val > 63)?(u8Val - 64):(63 - u8Val);
403 MS_U16 u16Direction = (u8Val > 63?0:1) << 6;
404 MS_U16 u16Val = u16Direction|u16Valtmp;
405 if (bScalerWin > SUB_WINDOW)
406 {
407 return FALSE;
408 }
409
410 if (bScalerWin == MAIN_WINDOW)
411 {
412 switch(eIHC)
413 {
414 case E_ACE_IHC_COLOR_R:
415 SC_W2BYTEMSK(0,REG_SC_BK18_61_L, u16Val, BITMASK(6:0));
416 break;
417 case E_ACE_IHC_COLOR_G:
418 SC_W2BYTEMSK(0,REG_SC_BK18_61_L, u16Val<<8, BITMASK(14:8));
419 break;
420 case E_ACE_IHC_COLOR_B:
421 SC_W2BYTEMSK(0,REG_SC_BK18_62_L, u16Val, BITMASK(6:0));
422 break;
423 case E_ACE_IHC_COLOR_C:
424 SC_W2BYTEMSK(0,REG_SC_BK18_62_L, u16Val<<8, BITMASK(14:8));
425 break;
426 case E_ACE_IHC_COLOR_M:
427 SC_W2BYTEMSK(0,REG_SC_BK18_63_L, u16Val, BITMASK(6:0));
428 break;
429 case E_ACE_IHC_COLOR_Y:
430 SC_W2BYTEMSK(0,REG_SC_BK18_63_L, u16Val<<8, BITMASK(14:8));
431 break;
432 case E_ACE_IHC_COLOR_F:
433 SC_W2BYTEMSK(0,REG_SC_BK18_64_L, u16Val, BITMASK(6:0));
434 break;
435 default:
436 break;
437 }
438 }
439 else
440 {
441 switch(eIHC)
442 {
443 case E_ACE_IHC_COLOR_R:
444 SC_W2BYTEMSK(0,REG_SC_BK18_65_L, u16Val, BITMASK(6:0));
445 break;
446 case E_ACE_IHC_COLOR_G:
447 SC_W2BYTEMSK(0,REG_SC_BK18_65_L, u16Val<<8, BITMASK(14:8));
448 break;
449 case E_ACE_IHC_COLOR_B:
450 SC_W2BYTEMSK(0,REG_SC_BK18_66_L, u16Val, BITMASK(6:0));
451 break;
452 case E_ACE_IHC_COLOR_C:
453 SC_W2BYTEMSK(0,REG_SC_BK18_66_L, u16Val<<8, BITMASK(14:8));
454 break;
455 case E_ACE_IHC_COLOR_M:
456 SC_W2BYTEMSK(0,REG_SC_BK18_67_L, u16Val, BITMASK(6:0));
457 break;
458 case E_ACE_IHC_COLOR_Y:
459 SC_W2BYTEMSK(0,REG_SC_BK18_67_L, u16Val<<8, BITMASK(14:8));
460 break;
461 case E_ACE_IHC_COLOR_F:
462 SC_W2BYTEMSK(0,REG_SC_BK18_68_L, u16Val, BITMASK(6:0));
463 break;
464 default:
465 break;
466 }
467 }
468 return TRUE;
469 }
470
Hal_ACE_GetIHC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IHC_COLOR_TYPE eIHC,MS_U8 * pu8Val)471 MS_BOOL Hal_ACE_GetIHC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IHC_COLOR_TYPE eIHC, MS_U8* pu8Val)
472 {
473 MS_U16 u16Value = 0;
474 MS_U8 u8ValueTmp = 0;
475 MS_BOOL bPositive = FALSE;
476
477 if (bScalerWin > SUB_WINDOW)
478 {
479 return FALSE;
480 }
481
482 if (bScalerWin == MAIN_WINDOW)
483 {
484 switch(eIHC)
485 {
486 case E_ACE_IHC_COLOR_R:
487 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_25_L, BITMASK(14:8));
488 u16Value = u16Value >>8;
489 break;
490 case E_ACE_IHC_COLOR_G:
491 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_26_L, BITMASK(6:0));
492 break;
493 case E_ACE_IHC_COLOR_B:
494 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_26_L, BITMASK(14:8));
495 u16Value = u16Value >>8;
496 break;
497 case E_ACE_IHC_COLOR_C:
498 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_27_L, BITMASK(6:0));
499 break;
500 case E_ACE_IHC_COLOR_M:
501 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_27_L, BITMASK(14:8));
502 u16Value = u16Value >>8;
503 break;
504 case E_ACE_IHC_COLOR_Y:
505 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_28_L, BITMASK(6:0));
506 break;
507 case E_ACE_IHC_COLOR_F:
508 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_28_L, BITMASK(14:8));
509 u16Value = u16Value >>8;
510 break;
511 default:
512 break;
513 }
514 }
515 else
516 {
517 switch(eIHC)
518 {
519 case E_ACE_IHC_COLOR_R:
520 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_2D_L, BITMASK(14:8));
521 u16Value = u16Value >>8;
522 break;
523 case E_ACE_IHC_COLOR_G:
524 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_2E_L, BITMASK(6:0));
525 break;
526 case E_ACE_IHC_COLOR_B:
527 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_2E_L, BITMASK(14:8));
528 u16Value = u16Value >>8;
529 break;
530 case E_ACE_IHC_COLOR_C:
531 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_2F_L, BITMASK(6:0));
532 break;
533 case E_ACE_IHC_COLOR_M:
534 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_2F_L, BITMASK(14:8));
535 u16Value = u16Value >>8;
536 break;
537 case E_ACE_IHC_COLOR_Y:
538 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_30_L, BITMASK(6:0));
539 break;
540 case E_ACE_IHC_COLOR_F:
541 u16Value = SC_R2BYTEMSK(0, REG_SC_BK1C_30_L, BITMASK(14:8));
542 u16Value = u16Value >>8;
543 break;
544 default:
545 break;
546 }
547 }
548
549 *pu8Val = (MS_U8) (u16Value & 0xFF);
550 bPositive = (*pu8Val > 63) ? FALSE:TRUE;
551 *pu8Val = (*pu8Val > 63) ? (*pu8Val -64) : (*pu8Val + 64);
552 *pu8Val = bPositive ? (*pu8Val) : (63 - *pu8Val);
553
554 return TRUE;
555 }
556
557
Hal_ACE_PatchDTGColorChecker(void * pInstance,MS_U8 u8Mode)558 void Hal_ACE_PatchDTGColorChecker(void* pInstance,MS_U8 u8Mode)
559 {
560 static MS_U8 u8Red, u8Green, u8Blue;
561 static MS_U8 u8VOP_50L, u8XVYCC_01L, u8VOP_16H;
562
563 if(u8Mode)
564 {
565 // specific settings for MHEG5
566 u8Red = SC_R2BYTEMSK(0,REG_SC_BK10_17_L, LBMASK);
567 u8Green = SC_R2BYTEMSK(0,REG_SC_BK10_17_L, HBMASK);
568 u8Blue = SC_R2BYTEMSK(0,REG_SC_BK10_18_L, LBMASK);
569 u8VOP_50L = SC_R2BYTEMSK(0,REG_SC_BK10_50_L, LBMASK);
570
571 u8XVYCC_01L= SC_R2BYTEMSK(0,REG_SC_BK25_01_L, LBMASK);
572 u8VOP_16H = SC_R2BYTEMSK(0,REG_SC_BK10_16_L, HBMASK);
573
574 SC_W2BYTEMSK(0,REG_SC_BK10_16_L, 0x0000, 0x0100);
575 SC_W2BYTEMSK(0,REG_SC_BK25_01_L, 0x0000, 0x00F0);
576
577 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, 0x80, LBMASK);
578 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, 0x80 <<8, HBMASK);
579 SC_W2BYTEMSK(0,REG_SC_BK10_50_L, 0x00, LBMASK);
580
581 // add from YT
582 SC_W2BYTE(0,REG_SC_BK18_41_L, 0x080C);
583 SC_W2BYTE(0,REG_SC_BK18_42_L, 0x0808);
584 SC_W2BYTE(0,REG_SC_BK18_43_L, 0x1008);
585 }
586 else
587 {
588 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, u8Red, LBMASK);
589 SC_W2BYTEMSK(0,REG_SC_BK10_17_L, ((MS_U16)u8Green) <<8, HBMASK);
590 SC_W2BYTEMSK(0,REG_SC_BK10_18_L, u8Blue, LBMASK);
591 SC_W2BYTEMSK(0,REG_SC_BK10_50_L, u8VOP_50L, LBMASK);
592
593 SC_W2BYTEMSK(0,REG_SC_BK25_01_L, u8XVYCC_01L, LBMASK);
594 SC_W2BYTEMSK(0,REG_SC_BK10_16_L, ((MS_U16)u8VOP_16H)<<8, HBMASK);
595 }
596 }
597
Hal_ACE_SetSlopValue(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8SlopValue)598 void Hal_ACE_SetSlopValue(void* pInstance, MS_BOOL bScalerWin, MS_U8 u8SlopValue)
599 {
600 if(bScalerWin == MAIN_WINDOW)
601 {
602 SC_W2BYTEMSK(0,REG_SC_BK1A_10_L, ((MS_U16)u8SlopValue) <<8, HBMASK);
603 }
604 else
605 {
606 SC_W2BYTEMSK(0,REG_SC_BK1A_12_L, ((MS_U16)u8SlopValue) <<8, HBMASK);
607 }
608 }
609
Hal_ACE_SetFCC_En(void * pInstance,MS_BOOL bScalerWin,MS_U8 u8Reg,MS_BOOL bEn)610 void Hal_ACE_SetFCC_En(void* pInstance, MS_BOOL bScalerWin, MS_U8 u8Reg, MS_BOOL bEn)
611 {
612 MS_U16 u16value;
613
614 if(u8Reg > 7)
615 u8Reg = 7;
616
617 if (bEn)
618 {
619 if(bScalerWin == MAIN_WINDOW)
620 u16value = (SC_R2BYTE(0,REG_SC_BK18_10_L) & 0x000F) | (1 << u8Reg);
621 else
622 u16value = (SC_R2BYTE(0,REG_SC_BK18_11_L) & 0x000F) | (1 << u8Reg);
623 }
624 else
625 {
626 if(bScalerWin == MAIN_WINDOW)
627 u16value = (SC_R2BYTE(0,REG_SC_BK18_10_L) & 0x000F) & ~(1 << u8Reg);
628 else
629 u16value = (SC_R2BYTE(0,REG_SC_BK18_11_L) & 0x000F) & ~(1 << u8Reg);
630 }
631
632 SC_W2BYTEMSK(0,REG_SC_BK18_10_L, u16value, 0x000F);
633 }
634
635
Hal_ACE_SetFCC_Cb(void * pInstance,MS_U8 u8Reg,MS_U8 u8value)636 void Hal_ACE_SetFCC_Cb(void* pInstance,MS_U8 u8Reg, MS_U8 u8value)
637 {
638 MS_U32 u32reg_addr;
639
640 if(u8Reg > 7)
641 u8Reg = 7;
642
643 u32reg_addr = REG_SC_BK18_18_L + u8Reg * 2;
644 SC_W2BYTEMSK(0,u32reg_addr, (MS_U16)u8value, LBMASK);
645 }
646
Hal_ACE_Set_IHC_SRAM(void * pInstance,MS_U16 * pBuf,MS_U8 u8SRAM_Idx,MS_U16 u16Cnt)647 void Hal_ACE_Set_IHC_SRAM(void* pInstance,MS_U16 *pBuf, MS_U8 u8SRAM_Idx, MS_U16 u16Cnt)
648 {
649 MS_U16 i;
650
651 if(u8SRAM_Idx > 3)
652 {
653 u8SRAM_Idx = 0;
654 }
655
656 SC_W2BYTEMSK(0,REG_SC_BK18_7C_L, BIT(0), BIT(0)); // io_en enable
657 SC_W2BYTEMSK(0,REG_SC_BK18_7C_L, u8SRAM_Idx<<1, BIT(2)|BIT(1)); // sram select
658
659 for(i=0; i<u16Cnt; i++)
660 {
661 while (SC_R2BYTE(0,REG_SC_BK18_7E_L) & BIT(8));
662
663 SC_W2BYTEMSK(0,REG_SC_BK18_7D_L, i, 0x00FF); // address
664 SC_W2BYTEMSK(0,REG_SC_BK18_7E_L, pBuf[i], 0x00FF); //data
665
666 SC_W2BYTEMSK(0,REG_SC_BK18_7E_L, BIT(8), BIT(8)); // io_w enable
667 }
668
669 SC_W2BYTEMSK(0,REG_SC_BK18_7C_L, 0, BIT(0)); // io_en disable
670 }
671
Hal_ACE_Set_ICC_SRAM(void * pInstance,MS_U16 * pBuf,MS_U16 u16Cnt)672 void Hal_ACE_Set_ICC_SRAM(void* pInstance,MS_U16 *pBuf, MS_U16 u16Cnt)
673 {
674 MS_U16 i;
675 SC_W2BYTEMSK(0,REG_SC_BK18_78_L, BIT(0), BIT(0)); // io_en enable
676
677 for(i=0; i<u16Cnt; i++)
678 {
679 while (SC_R2BYTE(0,REG_SC_BK18_7A_L) & BIT(8));
680
681 SC_W2BYTEMSK(0,REG_SC_BK18_79_L, i, 0x00FF); // address
682 SC_W2BYTEMSK(0,REG_SC_BK18_7A_L, (pBuf[i] & 0xFF), 0x00FF); //data
683 SC_W2BYTEMSK(0,REG_SC_BK18_7B_L, ((pBuf[i] & 0x100)<<4), 0x1000); //sign data
684
685 SC_W2BYTEMSK(0,REG_SC_BK18_7A_L, BIT(8), BIT(8)); // io_w enable
686 }
687
688 SC_W2BYTEMSK(0,REG_SC_BK18_78_L, 0, BIT(0)); // io_en disable
689 }
690
691 ////////////////////////////////////////////////////////////////////////////////
692 //
693 // MWE start
694 //
695 ////////////////////////////////////////////////////////////////////////////////
MHal_SC_SetMWEQuality(void)696 void MHal_SC_SetMWEQuality(void)
697 {
698 MS_U16 value ;
699
700 //////////////////////////////////////
701 /// Copy main window setting
702 //////////////////////////////////////
703 // Copy H-Peak
704 value = SC_R2BYTE(0,REG_SC_BK19_10_L);
705 SC_W2BYTE(0,REG_SC_BK19_14_L, value);
706 value = SC_R2BYTE(0,REG_SC_BK19_11_L);
707 SC_W2BYTE(0,REG_SC_BK19_15_L, value );
708 value = SC_R2BYTE(0,REG_SC_BK19_12_L);
709 SC_W2BYTE(0,REG_SC_BK19_16_L, value );
710 value = SC_R2BYTE(0,REG_SC_BK19_13_L);
711 SC_W2BYTE(0,REG_SC_BK19_17_L, value );
712 value = SC_R2BYTE(0,REG_SC_BK19_18_L);
713 SC_W2BYTE(0,REG_SC_BK19_28_L, value );
714 value = SC_R2BYTE(0,REG_SC_BK19_19_L);
715 SC_W2BYTE(0,REG_SC_BK19_29_L, value );
716 value = SC_R2BYTE(0,REG_SC_BK19_1A_L);
717 SC_W2BYTE(0,REG_SC_BK19_2A_L, value );
718 value = SC_R2BYTE(0,REG_SC_BK19_1B_L);
719 SC_W2BYTE(0,REG_SC_BK19_2B_L, value );
720 value = SC_R2BYTE(0,REG_SC_BK19_1C_L);
721 SC_W2BYTE(0,REG_SC_BK19_2C_L, value );
722 value = SC_R2BYTE(0,REG_SC_BK19_1D_L);
723 SC_W2BYTE(0,REG_SC_BK19_2D_L, value );
724 value = SC_R2BYTE(0,REG_SC_BK19_1E_L);
725 SC_W2BYTE(0,REG_SC_BK19_2E_L, value );
726 value = SC_R2BYTE(0,REG_SC_BK19_1F_L);
727 SC_W2BYTE(0,REG_SC_BK19_2F_L, value );
728
729
730 // Copy FCC from main window
731 value = SC_R2BYTE(0,REG_SC_BK18_10_L);
732 SC_W2BYTE(0,REG_SC_BK18_11_L, value);
733
734 // Copy ICC
735 value = SC_R2BYTE(0,REG_SC_BK18_30_L) ;
736 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, value >> 4, (BIT(2)|BIT(3)));
737 value = SC_R2BYTE(0,REG_SC_BK18_31_L);
738 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)));
739 value = SC_R2BYTE(0,REG_SC_BK18_32_L);
740 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)));
741 value = SC_R2BYTE(0,REG_SC_BK18_33_L);
742 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)));
743 value = SC_R2BYTE(0,REG_SC_BK18_34_L);
744 SC_W2BYTEMSK(0,REG_SC_BK18_34_L, (value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)));
745 value = SC_R2BYTE(0,REG_SC_BK18_35_L);
746 SC_W2BYTEMSK(0,REG_SC_BK18_35_L, (value << 8), 0xFF00);
747
748 // IBC
749 value = SC_R2BYTE(0,REG_SC_BK18_40_L);
750 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, value >> 1, BIT(6));
751 value = SC_R2BYTE(0,REG_SC_BK18_41_L);
752 SC_W2BYTE(0,REG_SC_BK18_45_L, value );
753 value = SC_R2BYTE(0,REG_SC_BK18_42_L);
754 SC_W2BYTE(0,REG_SC_BK18_46_L, value );
755 value = SC_R2BYTE(0,REG_SC_BK18_43_L);
756 SC_W2BYTE(0,REG_SC_BK18_47_L, value );
757 value = SC_R2BYTE(0,REG_SC_BK18_44_L);
758 SC_W2BYTEMSK(0,REG_SC_BK18_48_L, value ,(BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4)|BIT(5)));
759
760 // Y/C noise masking
761 value = SC_R2BYTE(0,REG_SC_BK18_55_L);
762 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)));
763
764 // IHC
765 value = SC_R2BYTE(0,REG_SC_BK18_60_L);
766 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, value >> 1, BIT(6));
767 // YC-Coring
768 value = SC_R2BYTE(0,REG_SC_BK18_50_L);
769 SC_W2BYTE(0,REG_SC_BK18_58_L, value );
770 value = SC_R2BYTE(0,REG_SC_BK18_51_L);
771 SC_W2BYTE(0,REG_SC_BK18_59_L, value);
772 value = SC_R2BYTE(0,REG_SC_BK18_52_L);
773 SC_W2BYTE(0,REG_SC_BK18_5A_L, value);
774 value = SC_R2BYTE(0,REG_SC_BK18_53_L);
775 SC_W2BYTE(0,REG_SC_BK18_5B_L, value);
776 value = SC_R2BYTE(0,REG_SC_BK18_54_L);
777 SC_W2BYTE(0,REG_SC_BK18_5C_L, value);
778
779 // copy Y-Adjust
780 value = SC_R2BYTE(0,REG_SC_BK1A_0E_L);
781 SC_W2BYTEMSK(0,REG_SC_BK1A_0E_L, (value << 8), BIT(8) | BIT(9));
782 value = SC_R2BYTE(0,REG_SC_BK1A_0F_L);
783 SC_W2BYTEMSK(0,REG_SC_BK1A_0F_L, (value << 8), 0xFF00);
784
785 // copy BLE
786 value = SC_R2BYTE(0,REG_SC_BK1A_10_L);
787 SC_W2BYTE(0,REG_SC_BK1A_12_L, value );
788 // copy WLE
789 value = SC_R2BYTE(0,REG_SC_BK1A_11_L);
790 SC_W2BYTE(0,REG_SC_BK1A_13_L, value );
791 // copy Y/C gain control
792 value = SC_R2BYTE(0,REG_SC_BK1A_14_L);
793 SC_W2BYTE(0,REG_SC_BK1A_15_L, value );
794 // Histogram data
795 value = SC_R2BYTE(0,REG_SC_BK1A_01_L);
796 SC_W2BYTE(0,REG_SC_BK1A_03_L, value );
797
798 // Copy DLC table
799 value = SC_R2BYTE(0,REG_SC_BK1A_30_L);
800 SC_W2BYTE(0,REG_SC_BK1A_38_L, value);
801 value = SC_R2BYTE(0,REG_SC_BK1A_31_L);
802 SC_W2BYTE(0,REG_SC_BK1A_39_L, value );
803 value = SC_R2BYTE(0,REG_SC_BK1A_32_L);
804 SC_W2BYTE(0,REG_SC_BK1A_3A_L, value );
805 value = SC_R2BYTE(0,REG_SC_BK1A_33_L);
806 SC_W2BYTE(0,REG_SC_BK1A_3B_L, value );
807 value = SC_R2BYTE(0,REG_SC_BK1A_34_L);
808 SC_W2BYTE(0,REG_SC_BK1A_3C_L, value );
809 value = SC_R2BYTE(0,REG_SC_BK1A_35_L);
810 SC_W2BYTE(0,REG_SC_BK1A_3D_L, value);
811 value = SC_R2BYTE(0,REG_SC_BK1A_36_L);
812 SC_W2BYTE(0,REG_SC_BK1A_3E_L, value );
813 value = SC_R2BYTE(0,REG_SC_BK1A_37_L);
814 SC_W2BYTE(0,REG_SC_BK1A_3F_L, value);
815
816 // Copy Statistic
817 value = SC_R2BYTE(0,REG_SC_BK1A_04_L);
818 SC_W2BYTEMSK(0,REG_SC_BK1A_04_L, value >> 1 , BIT(0));
819
820 // Copy Luma curve
821 value = SC_R2BYTE(0,REG_SC_BK1A_04_L);
822 SC_W2BYTEMSK(0,REG_SC_BK1A_04_L, value >> 1 , BIT(6));
823 // Read Brightness setting from main window
824 value = SC_R2BYTE(0,REG_SC_BK0F_36_L);
825 SC_W2BYTE(0,REG_SC_BK0F_39_L, value );
826 value = SC_R2BYTE(0,REG_SC_BK0F_37_L);
827 SC_W2BYTE(0,REG_SC_BK0F_3A_L, value );
828 value = SC_R2BYTE(0,REG_SC_BK0F_38_L);
829 SC_W2BYTE(0,REG_SC_BK0F_3B_L, value );
830
831 // copy Post Scaling filter selection from main to sub
832 value = SC_R2BYTE(0,REG_SC_BK23_0B_L);
833 SC_W2BYTE(0,REG_SC_BK23_2B_L, value );
834
835 //copy rgb2yuv enable flag
836 value = SC_R2BYTE(0,REG_SC_BK18_6E_L);
837 SC_W2BYTEMSK(0,REG_SC_BK18_6E_L, value << 4, BIT(4));
838 value = SC_R2BYTE(0,REG_SC_BK18_6F_L);
839 SC_W2BYTEMSK(0,REG_SC_BK18_6F_L, value << 4, BIT(4) | BIT(5));
840
841 // copy pre Y gain control
842 value = SC_R2BYTE(0,REG_SC_BK1A_16_L);
843 SC_W2BYTEMSK(0,REG_SC_BK1A_16_L, (value << 8), 0xFF00);
844 //clear sub window low 4bit to keep difference with main
845 SC_W2BYTEMSK(0,REG_SC_BK1A_16_L, 0x0000, 0x0F00);
846
847 // color matrix
848
849 {
850
851 value = SC_R2BYTE(0,REG_SC_BK10_26_L);
852 SC_W2BYTE(0,REG_SC_BK0F_1D_L, value );
853
854 value = SC_R2BYTE(0,REG_SC_BK10_27_L);
855 SC_W2BYTE(0,REG_SC_BK0F_1E_L, value );
856
857 value = SC_R2BYTE(0,REG_SC_BK10_28_L);
858 SC_W2BYTE(0,REG_SC_BK0F_1F_L, value );
859
860 value = SC_R2BYTE(0,REG_SC_BK10_29_L);
861 SC_W2BYTE(0,REG_SC_BK0F_20_L, value );
862
863 value = SC_R2BYTE(0,REG_SC_BK10_2A_L);
864 SC_W2BYTE(0,REG_SC_BK0F_21_L, value );
865
866 value = SC_R2BYTE(0,REG_SC_BK10_2B_L);
867 SC_W2BYTE(0,REG_SC_BK0F_22_L,value);
868
869 value = SC_R2BYTE(0,REG_SC_BK10_2C_L);
870 SC_W2BYTE(0,REG_SC_BK0F_23_L, value );
871
872 value = SC_R2BYTE(0,REG_SC_BK10_2D_L);
873 SC_W2BYTE(0,REG_SC_BK0F_24_L,value );
874
875 value = SC_R2BYTE(0,REG_SC_BK10_2E_L);
876 SC_W2BYTE(0,REG_SC_BK0F_25_L,value );
877
878 value = SC_R2BYTE(0,REG_SC_BK10_2F_L);
879 SC_W2BYTE(0,REG_SC_BK0F_26_L,value);
880
881 }
882
883 //////////////////////////////////////
884 /// Disable
885 //////////////////////////////////////
886 //disable ICC
887
888 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, 0x00 ,BIT(2));
889 //disable IBC
890 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, 0x00 ,BIT(6));
891 //disable IHC
892 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, 0x00 ,BIT(6));
893 //disable DLC ( fresh contrast )
894 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, 0x00 ,BIT(6));
895
896 // main window DLC
897 //REG_WI(REG_SC_DLC(0x04), 1, BIT(7));
898
899 }
900
Hal_ACE_MWESetWin(void * pInstance,MS_U16 u16hstart,MS_U16 u16hend,MS_U16 u16vstart,MS_U16 u16vend)901 void Hal_ACE_MWESetWin(void* pInstance,MS_U16 u16hstart, MS_U16 u16hend, MS_U16 u16vstart, MS_U16 u16vend)
902 {
903 if((MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED) && (!MApi_XC_GetForceWrite(E_MAIN_WINDOW_MUTE)) && (!MApi_XC_GetForceWrite(E_PANEL_MUTE)))
904 {
905
906 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_07_L, u16hstart, 0xFFF);
907 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_08_L, u16hend, 0xFFF);
908 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_09_L, u16vstart, 0xFFF);
909 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK0F_0A_L, u16vend, 0xFFF);
910
911 MApi_XC_MLoad_Fire(pInstance,TRUE);
912
913 }
914 else
915 {
916 SC_W2BYTEMSK(0,REG_SC_BK0F_07_L, u16hstart, 0xFFF);
917 SC_W2BYTEMSK(0,REG_SC_BK0F_08_L, u16hend, 0xFFF);
918 SC_W2BYTEMSK(0,REG_SC_BK0F_09_L, u16vstart, 0xFFF);
919 SC_W2BYTEMSK(0,REG_SC_BK0F_0A_L, u16vend, 0xFFF);
920 }
921 }
922
Hal_ACE_MWECloneVisualEffect(void * pInstance)923 void Hal_ACE_MWECloneVisualEffect(void* pInstance)
924 {
925 MS_U16 value ;
926
927 //////////////////////////////////////
928 /// Clone Main Window
929 //////////////////////////////////////
930
931 // copy pre Y gain control
932 value = SC_R2BYTE(0,REG_SC_BK1A_16_L);
933 SC_W2BYTEMSK(0,REG_SC_BK1A_16_L, (value << 8), 0xFF00);
934 //copy rgb2yuv enable flag
935 value = SC_R2BYTE(0,REG_SC_BK18_6E_L);
936 SC_W2BYTEMSK(0,REG_SC_BK18_6E_L, value << 4, BIT(4));
937 value = SC_R2BYTE(0,REG_SC_BK18_6F_L);
938 SC_W2BYTEMSK(0,REG_SC_BK18_6F_L, value << 4, BIT(4) | BIT(5));
939
940 //copy color temp
941 value = SC_R2BYTE(0,REG_SC_BK25_21_L);
942 SC_W2BYTEMSK(0,REG_SC_BK25_27_L, value, 0x07ff);
943 value = SC_R2BYTE(0,REG_SC_BK25_22_L);
944 SC_W2BYTEMSK(0,REG_SC_BK25_28_L, value, 0x07ff);
945 value = SC_R2BYTE(0,REG_SC_BK25_23_L);
946 SC_W2BYTEMSK(0,REG_SC_BK25_29_L, value, 0x07ff);
947
948 value = SC_R2BYTE(0,REG_SC_BK25_24_L);
949 SC_W2BYTEMSK(0,REG_SC_BK25_2A_L, value, 0x0fff);
950 value = SC_R2BYTE(0,REG_SC_BK25_25_L);
951 SC_W2BYTEMSK(0,REG_SC_BK25_2B_L, value, 0x0fff);
952 value = SC_R2BYTE(0,REG_SC_BK25_26_L);
953 SC_W2BYTEMSK(0,REG_SC_BK25_2C_L, value, 0x0fff);
954 value = SC_R2BYTE(0,REG_SC_BK25_01_L);
955 SC_W2BYTEMSK(0,REG_SC_BK25_11_L, value, BIT(6) | BIT(5) | BIT(4));
956 // copy brightness enable flag
957 value = SC_R2BYTE(0,REG_SC_BK10_16_L);
958 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, 0xFD00);
959 // copy color table enable flag
960 value = SC_R2BYTE(0,REG_SC_BK10_2F_L);
961 SC_W2BYTEMSK(0,REG_SC_BK0F_26_L, value, 0x0037);
962 //clone ICC
963 value = SC_R2BYTE(0,REG_SC_BK18_30_L);
964 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, value >> 4, BIT(2));
965 //clone IBC
966 value = SC_R2BYTE(0,REG_SC_BK18_40_L);
967 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, value >> 1, BIT(6));
968 //clone IHC
969 value = SC_R2BYTE(0,REG_SC_BK18_60_L);
970 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, value >> 1, BIT(6));
971 }
972
Hal_ACE_3DClonePQMap(void * pInstance,XC_ACE_WEAVETYPE enWeaveType)973 void Hal_ACE_3DClonePQMap(void* pInstance,XC_ACE_WEAVETYPE enWeaveType)
974 {
975 MS_U16 value = 0;
976
977 if((enWeaveType == E_ACE_WEAVETYPE_NONE) ||
978 (enWeaveType == E_ACE_WEAVETYPE_DUALVIEW))
979 {
980 SC_W2BYTEMSK(0,REG_SC_BK19_10_L, 0x8F00 ,0xFF00);
981 SC_W2BYTE(0,REG_SC_BK19_12_L, 0x0000);
982 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, 0x00, 0x00FF);
983 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, 0x00, BIT(4));
984 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00, BIT(0));
985 if(enWeaveType == E_ACE_WEAVETYPE_DUALVIEW)
986 {
987 return;
988 }
989 }
990
991 //FCC
992 {
993 value = SC_R2BYTE(0,REG_SC_BK18_10_L);
994 SC_W2BYTE(0,REG_SC_BK18_11_L, value);
995 }
996
997 //Y/C noise masking
998 {
999 value = SC_R2BYTE(0,REG_SC_BK18_55_L);
1000 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)));
1001 }
1002
1003 //YC-Coring
1004 {
1005 value = SC_R2BYTE(0,REG_SC_BK18_50_L);
1006 SC_W2BYTE(0,REG_SC_BK18_58_L, value );
1007 value = SC_R2BYTE(0,REG_SC_BK18_51_L);
1008 SC_W2BYTE(0,REG_SC_BK18_59_L, value);
1009 value = SC_R2BYTE(0,REG_SC_BK18_52_L);
1010 SC_W2BYTE(0,REG_SC_BK18_5A_L, value);
1011 value = SC_R2BYTE(0,REG_SC_BK18_53_L);
1012 SC_W2BYTE(0,REG_SC_BK18_5B_L, value);
1013 value = SC_R2BYTE(0,REG_SC_BK18_54_L);
1014 SC_W2BYTE(0,REG_SC_BK18_5C_L, value);
1015 }
1016
1017 //Y-Adjust
1018 {
1019 value = SC_R2BYTE(0,REG_SC_BK1A_0E_L);
1020 SC_W2BYTEMSK(0,REG_SC_BK1A_0E_L, (value << 8), BIT(8) | BIT(9));
1021 value = SC_R2BYTE(0,REG_SC_BK1A_0F_L);
1022 SC_W2BYTEMSK(0,REG_SC_BK1A_0F_L, (value << 8), 0xFF00);
1023 }
1024
1025 //Histogram data
1026 {
1027 value = SC_R2BYTE(0,REG_SC_BK1A_01_L);
1028 SC_W2BYTE(0,REG_SC_BK1A_03_L, value );
1029 }
1030
1031 //DLC table
1032 {
1033 value = SC_R2BYTE(0,REG_SC_BK1A_30_L);
1034 SC_W2BYTE(0,REG_SC_BK1A_38_L, value);
1035 value = SC_R2BYTE(0,REG_SC_BK1A_31_L);
1036 SC_W2BYTE(0,REG_SC_BK1A_39_L, value );
1037 value = SC_R2BYTE(0,REG_SC_BK1A_32_L);
1038 SC_W2BYTE(0,REG_SC_BK1A_3A_L, value );
1039 value = SC_R2BYTE(0,REG_SC_BK1A_33_L);
1040 SC_W2BYTE(0,REG_SC_BK1A_3B_L, value );
1041 value = SC_R2BYTE(0,REG_SC_BK1A_34_L);
1042 SC_W2BYTE(0,REG_SC_BK1A_3C_L, value );
1043 value = SC_R2BYTE(0,REG_SC_BK1A_35_L);
1044 SC_W2BYTE(0,REG_SC_BK1A_3D_L, value);
1045 value = SC_R2BYTE(0,REG_SC_BK1A_36_L);
1046 SC_W2BYTE(0,REG_SC_BK1A_3E_L, value );
1047 value = SC_R2BYTE(0,REG_SC_BK1A_37_L);
1048 SC_W2BYTE(0,REG_SC_BK1A_3F_L, value);
1049 }
1050
1051 //CTI
1052 {
1053 value = SC_R2BYTE(0,REG_SC_BK23_60_L);
1054 SC_W2BYTE(0,REG_SC_BK23_70_L, value );
1055
1056 value = SC_R2BYTE(0,REG_SC_BK23_61_L);
1057 SC_W2BYTE(0,REG_SC_BK23_71_L, value );
1058
1059 value = SC_R2BYTE(0,REG_SC_BK23_62_L);
1060 SC_W2BYTE(0,REG_SC_BK23_72_L, value );
1061
1062 value = SC_R2BYTE(0,REG_SC_BK23_63_L);
1063 SC_W2BYTE(0,REG_SC_BK23_73_L, value );
1064
1065 value = SC_R2BYTE(0,REG_SC_BK23_64_L);
1066 SC_W2BYTE(0,REG_SC_BK23_74_L, value );
1067
1068 value = SC_R2BYTE(0,REG_SC_BK23_65_L);
1069 SC_W2BYTE(0,REG_SC_BK23_75_L, value );
1070
1071 value = SC_R2BYTE(0,REG_SC_BK23_66_L);
1072 SC_W2BYTE(0,REG_SC_BK23_76_L, value );
1073
1074 value = SC_R2BYTE(0,REG_SC_BK23_67_L);
1075 SC_W2BYTE(0,REG_SC_BK23_77_L, value );
1076 }
1077
1078
1079 //rgb2yuv enable flag
1080 {
1081 value = SC_R2BYTE(0,REG_SC_BK18_6E_L);
1082 SC_W2BYTEMSK(0,REG_SC_BK18_6E_L, value << 4, BIT(4));
1083 value = SC_R2BYTE(0,REG_SC_BK18_6F_L);
1084 SC_W2BYTEMSK(0,REG_SC_BK18_6F_L, value << 4, BIT(4) | BIT(5));
1085 }
1086
1087 //color matrix
1088 {
1089 value = SC_R2BYTE(0,REG_SC_BK10_26_L);
1090 SC_W2BYTE(0,REG_SC_BK0F_1D_L, value );
1091
1092 value = SC_R2BYTE(0,REG_SC_BK10_27_L);
1093 SC_W2BYTE(0,REG_SC_BK0F_1E_L, value );
1094
1095 value = SC_R2BYTE(0,REG_SC_BK10_28_L);
1096 SC_W2BYTE(0,REG_SC_BK0F_1F_L, value );
1097
1098 value = SC_R2BYTE(0,REG_SC_BK10_29_L);
1099 SC_W2BYTE(0,REG_SC_BK0F_20_L, value );
1100
1101 value = SC_R2BYTE(0,REG_SC_BK10_2A_L);
1102 SC_W2BYTE(0,REG_SC_BK0F_21_L, value );
1103
1104 value = SC_R2BYTE(0,REG_SC_BK10_2B_L);
1105 SC_W2BYTE(0,REG_SC_BK0F_22_L,value);
1106
1107 value = SC_R2BYTE(0,REG_SC_BK10_2C_L);
1108 SC_W2BYTE(0,REG_SC_BK0F_23_L, value );
1109
1110 value = SC_R2BYTE(0,REG_SC_BK10_2D_L);
1111 SC_W2BYTE(0,REG_SC_BK0F_24_L,value );
1112
1113 value = SC_R2BYTE(0,REG_SC_BK10_2E_L);
1114 SC_W2BYTE(0,REG_SC_BK0F_25_L,value );
1115
1116 value = SC_R2BYTE(0,REG_SC_BK10_2F_L);
1117 SC_W2BYTE(0,REG_SC_BK0F_26_L,value);
1118 }
1119
1120 //DNR
1121 {
1122 value = SC_R2BYTE(0,REG_SC_BK06_21_L);
1123 SC_W2BYTE(0,REG_SC_BK06_01_L,value);
1124
1125 value = SC_R2BYTE(0,REG_SC_BK06_26_L);
1126 SC_W2BYTEMSK(0,REG_SC_BK06_06_L, value, 0x00FF);
1127
1128 value = SC_R2BYTE(0,REG_SC_BK06_27_L);
1129 SC_W2BYTE(0,REG_SC_BK06_07_L,value);
1130 }
1131
1132 //DBK
1133 {
1134 value = SC_R2BYTE(0,REG_SC_BK0C_10_L);
1135 SC_W2BYTEMSK(0,REG_SC_BK0C_10_L, value<<4, BIT(6) | BIT(5) | BIT(4));
1136
1137 // De-blocking strength F2 [3:0], De-blocking strength F1[11:8]
1138 // De-blocking motion ratio enable F2 [12], De-blocking motion ratio enable F1 [13],
1139 value = SC_R2BYTE(0,REG_SC_BK0C_11_L);
1140 SC_W2BYTEMSK(0,REG_SC_BK0C_11_L, value<<8, 0x0F00);
1141 SC_W2BYTEMSK(0,REG_SC_BK0C_11_L, value<<1, 0x2000);
1142
1143 value = SC_R2BYTE(0,REG_SC_BK0C_39_L);
1144 SC_W2BYTE(0,REG_SC_BK0C_3B_L,value);
1145
1146 value = SC_R2BYTE(0,REG_SC_BK0C_3A_L);
1147 SC_W2BYTEMSK(0,REG_SC_BK0C_3C_L,value,0x00FF);
1148
1149 value = SC_R2BYTE(0,REG_SC_BK0C_40_L);
1150 SC_W2BYTE(0,REG_SC_BK0C_43_L,value);
1151
1152 value = SC_R2BYTE(0,REG_SC_BK0C_41_L);
1153 SC_W2BYTE(0,REG_SC_BK0C_44_L,value);
1154
1155 value = SC_R2BYTE(0,REG_SC_BK0C_42_L);
1156 SC_W2BYTE(0,REG_SC_BK0C_46_L,value);
1157 }
1158
1159 //SNR
1160 {
1161 value = SC_R2BYTE(0,REG_SC_BK0C_30_L);
1162 SC_W2BYTEMSK(0,REG_SC_BK0C_30_L, value<<4, BIT(6) | BIT(5) | BIT(4));
1163
1164 value = SC_R2BYTE(0,REG_SC_BK0C_31_L);
1165 SC_W2BYTEMSK(0,REG_SC_BK0C_31_L, value<<8, 0x0F00);
1166 }
1167
1168 //NMR
1169 {
1170 value = SC_R2BYTE(0,REG_SC_BK0C_50_L);
1171 SC_W2BYTEMSK(0,REG_SC_BK0C_50_L, value<<4, BIT(5) | BIT(4));
1172
1173 value = SC_R2BYTE(0,REG_SC_BK0C_54_L);
1174 SC_W2BYTEMSK(0,REG_SC_BK0C_54_L, value<<8, 0xFF00);
1175 }
1176
1177 //HSP, VSP
1178 {
1179 value = SC_R2BYTE(0,REG_SC_BK23_0B_L);
1180 SC_W2BYTE(0,REG_SC_BK23_2B_L,value);
1181
1182 // 6 tap clone
1183 value = SC_R2BYTE(0,REG_SC_BK23_13_L);
1184 SC_W2BYTE(0,REG_SC_BK23_33_L,value);
1185 }
1186
1187 //MemFormat
1188 {
1189 value = SC_R2BYTE(0,REG_SC_BK12_01_L);
1190 SC_W2BYTE(0,REG_SC_BK12_41_L, value);
1191
1192 value = SC_R2BYTE(0,REG_SC_BK12_02_L);
1193 SC_W2BYTE(0,REG_SC_BK12_42_L, value);
1194
1195 value = SC_R2BYTE(0,REG_SC_BK12_03_L);
1196 SC_W2BYTEMSK(0,REG_SC_BK12_43_L, value, 0x00FF);
1197
1198 value = SC_R2BYTE(0,REG_SC_BK12_04_L);
1199 SC_W2BYTE(0,REG_SC_BK12_44_L, value);
1200
1201 value = SC_R2BYTE(0,REG_SC_BK12_05_L);
1202 SC_W2BYTE(0,REG_SC_BK12_45_L, value);
1203
1204 value = SC_R2BYTE(0,REG_SC_BK12_06_L);
1205 SC_W2BYTE(0,REG_SC_BK12_46_L, value);
1206
1207 value = SC_R2BYTE(0,REG_SC_BK12_19_L);
1208 SC_W2BYTEMSK(0,REG_SC_BK12_59_L, value, 0x00FF);
1209
1210 value = SC_R2BYTE(0,REG_SC_BK23_0C_L);
1211 SC_W2BYTEMSK(0,REG_SC_BK23_2C_L, value, 0x00FF);
1212 }
1213
1214 //Peaking
1215 {
1216 value = SC_R2BYTE(0,REG_SC_BK19_10_L);
1217 SC_W2BYTE(0,REG_SC_BK19_14_L,value);
1218
1219 value = SC_R2BYTE(0,REG_SC_BK19_11_L);
1220 SC_W2BYTE(0,REG_SC_BK19_15_L,value);
1221
1222 value = SC_R2BYTE(0,REG_SC_BK19_12_L);
1223 SC_W2BYTE(0,REG_SC_BK19_16_L,value);
1224
1225 value = SC_R2BYTE(0,REG_SC_BK19_13_L);
1226 SC_W2BYTE(0,REG_SC_BK19_17_L,value);
1227 }
1228
1229 //Sharpness
1230 {
1231 value = SC_R2BYTE(0,REG_SC_BK19_18_L);
1232 SC_W2BYTE(0,REG_SC_BK19_28_L,value);
1233
1234 value = SC_R2BYTE(0,REG_SC_BK19_19_L);
1235 SC_W2BYTE(0,REG_SC_BK19_29_L,value);
1236
1237 value = SC_R2BYTE(0,REG_SC_BK19_1A_L);
1238 SC_W2BYTE(0,REG_SC_BK19_2A_L,value);
1239
1240 value = SC_R2BYTE(0,REG_SC_BK19_1B_L);
1241 SC_W2BYTE(0,REG_SC_BK19_2B_L,value);
1242
1243 value = SC_R2BYTE(0,REG_SC_BK19_1C_L);
1244 SC_W2BYTE(0,REG_SC_BK19_2C_L,value);
1245
1246 value = SC_R2BYTE(0,REG_SC_BK19_1D_L);
1247 SC_W2BYTE(0,REG_SC_BK19_2D_L,value);
1248
1249 value = SC_R2BYTE(0,REG_SC_BK19_1E_L);
1250 SC_W2BYTE(0,REG_SC_BK19_2E_L,value);
1251
1252 value = SC_R2BYTE(0,REG_SC_BK19_1F_L);
1253 SC_W2BYTE(0,REG_SC_BK19_2F_L,value);
1254 }
1255
1256 //ICC
1257 {
1258 value = SC_R2BYTE(0,REG_SC_BK18_30_L) ;
1259 SC_W2BYTEMSK(0,REG_SC_BK18_30_L, value >> 4, (BIT(2)|BIT(3)));
1260 value = SC_R2BYTE(0,REG_SC_BK18_31_L);
1261 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)));
1262 value = SC_R2BYTE(0,REG_SC_BK18_32_L);
1263 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)));
1264 value = SC_R2BYTE(0,REG_SC_BK18_33_L);
1265 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)));
1266 value = SC_R2BYTE(0,REG_SC_BK18_34_L);
1267 SC_W2BYTEMSK(0,REG_SC_BK18_34_L, (value << 4), (BIT(4)|BIT(5)|BIT(6)|BIT(7)));
1268 value = SC_R2BYTE(0,REG_SC_BK18_35_L);
1269 SC_W2BYTEMSK(0,REG_SC_BK18_35_L, (value << 8), 0xFF00);
1270 value = SC_R2BYTE(0,REG_SC_BK27_30_L) ;
1271 SC_W2BYTEMSK(0,REG_SC_BK27_30_L, value >> 1, (BIT(6)|BIT(0)));
1272 }
1273
1274 //IBC
1275 {
1276 value = SC_R2BYTE(0,REG_SC_BK18_40_L);
1277 SC_W2BYTEMSK(0,REG_SC_BK18_40_L, value >> 1, BIT(6));
1278 value = SC_R2BYTE(0,REG_SC_BK18_41_L);
1279 SC_W2BYTE(0,REG_SC_BK18_45_L, value );
1280 value = SC_R2BYTE(0,REG_SC_BK18_42_L);
1281 SC_W2BYTE(0,REG_SC_BK18_46_L, value );
1282 value = SC_R2BYTE(0,REG_SC_BK18_43_L);
1283 SC_W2BYTE(0,REG_SC_BK18_47_L, value );
1284 value = SC_R2BYTE(0,REG_SC_BK18_44_L);
1285 SC_W2BYTEMSK(0,REG_SC_BK18_48_L, value ,(BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4)|BIT(5)));
1286 }
1287
1288 //IHC
1289 {
1290 value = SC_R2BYTE(0,REG_SC_BK18_60_L);
1291 SC_W2BYTEMSK(0,REG_SC_BK18_60_L, value >> 1, BIT(6));
1292 value = SC_R2BYTE(0,REG_SC_BK18_61_L);
1293 SC_W2BYTE(0,REG_SC_BK18_65_L, value );
1294 value = SC_R2BYTE(0,REG_SC_BK18_62_L);
1295 SC_W2BYTE(0,REG_SC_BK18_66_L, value );
1296 value = SC_R2BYTE(0,REG_SC_BK18_63_L);
1297 SC_W2BYTE(0,REG_SC_BK18_67_L, value );
1298 value = SC_R2BYTE(0,REG_SC_BK18_64_L);
1299 SC_W2BYTEMSK(0,REG_SC_BK18_68_L, value, 0x00FF);
1300 }
1301
1302 //ACK
1303 {
1304 value = SC_R2BYTE(0,REG_SC_BK18_38_L);
1305 SC_W2BYTEMSK(0,REG_SC_BK18_38_L, value>>4, BIT(3) | BIT(2));
1306 }
1307
1308 //Y offset
1309 {
1310 value = SC_R2BYTE(0,REG_SC_BK1A_0F_L);
1311 SC_W2BYTEMSK(0,REG_SC_BK1A_0F_L, value<<8, 0xFF00);
1312 }
1313
1314 //Y/C gain
1315 {
1316 value = SC_R2BYTE(0,REG_SC_BK1A_14_L);
1317 SC_W2BYTE(0,REG_SC_BK1A_15_L,value);
1318
1319 value = SC_R2BYTE(0,REG_SC_BK1A_16_L);
1320 SC_W2BYTEMSK(0,REG_SC_BK1A_16_L, value<<8, 0xFF00);
1321 }
1322
1323 //DMS
1324 {
1325 value = SC_R2BYTE(0,REG_SC_BK26_10_L);
1326 SC_W2BYTE(0,REG_SC_BK26_14_L,value);
1327
1328 value = SC_R2BYTE(0,REG_SC_BK26_11_L);
1329 SC_W2BYTE(0,REG_SC_BK26_15_L,value);
1330
1331 value = SC_R2BYTE(0,REG_SC_BK26_12_L);
1332 SC_W2BYTE(0,REG_SC_BK26_16_L,value);
1333
1334 value = SC_R2BYTE(0,REG_SC_BK26_13_L);
1335 SC_W2BYTE(0,REG_SC_BK26_17_L,value);
1336
1337 value = SC_R2BYTE(0,REG_SC_BK26_18_L);
1338 SC_W2BYTE(0,REG_SC_BK26_1B_L,value);
1339 }
1340
1341 //Spike NR
1342 {
1343 value = SC_R2BYTE(0,REG_SC_BK26_50_L);
1344 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, value<<4, 0X00F0);
1345 }
1346
1347 //Bri
1348 {
1349 value = SC_R2BYTE(0,REG_SC_BK10_16_L);
1350 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, BIT(8));
1351
1352 value = SC_R2BYTE(0,REG_SC_BK0F_36_L);
1353 SC_W2BYTE(0,REG_SC_BK0F_39_L, value );
1354
1355 value = SC_R2BYTE(0,REG_SC_BK0F_37_L);
1356 SC_W2BYTE(0,REG_SC_BK0F_3A_L, value );
1357
1358 value = SC_R2BYTE(0,REG_SC_BK0F_38_L);
1359 SC_W2BYTE(0,REG_SC_BK0F_3B_L, value );
1360 }
1361
1362 //Gamma
1363 {
1364 value = SC_R2BYTE(0,REG_SC_BK10_50_L);
1365 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, BIT(0));
1366 }
1367
1368 //DLC
1369 {
1370 value = SC_R2BYTE(0,REG_SC_BK1A_04_L);
1371 SC_W2BYTEMSK(0,REG_SC_BK1A_04_L, value >> 1 , BIT(0) | BIT(6));
1372 }
1373
1374 //BLE&WLE
1375 {
1376 // copy BLE
1377 value = SC_R2BYTE(0,REG_SC_BK1A_10_L);
1378 SC_W2BYTE(0,REG_SC_BK1A_12_L, value );
1379 // copy WLE
1380 value = SC_R2BYTE(0,REG_SC_BK1A_11_L);
1381 SC_W2BYTE(0,REG_SC_BK1A_13_L, value );
1382 }
1383
1384 //HBC
1385 {
1386 value = SC_R2BYTE(0,REG_SC_BK10_16_L);
1387 SC_W2BYTEMSK(0,REG_SC_BK0F_18_L, value, 0xFF00);
1388 }
1389
1390 //Color temp
1391 {
1392 value = SC_R2BYTE(0,REG_SC_BK25_21_L);
1393 SC_W2BYTEMSK(0,REG_SC_BK25_27_L, value, 0x07ff);
1394 value = SC_R2BYTE(0,REG_SC_BK25_22_L);
1395 SC_W2BYTEMSK(0,REG_SC_BK25_28_L, value, 0x07ff);
1396 value = SC_R2BYTE(0,REG_SC_BK25_23_L);
1397 SC_W2BYTEMSK(0,REG_SC_BK25_29_L, value, 0x07ff);
1398
1399 value = SC_R2BYTE(0,REG_SC_BK25_24_L);
1400 SC_W2BYTEMSK(0,REG_SC_BK25_2A_L, value, 0x0fff);
1401 value = SC_R2BYTE(0,REG_SC_BK25_25_L);
1402 SC_W2BYTEMSK(0,REG_SC_BK25_2B_L, value, 0x0fff);
1403 value = SC_R2BYTE(0,REG_SC_BK25_26_L);
1404 SC_W2BYTEMSK(0,REG_SC_BK25_2C_L, value, 0x0fff);
1405 value = SC_R2BYTE(0,REG_SC_BK25_01_L);
1406 SC_W2BYTEMSK(0,REG_SC_BK25_11_L, value, 0x00ff);
1407 }
1408
1409 if(enWeaveType & E_ACE_WEAVETYPE_H)
1410 {
1411 SC_W2BYTEMSK(0,REG_SC_BK23_54_L, 0x00 ,0x80);//disable HDSDD
1412 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, 0x00 ,0xFF);//disable snr_vertical vertical c low pass and spike NR
1413 SC_W2BYTEMSK(0,REG_SC_BK0C_70_L, 0x01 ,0x01);//SPF off
1414 SC_W2BYTEMSK(0,REG_SC_BK0C_10_L, 0x00 ,0x17);//disable SPF DBK
1415 SC_W2BYTE(0,REG_SC_BK0C_30_L, 0x0000);//disable SPF SNR
1416 SC_W2BYTE(0,REG_SC_BK0C_50_L, 0x0000);//disable SPF NMR
1417 SC_W2BYTE(0,REG_SC_BK26_10_L, 0x0000);//disable SPF DMS
1418 SC_W2BYTEMSK(0,REG_SC_BK23_0B_L, 0x00 ,0xFF00);//disable vsp filter
1419 SC_W2BYTEMSK(0,REG_SC_BK23_0C_L, 0x00 ,0x0C00);//disable VSP CoRing
1420 SC_W2BYTEMSK(0,REG_SC_BK23_11_L, 0x00 ,0x80);//disable VSP DeRing
1421 SC_W2BYTEMSK(0,REG_SC_BK23_13_L, 0x00 ,0x08);//disable VSP PreVBound
1422 SC_W2BYTE(0,REG_SC_BK19_12_L, 0x0000);//disable VNMR and VLPF
1423 SC_W2BYTEMSK(0,REG_SC_BK19_7B_L, 0x00 ,0x01);//disable VNMR Y lowY
1424 SC_W2BYTEMSK(0,REG_SC_BK19_10_L, 0x00 ,0x7000);//disable vertical peaking band
1425 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, 0x00 ,0x10);//disable vertical adaptive peaking band
1426 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, 0x00 ,0x01);//disable Post SNR
1427 }
1428
1429 if(enWeaveType & E_ACE_WEAVETYPE_V)
1430 {
1431 SC_W2BYTEMSK(0,REG_SC_BK22_08_L, 0x00 ,0xFF00);
1432 // diable H scaling filter
1433 SC_W2BYTEMSK(0,REG_SC_BK23_0B_L, 0x00 ,0x00FF);
1434 // RGB 8bits
1435 SC_W2BYTEMSK(0,REG_SC_BK12_01_L, 0x10 ,0x00FF);
1436 SC_W2BYTEMSK(0,REG_SC_BK12_02_L, 0x00 ,0xFF00);
1437 // disable 422To444
1438 SC_W2BYTEMSK(0,REG_SC_BK23_0C_L, 0x40 ,0x00FF);
1439 // disable 444To422
1440 SC_W2BYTEMSK(0,REG_SC_BK02_0A_L, 0x00 ,0x00FF);
1441 // disable DNR
1442 SC_W2BYTEMSK(0,REG_SC_BK06_21_L, 0x10 ,0x00FF);
1443 // disable 2D peaking
1444 SC_W2BYTEMSK(0,REG_SC_BK19_10_L, 0x80 ,0x00FF);
1445 // disable Precti
1446 SC_W2BYTE(0,REG_SC_BK23_60_L, 0x00);
1447 SC_W2BYTE(0,REG_SC_BK23_61_L, 0x00);
1448 // disable Postcti
1449 SC_W2BYTE(0,REG_SC_BK27_20_L, 0x00);
1450 SC_W2BYTE(0,REG_SC_BK27_21_L, 0x00);
1451 SC_W2BYTE(0,REG_SC_BK18_50_L, 0x00);
1452 }
1453 //disable dms_v12
1454 SC_W2BYTEMSK(0,REG_SC_BK26_10_L, 0x0000 ,BIT(15));
1455 }
1456
1457
Hal_ACE_MWEEnable(void * pInstance,MS_BOOL ben,MS_BOOL bLoadFromTable)1458 void Hal_ACE_MWEEnable(void* pInstance,MS_BOOL ben, MS_BOOL bLoadFromTable)
1459 {
1460 if (ben)
1461 {
1462 if(!bLoadFromTable)
1463 {
1464 MHal_SC_SetMWEQuality();
1465 }
1466 if((MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED) && (!MApi_XC_GetForceWrite(E_MAIN_WINDOW_MUTE)) && (!MApi_XC_GetForceWrite(E_PANEL_MUTE)))
1467 {
1468
1469 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK20_10_L, BIT(1) | BIT(2) , BIT(1) | BIT(2) );
1470 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK10_19_L, 0x00, BIT(5));
1471 MApi_XC_MLoad_Fire(pInstance,TRUE);
1472
1473 }
1474 else
1475 {
1476 SC_W2BYTEMSK(0,REG_SC_BK20_10_L, BIT(1) | BIT(2) , BIT(1) | BIT(2) );
1477 SC_W2BYTEMSK(0,REG_SC_BK10_19_L, 0x00, BIT(5));
1478 }
1479 }
1480 else
1481 {
1482 if((MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED) && (!MApi_XC_GetForceWrite(E_MAIN_WINDOW_MUTE)) && (!MApi_XC_GetForceWrite(E_PANEL_MUTE)))
1483 {
1484
1485 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK20_10_L, 0x00, BIT(1) | BIT(2) );
1486 MApi_XC_MLoad_WriteCmd(pInstance,REG_SC_BK10_19_L, BIT(5), BIT(5));
1487 MApi_XC_MLoad_Fire(pInstance,TRUE);
1488
1489 }
1490 else
1491 {
1492 SC_W2BYTEMSK(0,REG_SC_BK20_10_L, 0x00, BIT(1) | BIT(2) );
1493 SC_W2BYTEMSK(0,REG_SC_BK10_19_L, BIT(5), BIT(5));
1494 }
1495 }
1496 }
1497
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)1498 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)
1499 {
1500 if(bScalerWin == MAIN_WINDOW)
1501 {
1502 SC_W2BYTEMSK(0,REG_SC_BK10_24_L, ((u16color & 0xFF) <<8), HBMASK);
1503 SC_W2BYTEMSK(0,REG_SC_BK0F_02_L, ((u16_l & 0xFF) <<8), HBMASK);
1504 SC_W2BYTEMSK(0,REG_SC_BK0F_03_L, ((u16_r & 0xFF) <<8), HBMASK);
1505 SC_W2BYTEMSK(0,REG_SC_BK0F_04_L, ((u16_t & 0xFF) <<8), HBMASK);
1506 SC_W2BYTEMSK(0,REG_SC_BK0F_05_L, ((u16_d & 0xFF) <<8), HBMASK);
1507 }
1508 else
1509 {
1510 SC_W2BYTEMSK(0,REG_SC_BK0F_17_L, u16color & 0xFF, LBMASK);
1511 SC_W2BYTEMSK(0,REG_SC_BK0F_02_L, u16_l & 0xFF, LBMASK);
1512 SC_W2BYTEMSK(0,REG_SC_BK0F_03_L, u16_r & 0xFF, LBMASK);
1513 SC_W2BYTEMSK(0,REG_SC_BK0F_04_L, u16_t & 0xFF, LBMASK);
1514 SC_W2BYTEMSK(0,REG_SC_BK0F_05_L, u16_d & 0xFF, LBMASK);
1515 }
1516 }
1517 ////////////////////////////////////////////////////////////////////////////////
1518 //
1519 // MWE end
1520 //
1521 ////////////////////////////////////////////////////////////////////////////////
1522
1523
1524 ////////////////////////////////////////////////////////////////////////////////
1525 //
1526 // DynamicNR start
1527 //
1528 ////////////////////////////////////////////////////////////////////////////////
1529
Hal_ACE_DNR_GetMotion(void * pInstance)1530 MS_U8 Hal_ACE_DNR_GetMotion(void* pInstance)
1531 {
1532 MS_U8 u8motion = (MS_U8)(SC_R2BYTE(0,REG_SC_BK0A_1A_L) & 0x007F);
1533 return u8motion;
1534 }
1535
Hal_ACE_DNR_GetCoringThreshold(void * pInstance,MS_BOOL bScalerWin)1536 MS_U8 Hal_ACE_DNR_GetCoringThreshold(void* pInstance,MS_BOOL bScalerWin)
1537 {
1538 MS_U8 u8val;
1539
1540 if(bScalerWin == MAIN_WINDOW)
1541 {
1542 u8val = SC_R2BYTE(0,REG_SC_BK19_13_L) & 0xFF;
1543 }
1544 else
1545 {
1546 u8val = SC_R2BYTE(0,REG_SC_BK19_17_L) & 0xFF;
1547 }
1548
1549 return u8val;
1550 }
1551
Hal_ACE_DNR_GetSharpnessAdjust(void * pInstance,MS_BOOL bScalerWin)1552 MS_U8 Hal_ACE_DNR_GetSharpnessAdjust(void* pInstance,MS_BOOL bScalerWin)
1553 {
1554 MS_U8 u8val;
1555
1556 if(bScalerWin == MAIN_WINDOW)
1557 {
1558 u8val = ((SC_R2BYTE(0,REG_SC_BK19_13_L) & 0xFF00)>>8);
1559 }
1560 else
1561 {
1562 u8val = ((SC_R2BYTE(0,REG_SC_BK19_17_L) & 0xFF00)>>8);
1563 }
1564
1565 return u8val;
1566 }
1567
Hal_ACE_DNR_GetGuassin_SNR_Threshold(void * pInstance,MS_BOOL bScalerWin)1568 MS_U8 Hal_ACE_DNR_GetGuassin_SNR_Threshold(void* pInstance,MS_BOOL bScalerWin)
1569 {
1570 MS_U8 u8val;
1571
1572 if(bScalerWin == MAIN_WINDOW)
1573 {
1574 u8val = ((SC_R2BYTE(0,REG_SC_BK19_60_L) & 0xFF00)>>8);
1575 }
1576 else
1577 {
1578 u8val = ((SC_R2BYTE(0,REG_SC_BK19_61_L) & 0xFF00)>>8);
1579 }
1580
1581 return u8val;
1582 }
1583
Hal_ACE_DNR_SetCoringThreshold(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1584 void Hal_ACE_DNR_SetCoringThreshold(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1585 {
1586 if(bScalerWin == MAIN_WINDOW)
1587 {
1588 SC_W2BYTEMSK(0,REG_SC_BK19_13_L, u16val, 0x00FF);
1589 }
1590 else
1591 {
1592 SC_W2BYTEMSK(0,REG_SC_BK19_17_L, u16val, 0x00FF);
1593 }
1594 }
1595
Hal_ACE_DNR_SetSharpnessAdjust(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1596 void Hal_ACE_DNR_SetSharpnessAdjust(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1597 {
1598 if(bScalerWin == MAIN_WINDOW)
1599 {
1600 SC_W2BYTEMSK(0,REG_SC_BK19_13_L, (u16val<<8), 0xFF00);
1601 }
1602 else
1603 {
1604 SC_W2BYTEMSK(0,REG_SC_BK19_17_L, (u16val<<8), 0xFF00);
1605 }
1606 }
1607
Hal_ACE_DNR_SetNM_V(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1608 void Hal_ACE_DNR_SetNM_V(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1609 {
1610 if(bScalerWin == MAIN_WINDOW)
1611 {
1612 SC_W2BYTEMSK(0,REG_SC_BK19_12_L, u16val, 0x00FF);
1613 }
1614 else
1615 {
1616 SC_W2BYTEMSK(0,REG_SC_BK19_16_L, u16val, 0x00FF);
1617 }
1618 }
1619
Hal_ACE_DNR_SetGNR_0(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1620 void Hal_ACE_DNR_SetGNR_0(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1621 {
1622 if(bScalerWin == MAIN_WINDOW)
1623 {
1624 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, u16val, 0x00FF);
1625 }
1626 else
1627 {
1628 SC_W2BYTEMSK(0,REG_SC_BK19_61_L, u16val, 0x00FF);
1629 }
1630 }
1631
Hal_ACE_DNR_SetGNR_1(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1632 void Hal_ACE_DNR_SetGNR_1(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1633 {
1634 if(bScalerWin == MAIN_WINDOW)
1635 {
1636 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, (u16val<<8), 0xFF00);
1637 }
1638 else
1639 {
1640 SC_W2BYTEMSK(0,REG_SC_BK19_61_L, (u16val<<8), 0xFF00);
1641 }
1642 }
1643
Hal_ACE_DNR_SetCP(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1644 void Hal_ACE_DNR_SetCP(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1645 {
1646 if(bScalerWin == MAIN_WINDOW)
1647 {
1648 SC_W2BYTEMSK(0,REG_SC_BK19_30_L, u16val, 0x00C1); // BIT(0), BIT(1) are reserved.
1649 }
1650 else
1651 {
1652 SC_W2BYTEMSK(0,REG_SC_BK19_30_L, u16val, 0x000E); // BIT(0), BIT(1) are reserved.
1653 }
1654 }
1655
Hal_ACE_DNR_SetDP(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1656 void Hal_ACE_DNR_SetDP(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1657 {
1658 if(bScalerWin == MAIN_WINDOW)
1659 {
1660 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, u16val, 0x00FF);
1661 }
1662 else
1663 {
1664 SC_W2BYTEMSK(0,REG_SC_BK19_31_L, (u16val<<8), 0xFF00);
1665 }
1666 }
1667
Hal_ACE_DNR_SetNM_H_0(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1668 void Hal_ACE_DNR_SetNM_H_0(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1669 {
1670 if(bScalerWin == MAIN_WINDOW)
1671 {
1672 SC_W2BYTEMSK(0,REG_SC_BK18_55_L, u16val, 0x00FF);
1673 }
1674 else
1675 {
1676 SC_W2BYTEMSK(0,REG_SC_BK18_5D_L, u16val, 0x00FF);
1677 }
1678 }
1679
Hal_ACE_DNR_SetNM_H_1(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1680 void Hal_ACE_DNR_SetNM_H_1(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1681 {
1682 if(bScalerWin == MAIN_WINDOW)
1683 {
1684 SC_W2BYTEMSK(0,REG_SC_BK18_55_L, (u16val<<8), 0xFF00);
1685 }
1686 else
1687 {
1688 SC_W2BYTEMSK(0,REG_SC_BK18_5D_L, (u16val<<8), 0xFF00);
1689 }
1690 }
1691
Hal_ACE_DNR_SetGray_Ground_Gain(void * pInstance,MS_U16 u16val)1692 void Hal_ACE_DNR_SetGray_Ground_Gain(void* pInstance,MS_U16 u16val)
1693 {
1694 SC_W2BYTEMSK(0,REG_SC_BK18_21_L, (u16val<<8), 0xF000);
1695 }
1696
Hal_ACE_DNR_SetGray_Ground_En(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1697 void Hal_ACE_DNR_SetGray_Ground_En(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1698 {
1699 if(bScalerWin == MAIN_WINDOW)
1700 {
1701 SC_W2BYTEMSK(0,REG_SC_BK18_10_L, (u16val?(BIT(7)):(0)), 0x0080);
1702 }
1703 else
1704 {
1705 SC_W2BYTEMSK(0,REG_SC_BK18_11_L, (u16val?(BIT(7)):(0)), 0x0080);
1706 }
1707 }
1708
Hal_ACE_DNR_SetSC_Coring(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1709 void Hal_ACE_DNR_SetSC_Coring(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1710 {
1711 if(bScalerWin == MAIN_WINDOW)
1712 {
1713 SC_W2BYTEMSK(0,REG_SC_BK23_0D_L, (u16val<<8), 0xFF00); // BK23_1B (8bit address)
1714 }
1715 else
1716 {
1717 SC_W2BYTEMSK(0,REG_SC_BK23_2D_L, (u16val<<8), 0xFF00);
1718 }
1719 }
1720
Hal_ACE_DNR_SetSpikeNR_0(void * pInstance,MS_U16 u16val)1721 void Hal_ACE_DNR_SetSpikeNR_0(void* pInstance,MS_U16 u16val)
1722 {
1723 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, u16val, 0x0001);
1724 }
1725
Hal_ACE_DNR_SetSpikeNR_1(void * pInstance,MS_U16 u16val)1726 void Hal_ACE_DNR_SetSpikeNR_1(void* pInstance,MS_U16 u16val)
1727 {
1728 SC_W2BYTEMSK(0,REG_SC_BK26_50_L, (u16val<<8), 0x0F00); //BK26_A0 (8bit address)
1729 SC_W2BYTEMSK(0,REG_SC_BK26_53_L, (u16val>>5), 0x0007); //BK26_A6 (8bit address)
1730 }
1731
Hal_ACE_DNR_SetSNR_NM(void * pInstance,MS_U16 u16val)1732 void Hal_ACE_DNR_SetSNR_NM(void* pInstance,MS_U16 u16val)
1733 {
1734 SC_W2BYTEMSK(0,REG_SC_BK0C_54_L, u16val, 0x00FF);
1735 }
1736
Hal_ACE_DNR_SetBank_Coring(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1737 void Hal_ACE_DNR_SetBank_Coring(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1738 {
1739 if(bScalerWin == MAIN_WINDOW)
1740 {
1741 SC_W2BYTE(0,REG_SC_BK19_33_L, u16val);
1742 SC_W2BYTE(0,REG_SC_BK19_34_L, u16val);
1743 }
1744 else
1745 {
1746 SC_W2BYTE(0,REG_SC_BK19_35_L, u16val);
1747 SC_W2BYTE(0,REG_SC_BK19_36_L, u16val);
1748 }
1749 }
1750
1751
Hal_ACE_DNR_SetGuassin_SNR_Threshold(void * pInstance,MS_BOOL bScalerWin,MS_U16 u16val)1752 void Hal_ACE_DNR_SetGuassin_SNR_Threshold(void* pInstance,MS_BOOL bScalerWin, MS_U16 u16val)
1753 {
1754 if(bScalerWin == MAIN_WINDOW)
1755 {
1756 SC_W2BYTEMSK(0,REG_SC_BK19_60_L, (u16val<<8), 0xFF00);
1757 }
1758 else
1759 {
1760 SC_W2BYTEMSK(0,REG_SC_BK19_61_L, (u16val<<8), 0xFF00);
1761 }
1762 }
1763
Hal_ACE_DNR_SetNRTbl_Y(void * pInstance,MS_U8 u8Idx,MS_U16 u16val)1764 void Hal_ACE_DNR_SetNRTbl_Y(void* pInstance,MS_U8 u8Idx, MS_U16 u16val)
1765 {
1766 SC_W2BYTE(0,(REG_SC_BK06_40_L+u8Idx), u16val);
1767 }
1768
Hal_ACE_DNR_SetNRTbl_C(void * pInstance,MS_U8 u8Idx,MS_U16 u16val)1769 void Hal_ACE_DNR_SetNRTbl_C(void* pInstance,MS_U8 u8Idx, MS_U16 u16val)
1770 {
1771 SC_W2BYTE(0,(REG_SC_BK06_44_L+u8Idx), u16val);
1772 }
1773
1774 // Write command by Menuload
Hal_ACE_Write_Color_Matrix_Burst(void * pInstance,MS_BOOL bWindow,MS_U16 * psMatrix)1775 void Hal_ACE_Write_Color_Matrix_Burst( void* pInstance,MS_BOOL bWindow, MS_U16* psMatrix )
1776 {
1777 MS_U8 i,j;
1778 MS_U32 ucAddr;
1779 MS_S16 sTmp;
1780 //DECLARA_BANK_VARIABLE
1781
1782 //BACKUP_SC_BANK
1783 if( bWindow == MAIN_WINDOW )
1784 {
1785 //SET_SC_BANK(BANK_CM_MAIN);
1786 ucAddr = REG_SC_BK10_26_L;
1787
1788 }
1789 else
1790 {
1791 //SET_SC_BANK(BANK_CM_SUB);
1792 ucAddr = REG_SC_BK0F_1D_L;
1793
1794 }
1795
1796 for(i=0; i!=3; i++)
1797 {
1798 for(j=0; j!=3; j++)
1799 {
1800 sTmp = psMatrix[i*3+j];
1801 if( sTmp >= 0 )
1802 {
1803 if( sTmp > 0xfff )
1804 {
1805 sTmp = 0xfff;
1806 }
1807
1808 }
1809 else
1810 {
1811 sTmp = sTmp * -1;
1812 if( sTmp > 0xfff )
1813 {
1814 sTmp = 0xfff;
1815 }
1816 sTmp |= 0x1000;
1817
1818 }
1819 MApi_XC_MLoad_WriteCmd(pInstance, ucAddr, sTmp , 0x1FFF);
1820
1821 ucAddr += 2;
1822 } // for
1823 } // for
1824 MApi_XC_MLoad_Fire(pInstance,TRUE);
1825
1826
1827
1828 }
1829
1830 // Write command by Menuload
Hal_ACE_Is_Support_MLoad(void * pInstance)1831 MS_BOOL Hal_ACE_Is_Support_MLoad(void* pInstance)
1832 {
1833 if (MApi_XC_MLoad_GetStatus_U2(pInstance) == E_MLOAD_ENABLED)
1834 return TRUE;
1835 else
1836 return FALSE;
1837 }
1838
1839 //-------------------------------------------------------------------------------------------------
1840 // Skip Wait Vsync
1841 // @param eWindow \b IN: Indicates the window where the ACE function applies to.
1842 // @param Skip wait Vsync \b IN: Disable wait Vsync
1843 //-------------------------------------------------------------------------------------------------
Hal_ACE_SetSkipWaitVsync(void * pInstance,MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)1844 void Hal_ACE_SetSkipWaitVsync( void* pInstance,MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)
1845 {
1846
1847 if(eWindow == MAIN_WINDOW )
1848 {
1849 bMainWinSkipWaitVsyn= bIsSkipWaitVsyn;
1850 }
1851 else
1852 {
1853 bSubWinSkipWaitVsyn = bIsSkipWaitVsyn;
1854 }
1855 }
1856
Hal_ACE_GetSkipWaitVsync(void * pInstance,MS_BOOL bScalerWin)1857 MS_BOOL Hal_ACE_GetSkipWaitVsync( void* pInstance,MS_BOOL bScalerWin)
1858 {
1859 if(bScalerWin == MAIN_WINDOW)
1860 {
1861 return bMainWinSkipWaitVsyn;
1862 }
1863 else
1864 {
1865 return bSubWinSkipWaitVsyn;
1866 }
1867 }
Hal_ACE_GetBrightness(void * pInstance,MS_BOOL bScalerWin,MS_U8 * u8RedBrightness,MS_U8 * u8GreenBrightness,MS_U8 * u8BlueBrightness)1868 void Hal_ACE_GetBrightness(void* pInstance, MS_BOOL bScalerWin, MS_U8* u8RedBrightness, MS_U8* u8GreenBrightness, MS_U8* u8BlueBrightness)
1869 {
1870 }
Hal_ACE_Set_Device_Bank_Offset(void)1871 void Hal_ACE_Set_Device_Bank_Offset(void)
1872 {
1873 memset(u32XCDeviceBankOffset, 0, sizeof(MS_U32)*XC_ACE_MAX_DEVICE_NUM);
1874 u32XCDeviceBankOffset[XC_ACE_DEVICE0] = E_HALACE_DEVICE0_XC_BANK_OFFSET; // Set SC0 reg bank offset
1875 }
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)1876 void Hal_ACE_SetPostRGBGainOffsetTogether(void* pInstance, MS_BOOL bScalerWin,
1877 MS_U16 u16RedGain, MS_U16 u16GreenGain, MS_U16 u16BlueGain,
1878 MS_U16 u16RedOffset, MS_U16 u16GreenOffset, MS_U16 u16BlueOffset)
1879 {
1880 if(MAIN_WINDOW == bScalerWin)
1881 {
1882 SC_W2BYTE(0, REG_SC_BK25_21_L, u16RedOffset);
1883 SC_W2BYTE(0, REG_SC_BK25_22_L, u16GreenOffset);
1884 SC_W2BYTE(0, REG_SC_BK25_23_L, u16BlueOffset);
1885 SC_W2BYTE(0, REG_SC_BK25_24_L, u16RedGain);
1886 SC_W2BYTE(0, REG_SC_BK25_25_L, u16GreenGain);
1887 SC_W2BYTE(0, REG_SC_BK25_26_L, u16BlueGain);
1888 SC_W2BYTEMSK(0, REG_SC_BK25_01_L, BIT(6) | BIT(5) | BIT(4), BIT(6) | BIT(5) | BIT(4));
1889 }
1890 else
1891 {
1892 SC_W2BYTE(0, REG_SC_BK25_27_L, u16RedOffset);
1893 SC_W2BYTE(0, REG_SC_BK25_28_L, u16GreenOffset);
1894 SC_W2BYTE(0, REG_SC_BK25_29_L, u16BlueOffset);
1895 SC_W2BYTE(0, REG_SC_BK25_2A_L, u16RedGain);
1896 SC_W2BYTE(0, REG_SC_BK25_2B_L, u16GreenGain);
1897 SC_W2BYTE(0, REG_SC_BK25_2C_L, u16BlueGain);
1898 SC_W2BYTEMSK(0, REG_SC_BK25_11_L, BIT(6) | BIT(5) | BIT(4), BIT(6) | BIT(5) | BIT(4));
1899 }
1900 }
Hal_ACE_SetICC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_ICC_COLOR_TYPE eICC,MS_U8 u8Val)1901 MS_BOOL Hal_ACE_SetICC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_ICC_COLOR_TYPE eICC, MS_U8 u8Val)
1902 {
1903 return 0;
1904 }
1905
Hal_ACE_GetICC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_ICC_COLOR_TYPE eICC,MS_U8 * pu8Val)1906 MS_BOOL Hal_ACE_GetICC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_ICC_COLOR_TYPE eICC, MS_U8* pu8Val)
1907 {
1908 *pu8Val = 0;
1909 return 0;
1910 }
1911
Hal_ACE_SetIBC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IBC_COLOR_TYPE eIBC,MS_U8 u8Val)1912 MS_BOOL Hal_ACE_SetIBC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IBC_COLOR_TYPE eIBC, MS_U8 u8Val)
1913 {
1914 return 0;
1915 }
1916
Hal_ACE_GetIBC(void * pInstance,MS_BOOL bScalerWin,XC_ACE_IBC_COLOR_TYPE eIBC,MS_U8 * pu8Val)1917 MS_BOOL Hal_ACE_GetIBC(void* pInstance, MS_BOOL bScalerWin, XC_ACE_IBC_COLOR_TYPE eIBC, MS_U8* pu8Val)
1918 {
1919 *pu8Val = 0;
1920 return 0;
1921 }
1922
HAL_ACE_Set_RBChannelOffset(void * pInstance,MS_BOOL bScalerWin,MS_BOOL bEnable)1923 void HAL_ACE_Set_RBChannelOffset(void* pInstance, MS_BOOL bScalerWin, MS_BOOL bEnable)
1924 {
1925 }
1926
1927 ////////////////////////////////////////////////////////////////////////////////
1928 //
1929 // DynamicNR end
1930 //
1931 ////////////////////////////////////////////////////////////////////////////////
1932
1933 #undef MHAL_ACE_C
1934
1935