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