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