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
95
96 //-------------------------------------------------------------------------------------------------
97 // Include Files
98 //-------------------------------------------------------------------------------------------------
99 #include "MsCommon.h"
100 #ifndef MSOS_TYPE_LINUX_KERNEL
101 #include <string.h>
102 #endif
103 #include "regGE.h"
104 #include "drvGE.h"
105 #include "halGE.h"
106 #include "halCHIP.h"
107 #ifdef MSOS_TYPE_LINUX
108 #include "halMPool.h"
109 #endif
110 #include "drvCLKM.h"
111 //-------------------------------------------------------------------------------------------------
112 // Driver Compiler Options
113 //-------------------------------------------------------------------------------------------------
114 #define GE_DITHER_RAND_ENABLE 0UL //[TBD] Add new option for SetDither if rand is used in the future.
115 #define GE_PATCH_ENABLE 0UL
116
117 #define GE_LOG_ENABLE 0UL
118 #define MS_DEBUG 1UL
119
120 //-------------------------------------------------------------------------------------------------
121 // Local Defines
122 //-------------------------------------------------------------------------------------------------
123 #define GE_MIU_ADDR_MASK 0x7FFFFFFFUL
124
125 #define GE_CMDQ_FREECNT() ((GE_REG(REG_GE_STAT)&GE_STAT_CMDQ_MASK)>>GE_STAT_CMDQ_SHFT)
126 #define GE_VCMDQ_FREECNT() (GE_REG(REG_GE_VCMDQ_STAT) + ((GE_REG(REG_GE_BIST_STAT)&GE_VCMDQ_STAT_H_MASK) << 16))
127
128 #define GE_BUSY() (GE_REG(REG_GE_STAT) & GE_STAT_BUSY)
129
130 #define GE_CMDQ_ENABLE 1UL // Always Enable
131 #define GE_CMD_SIZE_MAX GE_STAT_CMDQ_MAX
132 #define GE_VCMD_SIZE_MAX GE_STAT_VCMDQ_MAX
133 #define GE_CMD_SIZE 1UL // 1 queue entry available for 2 commands, but we just check entry for convenience
134
135 #define GE_MAP_VCMD_SIZE_TO_HWDEF(x) ((x))
136
137 #define GE_YIELD() MsOS_YieldTask()
138
139 #ifdef MS_DEBUG
140 #define GE_DBG(_fmt, _args...) printf(_fmt, ##_args)
141 #else
142 #define GE_DBG(_fmt, _args...) { }
143 #endif
144 #define GE_BURST_LEN 128UL
145
146 //-------------------------------------------------------------------------------------------------
147 // Local Structures
148 //-------------------------------------------------------------------------------------------------
149
150
151 //-------------------------------------------------------------------------------------------------
152 // Global Variables
153 //------------------------------------------------------------------------------------------------- // line pattern reset
154
155
156 const MS_U8 _GE_Reg_Backup[] = {
157 REG_GE_EN, REG_GE_CFG, REG_GE_TH, REG_GE_ROP2, REG_GE_BLEND, REG_GE_ALPHA, REG_GE_ALPHA_CONST,
158 REG_GE_SCK_HTH_L, REG_GE_SCK_HTH_H, REG_GE_SCK_LTH_L, REG_GE_SCK_LTH_H, REG_GE_DCK_HTH_L,
159 REG_GE_DCK_HTH_H, REG_GE_DCK_LTH_L, REG_GE_DCK_LTH_H, REG_GE_OP_MODE, REG_GE_ATEST_TH,
160 REG_GE_YUV_MODE, REG_GE_SRC_BASE_L, REG_GE_SRC_BASE_H, REG_GE_DST_BASE_L, REG_GE_DST_BASE_H,
161 REG_GE_SRC_PITCH, REG_GE_DST_PITCH, REG_GE_FMT,
162 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, // I0~I4
163 0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, // I5-I9
164 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, // I10-I14
165 0x0053, 0x0054, // I15
166 REG_GE_CLIP_L, REG_GE_CLIP_R, REG_GE_CLIP_T, REG_GE_CLIP_B, REG_GE_ROT_MODE, REG_GE_BLT_SCK_MODE,
167 REG_GE_BLT_SCK_CONST_L, REG_GE_BLT_SCK_CONST_H, REG_GE_BLT_DST_X_OFST, REG_GE_BLT_DST_Y_OFST,
168 REG_GE_LINE_DELTA, REG_GE_LINE_STYLE, REG_GE_LINE_LENGTH, REG_GE_BLT_SRC_DX, REG_GE_BLT_SRC_DY,
169 REG_GE_ITALIC_OFFSET, REG_GE_ITALIC_DELTA, REG_GE_PRIM_V0_X, REG_GE_PRIM_V0_Y, REG_GE_PRIM_V1_X,
170 REG_GE_PRIM_V1_Y, REG_GE_PRIM_V2_X, REG_GE_PRIM_V2_Y, REG_GE_BLT_SRC_W, REG_GE_BLT_SRC_H,
171 REG_GE_PRIM_C_L, REG_GE_PRIM_C_H, REG_GE_PRIM_RDX_L, REG_GE_PRIM_RDX_H, REG_GE_PRIM_RDY_L,
172 REG_GE_PRIM_RDY_H, REG_GE_PRIM_GDX_L, REG_GE_PRIM_GDX_H, REG_GE_PRIM_GDY_L, REG_GE_PRIM_GDY_H,
173 REG_GE_PRIM_BDX_L, REG_GE_PRIM_BDX_H, REG_GE_PRIM_BDY_L, REG_GE_PRIM_BDY_H, REG_GE_PRIM_ADX,
174 REG_GE_PRIM_ADY, 0xFF
175 };
176
177 //-------------------------------------------------------------------------------------------------
178 // Debug Functions
179 //-------------------------------------------------------------------------------------------------
180
181
182 //------------------------------------------------------------------------------
183 // Local Var
184 //------------------------------------------------------------------------------
185 GE_CHIP_PROPERTY g_GeChipPro =
186 {
187 .WordUnit = GE_WordUnit,
188
189 .bSupportFourePixelMode = TRUE,
190 .bFourPixelModeStable = TRUE,
191
192 .bSupportMultiPixel = FALSE,
193 .bSupportSpiltMode = TRUE,
194 .bSupportTwoSourceBitbltMode = FALSE,
195 .bSupportTLBMode = FALSE,
196 .MIUSupportMaxNUM = GE_MAX_MIU,
197 .BltDownScaleCaps =
198 {
199 .u8RangeMax = 1,
200 .u8RangeMin = 32,
201 .u8ContinuousRangeMin = 1,
202 .bFullRangeSupport = TRUE,
203
204 .u8ShiftRangeMax = 0, /// 1 = 2^0 = 1<<0
205 .u8ShiftRangeMin = 5, /// 32 = 2^5 = 1<<5
206 .u8ShiftContinuousRangeMin = 0, /// 1 = 2^0 = 1<<0
207 }
208 };
209
210 //-------------------------------------------------------------------------------------------------
211 // Local Functions
212 //-------------------------------------------------------------------------------------------------
GE_Chip_Proprity_Init(GE_CTX_HAL_LOCAL * pGEHalLocal)213 void GE_Chip_Proprity_Init(GE_CTX_HAL_LOCAL *pGEHalLocal)
214 {
215 pGEHalLocal->pGeChipPro = &g_GeChipPro;
216 }
217
_GE_SetBltScaleRatio2HW(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_ScaleInfo * pScaleinfo)218 GE_Result _GE_SetBltScaleRatio2HW(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_ScaleInfo *pScaleinfo)
219 {
220 MS_U16 u16RegVal;
221
222 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SRC_DX, (MS_U16)(pScaleinfo->x&0xFFFF));
223 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SRC_DY, (MS_U16)(pScaleinfo->y&0xFFFF));
224 //Set Initial DeltaX, DeltaY:
225 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_X_OFST, (MS_U16)(pScaleinfo->init_x&0xFFFF));
226 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_Y_OFST, (MS_U16)(pScaleinfo->init_y&0xFFFF));
227
228 //set MSBs of REG_GE_BLT_SRC_DY, REG_GE_BLT_SRC_DY:
229 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_BLT_DST_X_OFST) & ~(GE_STBB_DX_MSB);
230 u16RegVal |= (((pScaleinfo->x>>16)<<GE_STBB_DX_MSB_SHFT) & GE_STBB_DX_MSB);
231 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_X_OFST, u16RegVal);
232
233 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_BLT_DST_Y_OFST) & ~(GE_STBB_DY_MSB);
234 u16RegVal |= (((pScaleinfo->y>>16)<<GE_STBB_DY_MSB_SHFT) & GE_STBB_DY_MSB);
235 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_Y_OFST, u16RegVal);
236
237 return E_GE_OK;
238 }
239
GE_SetActiveCtrlMiu1(GE_CTX_HAL_LOCAL * pGEHalLocal)240 void GE_SetActiveCtrlMiu1(GE_CTX_HAL_LOCAL *pGEHalLocal)
241 {
242 MIU1_REG(MIU1_GEGROUP) = MIU1_REG(MIU1_GEGROUP)|MIU1_GE_CLIENT;
243 }
244
245 //-------------------------------------------------------------------------------------------------
246 // Global Functions
247 //-------------------------------------------------------------------------------------------------
GE_DumpReg(GE_CTX_HAL_LOCAL * pGEHalLocal)248 static void GE_DumpReg(GE_CTX_HAL_LOCAL *pGEHalLocal)
249 {
250 MS_U32 i;
251
252 printf("Dump GE register:\n");
253 for (i = 0; i < 0x80; i++)
254 {
255 if(i % 0x08 == 0) {
256 printf(" \n");
257 printf("h%02x ", (MS_U8)i );
258 }
259 printf("%04x ", GE_REG(i) );
260 }
261
262 printf(" \n");
263 }
_GET_MIU_MASK_SHIFT(void)264 static MS_U32 _GET_MIU_MASK_SHIFT(void)
265 {
266 if (HAL_MIU1_BASE==0x20000000)
267 return (29UL);
268 else if (HAL_MIU1_BASE==0x10000000)
269 return (28UL);
270 else if (HAL_MIU1_BASE==0x8000000)
271 return (27UL);
272 else if (HAL_MIU1_BASE==0x4000000)
273 return (26UL);
274 else if (HAL_MIU1_BASE==0x60000000)
275 return (29UL);
276 else
277 {
278 printf("\n[%s] !!!!!! get miu1 base error!!!!!!", __FUNCTION__);
279 return (27UL); //default return case
280 }
281 }
282
_GFXAPI_MIU_ID(MS_PHY ge_fbaddr)283 MS_U8 _GFXAPI_MIU_ID(MS_PHY ge_fbaddr)
284 {
285 #if 1
286 if(ge_fbaddr>=HAL_MIU1_BASE)
287 {
288 return 1;
289 }
290 else
291 {
292 return 0;
293 }
294 #else
295 return ((MS_U8) (((ge_fbaddr)>>_GET_MIU_MASK_SHIFT())&((1UL<<GE_FB_ADDR_MIU_MASK_BIT)-1)));
296
297 #endif
298 }
299
_GFXAPI_PHYS_ADDR_IN_MIU(MS_PHY ge_fbaddr)300 MS_PHY _GFXAPI_PHYS_ADDR_IN_MIU(MS_PHY ge_fbaddr)
301 {
302 #if 1
303 if(ge_fbaddr>=HAL_MIU1_BASE)
304 {
305 return (ge_fbaddr -= HAL_MIU1_BASE);
306 }
307 else
308 {
309 return (ge_fbaddr);
310 }
311 #else
312 return ((ge_fbaddr)&((1UL<<_GET_MIU_MASK_SHIFT())-1));
313 #endif
314 }
315
_GFXAPI_PHYS_ADDR_2_API(MS_U8 u8MIUId,MS_PHY ge_addrInMIU)316 MS_PHY _GFXAPI_PHYS_ADDR_2_API(MS_U8 u8MIUId, MS_PHY ge_addrInMIU)
317 {
318 #if 1
319 if(u8MIUId == 1)
320 {
321 return (HAL_MIU1_BASE| (ge_addrInMIU&((1UL<<_GET_MIU_MASK_SHIFT())-1)));
322 }
323 else
324 {
325 return (ge_addrInMIU&((1UL<<_GET_MIU_MASK_SHIFT())-1));
326 }
327 #else
328
329 return (((((MS_U32)(u8MIUId))&((1UL<<GE_FB_ADDR_MIU_MASK_BIT)-1))<<_GET_MIU_MASK_SHIFT()) | \
330 (((MS_U32)(ge_addrInMIU))&((1UL<<_GET_MIU_MASK_SHIFT())-1)));
331 #endif
332 }
333
GE_Reset(GE_CTX_HAL_LOCAL * pGEHalLocal)334 static void GE_Reset(GE_CTX_HAL_LOCAL *pGEHalLocal)
335 {
336 MS_U16 reg0, reg1;
337
338 reg0 = GE_REG(REG_GE_EN);
339 reg1 = GE_REG(REG_GE_CFG);
340
341 GE_REG(REG_GE_EN) = 0;
342 GE_REG(REG_GE_CFG) = 0;
343
344 GE_REG(REG_GE_EN) = reg0;
345 GE_REG(REG_GE_CFG) = reg1;
346
347 }
348
GE_MapVQ2Reg(GE_VcmqBufSize enBufSize)349 static MS_U8 GE_MapVQ2Reg(GE_VcmqBufSize enBufSize)
350 {
351 switch(enBufSize)
352 {
353 case E_GE_VCMD_4K:
354 return GE_VQ_8K;
355 case E_GE_VCMD_8K:
356 return GE_VQ_8K;
357 case E_GE_VCMD_16K:
358 return GE_VQ_16K;
359 case E_GE_VCMD_32K:
360 return GE_VQ_32K;
361 case E_GE_VCMD_64K:
362 return GE_VQ_64K;
363 case E_GE_VCMD_128K:
364 return GE_VQ_128K;
365 case E_GE_VCMD_256K:
366 return GE_VQ_256K;
367 case E_GE_VCMD_512K:
368 return GE_VQ_512K;
369 case E_GE_VCMD_1024K:
370 return GE_VQ_1024K;
371 default:
372 return 0;
373 }
374 }
375
GE_WaitCmdQAvail(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U32 u32Count)376 void GE_WaitCmdQAvail(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U32 u32Count)
377 {
378 #if GE_CMDQ_ENABLE
379
380 #ifdef MS_DEBUG
381 MS_U32 waitcount = 0;
382 #endif
383 MS_U16 tmp1 = 0;
384 MS_U32 u32CmdMax;
385
386 /// VCMQ enabled
387 if((GE_REG(REG_GE_CFG) & GE_CFG_VCMDQ) != 0)
388 {
389 // 16 Bytes one command in VCMDQ.
390 u32CmdMax = (512 << (GE_REG(REG_GE_VCMDQ_SIZE) & 0x7));
391 u32Count = MIN(u32CmdMax, u32Count);
392
393 while (GE_CMDQ_FREECNT() < u32Count)
394 {
395 #ifdef MS_DEBUG
396 if (waitcount >= 0x80000)
397 {
398 printf("[GE] V0 Wait command queue: %d : %x, %tx\n", tmp1, GE_CMDQ_FREECNT(), (ptrdiff_t)u32Count);
399 waitcount = 0;
400 tmp1++;
401 if(tmp1 > 10)
402 {
403 GE_DumpReg(pGEHalLocal);
404 GE_Reset(pGEHalLocal);
405 }
406 }
407 waitcount++;
408 #endif
409 GE_YIELD();
410 }
411 tmp1 = 0;
412 waitcount = 0;
413
414
415 //If u32Count >= u32CmdMax, It will be dead loop. But since it won't happen, and if match
416 //Full VCMDQ, hw will hang, so keep the logic.
417 while ( (MS_U32)GE_VCMDQ_FREECNT() >= (MS_U32)(u32CmdMax- u32Count))
418 {
419 #ifdef MS_DEBUG
420 if (waitcount >= 0x80000)
421 {
422 printf("[GE] Wait VCMQ : %d : %tx, %tx \n", tmp1, (ptrdiff_t)GE_VCMDQ_FREECNT(), (ptrdiff_t)u32Count);
423 waitcount = 0;
424 tmp1++;
425 if(tmp1 > 10)
426 {
427 GE_DumpReg(pGEHalLocal);
428 GE_Reset(pGEHalLocal);
429 }
430 }
431 waitcount++;
432 #endif
433 GE_YIELD();
434 }
435 }
436 else
437 {
438 u32Count = MIN(GE_CMD_SIZE_MAX, u32Count);
439
440 while (GE_CMDQ_FREECNT() < u32Count)
441 {
442 #ifdef MS_DEBUG
443 if (waitcount >= 0x80000)
444 {
445 printf("[GE] Wait command queue: %d : %x, %tx \n", tmp1, GE_CMDQ_FREECNT(), (ptrdiff_t)u32Count);
446 waitcount = 0;
447 tmp1++;
448 if(tmp1 > 10)
449 {
450 GE_DumpReg(pGEHalLocal);
451 GE_Reset(pGEHalLocal);
452 }
453 }
454 waitcount++;
455 #endif
456 GE_YIELD();
457 }
458
459 }
460
461 #endif
462 }
463
GE_ConvertAPIAddr2HAL(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8MIUId,MS_PHY PhyGE_APIAddrInMIU)464 MS_PHY GE_ConvertAPIAddr2HAL(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8MIUId, MS_PHY PhyGE_APIAddrInMIU)
465 {
466 PhyGE_APIAddrInMIU &= (1UL<<MIU_SELETE_OFFSET)-1UL;
467 if(u8MIUId==1)
468 PhyGE_APIAddrInMIU |= 1UL<<MIU_SELETE_OFFSET;
469 return PhyGE_APIAddrInMIU;
470 }
GE_ConvertHALAddr2API(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8MIUId,MS_PHY PhyGE_HALAddr)471 MS_PHY GE_ConvertHALAddr2API(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8MIUId, MS_PHY PhyGE_HALAddr)
472 {
473 return _GFXAPI_PHYS_ADDR_2_API(u8MIUId, PhyGE_HALAddr&((1UL<<MIU_SELETE_OFFSET)-1));
474 }
475
GE_WaitIdle(GE_CTX_HAL_LOCAL * pGEHalLocal)476 void GE_WaitIdle(GE_CTX_HAL_LOCAL *pGEHalLocal)
477 {
478 #ifdef MS_DEBUG
479 MS_U32 waitcount = 0;
480 #endif
481 MS_U16 tmp1 = 0;
482
483 GE_WriteReg(pGEHalLocal, REG_GE_TAG, GE_GetNextTAGID(pGEHalLocal, FALSE)); // write dummy
484 // GE will pack 2 register commands before CMDQ
485 // We need to push fifo if there is one command in the fifo before
486 // CMDQ. Then the GE status register will be consistant after idle.
487 GE_WaitCmdQAvail(pGEHalLocal, GE_STAT_CMDQ_MAX); // Wait CMDQ empty
488
489 // Wait level-2 command queue flush
490 while (((GE_REG(REG_GE_STAT)&GE_STAT_CMDQ2_MASK)>>GE_STAT_CMDQ2_SHFT) != GE_STAT_CMDQ2_MAX)
491 {
492 #ifdef MS_DEBUG
493 if (waitcount >= 0x80000)
494 {
495 printf("[GE] Wait Idle: %u : %x\n", tmp1, GE_CMDQ_FREECNT());
496 waitcount = 0;
497 tmp1++;
498 if(tmp1 > 10)
499 {
500 GE_DumpReg(pGEHalLocal);
501 GE_Reset(pGEHalLocal);
502 }
503 }
504 waitcount++;
505 #endif
506
507 GE_YIELD();
508 }
509
510 #ifdef MS_DEBUG
511 waitcount = 0;
512 tmp1 = 0;
513 #endif
514 // Wait GE idle
515 while (GE_REG(REG_GE_STAT) & GE_STAT_BUSY)
516 {
517 #ifdef MS_DEBUG
518 if (waitcount >= 0x80000)
519 {
520 printf("[GE] Wait Busy: %d : %x\n", tmp1, GE_CMDQ_FREECNT());
521 waitcount = 0;
522 tmp1++;
523 if(tmp1 > 10)
524 {
525 GE_DumpReg(pGEHalLocal);
526 GE_Reset(pGEHalLocal);
527 }
528 }
529 waitcount++;
530 #endif
531
532 GE_YIELD();
533 }
534
535 }
536
GE_Map_Share_Reg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)537 GE_Result GE_Map_Share_Reg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
538 {
539 if(addr == REG_GE_CFG)
540 return E_GE_OK;
541 else
542 return E_GE_FAIL;
543 #if 0
544 switch(addr)
545 {
546 case REG_GE_CFG:
547 return E_GE_OK;
548 default:
549 return E_GE_FAIL;
550 }
551 #endif
552
553 }
554
GE_Map_Share_RegEX(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)555 GE_Result GE_Map_Share_RegEX(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
556 {
557 return E_GE_FAIL;
558 }
559
GE_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)560 MS_U16 GE_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
561 {
562 MS_U16 u16NoFIFOMask;
563
564 if(GE_TABLE_REGNUM <= addr)
565 {
566 GE_WaitIdle(pGEHalLocal);
567 return GE_REG(addr-GE_TABLE_REGNUM);
568 }
569 switch (addr)
570 {//for registers which do not go through command queue
571 case REG_GE_EN:
572 u16NoFIFOMask = GE_EN_GE;
573 break;
574 /*
575 case REG_GE_CFG:
576 //u16NoFIFOMask = ~(GE_CFG_BLT_STRETCH|GE_CFG_EN_CLIPCHK|GE_CFG_BLT_ITALIC|GE_CFG_SRC_TILE|GE_CFG_DST_TILE);
577 return pGEHalLocal->u16RegImage[addr];
578 break;
579 */
580 case REG_GE_DBG:
581 case REG_GE_TH:
582 case REG_GE_BIST_STAT:
583 case REG_GE_STAT:
584 case REG_GE_VCMDQ_STAT:
585 case REG_GE_MIU_PROT_LTH_L(0):
586 case REG_GE_MIU_PROT_LTH_H(0):
587 case REG_GE_MIU_PROT_HTH_L(0):
588 case REG_GE_MIU_PROT_HTH_H(0):
589 case REG_GE_MIU_PROT_LTH_L(1):
590 case REG_GE_MIU_PROT_LTH_H(1):
591 case REG_GE_MIU_PROT_HTH_L(1):
592 case REG_GE_MIU_PROT_HTH_H(1):
593 case REG_GE_TAG:
594 case REG_GE_VCMDQ_BASE_L:
595 case REG_GE_VCMDQ_BASE_H:
596 u16NoFIFOMask = 0xffff;
597 break;
598 case REG_GE_VCMDQ_SIZE:
599 u16NoFIFOMask = GE_VCMDQ_SIZE_MASK;
600 break;
601 default:
602 u16NoFIFOMask = 0;
603 break;
604 }
605
606 if(0 == u16NoFIFOMask)
607 {
608 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
609 return pGEHalLocal->pHALShared->u16ShareRegImage[addr];
610 else
611 {
612 return pGEHalLocal->u16RegGETable[addr];
613 }
614 }
615 return (GE_REG(addr)&u16NoFIFOMask)|(pGEHalLocal->u16RegGETable[addr]&~u16NoFIFOMask);
616 }
617
618
GE_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)619 void GE_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
620 {
621 // CMDQ special command
622 if(addr < GE_TABLE_REGNUM)
623 {
624 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
625 {
626 pGEHalLocal->pHALShared->u16ShareRegImage[addr]= value;
627 }
628
629 pGEHalLocal->u16RegGETable[addr] = value;
630 }
631 else
632 {
633 printf("[%s][%d] Reg Index [%d]is out of GE_TABLE_REGNUM [0x%lx]range!!!!\n",__FUNCTION__,__LINE__, addr, GE_TABLE_REGNUM);
634 }
635
636 if(pGEHalLocal->pHALShared->bGE_DirectToReg ==TRUE)
637 {
638 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
639 GE_REG(addr)= value;
640 return;
641 }
642 else
643 {
644 MS_U16 i=0;
645
646 switch (addr)
647 {
648 case REG_GE_EN:
649 case REG_GE_CFG:
650 case REG_GE_DBG:
651 case REG_GE_TH:
652 case REG_GE_BIST_STAT:
653 case REG_GE_STAT:
654 case REG_GE_VCMDQ_STAT:
655 case REG_GE_MIU_PROT_LTH_L(0):
656 case REG_GE_MIU_PROT_LTH_H(0):
657 case REG_GE_MIU_PROT_HTH_L(0):
658 case REG_GE_MIU_PROT_HTH_H(0):
659 case REG_GE_MIU_PROT_LTH_L(1):
660 case REG_GE_MIU_PROT_LTH_H(1):
661 case REG_GE_MIU_PROT_HTH_L(1):
662 case REG_GE_MIU_PROT_HTH_H(1):
663 case REG_GE_TAG:
664 case REG_GE_VCMDQ_BASE_L:
665 case REG_GE_VCMDQ_BASE_H:
666 case REG_GE_VCMDQ_SIZE:
667
668 //Palette
669 case REG_GE_CLUT_L:
670 case REG_GE_CLUT_H:
671 case REG_GE_CLUT_CTRL:
672 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
673 GE_REG(addr) = value;
674 break;
675
676 case REG_GE_CMD:
677 GE_WaitIdle(pGEHalLocal);
678
679 for(i=0; i<GE_TABLE_REGNUM; i++)
680 {
681 //CMQ/Palette
682 if(i==REG_GE_EN || i==REG_GE_CFG || i==REG_GE_DBG || i==REG_GE_TH || i==REG_GE_VCMDQ_STAT || i==REG_GE_BIST_STAT \
683 || i==REG_GE_MIU_PROT_LTH_L(0) || i==REG_GE_MIU_PROT_LTH_H(0) || i==REG_GE_MIU_PROT_HTH_L(0) || i==REG_GE_MIU_PROT_HTH_H(0)\
684 || i==REG_GE_MIU_PROT_LTH_L(1) || i==REG_GE_MIU_PROT_LTH_H(1) || i==REG_GE_MIU_PROT_HTH_L(1) || i==REG_GE_MIU_PROT_HTH_H(1)\
685 || i==REG_GE_VCMDQ_BASE_L || i==REG_GE_VCMDQ_BASE_H || i==REG_GE_VCMDQ_SIZE \
686 || i==REG_GE_CLUT_L || i==REG_GE_CLUT_H || i==REG_GE_CLUT_CTRL || i==REG_GE_TAG)
687 {
688 continue;
689 }
690
691 if(i == REG_GE_CMD )
692 {
693 continue;
694 }
695
696 if(i == (GE_TABLE_REGNUM-1))
697 {
698 GE_REG(i)= pGEHalLocal->u16RegGETable[i];
699 GE_REG(REG_GE_CMD)= pGEHalLocal->u16RegGETable[REG_GE_CMD];
700 }
701 else
702 {
703 if (GE_WordUnit/*256bit*//4/*32bit*/*16*2 < (GE_TABLE_REGNUM-20))
704 {
705 if(i%64==0)
706 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
707 }
708 GE_REG(i)= pGEHalLocal->u16RegGETable[i];
709 }
710 }
711 break;
712 default:
713 #if GE_LOG_ENABLE
714 GE_LOG(addr, value);
715 #endif
716 break;
717 }
718
719 }
720
721 }
722
GE2_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)723 MS_U16 GE2_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
724 {
725 return 0;
726 }
727
GE_RestoreReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)728 void GE_RestoreReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
729 {
730 // CMDQ special command
731 switch (addr)
732 {
733 case REG_GE_CMD:
734 break;
735 //[OBSOLETE]
736 default:
737 GE_WriteReg(pGEHalLocal, addr, value);
738 break;
739 }
740 }
741
742
GE_ResetState(GE_CTX_HAL_LOCAL * pGEHalLocal)743 void GE_ResetState(GE_CTX_HAL_LOCAL *pGEHalLocal)
744 {
745 GE_WaitIdle(pGEHalLocal);
746
747 GE_WriteReg(pGEHalLocal, REG_GE_EN, GE_EN_GE);
748 #if GE_DITHER_RAND_ENABLE
749 GE_WriteReg(pGEHalLocal, REG_GE_EN, GE_EN_GE | GE_EN_DITHER_RAND); //fixed random dither by default
750 #endif
751 GE_WriteReg(pGEHalLocal, REG_GE_TH, 0x0000); //0(<half) will be default to be half
752
753 GE_WriteReg(pGEHalLocal, REG_GE_LINE_STYLE, GE_LINEPAT_RST);
754 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SCK_MODE, GE_BLT_SCK_NEAREST);
755 GE_WriteReg(pGEHalLocal, REG_GE_BLEND, GE_ALPHA_ARGB1555); //force alpha constant of ARGB"1"555 to be 1.0 by default
756 }
757
758
GE_Init_RegImage(GE_CTX_HAL_LOCAL * pGEHalLocal)759 void GE_Init_RegImage(GE_CTX_HAL_LOCAL *pGEHalLocal)
760 {
761 MS_U8 addr;
762
763 for(addr = 0; addr<GE_TABLE_REGNUM; addr++)
764 {
765 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
766 pGEHalLocal->pHALShared->u16ShareRegImage[addr]= GE_REG(addr);
767 pGEHalLocal->u16RegGETable[addr] = GE_REG(addr);
768 }
769
770 }
771
GE_Init(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Config * cfg)772 void GE_Init(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_Config *cfg)
773 {
774 MS_U16 u16temp =0;
775
776 GE_WaitIdle(pGEHalLocal);
777
778 GE_SetClock(pGEHalLocal,TRUE);
779
780 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
781
782 if ((u16temp & BIT(1)) != BIT(1)) //if VQ is Not Enabled
783 {
784 #if GE_CMDQ_ENABLE
785 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
786 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16temp | GE_CFG_CMDQ); // enable command queue
787 #endif
788
789 // Set default FMT for avoiding 1st set buffinfo error.
790 GE_WriteReg(pGEHalLocal, REG_GE_FMT, (GE_FMT_ARGB1555<<GE_SRC_FMT_SHFT)+(GE_FMT_ARGB1555<<GE_DST_FMT_SHFT));
791
792 if (cfg->u32VCmdQSize >= GE_VCMDQ_SIZE_MIN)
793 {
794 MS_PHY PhyVQAddr = cfg->PhyVCmdQAddr;
795 MS_U32 u32VcmdqBufSz = cfg->u32VCmdQSize;
796
797 GE_SetVCmdBuffer(pGEHalLocal, PhyVQAddr, u32VcmdqBufSz);
798
799 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
800 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16temp | GE_CFG_VCMDQ);
801 }
802
803 GE_ResetState(pGEHalLocal);
804 }
805 else
806 {
807 //No need to set command queue
808 printf(" warning!!! Virtual Command queue has been activated!! \n");
809 }
810 //GE_Init_RegImage(pGEHalLocal);
811
812 GE_WriteReg(pGEHalLocal, REG_GE_TH, GE_THRESHOLD_SETTING);
813 //Mask Interrupt
814 GE_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, 0x00C0);
815
816 //enable dynamic clock gating
817 GE_EnableDynaClkGate(pGEHalLocal,TRUE);
818 }
819
GE_SetRotate(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RotateAngle geRotAngle)820 GE_Result GE_SetRotate(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RotateAngle geRotAngle)
821 {
822 MS_U16 u16RegVal;
823
824 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_ROT_MODE) & ~REG_GE_ROT_MODE_MASK) | (geRotAngle<<REG_GE_ROT_MODE_SHFT);
825 GE_WriteReg(pGEHalLocal, REG_GE_ROT_MODE, u16RegVal);
826
827 return E_GE_OK;
828 }
829
GE_SetOnePixelMode(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)830 GE_Result GE_SetOnePixelMode(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
831 {
832
833 MS_U16 u16en;
834 //GE_DBG("%s\n", __FUNCTION__);
835
836 u16en = GE_ReadReg(pGEHalLocal, REG_GE_EN);
837 if (enable)
838 {
839 u16en |= GE_EN_ONE_PIXEL_MODE;
840 }
841 else
842 {
843 u16en &= (~GE_EN_ONE_PIXEL_MODE);
844 }
845 u16en |= GE_EN_BURST;
846 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en);
847
848 return E_GE_OK;
849 }
850
GE_SetBlend(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_BlendOp eBlendOp)851 GE_Result GE_SetBlend(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_BlendOp eBlendOp)
852 {
853 MS_U16 u16op;
854
855 switch (eBlendOp)
856 {
857 case E_GE_BLEND_ONE:
858 case E_GE_BLEND_CONST:
859 case E_GE_BLEND_ASRC:
860 case E_GE_BLEND_ADST:
861 case E_GE_BLEND_ROP8_ALPHA:
862 case E_GE_BLEND_ROP8_SRCOVER:
863 case E_GE_BLEND_ROP8_DSTOVER:
864 case E_GE_BLEND_ZERO:
865 case E_GE_BLEND_CONST_INV:
866 case E_GE_BLEND_ASRC_INV:
867 case E_GE_BLEND_ADST_INV:
868 case E_GE_BLEND_ALPHA_ADST:
869 case E_GE_BLEND_SRC_ATOP_DST:
870 case E_GE_BLEND_DST_ATOP_SRC:
871 case E_GE_BLEND_SRC_XOR_DST:
872 case E_GE_BLEND_INV_CONST:
873
874 u16op = eBlendOp;
875 break;
876 default:
877 return E_GE_FAIL_PARAM;
878 break;
879 }
880
881 u16op = (GE_ReadReg(pGEHalLocal, REG_GE_BLEND) & ~GE_BLEND_MASK) | u16op;
882 GE_WriteReg(pGEHalLocal, REG_GE_BLEND, u16op);
883
884 return E_GE_OK;
885 }
886
887
GE_SetAlpha(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_AlphaSrc eAlphaSrc)888 GE_Result GE_SetAlpha(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_AlphaSrc eAlphaSrc)
889 {
890 MS_U16 u16src;
891
892 switch (eAlphaSrc)
893 {
894 case E_GE_ALPHA_CONST:
895 case E_GE_ALPHA_ASRC:
896 case E_GE_ALPHA_ADST:
897 case E_GE_ALPHA_ROP8_SRC:
898 case E_GE_ALPHA_ROP8_IN:
899 case E_GE_ALPHA_ROP8_DSTOUT:
900 case E_GE_ALPHA_ROP8_SRCOUT:
901 case E_GE_ALPHA_ROP8_OVER:
902 case E_GE_ALPHA_ROP8_INV_CONST:
903 case E_GE_ALPHA_ROP8_INV_ASRC:
904 case E_GE_ALPHA_ROP8_INV_ADST:
905 case E_GE_ALPHA_ROP8_SRC_ATOP_DST:
906 case E_GE_ALPHA_ROP8_DST_ATOP_SRC:
907 case E_GE_ALPHA_ROP8_SRC_XOR_DST:
908 case E_GE_ALPHA_ROP8_INV_SRC_ATOP_DST:
909 case E_GE_ALPHA_ROP8_INV_DST_ATOP_SRC:
910
911 u16src = eAlphaSrc;
912 break;
913 default:
914 return E_GE_FAIL_PARAM;
915 break;
916 }
917
918 u16src = (GE_ReadReg(pGEHalLocal, REG_GE_ALPHA) & ~GE_ALPHA_MASK) | (u16src<<GE_ALPHA_SHFT);
919 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA, u16src);
920
921 return E_GE_OK;
922 }
923
GE_QueryDFBBldCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 * pU16SupportedBldFlags)924 GE_Result GE_QueryDFBBldCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 *pU16SupportedBldFlags)
925 {
926 if(NULL == pU16SupportedBldFlags)
927 {
928 return E_GE_FAIL_PARAM;
929 }
930
931 (*pU16SupportedBldFlags) = E_GE_DFB_BLD_FLAG_ALL;
932
933 return E_GE_OK;
934 }
935
GE_EnableDFBBld(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)936 GE_Result GE_EnableDFBBld(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
937 {
938 MS_U16 u16RegVal;
939
940 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_EN);
941
942 if (enable)
943 {
944 u16RegVal |= GE_EN_DFB_BLD;
945 }
946 else
947 {
948 u16RegVal &= ~GE_EN_DFB_BLD;
949 }
950
951 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16RegVal);
952
953 return E_GE_OK;
954 }
955
GE_SetDFBBldFlags(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 u16DFBBldFlags)956 GE_Result GE_SetDFBBldFlags(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 u16DFBBldFlags)
957 {
958 MS_U16 u16RegVal;
959
960 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_FLAGS) & ~GE_DFB_BLD_FLAGS_MASK);
961
962 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_COLORALPHA)
963 {
964 u16RegVal |= GE_DFB_BLD_FLAG_COLORALPHA;
965 }
966
967 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_ALPHACHANNEL)
968 {
969 u16RegVal |= GE_DFB_BLD_FLAG_ALPHACHANNEL;
970 }
971
972 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_COLORIZE)
973 {
974 u16RegVal |= GE_DFB_BLD_FLAG_COLORIZE;
975 }
976
977 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_SRCPREMUL)
978 {
979 u16RegVal |= GE_DFB_BLD_FLAG_SRCPREMUL;
980 }
981
982 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_SRCPREMULCOL)
983 {
984 u16RegVal |= GE_DFB_BLD_FLAG_SRCPREMULCOL;
985 }
986
987 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_DSTPREMUL)
988 {
989 u16RegVal |= GE_DFB_BLD_FLAG_DSTPREMUL;
990 }
991
992 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_XOR)
993 {
994 u16RegVal |= GE_DFB_BLD_FLAG_XOR;
995 }
996
997 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_DEMULTIPLY)
998 {
999 u16RegVal |= GE_DFB_BLD_FLAG_DEMULTIPLY;
1000 }
1001
1002 GE_WriteReg(pGEHalLocal, REG_GE_DFB_BLD_FLAGS, u16RegVal);
1003
1004
1005 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_OP) & ~GE_DFB_SRC_COLORMASK);
1006
1007 if(u16DFBBldFlags & (E_GE_DFB_BLD_FLAG_SRCCOLORMASK | E_GE_DFB_BLD_FLAG_SRCALPHAMASK))
1008 {
1009 u16RegVal |= (1 << GE_DFB_SRC_COLORMASK_SHIFT);
1010 }
1011
1012
1013
1014 return E_GE_OK;
1015 }
1016
GE_SetDFBBldOP(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_DFBBldOP geSrcBldOP,GE_DFBBldOP geDstBldOP)1017 GE_Result GE_SetDFBBldOP(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_DFBBldOP geSrcBldOP, GE_DFBBldOP geDstBldOP)
1018 {
1019 MS_U16 u16RegVal;
1020
1021 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_OP) & ~(GE_DFB_SRCBLD_OP_MASK|GE_DFB_DSTBLD_OP_MASK));
1022 u16RegVal |= ((geSrcBldOP<<GE_DFB_SRCBLD_OP_SHFT) | (geDstBldOP<<GE_DFB_DSTBLD_OP_SHFT));
1023
1024 GE_WriteReg(pGEHalLocal, REG_GE_DFB_BLD_OP, u16RegVal);
1025
1026 return E_GE_OK;
1027 }
1028
GE_SetDFBBldConstColor(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RgbColor geRgbColor)1029 GE_Result GE_SetDFBBldConstColor(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RgbColor geRgbColor)
1030 {
1031 MS_U16 u16RegVal;
1032
1033 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_ALPHA_CONST) & ~GE_ALPHA_CONST_MASK) | (geRgbColor.a & 0xFF));
1034 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA_CONST, u16RegVal);
1035
1036 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_R_CONST) & ~GE_R_CONST_MASK) | ((geRgbColor.r<<GE_R_CONST_SHIFT) & GE_R_CONST_MASK));
1037 GE_WriteReg(pGEHalLocal, REG_GE_R_CONST, u16RegVal);
1038
1039 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_G_CONST) & ~GE_G_CONST_MASK) | ((geRgbColor.g<<GE_G_CONST_SHIFT) & GE_G_CONST_MASK));
1040 GE_WriteReg(pGEHalLocal, REG_GE_G_CONST, u16RegVal);
1041
1042 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_B_CONST) & ~GE_B_CONST_MASK) | ((geRgbColor.b<<GE_B_CONST_SHIFT) & GE_B_CONST_MASK));
1043 GE_WriteReg(pGEHalLocal, REG_GE_B_CONST, u16RegVal);
1044
1045 return E_GE_OK;
1046 }
1047
GE_SetDFBBldSrcColorMask(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RgbColor geRgbColor)1048 GE_Result GE_SetDFBBldSrcColorMask(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RgbColor geRgbColor)
1049 {
1050 //no more hw function
1051 /*
1052 MS_U16 u16RegVal;
1053
1054 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_ALPHA_CONST) & ~GE_ALPHA_SRCMASK_MASK) | (geRgbColor.a & 0xFF));
1055 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA_CONST, u16RegVal);
1056
1057 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_OP_MODE) & ~GE_SRCCOLOR_MASK_R) | ((geRgbColor.r<<GE_SRCCOLOR_MASK_R_SHIFT) & GE_SRCCOLOR_MASK_R));
1058 GE_WriteReg(pGEHalLocal, REG_GE_OP_MODE, u16RegVal);
1059
1060 u16RegVal = (geRgbColor.g<<GE_SRCCOLOR_MASK_G_SHIFT) | (geRgbColor.b<<GE_SRCCOLOR_MASK_B_SHIFT);
1061 GE_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, u16RegVal);
1062 */
1063 return E_GE_OK;
1064 }
1065
1066
GE_WriteProtect(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 miu,MS_PHY addr_low,MS_PHY addr_high,GE_WPType eWPType)1067 GE_Result GE_WriteProtect(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 miu, MS_PHY addr_low, MS_PHY addr_high, GE_WPType eWPType)
1068 {
1069 MS_U16 u16cfg;
1070
1071 if (miu > 2)
1072 {
1073 return E_GE_FAIL;
1074 }
1075
1076 if ( (eWPType == E_GE_WP_IN_RANGE) || (eWPType == E_GE_WP_OUT_RANGE) )
1077 {
1078 // range setting
1079 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_LTH_L(miu), addr_low & (GE_MIU_ADDR_MASK&0xFFFF));
1080 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_LTH_H(miu), ((addr_low>>16) & (GE_MIU_ADDR_MASK>>16)) | (eWPType<<GE_MIU_PROT_MODE_SHFT));
1081 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_HTH_L(miu), addr_high & (GE_MIU_ADDR_MASK&0xFFFF));
1082 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_HTH_H(miu), (addr_high>>16) & (GE_MIU_ADDR_MASK>>16));
1083 // enable setting
1084 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_CFG) | (GE_CFG_MIU0_PROT << miu);
1085 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16cfg);
1086 }
1087 else if (eWPType == E_GE_WP_DISABLE)
1088 {
1089 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_CFG) & ~(GE_CFG_MIU0_PROT<<miu);
1090 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16cfg);
1091 }
1092 else
1093 {
1094 return E_GE_FAIL;
1095 }
1096
1097 return E_GE_OK;
1098 }
1099
1100
GE_SetSrcTile(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL tile)1101 GE_Result GE_SetSrcTile(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL tile)
1102 {
1103 //GE_DBG("%s\n", __FUNCTION__);
1104
1105 return E_GE_NOT_SUPPORT;
1106
1107 }
1108
1109
GE_SetDstTile(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL tile)1110 GE_Result GE_SetDstTile(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL tile)
1111 {
1112 //GE_DBG("%s\n", __FUNCTION__);
1113
1114 return E_GE_NOT_SUPPORT;
1115
1116 }
GE_SetASCK(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1117 GE_Result GE_SetASCK(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1118 {
1119 MS_U16 u16cfg;
1120
1121 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1122 if (enable)
1123 {
1124 u16cfg |= GE_EN_ASCK;
1125 }
1126 else
1127 {
1128 u16cfg &= ~GE_EN_ASCK;
1129 }
1130 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16cfg);
1131
1132 return E_GE_OK;
1133 }
GE_SetADCK(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1134 GE_Result GE_SetADCK(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1135 {
1136 MS_U16 u16cfg;
1137
1138 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1139 if (enable)
1140 {
1141 u16cfg |= GE_EN_DSCK;
1142 }
1143 else
1144 {
1145 u16cfg &= ~GE_EN_DSCK;
1146 }
1147 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16cfg);
1148
1149 return E_GE_OK;
1150 }
1151
1152
GE_GetFmtCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_BufFmt fmt,GE_BufType type,GE_FmtCaps * caps)1153 GE_Result GE_GetFmtCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_BufFmt fmt, GE_BufType type, GE_FmtCaps *caps)
1154 {
1155 static const MS_U8 _u8GETileWidth[] = {8, 4, 2, 0, 1};
1156
1157 caps->fmt = fmt;
1158 if (type == E_GE_BUF_SRC)
1159 {
1160 switch (fmt)
1161 {
1162 case E_GE_FMT_I1:
1163 case E_GE_FMT_I2:
1164 case E_GE_FMT_I4:
1165 case E_GE_FMT_I8:
1166 caps->u8BaseAlign = 1;
1167 caps->u8PitchAlign = 1;
1168 caps->u8Non1pAlign = 0;
1169 caps->u8HeightAlign = 1;
1170 caps->u8StretchAlign = 1;
1171 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1172 caps->u8TileWidthAlign = _u8GETileWidth[fmt];
1173 caps->u8TileHeightAlign = 16;
1174 break;
1175 case E_GE_FMT_RGB565:
1176 case E_GE_FMT_RGBA5551:
1177 case E_GE_FMT_RGBA4444:
1178 case E_GE_FMT_ARGB1555:
1179 case E_GE_FMT_1ABFgBg12355:
1180 case E_GE_FMT_ARGB4444:
1181 case E_GE_FMT_YUV422:
1182 case E_GE_FMT_FaBaFgBg2266:
1183 caps->u8BaseAlign = 2;
1184 caps->u8PitchAlign = 2;
1185 caps->u8Non1pAlign = 0;
1186 caps->u8HeightAlign = 1;
1187 caps->u8StretchAlign = 2;
1188 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1189 caps->u8TileWidthAlign = 16;
1190 caps->u8TileHeightAlign = 16;
1191 break;
1192 case E_GE_FMT_ABGR8888:
1193 case E_GE_FMT_ARGB8888:
1194 caps->u8BaseAlign = 4;
1195 caps->u8PitchAlign = 4;
1196 caps->u8Non1pAlign = 0;
1197 caps->u8HeightAlign = 1;
1198 caps->u8StretchAlign = 4;
1199 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1200 caps->u8TileWidthAlign = 8;
1201 caps->u8TileHeightAlign = 16;
1202 break;
1203 // Not Support
1204 default:
1205 caps->fmt = E_GE_FMT_GENERIC;
1206 caps->u8BaseAlign = 4;
1207 caps->u8PitchAlign = 4;
1208 caps->u8Non1pAlign = 0;
1209 caps->u8HeightAlign = 1;
1210 caps->u8StretchAlign = 4;
1211 caps->u8TileBaseAlign = 0;
1212 caps->u8TileWidthAlign = 0;
1213 caps->u8TileHeightAlign = 0;
1214 return E_GE_FAIL_FORMAT;
1215 }
1216 }
1217 else
1218 {
1219 switch (fmt)
1220 {
1221 case E_GE_FMT_I8:
1222 caps->u8BaseAlign = 1;
1223 caps->u8PitchAlign = 1;
1224 caps->u8Non1pAlign = 0;
1225 caps->u8HeightAlign = 1;
1226 caps->u8StretchAlign = 1;
1227 caps->u8TileBaseAlign = 8;
1228 caps->u8TileWidthAlign = _u8GETileWidth[fmt];
1229 caps->u8TileHeightAlign = 16;
1230 break;
1231 case E_GE_FMT_RGB565:
1232 case E_GE_FMT_ARGB1555:
1233 case E_GE_FMT_RGBA5551:
1234 case E_GE_FMT_RGBA4444:
1235 case E_GE_FMT_1ABFgBg12355:
1236 case E_GE_FMT_ARGB4444:
1237 case E_GE_FMT_YUV422:
1238 case E_GE_FMT_FaBaFgBg2266:
1239 case E_GE_FMT_ARGB1555_DST:
1240 caps->u8BaseAlign = 2;
1241 caps->u8PitchAlign = 2;
1242 caps->u8Non1pAlign = 0;
1243 caps->u8HeightAlign = 1;
1244 caps->u8StretchAlign = 2;
1245 caps->u8TileBaseAlign = 8;
1246 caps->u8TileWidthAlign = 16;
1247 caps->u8TileHeightAlign = 16;
1248 break;
1249 case E_GE_FMT_ABGR8888:
1250 case E_GE_FMT_ARGB8888:
1251 caps->u8BaseAlign = 4;
1252 caps->u8PitchAlign = 4;
1253 caps->u8Non1pAlign = 0;
1254 caps->u8HeightAlign = 1;
1255 caps->u8StretchAlign = 4;
1256 caps->u8TileBaseAlign = 8;
1257 caps->u8TileWidthAlign = 8;
1258 caps->u8TileHeightAlign = 16;
1259 break;
1260 // Not Support
1261 case E_GE_FMT_I1:
1262 case E_GE_FMT_I2:
1263 case E_GE_FMT_I4:
1264 default:
1265 caps->fmt = E_GE_FMT_GENERIC;
1266 caps->u8BaseAlign = 4;
1267 caps->u8PitchAlign = 4;
1268 caps->u8Non1pAlign = 0;
1269 caps->u8HeightAlign = 1;
1270 caps->u8StretchAlign = 4;
1271 caps->u8TileBaseAlign = 0;
1272 caps->u8TileWidthAlign = 0;
1273 caps->u8TileHeightAlign = 0;
1274 return E_GE_FAIL_FORMAT;
1275 }
1276 }
1277
1278 return E_GE_OK;
1279 }
1280
1281
GE_Set_IOMap_Base(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_VIRT addr)1282 GE_Result GE_Set_IOMap_Base(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_VIRT addr)
1283 {
1284 pGEHalLocal->va_mmio_base = addr;
1285 return E_GE_OK;
1286 }
1287
1288
direct_serial_diff(MS_U16 tagID1,MS_U16 tagID2)1289 static MS_S32 direct_serial_diff( MS_U16 tagID1, MS_U16 tagID2)
1290 {
1291 if(tagID1 < tagID2)
1292 {
1293 if((tagID2-tagID1)>0x7FFF)
1294 {
1295 return (MS_S32)(0xFFFFUL-tagID2+tagID1+1);
1296 }
1297 else
1298 return -(MS_S32)(tagID2-tagID1);
1299 }
1300 else
1301 {
1302 if((tagID1-tagID2)>0x7FFF)
1303 {
1304 return -(MS_S32)(0xFFFF-tagID1+tagID2+1);
1305 }
1306 else
1307 return (MS_S32)(tagID1-tagID2);
1308 }
1309 }
1310
1311 //-------------------------------------------------------------------------------------------------
1312 /// Wait GE TagID back
1313 /// @param tagID \b IN: tag id number for wating
1314 /// @return @ref GE_Result
1315 //-------------------------------------------------------------------------------------------------
GE_WaitTAGID(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tagID)1316 GE_Result GE_WaitTAGID(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tagID)
1317 {
1318 MS_U16 tagID_HW;
1319 MS_U32 u32Temp;
1320
1321
1322 while(1)
1323 {
1324
1325 tagID_HW = GE_ReadReg(pGEHalLocal, REG_GE_TAG);
1326 if(direct_serial_diff(tagID_HW, tagID) >= 0)
1327 {
1328 //printf("tagIDHW = %04x %04x\n", tagID_HW, tagID);
1329 break;
1330 }
1331
1332 u32Temp = GE_ReadReg(pGEHalLocal, REG_GE_STAT);
1333 if((u32Temp&GE_STAT_CMDQ_MASK) < (16UL<<11))
1334 continue;
1335 if((u32Temp&GE_STAT_CMDQ2_MASK) < (16UL<<3))
1336 continue;
1337 if(GE_ReadReg(pGEHalLocal, REG_GE_CFG) & GE_CFG_VCMDQ)
1338 {
1339 u32Temp = GE_ReadReg(pGEHalLocal, REG_GE_VCMDQ_STAT);
1340 u32Temp |= (GE_ReadReg(pGEHalLocal, REG_GE_BIST_STAT)&1)<<16;
1341 if(u32Temp)
1342 continue;
1343
1344 }
1345
1346 if(GE_ReadReg(pGEHalLocal, REG_GE_STAT) & GE_STAT_BUSY)
1347 continue;
1348
1349 break;
1350 GE_YIELD();
1351
1352 }
1353
1354 return E_GE_OK;
1355
1356 }
1357 //-------------------------------------------------------------------------------------------------
1358 /// MDrv_GE_SAVE_CHIP_IMAGE
1359 //-------------------------------------------------------------------------------------------------
GE_Restore_HAL_Context(GE_CTX_HAL_LOCAL * pGEHalLocal)1360 GE_Result GE_Restore_HAL_Context(GE_CTX_HAL_LOCAL *pGEHalLocal)
1361 {
1362 MS_U16 i = 0;
1363 MS_U16 u16RegVal;
1364
1365 //GE_WaitIdle(pGEHalLocal);
1366
1367 while( (_GE_Reg_Backup[i] != 0xFF) )
1368 {
1369 if(_GE_Reg_Backup[i]>= 0x80)
1370 {
1371 break;
1372 }
1373
1374 u16RegVal = GE_ReadReg(pGEHalLocal, _GE_Reg_Backup[i]);
1375 GE_RestoreReg(pGEHalLocal, _GE_Reg_Backup[i], u16RegVal);
1376 i++;
1377 }
1378
1379 //GE_DBG(printf("GE_Restore_HAL_Context finished \n\n"));
1380
1381 return E_GE_OK;
1382 }
1383
1384 //-------------------------------------------------------------------------------------------------
1385 /// Calculate Blit Scale Ratio:
1386 //-------------------------------------------------------------------------------------------------
GE_CalcBltScaleRatio(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 u16SrcWidth,MS_U16 u16SrcHeight,MS_U16 u16DstWidth,MS_U16 u16DstHeight,GE_ScaleInfo * pScaleinfo)1387 GE_Result GE_CalcBltScaleRatio(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 u16SrcWidth, MS_U16 u16SrcHeight, MS_U16 u16DstWidth, MS_U16 u16DstHeight, GE_ScaleInfo *pScaleinfo)
1388 {
1389 if(NULL == pScaleinfo)
1390 {
1391 return E_GE_FAIL_PARAM;
1392 }
1393
1394 if(u16SrcWidth >= (u16DstWidth<< g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1395 {
1396 pScaleinfo->x = 0xFFFFFFFF;
1397 }
1398 else
1399 {
1400 pScaleinfo->x = GE_Divide2Fixed(u16SrcWidth, u16DstWidth, g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin, 12);
1401 }
1402
1403 if(u16SrcHeight >= (u16DstHeight<< g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1404 {
1405 pScaleinfo->y = 0xFFFFFFFF;
1406 }
1407 else
1408 {
1409 pScaleinfo->y = GE_Divide2Fixed(u16SrcHeight, u16DstHeight, g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin, 12);
1410 }
1411
1412 /* HW use format S0.12 which means Bit(12) should be Sign bit
1413 // If overflow, S bit maybe wrong, handle it as actually value we hoped*/
1414 pScaleinfo->init_x = GE_Divide2Fixed(u16SrcWidth-u16DstWidth, 2 * u16DstWidth, 0, 12);
1415 if((u16SrcWidth/2) > u16DstWidth)
1416 {
1417 pScaleinfo->init_x = 0;
1418 }
1419 else if(u16SrcWidth >= u16DstWidth)
1420 {
1421 pScaleinfo->init_x &= (~(1<<12));
1422 }
1423 else
1424 {
1425 pScaleinfo->init_x |= (1<<12);
1426 }
1427
1428 pScaleinfo->init_y = GE_Divide2Fixed(u16SrcHeight-u16DstHeight, 2 * u16DstHeight, 0, 12);
1429 if((u16SrcHeight/2) > u16DstHeight)
1430 {
1431 pScaleinfo->init_y = 0;
1432 }
1433 else if(u16SrcHeight >= u16DstHeight)
1434 {
1435 pScaleinfo->init_y &= (~(1<<12));
1436 }
1437 else
1438 {
1439 pScaleinfo->init_y |= (1<<12);
1440 }
1441
1442 if (pGEHalLocal->bYScalingPatch)
1443 {
1444 if (u16SrcHeight<=5)
1445 pScaleinfo->init_y = (1<<12);
1446 }
1447 return E_GE_OK;
1448 }
1449
1450 //-------------------------------------------------------------------------------------------------
1451 /// Set GE scale register
1452 /// @param GE_Rect *src \b IN: src coordinate setting
1453 /// @param GE_DstBitBltType *dst \b IN: dst coordinate setting
1454 /// @return @ref GE_Result
1455 //-------------------------------------------------------------------------------------------------
GE_SetBltScaleRatio(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Rect * src,GE_DstBitBltType * dst,GE_Flag flags,GE_ScaleInfo * scaleinfo)1456 GE_Result GE_SetBltScaleRatio(GE_CTX_HAL_LOCAL *pGEHalLocal,GE_Rect *src, GE_DstBitBltType *dst, GE_Flag flags, GE_ScaleInfo* scaleinfo)
1457 {
1458 GE_ScaleInfo geScaleinfo, *pGeScaleInfo = scaleinfo;
1459
1460 if(flags & E_GE_FLAG_BYPASS_STBCOEF)
1461 {
1462 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1463 }
1464 else if (flags & E_GE_FLAG_BLT_STRETCH)
1465 {
1466 /* Safe Guard. Prevent set scaling ratio < 1/32. Also prevent 0 h/w */
1467 if ((src->width-1) >= (dst->dstblk.width << g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1468 {
1469 if(pGEHalLocal->bIsComp == FALSE)
1470 {
1471 return E_GE_FAIL_PARAM;
1472 }
1473
1474 dst->dstblk.width = ((src->width-1) >> g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin) + 1;
1475 }
1476 if ((src->height-1) >= (dst->dstblk.height << g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1477 {
1478 if(pGEHalLocal->bIsComp == FALSE)
1479 {
1480 return E_GE_FAIL_PARAM;
1481 }
1482
1483 dst->dstblk.height = ((src->height-1) >> g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin) + 1;
1484 }
1485
1486 pGeScaleInfo = &geScaleinfo;
1487 GE_CalcBltScaleRatio(pGEHalLocal, src->width, src->height, dst->dstblk.width, dst->dstblk.height, pGeScaleInfo);
1488 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1489 }
1490 else
1491 {
1492 pGeScaleInfo = &geScaleinfo;
1493
1494 pGeScaleInfo->x = (1<<12);
1495 pGeScaleInfo->y = (1<<12);
1496 pGeScaleInfo->init_x = 0;
1497 pGeScaleInfo->init_y = 0;
1498
1499 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1500 }
1501
1502 return E_GE_OK;
1503 }
1504
GE_BitBltEX_Trape(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Rect * pSrcRect,GE_Normalized_Trapezoid * pGENormTrapezoid,MS_U32 u32Flags,GE_ScaleInfo * pScaleinfo)1505 GE_Result GE_BitBltEX_Trape(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_Rect *pSrcRect, GE_Normalized_Trapezoid *pGENormTrapezoid, MS_U32 u32Flags, GE_ScaleInfo* pScaleinfo)
1506 {
1507 return E_GE_NOT_SUPPORT;
1508 }
1509
1510 //-------------------------------------------------------------------------------------------------
1511 /// GE Primitive Drawing - TRAPEZOID
1512 /// @param pGENormTrapezoid \b IN: pointer to position of TRAPEZOID
1513 /// @param u32ColorS \b IN: start color of TRAPEZOID when gradient
1514 /// @param u32ColorE \b IN: end color of TRAPEZOID when gradient
1515 /// @param pColorDeltaX \b IN: x gradient color
1516 /// @param pColorDeltaY \b IN: y gradient color
1517 /// @return @ref GE_Result
1518 //-------------------------------------------------------------------------------------------------
GE_FillTrapezoid(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bYTrapezoid,GE_Normalized_Trapezoid * pGENormTrapezoid,MS_U32 u32Color,GE_ColorDelta * pColorDeltaX,GE_ColorDelta * pColorDeltaY)1519 GE_Result GE_FillTrapezoid(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bYTrapezoid, GE_Normalized_Trapezoid *pGENormTrapezoid, MS_U32 u32Color, GE_ColorDelta *pColorDeltaX, GE_ColorDelta *pColorDeltaY)
1520 {
1521 return E_GE_NOT_SUPPORT;
1522 }
1523
1524 //-------------------------------------------------------------------------------------------------
1525 /// Set GE DISABLE MIU ACCESS
1526 /// @param enable \b IN: enable and update setting
1527 /// @return @ref GE_Result
1528 //-------------------------------------------------------------------------------------------------
GE_SetDisaMIUAccess(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1529 GE_Result GE_SetDisaMIUAccess(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1530 {
1531 MS_U16 u16en;
1532
1533 GE_DBG("%s\n", __FUNCTION__);
1534
1535 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1536 if (enable)
1537 {
1538 u16en |= GE_CFG_DISABLE_MIU_ACS;
1539 }
1540 else
1541 {
1542 u16en &= ~GE_CFG_DISABLE_MIU_ACS;
1543 }
1544 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1545
1546 return E_GE_OK;
1547 }
1548 //-------------------------------------------------------------------------------------------------
1549 /// Set GE Clear Invalid MIU Flag
1550 /// @param enable \b IN: enable and update setting
1551 /// @return @ref GE_Result
1552 //-------------------------------------------------------------------------------------------------
GE_ClrInvalMIUFlg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1553 GE_Result GE_ClrInvalMIUFlg(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1554 {
1555 MS_U16 u16en;
1556
1557 GE_DBG("%s\n", __FUNCTION__);
1558
1559 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1560 if (enable)
1561 {
1562 u16en |= GE_CFG_CLR_MIU_FLG;
1563 }
1564 else
1565 {
1566 u16en &= ~GE_CFG_CLR_MIU_FLG;
1567 }
1568 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1569
1570 return E_GE_OK;
1571 }
1572
1573 //-------------------------------------------------------------------------------------------------
1574 /// Set Enable Dynamic Clock Gating
1575 /// @param enable \b IN: enable and update setting
1576 /// @return @ref GE_Result
1577 //-------------------------------------------------------------------------------------------------
GE_EnableDynaClkGate(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1578 GE_Result GE_EnableDynaClkGate(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1579 {
1580 MS_U16 u16en;
1581
1582 GE_DBG("%s\n", __FUNCTION__);
1583
1584 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1585 if (enable)
1586 {
1587 u16en |= GE_CFG_EN_DNY_CLK_GATE;
1588 }
1589 else
1590 {
1591 u16en &= ~GE_CFG_EN_DNY_CLK_GATE;
1592 }
1593 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1594
1595 return E_GE_OK;
1596 }
1597
GE_EnableTrapezoidAA(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1598 GE_Result GE_EnableTrapezoidAA(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1599 {
1600 //GE_DBG("%s\n", __FUNCTION__);
1601
1602 return E_GE_NOT_SUPPORT;
1603
1604 }
1605
GE_EnableTrapSubPixCorr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1606 GE_Result GE_EnableTrapSubPixCorr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1607 {
1608 //GE_DBG("%s\n", __FUNCTION__);
1609
1610 return E_GE_NOT_SUPPORT;
1611
1612 }
1613
GE_GetNextTAGID(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bStepTagBefore)1614 MS_U16 GE_GetNextTAGID(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bStepTagBefore)
1615 {
1616 MS_U16 tagID;
1617 if(bStepTagBefore)
1618 {
1619 if(0 == ++pGEHalLocal->pHALShared->global_tagID)
1620 ++pGEHalLocal->pHALShared->global_tagID;
1621 }
1622 tagID =pGEHalLocal->pHALShared->global_tagID;
1623
1624 return tagID;
1625 }
1626
GE_SetVCmdBuffer(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY PhyAddr,GE_VcmqBufSize enBufSize)1627 GE_Result GE_SetVCmdBuffer(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY PhyAddr, GE_VcmqBufSize enBufSize)
1628 {
1629 MS_U16 u16RegVal;
1630 #if GE_VQADDR_LOCK_PATCH
1631 MS_U16 i=0;
1632 #endif
1633
1634 if(enBufSize >= E_GE_VCMD_1024K)
1635 {
1636 return E_GE_NOT_SUPPORT;
1637 }
1638
1639 GE_SetVQBufMIUId(pGEHalLocal, _GFXAPI_MIU_ID(PhyAddr));
1640 PhyAddr = GE_ConvertAPIAddr2HAL(pGEHalLocal, _GFXAPI_MIU_ID(PhyAddr), _GFXAPI_PHYS_ADDR_IN_MIU(PhyAddr));
1641
1642 #ifdef GE_VQ_MIU_HANG_PATCH
1643 pGEHalLocal->pHALShared->u8VCmdQMiu = _GFXAPI_MIU_ID(PhyAddr);
1644 #endif
1645
1646 #if GE_VQADDR_LOCK_PATCH
1647 for (i=0; i<GE_VQADDR_ENHANCE_LOCK_TIMES; i++)
1648 {
1649 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_H, PhyAddr >> 16); // Address
1650 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_L, PhyAddr & 0xffff); // Address
1651 }
1652 #else
1653 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_L, PhyAddr & 0xffff); // Address
1654 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_H, PhyAddr >> 16); // Address
1655 #endif
1656
1657 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_VCMDQ_SIZE) & ~GE_VCMDQ_SIZE_MASK) | ((GE_MapVQ2Reg(enBufSize) & GE_VCMDQ_SIZE_MASK));
1658 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_SIZE, u16RegVal);
1659
1660 return E_GE_OK;
1661 }
1662
GE_InitCtxHalPalette(GE_CTX_HAL_LOCAL * pGEHalLocal)1663 GE_Result GE_InitCtxHalPalette(GE_CTX_HAL_LOCAL *pGEHalLocal)
1664 {
1665 MS_U32 u32Idx;
1666
1667 for(u32Idx=0; u32Idx<GE_PALETTE_NUM; u32Idx++)
1668 {
1669 GE_WriteReg(pGEHalLocal, REG_GE_CLUT_CTRL, ((u32Idx) & GE_CLUT_CTRL_IDX_MASK) | GE_CLUT_CTRL_RD);
1670 GE_WaitIdle(pGEHalLocal);
1671 pGEHalLocal->u32Palette[u32Idx] = ByteSwap32(((GE_ReadReg(pGEHalLocal, REG_GE_CLUT_H)<<16) | GE_ReadReg(pGEHalLocal, REG_GE_CLUT_L)));
1672 }
1673
1674 pGEHalLocal->bPaletteDirty = FALSE;
1675
1676 return (E_GE_OK);
1677 }
1678
GE_Init_HAL_Context(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_CTX_HAL_SHARED * pHALShared,MS_BOOL bNeedInitShared)1679 void GE_Init_HAL_Context(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_CTX_HAL_SHARED *pHALShared, MS_BOOL bNeedInitShared)
1680 {
1681 memset(pGEHalLocal, 0, sizeof(*pGEHalLocal));
1682
1683 if(bNeedInitShared)
1684 {
1685 memset(pHALShared, 0, sizeof(*pHALShared));
1686 pHALShared->global_tagID = 1;
1687 }
1688 pGEHalLocal->pHALShared = pHALShared;
1689 pGEHalLocal->bYScalingPatch = FALSE;
1690 }
1691
GE_Set_IOMap_Base2(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_VIRT addr)1692 GE_Result GE_Set_IOMap_Base2(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_VIRT addr)
1693 {
1694 pGEHalLocal->va_mmio_base2 = addr;
1695 return E_GE_OK;
1696 }
1697
GE_SetClock(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bOnOff)1698 GE_Result GE_SetClock(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bOnOff)
1699 {
1700 #ifdef CONFIG_MSTAR_CLKM
1701 MS_S32 handle;
1702
1703 handle = Drv_Clkm_Get_Handle("g_clk_ge");
1704 Drv_Clkm_Set_Clk_Source(handle,"CLK_FASTEST");
1705 #else
1706 MS_U16 u16tmp = 0;
1707
1708 u16tmp = CLK_REG(CHIP_GE_CLK);
1709
1710 if (bOnOff)
1711 {
1712 u16tmp &= ~ BIT(0);
1713 }
1714 else
1715 {
1716 u16tmp |= BIT(0);
1717 }
1718 CLK_REG(CHIP_GE_CLK) = u16tmp;
1719 #endif
1720 return E_GE_OK;
1721 }
1722
GE_NonOnePixelModeCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,PatchBitBltInfo * patchInfo)1723 MS_BOOL GE_NonOnePixelModeCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, PatchBitBltInfo* patchInfo)
1724 {
1725 GE_ScaleInfo geScaleinfo;
1726 GE_Result ret;
1727
1728 patchInfo->scaleinfo =&geScaleinfo;
1729 ret = GE_CalcBltScaleRatio(pGEHalLocal, patchInfo->src.width , patchInfo->src.height ,patchInfo->dst.dstblk.width , patchInfo->dst.dstblk.height, patchInfo->scaleinfo);
1730
1731 if(ret == E_GE_FAIL_PARAM)
1732 {
1733 return pGEHalLocal->pGeChipPro->bFourPixelModeStable;
1734 }
1735 else if ((patchInfo->scaleinfo->init_x>0xFFF)||(patchInfo->scaleinfo->init_y>0xFFF))
1736 {
1737 return FALSE;
1738 }
1739 else
1740 {
1741 return pGEHalLocal->pGeChipPro->bFourPixelModeStable;
1742 }
1743 }
1744
HAL_GE_EnableCalcSrc_WidthHeight(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1745 GE_Result HAL_GE_EnableCalcSrc_WidthHeight(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1746 {
1747 MS_U16 u16en;
1748
1749 u16en = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1750
1751 if(bEnable)
1752 {
1753 if(u16en & GE_EN_BURST)
1754 {
1755 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en | GE_EN_CALC_SRC_WH);
1756 }
1757 }
1758 else
1759 {
1760 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en & (~GE_EN_CALC_SRC_WH));
1761 }
1762
1763 return E_GE_OK;
1764 }
1765
GEWD_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 * value)1766 GE_Result GEWD_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16* value)
1767 {
1768 //For two source buffer read register
1769 return E_GE_NOT_SUPPORT;
1770 }
1771
GEWD_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)1772 GE_Result GEWD_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
1773 {
1774 //For two source buffer write register
1775 return E_GE_NOT_SUPPORT;
1776 }
1777
GE_SetTLBMode(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_TLB_Mode tlb_type)1778 GE_Result GE_SetTLBMode(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_TLB_Mode tlb_type)
1779 {
1780 return E_GE_NOT_SUPPORT;
1781 }
1782
GE_GetTLBSRCADDR(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY * addr)1783 GE_Result GE_GetTLBSRCADDR(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY* addr)
1784 {
1785 return E_GE_NOT_SUPPORT;
1786 }
1787
GE_GetTLBDSTADDR(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY * addr)1788 GE_Result GE_GetTLBDSTADDR(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY* addr)
1789 {
1790 return E_GE_NOT_SUPPORT;
1791 }
1792
GE_SetTLBSrcBaseAddr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY addr)1793 GE_Result GE_SetTLBSrcBaseAddr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY addr)
1794 {
1795 return E_GE_NOT_SUPPORT;
1796 }
1797
GE_SetTLBDstBaseAddr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY addr)1798 GE_Result GE_SetTLBDstBaseAddr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY addr)
1799 {
1800 return E_GE_NOT_SUPPORT;
1801 }
1802
GE_FlushTLBTable(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1803 GE_Result GE_FlushTLBTable(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1804 {
1805 return E_GE_NOT_SUPPORT;
1806 }
1807
GE_SetTLBTag(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tag)1808 GE_Result GE_SetTLBTag(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tag)
1809 {
1810 return E_GE_NOT_SUPPORT;
1811 }
1812
GE_StopFlushTLB(GE_CTX_HAL_LOCAL * pGEHalLocal)1813 GE_Result GE_StopFlushTLB(GE_CTX_HAL_LOCAL *pGEHalLocal)
1814 {
1815 return E_GE_NOT_SUPPORT;
1816 }
1817
GE_Get_MIU_INTERVAL(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 miu,MS_PHY * value)1818 GE_Result GE_Get_MIU_INTERVAL(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 miu, MS_PHY* value)
1819 {
1820 if(miu==1)
1821 {
1822 *value = HAL_MIU1_BASE;
1823 }
1824 else if(miu==0)
1825 {
1826 *value = 0;
1827 }
1828 else
1829 {
1830 *value = 0;
1831 return E_GE_FAIL;
1832 }
1833
1834 return E_GE_OK;
1835 }
1836
HAL_GE_AdjustDstWin(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bDstXInv)1837 GE_Result HAL_GE_AdjustDstWin( GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bDstXInv )
1838 {
1839 MS_U16 u16ClipL=0,u16ClipR=0;
1840 MS_U16 u16DstX=0;
1841
1842 u16DstX = GE_ReadReg(pGEHalLocal, REG_GE_PRIM_V1_X);
1843 if( bDstXInv==FALSE )
1844 {
1845 u16ClipR = GE_ReadReg(pGEHalLocal, REG_GE_CLIP_R);
1846 if( u16ClipR < u16DstX )
1847 {
1848 GE_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, u16ClipR);
1849 }
1850 }
1851 else
1852 {
1853 u16ClipL = GE_ReadReg(pGEHalLocal, REG_GE_CLIP_L);
1854 if( u16ClipL > u16DstX )
1855 {
1856 GE_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, u16ClipL);
1857 }
1858 }
1859
1860 return E_GE_OK;
1861 }
1862
HAL_GE_AdjustRotateDstWin(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8Rotate)1863 GE_Result HAL_GE_AdjustRotateDstWin( GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8Rotate )
1864 {
1865 return E_GE_OK;
1866 }
1867
HAL_GE_SetBurstMiuLen(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable,MS_U32 u32BurstLen)1868 GE_Result HAL_GE_SetBurstMiuLen(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL bEnable,MS_U32 u32BurstLen)
1869 {
1870 MS_U16 u16Reg = 0;
1871
1872 u16Reg = GE_ReadReg(pGEHalLocal, REG_GE_DBG);
1873 u16Reg &= ( ~GE_DBG_MIU_MAX_LEG );
1874 u16Reg |= ( ((u32BurstLen - 1)<<8) & GE_DBG_MIU_MAX_LEG );
1875 GE_WriteReg(pGEHalLocal, REG_GE_DBG, u16Reg);
1876
1877 u16Reg = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
1878 if(bEnable)
1879 u16Reg |= GE_CFG_LENGTH_LIMIT;
1880 else
1881 u16Reg &= (~GE_CFG_LENGTH_LIMIT);
1882 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16Reg);
1883
1884 return E_GE_OK;
1885 }
1886