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