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