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