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-2010 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
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 /// file Mdrv_ld.c
97 /// @brief local dimming Driver Interface
98 /// @author MStar Semiconductor Inc.
99 ///////////////////////////////////////////////////////////////////////////////////////////////////
100
101 #define _MDRV_LD_C_
102
103 #include "MsCommon.h"
104 #include "MsOS.h"
105 #include "mhal_xc_chip_config.h"
106 #include "halCHIP.h"
107 #include "utopia.h"
108 #include "utopia_dapi.h"
109 #include "drvXC_IOPort.h"
110 #include "apiXC.h"
111 #include "apiXC_Adc.h"
112 #include "apiXC_Auto.h"
113 #include "drv_sc_display.h"
114 #include "drv_sc_isr.h"
115 #include "apiXC_PCMonitor.h"
116 #include "apiXC_ModeParse.h"
117 #include "drvXC_HDMI_if.h"
118 #include "mvideo_context.h"
119 #include "drv_sc_ip.h"
120 #if (LD_ENABLE==1)
121 #include "mdrv_ld.h"
122 #include "mdrv_ldalgo.h"
123 #endif
124 #include "mdrv_sc_3d.h"
125 #include "drv_sc_menuload.h"
126 #include "drvXC_ADC_Internal.h"
127 #include "mhal_sc.h"
128 #if FRC_INSIDE
129 #include "mdrv_frc.h"
130 #include "mhal_frc.h"
131 #endif
132 #include "XC_private.h"
133 #include "apiXC_v2.h"
134 #ifndef UNUSED
135 #define UNUSED(x) ((x) = (x))
136 #endif
137
138 #ifndef ASSERT
139 #define ASSERT(arg) do {\
140 if (!(arg)) {\
141 printf("BUG at %s:%d assert(%s)\n",\
142 __FILE__, __LINE__, #arg);\
143 }\
144 } while (0)
145 #endif
146
147 #define H_SCACLING_TABLE_SIZE 128
148 #define V_SCACLING_TABLE_SIZE 128
149 #define COMPENSATION_LENGTH 512
150
151 #if (LD_ENABLE == 1)
152 #include "mdrv_ld_compensation.h"
153 #include "mdrv_ld_edge2d.h"
154
155 #define LD_LED_NUMBER (((MS_U16)pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH) * pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV)
156 #define LD_PANEL_WIDTH pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u16PanelWidth // 1920
157 #define LD_PANEL_HEIGHT pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u16PanelHeight // 1080
158
159
160 #define EDGE2D_PACKET_LENGTH 16
161 #define H_V_RATIO_CONST 1048576ul
162
163 // When mspi_internal_clk=27M
164 // DIV_2 = 0.074us
165 // DIV_4 = 0.148us
166 // DIV_8 = 0.296us
167 // DIV_16 = 0.592us
168 // DIV_32 = 1.185us
169 // DIV_64 = 2.370us
170 // DIV_128 = 4.740us
171 // DIV_256 = 9.481us
172
173 // LG spec:
174 // SPI clock: 1.66us ~ 10us ==> MSPI_CLK_SPD__CPU_DIV_256
175 // V sync to first clk: 20us ~ 50u5 ==> 20 = Tr_Start=16, Tr_End=0
176 // Between byte to byte: 5 ~ 20 ==> 10 = Tr_Start=5, Tr_End=0
177 static ST_DRV_LD_INFO _stDrvLDInfo_Defalut =
178 {
179 1920, 1080, // Panel size
180
181 4, // u8LedNumH
182 2, // u8LedNumV
183
184 32, 32, // Backlight
185
186 Tbl_LD_Compensation_LG37inch_LR10,
187 #if !defined (__aarch64__)
188 0,
189 #endif
190
191 Tbl_LD_Edge2D_LG37inch_LR10,
192 #if !defined (__aarch64__)
193 0,
194 #endif
195 // MSPI_CLK_SPD__DIV_64, // eMSPIClockSpeed
196 0, // u8SpiClockPolarity
197 0, // u8SpiClockPhase
198
199 10, // u8SpiTime_VSyncWidth
200 20, // u8SpiTime_VSync_To_FirstClock
201 5, // u8SpiTime_Byte_to_Byte
202
203 2, // SPI Command length
204 {0xAA,0x83}, // SPI Command
205 1, // u8CheckSumMode
206 };
207
208 static ST_DRV_LD_INFO _stDrvLDInfo_LD_PANEL_LG37inch_LR10 =
209 {
210 1920, 1080, // Panel size
211
212 2, // u8LedNumH
213 5, // u8LedNumV
214
215 16, 10, // Backlight
216
217 Tbl_LD_Compensation_LG37inch_LR10,
218 #if !defined (__aarch64__)
219 0,
220 #endif
221 Tbl_LD_Edge2D_LG37inch_LR10,
222 #if !defined (__aarch64__)
223 0,
224 #endif
225 // MSPI_CLK_SPD__DIV_64, // eMSPIClockSpeed
226 0, // u8SpiClockPolarity
227 0, // u8SpiClockPhase
228
229 10, // u8SpiTime_VSyncWidth
230 20, // u8SpiTime_VSync_To_FirstClock
231 5, // u8SpiTime_Byte_to_Byte
232
233 2, // SPI Command length
234 {0xAA,0x83}, // SPI Command
235 1, // u8CheckSumMode
236 };
237
238 static ST_DRV_LD_INFO _stDrvLDInfo_LD_PANEL_LG42inch_LR16 =
239 {
240 1920, 1080, // Panel size
241
242 2, // u8LedNumH
243 8, // u8LedNumV
244
245 24, 16, // Backlight
246
247 Tbl_LD_Compensation_LG42inch_LR16,
248 #if !defined (__aarch64__)
249 0,
250 #endif
251 Tbl_LD_Edge2D_LG42inch_LR16,
252 #if !defined (__aarch64__)
253 0,
254 #endif
255 //MSPI_CLK_SPD__DIV_64, // eMSPIClockSpeed
256 0, // u8SpiClockPolarity
257 0, // u8SpiClockPhase
258
259 20, // u8SpiTime_VSyncWidth
260 32, // u8SpiTime_VSync_To_FirstClock
261 5, // u8SpiTime_Byte_to_Byte
262
263 2, // SPI Command length
264 {0xAA,0x83}, // SPI Command
265 1, // u8CheckSumMode
266 };
267
268 static ST_DRV_LD_INFO _stDrvLDInfo_LD_PANEL_LG55inch_LR12 =
269 {
270 1920, 1080, // Panel size
271
272 2, // u8LedNumH
273 6, // u8LedNumV
274
275 24, 18, // Backlight
276
277 Tbl_LD_Compensation_LG55inch_LR12,
278 #if !defined (__aarch64__)
279 0,
280 #endif
281 Tbl_LD_Edge2D_LG55inch_LR12,
282 #if !defined (__aarch64__)
283 0,
284 #endif
285 //MSPI_CLK_SPD__DIV_64, // eMSPIClockSpeed
286 0, // u8SpiClockPolarity
287 0, // u8SpiClockPhase
288
289 20, // u8SpiTime_VSyncWidth
290 32, // u8SpiTime_VSync_To_FirstClock
291 5, // u8SpiTime_Byte_to_Byte
292
293 2, // SPI Command length
294 {0xAA,0x85}, // SPI Command
295 1, // u8CheckSumMode
296 };
297
298 static ST_DRV_LD_INFO _stDrvLDInfo_LD_PANEL_CMO42inch_LR16 =
299 {
300 1920, 1080, // Panel size
301
302 2, // u8LedNumH
303 8, // u8LedNumV
304
305 24, 16, // Backlight
306
307 Tbl_LD_Compensation_CMO42inch_LR16,
308 #if !defined (__aarch64__)
309 0,
310 #endif
311 Tbl_LD_Edge2D_CMO42inch_LR16,
312 #if !defined (__aarch64__)
313 0,
314 #endif
315 //MSPI_CLK_SPD__DIV_64, // eMSPIClockSpeed
316 0, // u8SpiClockPolarity
317 0, // u8SpiClockPhase
318
319 20, // u8SpiTime_VSyncWidth
320 32, // u8SpiTime_VSync_To_FirstClock
321 5, // u8SpiTime_Byte_to_Byte
322
323 2, // SPI Command length
324 {0xAA,0x83}, // SPI Command
325 1, // u8CheckSumMode
326 };
327
328 static ST_DRV_LD_INFO _stDrvLDInfo_LD_PANEL_LG50inch_4K2K_VB1 =
329 {
330 3840, 2160, // Panel size
331
332 1, // u8LedNumH
333 8, // u8LedNumV
334
335 24, 16, // Backlight
336
337 Tbl_LD_Compensation_CMO42inch_LR16,
338 #if !defined (__aarch64__)
339 0,
340 #endif
341 Tbl_LD_Edge2D_CMO42inch_LR16,
342 #if !defined (__aarch64__)
343 0,
344 #endif
345 //MSPI_CLK_SPD__DIV_64, // eMSPIClockSpeed
346 0, // u8SpiClockPolarity
347 0, // u8SpiClockPhase
348
349 20, // u8SpiTime_VSyncWidth
350 32, // u8SpiTime_VSync_To_FirstClock
351 5, // u8SpiTime_Byte_to_Byte
352
353 2, // SPI Command length
354 {0xAA,0x83}, // SPI Command
355 1, // u8CheckSumMode
356 };
357
358 //static MS_U8 s_au8DrvLD_SPIBuf[DRV_LD_SPI_BUF_MAX_SIZE];
359 //static MS_U8 s_au8DrvLD_SPI_delay[DRV_LD_SPI_BUF_MAX_SIZE];
360
361 MS_U8 au8Coeff_HScaling[128*6] =
362 {
363 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00,
364 0x00, 0x00, 0x02, 0xFE, 0x00, 0x00,
365 0x00, 0x00, 0x03, 0xFD, 0x00, 0x00,
366 0x00, 0x00, 0x04, 0xFC, 0x00, 0x00,
367 0x00, 0x00, 0x05, 0xFB, 0x00, 0x00,
368 0x00, 0x00, 0x06, 0xFA, 0x00, 0x00,
369 0x00, 0x00, 0x07, 0xF9, 0x00, 0x00,
370 0x00, 0x00, 0x08, 0xF8, 0x00, 0x00,
371 0x00, 0x00, 0x09, 0xF7, 0x00, 0x00,
372 0x00, 0x00, 0x0A, 0xF6, 0x00, 0x00,
373 0x00, 0x00, 0x0B, 0xF5, 0x00, 0x00,
374 0x00, 0x00, 0x0C, 0xF4, 0x00, 0x00,
375 0x00, 0x00, 0x0D, 0xF3, 0x00, 0x00,
376 0x00, 0x00, 0x0E, 0xF2, 0x00, 0x00,
377 0x00, 0x00, 0x0F, 0xF1, 0x00, 0x00,
378 0x00, 0x00, 0x10, 0xF0, 0x00, 0x00,
379 0x00, 0x00, 0x11, 0xEF, 0x00, 0x00,
380 0x00, 0x00, 0x12, 0xEE, 0x00, 0x00,
381 0x00, 0x00, 0x13, 0xED, 0x00, 0x00,
382 0x00, 0x00, 0x14, 0xEC, 0x00, 0x00,
383 0x00, 0x00, 0x15, 0xEB, 0x00, 0x00,
384 0x00, 0x00, 0x16, 0xEA, 0x00, 0x00,
385 0x00, 0x00, 0x17, 0xE9, 0x00, 0x00,
386 0x00, 0x00, 0x18, 0xE8, 0x00, 0x00,
387 0x00, 0x00, 0x19, 0xE7, 0x00, 0x00,
388 0x00, 0x00, 0x1A, 0xE6, 0x00, 0x00,
389 0x00, 0x00, 0x1B, 0xE5, 0x00, 0x00,
390 0x00, 0x00, 0x1C, 0xE4, 0x00, 0x00,
391 0x00, 0x00, 0x1D, 0xE3, 0x00, 0x00,
392 0x00, 0x00, 0x1E, 0xE2, 0x00, 0x00,
393 0x00, 0x00, 0x1F, 0xE1, 0x00, 0x00,
394 0x00, 0x00, 0x20, 0xE0, 0x00, 0x00,
395 0x00, 0x00, 0x21, 0xDF, 0x00, 0x00,
396 0x00, 0x00, 0x22, 0xDE, 0x00, 0x00,
397 0x00, 0x00, 0x23, 0xDD, 0x00, 0x00,
398 0x00, 0x00, 0x24, 0xDC, 0x00, 0x00,
399 0x00, 0x00, 0x25, 0xDB, 0x00, 0x00,
400 0x00, 0x00, 0x26, 0xDA, 0x00, 0x00,
401 0x00, 0x00, 0x27, 0xD9, 0x00, 0x00,
402 0x00, 0x00, 0x28, 0xD8, 0x00, 0x00,
403 0x00, 0x00, 0x29, 0xD7, 0x00, 0x00,
404 0x00, 0x00, 0x2A, 0xD6, 0x00, 0x00,
405 0x00, 0x00, 0x2B, 0xD5, 0x00, 0x00,
406 0x00, 0x00, 0x2C, 0xD4, 0x00, 0x00,
407 0x00, 0x00, 0x2D, 0xD3, 0x00, 0x00,
408 0x00, 0x00, 0x2E, 0xD2, 0x00, 0x00,
409 0x00, 0x00, 0x2F, 0xD1, 0x00, 0x00,
410 0x00, 0x00, 0x30, 0xD0, 0x00, 0x00,
411 0x00, 0x00, 0x31, 0xCF, 0x00, 0x00,
412 0x00, 0x00, 0x32, 0xCE, 0x00, 0x00,
413 0x00, 0x00, 0x33, 0xCD, 0x00, 0x00,
414 0x00, 0x00, 0x34, 0xCC, 0x00, 0x00,
415 0x00, 0x00, 0x35, 0xCB, 0x00, 0x00,
416 0x00, 0x00, 0x36, 0xCA, 0x00, 0x00,
417 0x00, 0x00, 0x37, 0xC9, 0x00, 0x00,
418 0x00, 0x00, 0x38, 0xC8, 0x00, 0x00,
419 0x00, 0x00, 0x39, 0xC7, 0x00, 0x00,
420 0x00, 0x00, 0x3A, 0xC6, 0x00, 0x00,
421 0x00, 0x00, 0x3B, 0xC5, 0x00, 0x00,
422 0x00, 0x00, 0x3C, 0xC4, 0x00, 0x00,
423 0x00, 0x00, 0x3D, 0xC3, 0x00, 0x00,
424 0x00, 0x00, 0x3E, 0xC2, 0x00, 0x00,
425 0x00, 0x00, 0x3F, 0xC1, 0x00, 0x00,
426 0x00, 0x00, 0x40, 0xC0, 0x00, 0x00,
427 0x00, 0x00, 0x41, 0xBF, 0x00, 0x00,
428 0x00, 0x00, 0x42, 0xBE, 0x00, 0x00,
429 0x00, 0x00, 0x43, 0xBD, 0x00, 0x00,
430 0x00, 0x00, 0x44, 0xBC, 0x00, 0x00,
431 0x00, 0x00, 0x45, 0xBB, 0x00, 0x00,
432 0x00, 0x00, 0x46, 0xBA, 0x00, 0x00,
433 0x00, 0x00, 0x47, 0xB9, 0x00, 0x00,
434 0x00, 0x00, 0x48, 0xB8, 0x00, 0x00,
435 0x00, 0x00, 0x49, 0xB7, 0x00, 0x00,
436 0x00, 0x00, 0x4A, 0xB6, 0x00, 0x00,
437 0x00, 0x00, 0x4B, 0xB5, 0x00, 0x00,
438 0x00, 0x00, 0x4C, 0xB4, 0x00, 0x00,
439 0x00, 0x00, 0x4D, 0xB3, 0x00, 0x00,
440 0x00, 0x00, 0x4E, 0xB2, 0x00, 0x00,
441 0x00, 0x00, 0x4F, 0xB1, 0x00, 0x00,
442 0x00, 0x00, 0x50, 0xB0, 0x00, 0x00,
443 0x00, 0x00, 0x51, 0xAF, 0x00, 0x00,
444 0x00, 0x00, 0x52, 0xAE, 0x00, 0x00,
445 0x00, 0x00, 0x53, 0xAD, 0x00, 0x00,
446 0x00, 0x00, 0x54, 0xAC, 0x00, 0x00,
447 0x00, 0x00, 0x55, 0xAB, 0x00, 0x00,
448 0x00, 0x00, 0x56, 0xAA, 0x00, 0x00,
449 0x00, 0x00, 0x57, 0xA9, 0x00, 0x00,
450 0x00, 0x00, 0x58, 0xA8, 0x00, 0x00,
451 0x00, 0x00, 0x59, 0xA7, 0x00, 0x00,
452 0x00, 0x00, 0x5A, 0xA6, 0x00, 0x00,
453 0x00, 0x00, 0x5B, 0xA5, 0x00, 0x00,
454 0x00, 0x00, 0x5C, 0xA4, 0x00, 0x00,
455 0x00, 0x00, 0x5D, 0xA3, 0x00, 0x00,
456 0x00, 0x00, 0x5E, 0xA2, 0x00, 0x00,
457 0x00, 0x00, 0x5F, 0xA1, 0x00, 0x00,
458 0x00, 0x00, 0x60, 0xA0, 0x00, 0x00,
459 0x00, 0x00, 0x61, 0x9F, 0x00, 0x00,
460 0x00, 0x00, 0x62, 0x9E, 0x00, 0x00,
461 0x00, 0x00, 0x63, 0x9D, 0x00, 0x00,
462 0x00, 0x00, 0x64, 0x9C, 0x00, 0x00,
463 0x00, 0x00, 0x65, 0x9B, 0x00, 0x00,
464 0x00, 0x00, 0x66, 0x9A, 0x00, 0x00,
465 0x00, 0x00, 0x67, 0x99, 0x00, 0x00,
466 0x00, 0x00, 0x68, 0x98, 0x00, 0x00,
467 0x00, 0x00, 0x69, 0x97, 0x00, 0x00,
468 0x00, 0x00, 0x6A, 0x96, 0x00, 0x00,
469 0x00, 0x00, 0x6B, 0x95, 0x00, 0x00,
470 0x00, 0x00, 0x6C, 0x94, 0x00, 0x00,
471 0x00, 0x00, 0x6D, 0x93, 0x00, 0x00,
472 0x00, 0x00, 0x6E, 0x92, 0x00, 0x00,
473 0x00, 0x00, 0x6F, 0x91, 0x00, 0x00,
474 0x00, 0x00, 0x70, 0x90, 0x00, 0x00,
475 0x00, 0x00, 0x71, 0x8F, 0x00, 0x00,
476 0x00, 0x00, 0x72, 0x8E, 0x00, 0x00,
477 0x00, 0x00, 0x73, 0x8D, 0x00, 0x00,
478 0x00, 0x00, 0x74, 0x8C, 0x00, 0x00,
479 0x00, 0x00, 0x75, 0x8B, 0x00, 0x00,
480 0x00, 0x00, 0x76, 0x8A, 0x00, 0x00,
481 0x00, 0x00, 0x77, 0x89, 0x00, 0x00,
482 0x00, 0x00, 0x78, 0x88, 0x00, 0x00,
483 0x00, 0x00, 0x79, 0x87, 0x00, 0x00,
484 0x00, 0x00, 0x7A, 0x86, 0x00, 0x00,
485 0x00, 0x00, 0x7B, 0x85, 0x00, 0x00,
486 0x00, 0x00, 0x7C, 0x84, 0x00, 0x00,
487 0x00, 0x00, 0x7D, 0x83, 0x00, 0x00,
488 0x00, 0x00, 0x7E, 0x82, 0x00, 0x00,
489 0x00, 0x00, 0x7F, 0x81, 0x00, 0x00,
490 0x00, 0x00, 0x80, 0x80, 0x00, 0x00
491 };
492
MDrv_XC_LD_Init(void * pInstance,EN_LD_PANEL_TYPE enLDPanelType)493 MS_BOOL MDrv_XC_LD_Init(void* pInstance, EN_LD_PANEL_TYPE enLDPanelType)
494 {
495 MS_BOOL bReturn = FALSE;
496 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
497 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
498 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
499
500 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
501 pXCResourcePrivate->stdrv_LD._bIsLDPanel = FALSE;
502 switch(enLDPanelType)
503 {
504 case E_LD_PANEL_LG37inch_LR10:
505 pXCResourcePrivate->stdrv_LD._stDrvLDInfo = _stDrvLDInfo_LD_PANEL_LG37inch_LR10;
506 pXCResourcePrivate->stdrv_LD._bIsLDPanel = TRUE;
507 break;
508 case E_LD_PANEL_LG42inch_LR16:
509 pXCResourcePrivate->stdrv_LD._stDrvLDInfo = _stDrvLDInfo_LD_PANEL_LG42inch_LR16;
510 pXCResourcePrivate->stdrv_LD._bIsLDPanel = TRUE;
511 break;
512 case E_LD_PANEL_LG55inch_LR12:
513 pXCResourcePrivate->stdrv_LD._stDrvLDInfo = _stDrvLDInfo_LD_PANEL_LG55inch_LR12;
514 pXCResourcePrivate->stdrv_LD._bIsLDPanel = TRUE;
515 break;
516 case E_LD_PANEL_CMO42inch_LR16:
517 pXCResourcePrivate->stdrv_LD._stDrvLDInfo = _stDrvLDInfo_LD_PANEL_CMO42inch_LR16;
518 pXCResourcePrivate->stdrv_LD._bIsLDPanel = TRUE;
519 break;
520 case E_LD_PANEL_LG50inch_4K2K_VB1:
521 pXCResourcePrivate->stdrv_LD._stDrvLDInfo = _stDrvLDInfo_LD_PANEL_LG50inch_4K2K_VB1;
522 break;
523 case E_LD_PANEL_DEFAULT:
524 //_stDrvLDInfo = _stDrvLDInfo__defalut;
525 pXCResourcePrivate->stdrv_LD._stDrvLDInfo = _stDrvLDInfo_Defalut;
526 break;
527 default:
528 //printf("Unknown LD panel type=%u\n", enLDPanelType);
529 ASSERT(enLDPanelType < E_LD_PANEL_NUMS);
530 bReturn = FALSE;
531 return bReturn;
532 }
533
534 pXCResourcePrivate->stdrv_LD._enLDPanelType = enLDPanelType;
535
536 MDrv_LD_Init(pInstance);
537 MDrv_LD_CommonInit(pInstance);
538 MDrv_XC_LD_SetPanelType(pInstance, enLDPanelType);
539
540 MDrv_XC_LD_ISR(pInstance);
541 pXCResourcePrivate->stdrv_LD._bMDrvLD_InitFinished = TRUE;
542 bReturn = TRUE;
543 return bReturn;
544 }
545
MApi_XC_LD_Init_U2(void * pInstance,EN_LD_PANEL_TYPE enLDPanelType)546 MS_BOOL MApi_XC_LD_Init_U2(void* pInstance, EN_LD_PANEL_TYPE enLDPanelType )
547 {
548 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
549 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
550 MS_BOOL bReturn = FALSE;
551 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
552 bReturn = MDrv_XC_LD_Init(pInstance, enLDPanelType);
553 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
554 return bReturn;
555 }
556
MApi_XC_LD_Init(EN_LD_PANEL_TYPE enLDPanelType)557 MS_BOOL MApi_XC_LD_Init(EN_LD_PANEL_TYPE enLDPanelType )
558 {
559 if (pu32XCInst == NULL)
560 {
561 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
562 return FALSE;
563 }
564
565 stXC_LD_INIT XCArgs;
566 XCArgs.enLDPanelType = enLDPanelType;
567 XCArgs.bReturnValue = FALSE;
568
569 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_LD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
570 {
571 printf("Obtain XC engine fail\n");
572 return FALSE;
573 }
574 else
575 {
576 return XCArgs.bReturnValue;
577 }
578 }
579
MDrv_XC_LD_SetMemoryAddress(void * pInstance,MS_PHY u32LDFBase0,MS_PHY u32LDFBase1,MS_PHY u32LDBBase0,MS_PHY u32LDBBase1,MS_PHY u32EDGE2DBase,MS_PHY u32LEDOffset)580 void MDrv_XC_LD_SetMemoryAddress(void* pInstance,
581 MS_PHY u32LDFBase0,
582 MS_PHY u32LDFBase1,
583 MS_PHY u32LDBBase0,
584 MS_PHY u32LDBBase1,
585 MS_PHY u32EDGE2DBase,
586 MS_PHY u32LEDOffset)
587 {
588 MS_PHY u32R2BaseAddr = 0;
589 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
590 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
591 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
592
593 MDrv_LD_Set_LDF_FrameBufBaseAddr(pInstance, 0, u32LDFBase0);
594 MDrv_LD_Set_LDF_FrameBufBaseAddr(pInstance, 1, u32LDFBase1);
595 MDrv_LD_Set_LDB_FrameBufBaseAddr(pInstance, 0, u32LDBBase0);
596 MDrv_LD_Set_LDB_FrameBufBaseAddr(pInstance, 1, u32LDBBase1);
597 MDrv_LD_Set_EDGE2D_BaseAddr(pInstance, u32EDGE2DBase);
598 MDrv_LD_Set_LEDData_BaseOffset(pInstance, u32LEDOffset);
599
600 //DRAM buffer address Init
601 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
602 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32LDFReadBuf0Base = MDrv_LD_Get_LDF_FrameBufBaseAddr(pInstance, 0) - u32R2BaseAddr;
603 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32LDFReadBuf1Base = MDrv_LD_Get_LDF_FrameBufBaseAddr(pInstance, 1) - u32R2BaseAddr;
604 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32LDBWriteBuf0Base= MDrv_LD_Get_LDB_FrameBufBaseAddr(pInstance, 0) - u32R2BaseAddr;
605 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32LDBWriteBuf1Base= MDrv_LD_Get_LDB_FrameBufBaseAddr(pInstance, 1) - u32R2BaseAddr;
606 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32SPIDataBuf0Base = MDrv_LD_Get_SPIData_BaseAddr(pInstance, 0) - u32R2BaseAddr;
607 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32SPIDataBuf1Base = MDrv_LD_Get_SPIData_BaseAddr(pInstance, 1) - u32R2BaseAddr;
608 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u32Edge2DCoeffBase = MDrv_LD_Get_EDGE2D_BaseAddr(pInstance) - u32R2BaseAddr;
609 }
610
MApi_XC_LD_SetMemoryAddress_U2(void * pInstance,MS_U8 u8MIU,MS_PHY u32LDFBase0,MS_PHY u32LDFBase1,MS_PHY u32LDBBase0,MS_PHY u32LDBBase1,MS_PHY u32EDGE2DBase,MS_PHY u32LEDOffset)611 MS_BOOL MApi_XC_LD_SetMemoryAddress_U2(void* pInstance,
612 MS_U8 u8MIU ,
613 MS_PHY u32LDFBase0,
614 MS_PHY u32LDFBase1,
615 MS_PHY u32LDBBase0,
616 MS_PHY u32LDBBase1,
617 MS_PHY u32EDGE2DBase,
618 MS_PHY u32LEDOffset)
619 {
620 #if(HW_DESIGN_LD_VER > 4)
621 printf("\r\n Local Dimming do not Support this HW Version ");
622 return FALSE;
623 #endif
624 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
625 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
626
627 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
628 MDrv_XC_LD_Set_MIUSel(pInstance, u8MIU);
629
630 if (u8MIU != 0x00)
631 {
632 u32LDFBase0 = u32LDFBase0 + HAL_MIU1_BASE;
633 u32LDFBase1 = u32LDFBase1 + HAL_MIU1_BASE;
634 u32LDBBase0 = u32LDBBase0 + HAL_MIU1_BASE;
635 u32LDBBase1 = u32LDBBase1 + HAL_MIU1_BASE;
636 u32EDGE2DBase = u32EDGE2DBase + HAL_MIU1_BASE;
637 }
638
639 MDrv_XC_LD_SetMemoryAddress(pInstance, u32LDFBase0,
640 u32LDFBase1,
641 u32LDBBase0,
642 u32LDBBase1,
643 u32EDGE2DBase,
644 u32LEDOffset);
645 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
646 return TRUE;
647 }
648
MApi_XC_LD_SetMemoryAddress(MS_U8 u8MIU,MS_PHY u32LDFBase0,MS_PHY u32LDFBase1,MS_PHY u32LDBBase0,MS_PHY u32LDBBase1,MS_PHY u32EDGE2DBase,MS_PHY u32LEDOffset)649 MS_BOOL MApi_XC_LD_SetMemoryAddress(MS_U8 u8MIU ,
650 MS_PHY u32LDFBase0,
651 MS_PHY u32LDFBase1,
652 MS_PHY u32LDBBase0,
653 MS_PHY u32LDBBase1,
654 MS_PHY u32EDGE2DBase,
655 MS_PHY u32LEDOffset)
656 {
657 if (pu32XCInst == NULL)
658 {
659 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
660 return FALSE;
661 }
662
663 stXC_SET_LD_MEMORYADDRESS XCArgs;
664 XCArgs.u8MIU = u8MIU;
665 XCArgs.u32LDFBase0 = u32LDFBase0;
666 XCArgs.u32LDFBase1 = u32LDFBase1;
667 XCArgs.u32LDBBase0 = u32LDBBase0;
668 XCArgs.u32LDBBase1 = u32LDBBase1;
669 XCArgs.u32EDGE2DBase = u32EDGE2DBase;
670 XCArgs.u32LEDOffset = u32LEDOffset;
671 XCArgs.bReturnValue = FALSE;
672
673 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_MEMORYADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
674 {
675 printf("Obtain XC engine fail\n");
676 return FALSE;
677 }
678 else
679 {
680 return XCArgs.bReturnValue;
681 }
682 }
683
MDrv_XC_LD_Set_MIUSel(void * pInstance,MS_U8 u8MIU)684 void MDrv_XC_LD_Set_MIUSel(void* pInstance, MS_U8 u8MIU)
685 {
686 Hal_SC_Enable_MiuMask(pInstance);
687 #if(HW_DESIGN_LD_VER == 1) // add
688 if(u8MIU != 0x00) // MIU1
689 {
690 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF4, 0x0C, 0x0C); // MIU select (Group1 BIT15)
691 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF4, 0x00, 0x0C); // IP select
692 }
693 else
694 {
695 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF4, 0x00, 0x0C); // MIU select (Group1 BIT15)
696 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF4, 0x0C, 0x0C); // IP select
697 }
698 #elif(HW_DESIGN_LD_VER == 2)
699 if(u8MIU != 0x00) // MIU1
700 {
701 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF0, 0x08, 0x08); // MIU select (Group1 BIT15)
702 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF0, 0x00, 0x08); // IP select
703 }
704 else
705 {
706 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF0, 0x00, 0x08); // MIU select (Group1 BIT15)
707 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF0, 0x08, 0x08); // IP select
708 }
709 #elif(HW_DESIGN_LD_VER == 3)
710 if(u8MIU != 0x00) // MIU1
711 {
712 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF4, 0x0C, 0x0C); // MIU select (Group1 BIT15)
713 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF4, 0x00, 0x0C); // IP select
714 }
715 else
716 {
717 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF4, 0x00, 0x0C); // MIU select (Group1 BIT15)
718 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF4, 0x0C, 0x0C); // IP select
719 }
720 #elif(HW_DESIGN_LD_VER == 4)
721 if(u8MIU != 0x00) // MIU1
722 {
723 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF2, 0x40, 0x40); // MIU select (Group1 BIT15)
724 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF2, 0x00, 0x40); // IP select
725 }
726 else
727 {
728 MDrv_WriteByteMask(REG_MIU0_BASE + 0xF2, 0x00, 0x40); // MIU select (Group1 BIT15)
729 MDrv_WriteByteMask(REG_MIU1_BASE + 0xF2, 0x40, 0x40); // IP select
730 }
731 #elif(HW_DESIGN_LD_VER > 4)
732 {
733 printf("\r\n Local Dimming do not Support this HW Version ");
734 }
735 #endif
736 Hal_SC_Disable_MiuMask(pInstance);
737
738 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
739 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
740 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
741 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
742 pXCResourcePrivate->stdrv_LD.gsLDDramBaseAddr.u8MIU = u8MIU;
743 }
744
MApi_XC_LD_Get_Value_U2(void * pInstance,MS_U8 * pu8LDValue,MS_U8 u8WSize,MS_U8 u8HSize)745 MS_BOOL MApi_XC_LD_Get_Value_U2(void* pInstance, MS_U8 *pu8LDValue, MS_U8 u8WSize, MS_U8 u8HSize)
746 {
747 MS_BOOL bReturn = FALSE;
748 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
749 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
750 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
751 bReturn = MDrv_LD_Get_Value(pInstance, pu8LDValue, u8WSize, u8HSize );
752 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
753 return bReturn;
754 }
755
MApi_XC_LD_Get_Value(MS_U8 * pu8LDValue,MS_U8 u8WSize,MS_U8 u8HSize)756 MS_BOOL MApi_XC_LD_Get_Value(MS_U8 *pu8LDValue, MS_U8 u8WSize, MS_U8 u8HSize)
757 {
758 if (pu32XCInst == NULL)
759 {
760 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
761 return FALSE;
762 }
763
764 stXC_GET_LD_VALUE XCArgs;
765 XCArgs.pu8LDValue = pu8LDValue;
766 XCArgs.u8WSize = u8WSize;
767 XCArgs.u8HSize = u8HSize;
768 XCArgs.bReturnValue = FALSE;
769
770 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_LD_VALUE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
771 {
772 printf("Obtain XC engine fail\n");
773 return FALSE;
774 }
775 else
776 {
777 return XCArgs.bReturnValue;
778 }
779 }
780
MDrv_LD_CommonInit(void * pInstance)781 void MDrv_LD_CommonInit(void *pInstance)
782 {
783 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
784 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
785 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
786 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
787 MS_U16 u16PanelWidth = LD_PANEL_WIDTH;
788 MS_U16 u16PanelHeight = LD_PANEL_HEIGHT;
789 MS_U16 u16Value = 0, u16Mask = 0;
790
791 //LDF Init
792 //horizontal low-pass filter before MAXin enable
793 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1D_L, (ENABLE<<12), BIT(12));
794 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
795 {
796 //blending weight parameter DC*(8-reg_alpha)+MAX*reg_alpha
797 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, 0x02, 0x0F);
798 }
799
800 //pixel white mode enable
801 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, (ENABLE<<7), BIT(7));
802 //Write out RGB/DC/MAX data
803 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, (DISABLE<<8), BIT(8));
804 //LSF HSU Init
805 #if (HW_DESIGN_LD_VER == 2 || HW_DESIGN_LD_VER == 3 || HW_DESIGN_LD_VER == 4)
806 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_38_L, 0x8000 & 0xFFFFF);
807 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, 0x8000 & 0xFFFFF);
808 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, ((E_LD_LSF_H_SHIFT|E_LD_LSF_V_SHIFT)&(~0)), (((E_LD_LSF_H_SHIFT|E_LD_LSF_V_SHIFT)|0)&LD_LSFCONFIG_VALID));
809 #elif(HW_DESIGN_LD_VER == 1)
810 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3B_L, 0x80,0x00FF);
811 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3B_L, 0x80<<8,0xFF00);
812 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, ((E_LD_LSF_H_SHIFT|E_LD_LSF_V_SHIFT|E_LD_LSF_SIGNBIT)&(~0)), ((E_LD_LSF_H_SHIFT|E_LD_LSF_V_SHIFT|E_LD_LSF_SIGNBIT)|0)&LD_LSFCONFIG_VALID);
813 //vlpf enable hlpf enable
814 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3E_L, (MS_U16)(((DISABLE)<<14)|((DISABLE)<<15)), 0xC000);
815 //hlpf 10-bit mode
816 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3D_L, (DISABLE<<14), BIT(14));
817 //LSFLPF HTapsSel
818 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (E_LD_LSFLPF_9TAPS<<7), 0x0180);
819 //pel_offset_en
820 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, (DISABLE<<9), BIT(9));
821 #endif
822 // lsf out mode
823 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
824 {
825 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_72_L, (E_LD_LSF_OUT_0x3FF<<1), 0x0E);
826 }
827 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_70_L, (u16PanelWidth-1)&0x1FFF, 0x1FFF);
828 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_71_L, (u16PanelHeight-1)&0x0FFF, 0x0FFF);
829
830 //MDrv_LD_Load_Hscaling_Table(au8Coeff_HScaling);
831 //MDrv_LD_Load_Vscaling_Table(au8Coeff_HScaling);
832
833 //Compensation Init
834 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (DISABLE<<6), BIT(6));
835 //pixel blending between cmpensation and ori-data
836 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, (0x07<<4), 0x01F0);
837 //comp_out_mode
838 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_72_L, (E_LD_COMP_OUT_NORMAL<<4), 0x0030);
839 #if(HW_DESIGN_LD_VER == 1)
840 //Offset Init
841 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, (DISABLE<<9), BIT(9));
842 ////Compensation Init
843 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (DISABLE<<14), BIT(14));
844 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, 0x00, 0x3E00);
845 //Dither Init
846 u16Value = (E_LD_DITHER_COMPENSATION_OUT&(~(E_LD_DITHER_MIN_SELECT|E_LD_DITHER_COMPENSATION|E_LD_DITHER_SATURATION)));
847 u16Mask = (E_LD_DITHER_COMPENSATION_OUT|(E_LD_DITHER_MIN_SELECT|E_LD_DITHER_COMPENSATION|E_LD_DITHER_SATURATION))&LD_DITHER3C_VALID;
848 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, u16Value, u16Mask);
849 //combine value and mask.
850 u16Value = (0&(~E_LD_DITHER_VLPF|E_LD_DITHER_HLPF|E_LD_DITHER_OFFSET));
851 u16Mask = (0|(E_LD_DITHER_VLPF|E_LD_DITHER_HLPF|E_LD_DITHER_OFFSET))&LD_DITHER3D_VALID;
852 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3D_L, u16Value, u16Mask);
853 //min clamp value
854 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_76_L, 0x9, 0x03FF);
855 #elif(HW_DESIGN_LD_VER == 2 || HW_DESIGN_LD_VER == 3 || HW_DESIGN_LD_VER == 4)
856 //Dither Init
857 u16Value = (E_LD_DITHER_COMPENSATION_OUT&(~(E_LD_DITHER_COMPENSATION)));
858 u16Mask = (E_LD_DITHER_COMPENSATION_OUT|(E_LD_DITHER_COMPENSATION))&LD_DITHER3C_VALID;
859 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, u16Value, u16Mask);
860 #endif
861 //BL Globe Gain Init
862 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_4B_L,(0x20)&0x00FF, 0x00FF);
863 //BL GlobeGainMode
864 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_4B_L,(E_LD_BL_GLOBAL_GAIN_8BIT<<8), 0x0700);
865 }
866
867 #if 0
868 void MDrv_LD_Print_Compensation_Table(void)
869 {
870 MS_U16 u16Addr = 0;
871 MS_U16 u16Index = 0;
872
873 printf("\nHal_LD_Print_Compensation_Table\n");
874
875 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_72_L, ENABLE, BIT(0));
876
877 for( u16Addr = 0; u16Addr < 256; ++ u16Addr )
878 {
879 if(u16Addr % 0x10 == 0) printf("\n");
880 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3F_L, u16Addr,0x00FF);// write address for compensation LUT
881 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3F_L, ENABLE<<11, BIT(11)); // Compensation LUT read
882 printf("%02X%02X ", ((SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3E_L)&0xFF00)>>8), (SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3E_L)&0x00FF));
883 }
884
885 SC_W2BYTEMSK(REG_SC_BK2E_72_L, 0, BIT(0));
886 }
887 #endif
888
MDrv_LD_Load_Compensation_Table(void * pInstance,MS_U8 * pu8CompTable,MS_U16 u16CompTableLength)889 void MDrv_LD_Load_Compensation_Table(void *pInstance, MS_U8* pu8CompTable,MS_U16 u16CompTableLength)
890 {
891 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
892 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
893 MS_U16 u16Addr = 0;
894 MS_U16 u16Index = 0;
895 MS_U16 u16Tmp = 0, u16Tmp2 =0;
896 if (pu8CompTable != NULL)
897 {
898 for( u16Addr = 0; u16Addr < u16CompTableLength/2; ++ u16Addr )
899 {
900 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3F_L, u16Addr, 0x00FF);// write address for compensation LUT
901 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3D_L, ((pu8CompTable[u16Index+1]<<8) + pu8CompTable[u16Index]), 0x0FFF);
902
903 u16Index += 2;
904 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3F_L, (ENABLE<<10), BIT(10)); // Compensation LUT write
905
906 //MsOS_DelayTaskUs(1);
907 for(u16Tmp = 0; u16Tmp < 255; ++u16Tmp)
908 {
909 u16Tmp2 = u16Tmp;
910 }
911 }
912 }
913 }
914
915 /*
916 Edge 2D Table Format
917 Normal: Width = LED Number(HxV) / 4
918 Height = Backlight size (HxV)
919
920 Special(for Edge-LR panel and odd V size)
921 Width = (LED Height+1) x V / 4
922 Height = Backlight size (HxV)
923
924 H-direction: zero padding to Packet Length (16byte)
925 */
MDrv_LD_Load_EDGE2D_Table(void * pInstance,MS_U8 u8LEDWidth,MS_U8 u8LEDHeight,MS_U8 u8BLWidth,MS_U8 u8BLHeight,MS_U8 * pu8Edge2DTable)926 void MDrv_LD_Load_EDGE2D_Table(void *pInstance, MS_U8 u8LEDWidth, MS_U8 u8LEDHeight, MS_U8 u8BLWidth, MS_U8 u8BLHeight, MS_U8* pu8Edge2DTable)
927 {
928 MS_U16 u16RowIdx = 0, u16ColumnIdx = 0;
929 MS_U16 u16Tbl_Active_Width = ((u8LEDWidth*u8LEDHeight)+2)/4;
930 MS_U16 u16Tbl_Active_Height = (MS_U16)u8BLWidth * u8BLHeight;
931 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
932 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
933 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
934 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
935 for(u16RowIdx = 0; u16RowIdx < u16Tbl_Active_Height; ++u16RowIdx)
936 {
937 for(u16ColumnIdx = 0; u16ColumnIdx < EDGE2D_PACKET_LENGTH; ++u16ColumnIdx)
938 {
939 if(u16ColumnIdx < u16Tbl_Active_Width)
940 {
941 if (pu8Edge2DTable != NULL)
942 {
943 MDrv_LD_MIUWriteByte(LD_BUF_Edge2DCoe, (u16RowIdx*EDGE2D_PACKET_LENGTH + u16ColumnIdx), pu8Edge2DTable[u16RowIdx*u16Tbl_Active_Width + u16ColumnIdx]);
944 }
945 }
946 else
947 {
948 MDrv_LD_MIUWriteByte(LD_BUF_Edge2DCoe, (u16RowIdx*EDGE2D_PACKET_LENGTH + u16ColumnIdx), 0);
949 }
950 }
951 }
952 }
953
MDrv_XC_LD_SetPanelType(void * pInstance,EN_LD_PANEL_TYPE enLDPanelType)954 MS_BOOL MDrv_XC_LD_SetPanelType(void *pInstance, EN_LD_PANEL_TYPE enLDPanelType )
955 {
956 #if 0
957 MS_U16 i;
958 MS_U16 u16TotalSPIDataLen = 0;
959 #endif
960 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
961 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
962 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
963 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
964 MS_U32 u32Ratio = 0;
965 MS_U16 u16Tmp = 0;
966 MS_U16 u16PanelWidth = LD_PANEL_WIDTH;
967 MS_U16 u16PanelHeight = LD_PANEL_HEIGHT;
968 UNUSED(enLDPanelType);
969 #if 0 //
970 if( _enLDPanelType != enLDPanelType )
971 {
972 #if( DRV_LD_USE_SWSPI )
973 MDrv_SPI_SetTriggerMode(E_SPI_TRIGGER_NONE);
974 #else
975 #endif
976 }
977 #endif
978 #if 0
979 Hal_MSPI_SetClockSpeed( _stDrvLDInfo.eMSPIClockSpeed );
980 Hal_MSPI_SetClockPolarity( _stDrvLDInfo.u8SpiClockPolarity );
981 Hal_MSPI_SetClockPhase( _stDrvLDInfo.u8SpiClockPhase );
982
983 #if( DRV_LD_USE_SWSPI )
984
985 // Setup SPI cmd data...
986 for( i = 0; i < _stDrvLDInfo.u8SpiCmdLen; ++ i )
987 {
988 s_au8DrvLD_SPIBuf[i] = _stDrvLDInfo.au16SpiCmd[i];
989 }
990
991 // Setup MSPI timing ...
992 u16TotalSPIDataLen = _stDrvLDInfo.u8SpiCmdLen + LD_LED_NUMBER;
993 if( _stDrvLDInfo.u8CheckSumMode )
994 {
995 u16TotalSPIDataLen += 1;
996 }
997
998 // Setup the delay time before every data
999 //s_au8DrvLD_SPI_delay[0] = (_stDrvLDInfo.u8SpiTime_VSyncWidth + _stDrvLDInfo.u8SpiTime_VSync_To_FirstClock);
1000 s_au8DrvLD_SPI_delay[0] = _stDrvLDInfo.u8SpiTime_VSync_To_FirstClock;
1001
1002 for( i = 1; i < u16TotalSPIDataLen; ++ i )
1003 {
1004 s_au8DrvLD_SPI_delay[i] = _stDrvLDInfo.u8SpiTime_Byte_to_Byte;
1005 }
1006 MDrv_SPI_SetWriteBuf_Delay( s_au8DrvLD_SPI_delay, u16TotalSPIDataLen );
1007
1008 #else
1009 #endif
1010 #endif
1011 //LR and odd vertical block case, need patch for HW Edge2D bug
1012 if((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH == 2) && (pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV % 2) == 1)
1013 {
1014 u16Tmp = ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH-1)<<5)|((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV+1)-1);
1015 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_63_L, u16Tmp, 0x3FF);
1016 #if ( HW_DESIGN_LD_VER == 3)
1017 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV+1)-1), 0x003F);
1018 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH-1)<<8), 0x3F00);
1019 #else
1020 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, u16Tmp, 0x3FF);
1021 #endif
1022 }
1023 else if((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH == 2) && !(pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV % 2))
1024 {
1025 u16Tmp = ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH-1)<<5)|((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV)-1);
1026 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_63_L, u16Tmp, 0x3FF);
1027 #if ( HW_DESIGN_LD_VER == 3)
1028 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV)-1), 0x003F);
1029 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH-1)<<8), 0x3F00);
1030 #else
1031 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, u16Tmp, 0x3FF);
1032 #endif
1033 }
1034 else
1035 {
1036 u16Tmp = ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV-1)<<5)|((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH)-1);
1037 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_63_L, u16Tmp, 0x3FF);
1038 #if ( HW_DESIGN_LD_VER == 3)
1039 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH)-1), 0x003F);
1040 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV-1)<<8), 0x3F00);
1041 #else
1042 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_60_L, u16Tmp, 0x3FF);
1043 #endif
1044 }
1045
1046 u16Tmp = ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightV-1)<<5)|(pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightH-1);
1047 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_03_L, u16Tmp, 0x03FF);
1048 #if ( HW_DESIGN_LD_VER == 3)
1049 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_4C_L, (pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightH-1), 0x003F);
1050 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_4C_L, ((pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightV-1)<<8), 0x03F00);
1051 #else
1052 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_4C_L, u16Tmp, 0x03FF); // For LSF
1053 #endif
1054
1055
1056 u32Ratio= (H_V_RATIO_CONST * pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightH / u16PanelWidth)+1;
1057 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_19_L, u32Ratio&0x0FFFFF);
1058 u32Ratio= (H_V_RATIO_CONST * pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightV / u16PanelHeight)+1;
1059 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_1B_L, u32Ratio&0x0FFFFF);
1060
1061 u32Ratio= H_V_RATIO_CONST*pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightH/(u16PanelWidth-1);
1062 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_30_L, u32Ratio&0x0FFFFF);
1063 u32Ratio= H_V_RATIO_CONST*pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightV/(u16PanelHeight-1);
1064 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_32_L, u32Ratio&0x0FFFFF);
1065
1066
1067 MDrv_LD_Load_Compensation_Table(pInstance, pXCResourcePrivate->stdrv_LD._stDrvLDInfo.pu8CompTable,COMPENSATION_LENGTH);
1068
1069 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1070 {
1071 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (ENABLE<<6), BIT(6));
1072 }
1073
1074 MDrv_LD_Load_EDGE2D_Table(pInstance,
1075 pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumH,
1076 pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LedNumV,
1077 pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightH,
1078 pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightV,
1079 pXCResourcePrivate->stdrv_LD._stDrvLDInfo.pu8Edge2DTable);
1080 //MDrv_LD_Print_Compensation_Table();
1081 return TRUE;
1082 }
1083
Mdrv_LD_GetPanelType(void * pInstance)1084 EN_LD_PANEL_TYPE Mdrv_LD_GetPanelType(void *pInstance)
1085 {
1086 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1087 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1088 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1089 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1090 return pXCResourcePrivate->stdrv_LD._enLDPanelType;
1091 }
1092
MDrv_LD_Init(void * pInstance)1093 MS_BOOL MDrv_LD_Init(void *pInstance)
1094 {
1095 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1096 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1097 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1098 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1099
1100 #if(HW_DESIGN_LD_VER == 1)
1101 MDrv_WriteByte(0x1012F4, 0x03);
1102 #endif
1103 //----------------------
1104 // Local Dimming
1105 //wriu -w 0x102f08 0x6000
1106 //wriu -w 0x102f0a 0x0001
1107 //wriu -w 0x102f0c 0x7000
1108 //wriu -w 0x102f0e 0x0001 //write base address
1109 //----------------------
1110 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_02_L, 0x0010); //////
1111 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_03_L, 0x023f); /////////
1112 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_4C_L, 0x023f);
1113
1114 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_19_L, 0x4445);
1115 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_1B_L, 0x4445);
1116 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_1D_L, 0x1000);
1117 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, 0x0088);
1118 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_30_L, 0x444D);
1119 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_32_L, 0x4454);
1120 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, 0x0903);
1121 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_70_L, 0x077f);
1122 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_71_L, 0x0437);
1123 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_4B_L, 0x0320); ///
1124 //SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_76_L, 0x0000); ///
1125 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_7B_L, 0x0000); ///
1126 //spi
1127 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_64_L, 0x0, 0x00FF); ///
1128 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_65_L, 0x5, 0x00FF); ///
1129 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_66_L, 0x0, 0x00FF);
1130 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_67_L, 0x0, 0x00FF);
1131 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_68_L, 0x0, 0x00FF);
1132 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_69_L, 0x0, 0x00FF);
1133 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_6A_L, 0x0, 0x00FF);
1134 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_6B_L, 0x0, 0x00FF);
1135 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_6C_L, 0x0, 0x00FF);
1136 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_6D_L, 0xffff );///
1137 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_6E_L, 0xffff );///
1138 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_6F_L, 0xffff );///
1139
1140
1141 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L) | 0x0800);
1142 //MDrv_Write2ByteMask(0x100bb2, 0x0, 0x3);
1143 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_24_L, 0xfa20);
1144 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1145 {
1146 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, 0x40, 0x00FF);
1147 }
1148
1149 //SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_01_L, 0x0001);
1150 MDrv_LD_Set_LocalDimmingEn(pInstance, TRUE);
1151 return TRUE;
1152 }
1153
1154
1155 #if 0
1156 static MS_U8 _MDrv_LD_CalCheckSum( MS_U8* pu8DataBuf, MS_U16 u16DataLen )
1157 {
1158 MS_U8 u8CheckSum = 0;
1159 MS_U16 i;
1160
1161 if (pu8DataBuf == NULL)
1162 {
1163 return u8CheckSum;
1164 }
1165 switch( _stDrvLDInfo.u8CheckSumMode )
1166 {
1167 case 1: // TODO
1168 u8CheckSum = pu8DataBuf[0];
1169 for( i = 1; i < u16DataLen; ++ i )
1170 {
1171 u8CheckSum = u8CheckSum ^ pu8DataBuf[i];
1172 }
1173 break;
1174 default:
1175 u8CheckSum = 0;
1176 break;
1177 }
1178
1179 return u8CheckSum;
1180 }
1181 #endif
1182
MDrv_LD_SetLocalDimmingData(void * pInstance,MS_U8 * pu8LocalDimmingData,MS_U16 u16DataLen)1183 MS_BOOL MDrv_LD_SetLocalDimmingData(void *pInstance, MS_U8* pu8LocalDimmingData, MS_U16 u16DataLen)
1184 {
1185 #if 0
1186 MS_U8 h,v;
1187 MS_U16 i;
1188 MS_U16 u16SPIDataLen = 0;
1189 #endif
1190
1191 // PRINT_FUNCTION_LINE();
1192 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1193 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1194 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1195
1196 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1197 if( (pXCResourcePrivate->stdrv_LD._bMDrvLD_InitFinished == FALSE) || (pu8LocalDimmingData == NULL)
1198 || (u16DataLen == 0) || (u16DataLen > LD_LED_NUMBER))
1199 {
1200
1201 return FALSE;
1202 }
1203 #if 0
1204 printf("MDrv_LD_SetLocalDimmingData:\n");
1205 i = 0;
1206 for( v = 0; v < _stDrvLDInfo.u8LedNumV; ++ v )
1207 {
1208 for( h = 0; h < _stDrvLDInfo.u8LedNumH; ++ h )
1209 {
1210 printf("0x%02X,", pu8LocalDimmingData[i] );
1211 i += 1;
1212 }
1213 printf("\n" );
1214 }
1215 #endif
1216
1217 #if 0 // mark for hw spi driver
1218 #if( DRV_LD_USE_SWSPI )
1219 // Cmd len + data len must be small 256
1220 if( (_stDrvLDInfo.u8SpiCmdLen+u16DataLen) >= DRV_LD_SPI_BUF_MAX_SIZE )
1221 {
1222 return FALSE;
1223 }
1224
1225 u16SPIDataLen = _stDrvLDInfo.u8SpiCmdLen;
1226
1227 // Setup dimming data
1228 for( i = 0; i < u16DataLen; ++ i )
1229 {
1230 s_au8DrvLD_SPIBuf[u16SPIDataLen+i] = pu8LocalDimmingData[i];
1231 }
1232 u16SPIDataLen += u16DataLen;
1233
1234 // Setup check sum
1235 if( _stDrvLDInfo.u8CheckSumMode )
1236 {
1237 s_au8DrvLD_SPIBuf[u16SPIDataLen] = _MDrv_LD_CalCheckSum(s_au8DrvLD_SPIBuf, u16SPIDataLen);
1238 u16SPIDataLen += 1;
1239 }
1240
1241 #if 0 // Debug
1242 {
1243 printf("Send to SPI:\n");
1244 for( i = 0; i < u16SPIDataLen; ++ i )
1245 {
1246 printf("[%X]", s_au8DrvLD_SPIBuf[i]);
1247 }
1248 printf("\n");
1249 }
1250 #endif
1251
1252 MDrv_SPI_WriteBytes( s_au8DrvLD_SPIBuf, u16SPIDataLen, E_SPI_TRIGGER_BY_EVERY_V_SYNC);
1253
1254 #else // Use DLM-DMA
1255 #endif
1256 #endif
1257 return TRUE;
1258 }
1259
1260
MApi_LD_Set3DMode(void * pInstance,MS_BOOL bEnable)1261 void MApi_LD_Set3DMode(void *pInstance, MS_BOOL bEnable)
1262 {
1263 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1264 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1265 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_29_L, bEnable, BIT(0));
1266 }
1267
MApi_XC_LD_SetLevel_U2(void * pInstance,EN_LD_MODE enMode)1268 MS_BOOL MApi_XC_LD_SetLevel_U2(void* pInstance, EN_LD_MODE enMode)
1269 {
1270 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1271 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1272 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1273 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1274 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1275
1276 switch(enMode)
1277 {
1278 case E_LD_MODE_OFF:
1279 MDrv_LD_EnableLD(pInstance, FALSE); //LDimmingFunction
1280 MDrv_LD_Set_LocalDimmingEn(pInstance, FALSE);
1281
1282 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1283 {
1284 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (ENABLE<<6), BIT(6));
1285 }
1286
1287 break;
1288 case E_LD_MODE_LOW:
1289
1290 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1291 {
1292 //blending weight parameter DC*(8-reg_alpha)+MAX*reg_alpha
1293 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, 0x01, 0x0F);
1294 }
1295
1296 //pixel blending between cmpensation and ori-data
1297 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, (0x10<<4), 0x01F0);
1298 MDrv_LD_SetGammaControl(pInstance, 3);//_u8Gamma_Control = //BLgamma
1299 MDrv_LD_EnableLD(pInstance, TRUE); //LDimmingFunction
1300 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1301 {
1302 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (ENABLE<<6), BIT(6));
1303 }
1304
1305 MDrv_LD_Set_LocalDimmingEn(pInstance, TRUE);
1306 break;
1307 case E_LD_MODE_MID:
1308
1309 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1310 {
1311 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, 0x02, 0x0F);
1312 }
1313
1314 //pixel blending between cmpensation and ori-data
1315 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, (0x0C<<4), 0x01F0);
1316 MDrv_LD_SetGammaControl(pInstance, 0);//_u8Gamma_Control = //BLgamma
1317 MDrv_LD_EnableLD(pInstance, TRUE); //LDimmingFunction
1318
1319 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1320 {
1321 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (ENABLE<<6), BIT(6));
1322 }
1323
1324 MDrv_LD_Set_LocalDimmingEn(pInstance, TRUE);
1325 break;
1326 case E_LD_MODE_HIGH:
1327
1328 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1329 {
1330 //blending weight parameter DC*(8-reg_alpha)+MAX*reg_alpha
1331 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, 0x02, 0x0F);
1332
1333 }
1334
1335 //pixel blending between cmpensation and ori-data
1336 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3C_L, (0x0E<<4), 0x01F0);
1337 MDrv_LD_SetGammaControl(pInstance, 0);//_u8Gamma_Control = //BLgamma
1338 MDrv_LD_EnableLD(pInstance, TRUE); //LDimmingFunction
1339
1340 if (pXCResourcePrivate->stdrv_LD._bIsLDPanel== TRUE)
1341 {
1342 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, (ENABLE<<6), BIT(6));
1343 }
1344
1345 MDrv_LD_Set_LocalDimmingEn(pInstance, TRUE);
1346 break;
1347 default:
1348 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1349 return FALSE;
1350 }
1351 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1352 return TRUE;
1353 }
1354
MApi_XC_LD_SetLevel(EN_LD_MODE enMode)1355 MS_BOOL MApi_XC_LD_SetLevel(EN_LD_MODE enMode)
1356 {
1357 if (pu32XCInst == NULL)
1358 {
1359 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1360 return FALSE;
1361 }
1362
1363 stXC_SET_LD_LEVEL XCArgs;
1364 XCArgs.enMode = enMode;
1365 XCArgs.bReturnValue = FALSE;
1366
1367 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1368 {
1369 printf("Obtain XC engine fail\n");
1370 return FALSE;
1371 }
1372 else
1373 {
1374 return XCArgs.bReturnValue;
1375 }
1376 }
1377
MDrv_LD_Test1(void * pInstance)1378 void MDrv_LD_Test1(void *pInstance)
1379 {
1380 MS_U16 i;
1381 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1382 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1383 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1384
1385 // PRINT_FUNCTION_LINE();
1386
1387 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1388 if( pXCResourcePrivate->stdrv_LD._bMDrvLD_InitFinished == FALSE )
1389 {
1390 return;
1391 }
1392 if( pXCResourcePrivate->stdrv_LD._u16LedPos < LD_LED_NUMBER )
1393 {
1394 for( i = 0; (i < LD_LED_NUMBER)&&(i<DRV_LD_SPI_BUF_MAX_SIZE); ++ i )
1395 {
1396 pXCResourcePrivate->stdrv_LD._au8Test_LedData[i] = 0;
1397 }
1398 pXCResourcePrivate->stdrv_LD._au8Test_LedData[pXCResourcePrivate->stdrv_LD._u16LedPos] = 0xFF;
1399 }
1400 else if( pXCResourcePrivate->stdrv_LD._u16LedPos == (LD_LED_NUMBER) )
1401 {
1402 for( i = 0; (i < LD_LED_NUMBER)&&(i<DRV_LD_SPI_BUF_MAX_SIZE); ++ i )
1403 {
1404 pXCResourcePrivate->stdrv_LD._au8Test_LedData[i] = 0;
1405 }
1406 }
1407 else // LD_LED_NUMBER + 1
1408 {
1409 for( i = 0; (i < LD_LED_NUMBER)&&(i<DRV_LD_SPI_BUF_MAX_SIZE); ++ i )
1410 {
1411 pXCResourcePrivate->stdrv_LD._au8Test_LedData[i] = 0xFF;
1412 }
1413 }
1414 pXCResourcePrivate->stdrv_LD._u16LedPos += 1;
1415
1416 if( pXCResourcePrivate->stdrv_LD._u16LedPos >= (LD_LED_NUMBER+2) )
1417 {
1418 pXCResourcePrivate->stdrv_LD._u16LedPos = 0;
1419 }
1420
1421 /*
1422 _au8Test_LedData[0] = 0x33;
1423 _au8Test_LedData[1] = 0x44;
1424 _au8Test_LedData[2] = 0x55;
1425 _au8Test_LedData[3] = 0x66;
1426 _au8Test_LedData[4] = 0x77;
1427 _au8Test_LedData[5] = 0x88;
1428 _au8Test_LedData[6] = 0x99;
1429 _au8Test_LedData[7] = 0xAA;
1430 */
1431
1432 MDrv_LD_SetLocalDimmingData(pInstance, pXCResourcePrivate->stdrv_LD._au8Test_LedData, LD_LED_NUMBER);
1433 }
1434
1435 //DRAM R/W test, Move frame buffer 0 data from LDF to LDB
MDrv_LD_Test2(void * pInstance)1436 void MDrv_LD_Test2(void *pInstance)
1437 {
1438 MS_U8 u8Idx = 0;
1439 MS_U16 u16Buf = 0;
1440 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1441 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1442 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1443 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1444 for(u8Idx = 0; u8Idx < (((MS_U16)pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightH) *pXCResourcePrivate->stdrv_LD._stDrvLDInfo.u8LD_BackLightV); u8Idx += 2)
1445 {
1446 u16Buf = MDrv_LD_MIURead2Bytes(LD_BUF_ReadDBuf_0, u8Idx);
1447 MDrv_LD_MIUWrite2Bytes(LD_BUF_WriteBuf_0, u8Idx, u16Buf);
1448 }
1449 }
1450
1451 #if(HW_DESIGN_LD_VER == 1)
MDrv_LD_Load_Hscaling_Table(void * pInstance,MS_U8 * pu8CoefTable)1452 void MDrv_LD_Load_Hscaling_Table(void *pInstance, MS_U8* pu8CoefTable)
1453 {
1454 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1455 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1456 MS_U8 u8ByAddr = 0;
1457 MS_U16 u16WIndex = 0;
1458
1459 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, (ENABLE<<10), BIT(10)); //Write Horizontal
1460 if (pu8CoefTable == NULL)
1461 {
1462 return;
1463 }
1464
1465 while (u8ByAddr < H_SCACLING_TABLE_SIZE)
1466 {
1467 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, u8ByAddr ,0x00FF);
1468
1469 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_34_L, pu8CoefTable[u16WIndex++] , 0x00FF);
1470 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_34_L, (MS_U16)((pu8CoefTable[u16WIndex++] & 0x00FF)<<8),0xFF00);
1471 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_35_L, pu8CoefTable[u16WIndex++] , 0x00FF);
1472 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_35_L, (MS_U16)((pu8CoefTable[u16WIndex++] & 0x00FF)<<8),0xFF00);
1473 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_36_L, pu8CoefTable[u16WIndex++] ,0x00FF);
1474 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_36_L, (MS_U16)((pu8CoefTable[u16WIndex++] & 0x00FF)<<8),0xFF00);
1475
1476 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, (ENABLE<<8), BIT(8)); //Write trigger
1477 u8ByAddr++;
1478 }
1479 }
1480
MDrv_LD_Load_Vscaling_Table(void * pInstance,MS_U8 * pu8CoefTable)1481 void MDrv_LD_Load_Vscaling_Table(void *pInstance, MS_U8* pu8CoefTable)
1482 {
1483 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1484 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1485 MS_U8 u8ByAddr = 0;
1486 MS_U16 u16WIndex = 0;
1487
1488 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, (DISABLE<<10), BIT(10)); //Write Vertical
1489
1490 if (pu8CoefTable == NULL)
1491 {
1492 return;
1493 }
1494
1495 while (u8ByAddr < V_SCACLING_TABLE_SIZE)
1496 {
1497 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, u8ByAddr);
1498
1499 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_34_L, pu8CoefTable[u16WIndex++] , 0x00FF);
1500 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_34_L, (MS_U16)((pu8CoefTable[u16WIndex++] & 0x00FF)<<8),0xFF00);
1501 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_35_L, pu8CoefTable[u16WIndex++] ,0x00FF);
1502 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_35_L, (MS_U16)((pu8CoefTable[u16WIndex++] & 0x00FF)<<8),0xFF00);
1503 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_36_L, pu8CoefTable[u16WIndex++] ,0x00FF);
1504 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_36_L, (MS_U16)((pu8CoefTable[u16WIndex++] & 0x00FF)<<8),0xFF00);
1505
1506 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_3A_L, (ENABLE<<8), BIT(8)); //Write trigger
1507 u8ByAddr++;
1508 }
1509 }
1510
MDrvl_LD_Set_DmaXOffset(void * pInstance,MS_U8 u8DmaIdx,MS_U8 u8XStart,MS_U8 u8XEnd)1511 void MDrvl_LD_Set_DmaXOffset(void *pInstance, MS_U8 u8DmaIdx, MS_U8 u8XStart, MS_U8 u8XEnd)
1512 {
1513 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1514 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1515 MS_U32 u32RegAddr = REG_SC_BK2E_64_L + (u8DmaIdx*2);
1516
1517 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32RegAddr,u8XStart, 0x001F);
1518 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32RegAddr,(u8XEnd<<8), 0x1F00);
1519 }
1520
MDrv_LD_Set_DmaYOffset(void * pInstance,MS_U8 u8DmaIdx,MS_U8 u8YStart)1521 void MDrv_LD_Set_DmaYOffset(void *pInstance, MS_U8 u8DmaIdx, MS_U8 u8YStart)
1522 {
1523 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1524 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1525 MS_U32 u32RegAddr = REG_SC_BK2E_6C_L + u8DmaIdx/2;
1526 if(u8DmaIdx%2 == 0)
1527 {
1528 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32RegAddr, u8YStart, 0x1F);
1529 }
1530 else
1531 {
1532 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32RegAddr, (u8YStart)<<8, 0x1F00);
1533 }
1534 }
1535
1536 #endif
1537
1538
MDrv_LD_Set_LDF_FrameBufBaseAddr(void * pInstance,MS_U8 u8BufIdx,MS_PHY u32LDFBase)1539 void MDrv_LD_Set_LDF_FrameBufBaseAddr(void *pInstance, MS_U8 u8BufIdx, MS_PHY u32LDFBase)
1540 {
1541 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1542 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1543 MS_U32 u32RegAddr = REG_SC_BK2E_04_L + (u8BufIdx*4);
1544 SC_W4BYTE(psXCInstPri->u32DeviceID, u32RegAddr, (u32LDFBase/LD_MIU_ALIGN)& MEMORY_MASK);
1545 }
1546
MDrv_LD_Get_LDF_FrameBufBaseAddr(void * pInstance,MS_PHY u8BufIdx)1547 MS_PHY MDrv_LD_Get_LDF_FrameBufBaseAddr(void *pInstance, MS_PHY u8BufIdx)
1548 {
1549 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1550 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1551 MS_U32 u32RegAddr = REG_SC_BK2E_04_L + (u8BufIdx*4);
1552 return ((MS_PHY)((SC_R4BYTE(psXCInstPri->u32DeviceID, u32RegAddr)& MEMORY_MASK)*LD_MIU_ALIGN) );
1553 }
1554
1555
MDrv_LD_Set_LDB_FrameBufBaseAddr(void * pInstance,MS_U8 u8BufIdx,MS_PHY u32LDBBase)1556 void MDrv_LD_Set_LDB_FrameBufBaseAddr(void *pInstance, MS_U8 u8BufIdx, MS_PHY u32LDBBase)
1557 {
1558 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1559 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1560 MS_U32 u32RegAddr = REG_SC_BK2E_4D_L + (u8BufIdx*4);
1561 SC_W4BYTE(psXCInstPri->u32DeviceID, u32RegAddr, (u32LDBBase/LD_MIU_ALIGN));
1562 }
1563
MDrv_LD_Get_LDB_FrameBufBaseAddr(void * pInstance,MS_PHY u8BufIdx)1564 MS_PHY MDrv_LD_Get_LDB_FrameBufBaseAddr(void *pInstance, MS_PHY u8BufIdx)
1565 {
1566 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1567 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1568 MS_U32 u32RegAddr = REG_SC_BK2E_4D_L + (u8BufIdx*4);
1569 return ((MS_PHY)(SC_R4BYTE(psXCInstPri->u32DeviceID, u32RegAddr)& MEMORY_MASK)*LD_MIU_ALIGN);
1570 }
1571
MDrv_LD_Set_LEDData_BaseOffset(void * pInstance,MS_PHY u32LEDOffset)1572 void MDrv_LD_Set_LEDData_BaseOffset(void *pInstance, MS_PHY u32LEDOffset)
1573 {
1574 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1575 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1576 //SPI data base address = LDB baseaddress + SPI data base address offset
1577 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_7E_L,(u32LEDOffset/LD_MIU_ALIGN) & MEMORY_MASK);
1578 }
1579
MDrv_LD_Get_SPIData_BaseAddr(void * pInstance,MS_PHY u8BufIdx)1580 MS_PHY MDrv_LD_Get_SPIData_BaseAddr(void *pInstance, MS_PHY u8BufIdx)
1581 {
1582 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1583 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1584 //SPI data base address = LDB baseaddress + SPI data base address offset
1585 MS_U32 u32SPIBaseOffset = SC_R4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_7E_L)& MEMORY_MASK;
1586 MS_U32 u32LDBBaseAddr = MDrv_LD_Get_LDB_FrameBufBaseAddr(pInstance, u8BufIdx);
1587 return ((MS_PHY)u32LDBBaseAddr + (MS_PHY)(u32SPIBaseOffset*LD_MIU_ALIGN));
1588 }
1589
MDrv_LD_Set_EDGE2D_BaseAddr(void * pInstance,MS_PHY u32EDGE2DBase)1590 void MDrv_LD_Set_EDGE2D_BaseAddr(void *pInstance, MS_PHY u32EDGE2DBase)
1591 {
1592 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1593 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1594 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_79_L, (u32EDGE2DBase/LD_MIU_ALIGN) & MEMORY_MASK);
1595 }
1596
MDrv_LD_Get_EDGE2D_BaseAddr(void * pInstance)1597 MS_PHY MDrv_LD_Get_EDGE2D_BaseAddr(void *pInstance)
1598 {
1599 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1600 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1601 return ((MS_PHY)(SC_R4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_79_L)& MEMORY_MASK)*LD_MIU_ALIGN);
1602 }
1603
1604
MDrv_LD_Set_LocalDimmingEn(void * pInstance,MS_BOOL bEn)1605 void MDrv_LD_Set_LocalDimmingEn(void *pInstance, MS_BOOL bEn)
1606 {
1607 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1608 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1609 if (bEn)
1610 {
1611 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_01_L, BIT(0), BIT(0));
1612 }
1613 else
1614 {
1615 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_01_L, 0x0, BIT(0));
1616 }
1617 }
1618
MDrv_LD_Get_LocalDimmingEn(void * pInstance)1619 MS_BOOL MDrv_LD_Get_LocalDimmingEn(void *pInstance)
1620 {
1621 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1622 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1623 return ((MS_BOOL)SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_01_L)&0x01);
1624 }
1625
MDrv_LD_GetLDInfo(void * pInstance)1626 ST_DRV_LD_INFO MDrv_LD_GetLDInfo(void *pInstance)
1627 {
1628 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1629 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1630 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1631 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1632 return pXCResourcePrivate->stdrv_LD._stDrvLDInfo;
1633 }
1634
MApi_Set_BLLevel_U2(void * pInstance,MS_U8 u8BLLevel)1635 MS_BOOL MApi_Set_BLLevel_U2(void* pInstance, MS_U8 u8BLLevel)
1636 {
1637 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1638 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1639 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_29_L, ((MS_U16)(u8BLLevel<<8)), 0xFF00);
1640 return TRUE;
1641 }
1642
MApi_Set_BLLevel(MS_U8 u8BLLevel)1643 MS_BOOL MApi_Set_BLLevel(MS_U8 u8BLLevel)
1644 {
1645 if (pu32XCInst == NULL)
1646 {
1647 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1648 return FALSE;
1649 }
1650
1651 stXC_SET_BL_LEVEL XCArgs;
1652 XCArgs.u8BLLevel = u8BLLevel;
1653 XCArgs.bReturnValue = FALSE;
1654
1655 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_BL_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1656 {
1657 printf("Obtain XC engine fail\n");
1658 return FALSE;
1659 }
1660 else
1661 {
1662 return XCArgs.bReturnValue;
1663 }
1664 }
1665
MApi_Set_notUpdateSPIDataFlags_U2(void * pInstance,MS_BOOL bRefreshSPIData)1666 MS_BOOL MApi_Set_notUpdateSPIDataFlags_U2(void* pInstance, MS_BOOL bRefreshSPIData)
1667 {
1668 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1669 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1670 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_29_L, (bRefreshSPIData)<<2 ,BIT(2));
1671 return TRUE;
1672 }
1673
MApi_Set_notUpdateSPIDataFlags(MS_BOOL bRefreshSPIData)1674 MS_BOOL MApi_Set_notUpdateSPIDataFlags(MS_BOOL bRefreshSPIData)
1675 {
1676 if (pu32XCInst == NULL)
1677 {
1678 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1679 return FALSE;
1680 }
1681
1682 stXC_SET_NOTUPDATE_SPI_DATA_FLAGS XCArgs;
1683 XCArgs.bRefreshSPIData = bRefreshSPIData;
1684 XCArgs.bReturnValue = FALSE;
1685
1686 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_NOTUPDATE_SPI_DATA_FLAGS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1687 {
1688 printf("Obtain XC engine fail\n");
1689 return FALSE;
1690 }
1691 else
1692 {
1693 return XCArgs.bReturnValue;
1694 }
1695 }
1696
MApi_Set_TurnoffLDBL_U2(void * pInstance,MS_BOOL bTurnoffBL)1697 MS_BOOL MApi_Set_TurnoffLDBL_U2(void* pInstance, MS_BOOL bTurnoffBL)
1698 {
1699 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1700 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1701 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_29_L, (bTurnoffBL)<<1 ,BIT(1));
1702 return TRUE;
1703 }
1704
MApi_Set_TurnoffLDBL(MS_BOOL bTurnoffBL)1705 MS_BOOL MApi_Set_TurnoffLDBL(MS_BOOL bTurnoffBL)
1706 {
1707 if (pu32XCInst == NULL)
1708 {
1709 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1710 return FALSE;
1711 }
1712
1713 stXC_SET_LD_TURNOFF_LDBL XCArgs;
1714 XCArgs.bTurnoffBL = bTurnoffBL;
1715 XCArgs.bReturnValue = FALSE;
1716
1717 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_TURNOFF_LDBL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1718 {
1719 printf("Obtain XC engine fail\n");
1720 return FALSE;
1721 }
1722 else
1723 {
1724 return XCArgs.bReturnValue;
1725 }
1726 }
1727
MApi_Set_UsermodeLDFlags_U2(void * pInstance,MS_BOOL bUserLDFlags)1728 MS_BOOL MApi_Set_UsermodeLDFlags_U2(void* pInstance, MS_BOOL bUserLDFlags)
1729 {
1730 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1731 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1732 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_29_L, bUserLDFlags , BIT(0));
1733 return TRUE;
1734 }
1735
MApi_Set_UsermodeLDFlags(MS_BOOL bUserLDFlags)1736 MS_BOOL MApi_Set_UsermodeLDFlags(MS_BOOL bUserLDFlags)
1737 {
1738 if (pu32XCInst == NULL)
1739 {
1740 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1741 return FALSE;
1742 }
1743
1744 stXC_SET_LD_USERMODEFLAGS XCArgs;
1745 XCArgs.bUserLDFlags = bUserLDFlags;
1746 XCArgs.bReturnValue = FALSE;
1747
1748 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_USERMODEFLAGS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1749 {
1750 printf("Obtain XC engine fail\n");
1751 return FALSE;
1752 }
1753 else
1754 {
1755 return XCArgs.bReturnValue;
1756 }
1757 }
1758
1759 #else
MApi_XC_LD_SetMemoryAddress_U2(void * pInstance,MS_U8 u8MIU,MS_PHY u32LDFBase0,MS_PHY u32LDFBase1,MS_PHY u32LDBBase0,MS_PHY u32LDBBase1,MS_PHY u32EDGE2DBase,MS_PHY u32LEDOffset)1760 MS_BOOL MApi_XC_LD_SetMemoryAddress_U2(void* pInstance,
1761 MS_U8 u8MIU ,
1762 MS_PHY u32LDFBase0,
1763 MS_PHY u32LDFBase1,
1764 MS_PHY u32LDBBase0,
1765 MS_PHY u32LDBBase1,
1766 MS_PHY u32EDGE2DBase,
1767 MS_PHY u32LEDOffset)
1768 {
1769 //not support
1770 UNUSED(pInstance);
1771 UNUSED(u8MIU);
1772 UNUSED(u32LDFBase0);
1773 UNUSED(u32LDFBase1);
1774 UNUSED(u32LDBBase0);
1775 UNUSED(u32LDBBase1);
1776 UNUSED(u32EDGE2DBase);
1777 UNUSED(u32EDGE2DBase);
1778 UNUSED(u32LEDOffset);
1779 return TRUE;
1780 }
1781
MApi_XC_LD_SetMemoryAddress(MS_U8 u8MIU,MS_PHY u32LDFBase0,MS_PHY u32LDFBase1,MS_PHY u32LDBBase0,MS_PHY u32LDBBase1,MS_PHY u32EDGE2DBase,MS_PHY u32LEDOffset)1782 MS_BOOL MApi_XC_LD_SetMemoryAddress(MS_U8 u8MIU ,
1783 MS_PHY u32LDFBase0,
1784 MS_PHY u32LDFBase1,
1785 MS_PHY u32LDBBase0,
1786 MS_PHY u32LDBBase1,
1787 MS_PHY u32EDGE2DBase,
1788 MS_PHY u32LEDOffset)
1789 {
1790 if (pu32XCInst == NULL)
1791 {
1792 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1793 return FALSE;
1794 }
1795
1796 stXC_SET_LD_MEMORYADDRESS XCArgs;
1797 XCArgs.u8MIU = u8MIU;
1798 XCArgs.u32LDFBase0 = u32LDFBase0;
1799 XCArgs.u32LDFBase1 = u32LDFBase1;
1800 XCArgs.u32LDBBase0 = u32LDBBase0;
1801 XCArgs.u32LDBBase1 = u32LDBBase1;
1802 XCArgs.u32EDGE2DBase = u32EDGE2DBase;
1803 XCArgs.u32LEDOffset = u32LEDOffset;
1804 XCArgs.bReturnValue = FALSE;
1805
1806 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_MEMORYADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1807 {
1808 printf("Obtain XC engine fail\n");
1809 return FALSE;
1810 }
1811 else
1812 {
1813 return XCArgs.bReturnValue;
1814 }
1815 }
1816
MApi_XC_LD_Get_Value_U2(void * pInstance,MS_U8 * pu8LDValue,MS_U8 u8WSize,MS_U8 u8HSize)1817 MS_BOOL MApi_XC_LD_Get_Value_U2(void* pInstance, MS_U8 *pu8LDValue, MS_U8 u8WSize, MS_U8 u8HSize)
1818 {
1819 //not support
1820 UNUSED(pu8LDValue);
1821 UNUSED(u8WSize);
1822 UNUSED(u8HSize);
1823 return TRUE;
1824 }
1825
MApi_XC_LD_Get_Value(MS_U8 * pu8LDValue,MS_U8 u8WSize,MS_U8 u8HSize)1826 MS_BOOL MApi_XC_LD_Get_Value(MS_U8 *pu8LDValue, MS_U8 u8WSize, MS_U8 u8HSize)
1827 {
1828 if (pu32XCInst == NULL)
1829 {
1830 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1831 return FALSE;
1832 }
1833
1834 stXC_GET_LD_VALUE XCArgs;
1835 XCArgs.pu8LDValue = pu8LDValue;
1836 XCArgs.u8WSize = u8WSize;
1837 XCArgs.u8HSize = u8HSize;
1838 XCArgs.bReturnValue = FALSE;
1839
1840 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_LD_VALUE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1841 {
1842 printf("Obtain XC engine fail\n");
1843 return FALSE;
1844 }
1845 else
1846 {
1847 return XCArgs.bReturnValue;
1848 }
1849 }
1850
MApi_XC_LD_SetLevel_U2(void * pInstance,EN_LD_MODE enMode)1851 MS_BOOL MApi_XC_LD_SetLevel_U2(void* pInstance, EN_LD_MODE enMode)
1852 {
1853 //not support
1854 UNUSED(pInstance);
1855 UNUSED(enMode);
1856 return TRUE;
1857 }
1858
MApi_XC_LD_SetLevel(EN_LD_MODE enMode)1859 MS_BOOL MApi_XC_LD_SetLevel(EN_LD_MODE enMode)
1860 {
1861 if (pu32XCInst == NULL)
1862 {
1863 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1864 return FALSE;
1865 }
1866
1867 stXC_SET_LD_LEVEL XCArgs;
1868 XCArgs.enMode = enMode;
1869 XCArgs.bReturnValue = FALSE;
1870
1871 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1872 {
1873 printf("Obtain XC engine fail\n");
1874 return FALSE;
1875 }
1876 else
1877 {
1878 return XCArgs.bReturnValue;
1879 }
1880 }
1881
MApi_XC_LD_Init_U2(void * pInstance,EN_LD_PANEL_TYPE enLDPanelType)1882 MS_BOOL MApi_XC_LD_Init_U2(void* pInstance, EN_LD_PANEL_TYPE enLDPanelType )
1883 {
1884 UNUSED(pInstance);
1885 UNUSED(enLDPanelType);
1886 return TRUE;
1887 }
1888
MApi_XC_LD_Init(EN_LD_PANEL_TYPE enLDPanelType)1889 MS_BOOL MApi_XC_LD_Init(EN_LD_PANEL_TYPE enLDPanelType )
1890 {
1891 if (pu32XCInst == NULL)
1892 {
1893 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1894 return FALSE;
1895 }
1896
1897 stXC_LD_INIT XCArgs;
1898 XCArgs.enLDPanelType = enLDPanelType;
1899 XCArgs.bReturnValue = FALSE;
1900
1901 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_LD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1902 {
1903 printf("Obtain XC engine fail\n");
1904 return FALSE;
1905 }
1906 else
1907 {
1908 return XCArgs.bReturnValue;
1909 }
1910 }
1911
MApi_Set_BLLevel_U2(void * pInstance,MS_U8 u8BLLevel)1912 MS_BOOL MApi_Set_BLLevel_U2(void* pInstance, MS_U8 u8BLLevel)
1913 {
1914 UNUSED(pInstance);
1915 UNUSED(u8BLLevel);
1916 return TRUE;
1917 }
1918
MApi_Set_BLLevel(MS_U8 u8BLLevel)1919 MS_BOOL MApi_Set_BLLevel(MS_U8 u8BLLevel)
1920 {
1921 if (pu32XCInst == NULL)
1922 {
1923 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1924 return FALSE;
1925 }
1926
1927 stXC_SET_BL_LEVEL XCArgs;
1928 XCArgs.u8BLLevel = u8BLLevel;
1929 XCArgs.bReturnValue = FALSE;
1930
1931 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_BL_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1932 {
1933 printf("Obtain XC engine fail\n");
1934 return FALSE;
1935 }
1936 else
1937 {
1938 return XCArgs.bReturnValue;
1939 }
1940 }
1941
MApi_Set_TurnoffLDBL_U2(void * pInstance,MS_BOOL bTurnoffBL)1942 MS_BOOL MApi_Set_TurnoffLDBL_U2(void* pInstance, MS_BOOL bTurnoffBL)
1943 {
1944 UNUSED(pInstance);
1945 UNUSED(bTurnoffBL);
1946 return TRUE;
1947 }
1948
MApi_Set_TurnoffLDBL(MS_BOOL bTurnoffBL)1949 MS_BOOL MApi_Set_TurnoffLDBL(MS_BOOL bTurnoffBL)
1950 {
1951 if (pu32XCInst == NULL)
1952 {
1953 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1954 return FALSE;
1955 }
1956
1957 stXC_SET_LD_TURNOFF_LDBL XCArgs;
1958 XCArgs.bTurnoffBL = bTurnoffBL;
1959 XCArgs.bReturnValue = FALSE;
1960
1961 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_TURNOFF_LDBL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1962 {
1963 printf("Obtain XC engine fail\n");
1964 return FALSE;
1965 }
1966 else
1967 {
1968 return XCArgs.bReturnValue;
1969 }
1970 }
1971
MApi_Set_UsermodeLDFlags_U2(void * pInstance,MS_BOOL bUserLDFlags)1972 MS_BOOL MApi_Set_UsermodeLDFlags_U2(void* pInstance, MS_BOOL bUserLDFlags)
1973 {
1974 UNUSED(pInstance);
1975 UNUSED(bUserLDFlags);
1976 return TRUE;
1977 }
1978
MApi_Set_UsermodeLDFlags(MS_BOOL bUserLDFlags)1979 MS_BOOL MApi_Set_UsermodeLDFlags(MS_BOOL bUserLDFlags)
1980 {
1981 if (pu32XCInst == NULL)
1982 {
1983 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1984 return FALSE;
1985 }
1986
1987 stXC_SET_LD_USERMODEFLAGS XCArgs;
1988 XCArgs.bUserLDFlags = bUserLDFlags;
1989 XCArgs.bReturnValue = FALSE;
1990
1991 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_LD_USERMODEFLAGS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1992 {
1993 printf("Obtain XC engine fail\n");
1994 return FALSE;
1995 }
1996 else
1997 {
1998 return XCArgs.bReturnValue;
1999 }
2000 }
2001
MApi_Set_notUpdateSPIDataFlags_U2(void * pInstance,MS_BOOL bRefreshSpidata)2002 MS_BOOL MApi_Set_notUpdateSPIDataFlags_U2(void* pInstance, MS_BOOL bRefreshSpidata)
2003 {
2004 UNUSED(pInstance);
2005 UNUSED(bRefreshSpidata);
2006 return TRUE;
2007 }
2008
MApi_Set_notUpdateSPIDataFlags(MS_BOOL bRefreshSPIData)2009 MS_BOOL MApi_Set_notUpdateSPIDataFlags(MS_BOOL bRefreshSPIData)
2010 {
2011 if (pu32XCInst == NULL)
2012 {
2013 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2014 return FALSE;
2015 }
2016
2017 stXC_SET_NOTUPDATE_SPI_DATA_FLAGS XCArgs;
2018 XCArgs.bRefreshSPIData = bRefreshSPIData;
2019 XCArgs.bReturnValue = FALSE;
2020
2021 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_NOTUPDATE_SPI_DATA_FLAGS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2022 {
2023 printf("Obtain XC engine fail\n");
2024 return FALSE;
2025 }
2026 else
2027 {
2028 return XCArgs.bReturnValue;
2029 }
2030 }
2031
2032 #endif
2033
2034