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, GE_WaitCmdQAvail, 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 // Include Files
97 //-------------------------------------------------------------------------------------------------
98 #include "MsCommon.h"
99 #include <string.h>
100 #include "regGE.h"
101 #include "drvGE.h"
102 #include "halGE.h"
103 #include "halCHIP.h"
104 #ifdef MSOS_TYPE_LINUX
105 #include "halMPool.h"
106 #endif
107 //-------------------------------------------------------------------------------------------------
108 // Driver Compiler Options
109 //-------------------------------------------------------------------------------------------------
110 #define GE_DITHER_RAND_ENABLE 0 //[TBD] Add new option for SetDither if rand is used in the future.
111 #define GE_PATCH_ENABLE 0
112
113 #define GE_LOG_ENABLE 0
114 #define MS_DEBUG 1
115
116 //-------------------------------------------------------------------------------------------------
117 // Local Defines
118 //-------------------------------------------------------------------------------------------------
119 #define GE_MIU_ADDR_MASK 0x7FFFFFFF
120
121 #define GE_CMDQ_FREECNT() ((GE_REG(REG_GE_STAT)&GE_STAT_CMDQ_MASK)>>GE_STAT_CMDQ_SHFT)
122 #define GE_VCMDQ_FREECNT() (GE_REG(REG_GE_VCMDQ_STAT) + ((GE_REG(REG_GE_BIST_STAT)&GE_VCMDQ_STAT_H_MASK) << 16))
123
124 #define GE_BUSY() (GE_REG(REG_GE_STAT) & GE_STAT_BUSY)
125
126 #define GE_CMDQ_ENABLE 1 // Always Enable
127 #define GE_CMD_SIZE_MAX GE_STAT_CMDQ_MAX
128 #define GE_VCMD_SIZE_MAX GE_STAT_VCMDQ_MAX
129 #define GE_CMD_SIZE 1 // 1 queue entry available for 2 commands, but we just check entry for convenience
130
131 #define GE_MAP_VCMD_SIZE_TO_HWDEF(x) ((x))
132
133 #define GE_YIELD() MsOS_DelayTask(2)
134
135 #define GE_RESET_COUNT 0x800
136
137 #ifdef MS_DEBUG
138 #define GE_DBG(_fmt, _args...) printf(_fmt, ##_args)
139 #else
140 #define GE_DBG(_fmt, _args...) { }
141 #endif
142 #define GE_BURST_LEN 128
143
144 #define GE_TAG_INTERRUPT_WAITING_TIME 10 // ms
145 #define GE_TAG_INTERRUPT_DEBUG_PRINT_THRESHOLD (500/GE_TAG_INTERRUPT_WAITING_TIME)
146
147 //-------------------------------------------------------------------------------------------------
148 // Local Structures
149 //-------------------------------------------------------------------------------------------------
150 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
151 typedef enum
152 {
153 E_GE_CLEAR_INT = 0x0001,
154 E_GE_MASK_INT = 0x0002,
155 E_GE_UNMASK_INT = 0x0004,
156 E_GE_INT_TAG_MODE = 0x0008,
157 E_GE_INT_NORMAL_MODE = 0x0010
158 } E_GE_INT_OP;
159 #endif
160
161 //-------------------------------------------------------------------------------------------------
162 // Global Variables
163 //------------------------------------------------------------------------------------------------- // line pattern reset
164
165
166 const MS_U8 _GE_Reg_Backup[] = {
167 REG_GE_EN, REG_GE_CFG, REG_GE_TH, REG_GE_ROP2, REG_GE_BLEND, REG_GE_ALPHA, REG_GE_ALPHA_CONST,
168 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,
169 REG_GE_DCK_HTH_H, REG_GE_DCK_LTH_L, REG_GE_DCK_LTH_H, REG_GE_OP_MODE, REG_GE_ATEST_TH,
170 REG_GE_YUV_MODE, REG_GE_SRC_BASE_L, REG_GE_SRC_BASE_H, REG_GE_DST_BASE_L, REG_GE_DST_BASE_H,
171 REG_GE_SRC_PITCH, REG_GE_DST_PITCH, REG_GE_FMT,
172 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, // I0~I4
173 0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, // I5-I9
174 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, // I10-I14
175 0x0053, 0x0054, // I15
176 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,
177 REG_GE_BLT_SCK_CONST_L, REG_GE_BLT_SCK_CONST_H, REG_GE_BLT_DST_X_OFST, REG_GE_BLT_DST_Y_OFST,
178 REG_GE_LINE_DELTA, REG_GE_LINE_STYLE, REG_GE_LINE_LENGTH, REG_GE_BLT_SRC_DX, REG_GE_BLT_SRC_DY,
179 REG_GE_ITALIC_OFFSET, REG_GE_ITALIC_DELTA, REG_GE_PRIM_V0_X, REG_GE_PRIM_V0_Y, REG_GE_PRIM_V1_X,
180 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,
181 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,
182 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,
183 REG_GE_PRIM_BDX_L, REG_GE_PRIM_BDX_H, REG_GE_PRIM_BDY_L, REG_GE_PRIM_BDY_H, REG_GE_PRIM_ADX,
184 REG_GE_PRIM_ADY, 0xFF
185 };
186
187 //-------------------------------------------------------------------------------------------------
188 // Debug Functions
189 //-------------------------------------------------------------------------------------------------
190
191
192 //------------------------------------------------------------------------------
193 // Local Var
194 //------------------------------------------------------------------------------
195 GE_CHIP_PROPERTY g_GeChipPro =
196 {
197 .WordUnit = GE_WORD_UNIT,
198
199 .bSupportFourePixelMode = TRUE,
200 .bFourPixelModeStable = TRUE,
201
202 .bSupportMultiPixel = FALSE,
203 .bSupportSpiltMode = TRUE,
204 .bSupportTwoSourceBitbltMode = FALSE,
205 .bSupportTLBMode = TRUE,
206 .MIUSupportMaxNUM = GE_MAX_MIU,
207 .BltDownScaleCaps =
208 {
209 .u8RangeMax = 1,
210 .u8RangeMin = 32,
211 .u8ContinuousRangeMin = 1,
212 .bFullRangeSupport = TRUE,
213
214 .u8ShiftRangeMax = 0, /// 1 = 2^0 = 1<<0
215 .u8ShiftRangeMin = 5, /// 32 = 2^5 = 1<<5
216 .u8ShiftContinuousRangeMin = 0, /// 1 = 2^0 = 1<<0
217 }
218 };
219
220
221 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
222 static MS_U32 s32HalIomapBaseAddr = 0;
223 static MS_BOOL bGeIrqInited = FALSE;
224 static MS_S32 s32GeWaitTagEventHandle = -1;
225 static MS_S32 s32WaitingTagPid = -1;
226
227 void _GE_WaitTag_InterruptCbk(InterruptNum eIntNum);
228 static void _GE_InitGE1Regs( GE_CTX_HAL_LOCAL *pGEHalLocal );
229 static void _GE_SetGeThreshold(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8GeIdx, MS_U8 u8Threshold);
230 static GE_Result _GE_Ctrl_IntMode(GE_CTX_HAL_LOCAL *pGEHalLocal, E_GE_INT_OP int_op);
231 static void _GE_Print_GeWaitTagTimeout_Msg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tagID);
232 static MS_U16 _GE1_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr);
233 #endif
234
235
236 //-------------------------------------------------------------------------------------------------
237 // Local Functions
238 //-------------------------------------------------------------------------------------------------
GE_Chip_Proprity_Init(GE_CTX_HAL_LOCAL * pGEHalLocal)239 void GE_Chip_Proprity_Init(GE_CTX_HAL_LOCAL *pGEHalLocal)
240 {
241 pGEHalLocal->pGeChipPro = &g_GeChipPro;
242 }
243
_GE_SetBltScaleRatio2HW(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_ScaleInfo * pScaleinfo)244 GE_Result _GE_SetBltScaleRatio2HW(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_ScaleInfo *pScaleinfo)
245 {
246 MS_U16 u16RegVal;
247
248 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SRC_DX, (MS_U16)(pScaleinfo->x&0xFFFF));
249 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SRC_DY, (MS_U16)(pScaleinfo->y&0xFFFF));
250 //Set Initial DeltaX, DeltaY:
251 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_X_OFST, (MS_U16)(pScaleinfo->init_x&0xFFFF));
252 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_Y_OFST, (MS_U16)(pScaleinfo->init_y&0xFFFF));
253
254 //set MSBs of REG_GE_BLT_SRC_DY, REG_GE_BLT_SRC_DY:
255 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_BLT_DST_X_OFST) & ~(GE_STBB_DX_MSB);
256 u16RegVal |= (((pScaleinfo->x>>16)<<GE_STBB_DX_MSB_SHFT) & GE_STBB_DX_MSB);
257 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_X_OFST, u16RegVal);
258
259 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_BLT_DST_Y_OFST) & ~(GE_STBB_DY_MSB);
260 u16RegVal |= (((pScaleinfo->y>>16)<<GE_STBB_DY_MSB_SHFT) & GE_STBB_DY_MSB);
261 GE_WriteReg(pGEHalLocal, REG_GE_BLT_DST_Y_OFST, u16RegVal);
262
263 return E_GE_OK;
264 }
265
GE_SetActiveCtrlMiu1(GE_CTX_HAL_LOCAL * pGEHalLocal)266 void GE_SetActiveCtrlMiu1(GE_CTX_HAL_LOCAL *pGEHalLocal)
267 {
268 MIU1_REG(MIU1_GEGROUP) = MIU1_REG(MIU1_GEGROUP)|MIU1_GE_CLIENT;
269 }
270
271 //-------------------------------------------------------------------------------------------------
272 // Global Functions
273 //-------------------------------------------------------------------------------------------------
GE_DumpReg(GE_CTX_HAL_LOCAL * pGEHalLocal)274 static void GE_DumpReg(GE_CTX_HAL_LOCAL *pGEHalLocal)
275 {
276 MS_U32 i;
277
278 printf("Dump GE register:\n");
279 for (i = 0; i < 0x80; i++)
280 {
281 if(i % 0x08 == 0) {
282 printf("\n");
283 printf("h%02x ", (MS_U8)i );
284 }
285 printf("%04x ", GE_REG(i) );
286 }
287
288 printf("\n");
289 }
_GET_MIU_MASK_SHIFT(void)290 static MS_U32 _GET_MIU_MASK_SHIFT(void)
291 {
292 if (HAL_MIU1_BASE==0x20000000)
293 return (29UL);
294 else if (HAL_MIU1_BASE==0x10000000)
295 return (28UL);
296 else if (HAL_MIU1_BASE==0x8000000)
297 return (27UL);
298 else if (HAL_MIU1_BASE==0x4000000)
299 return (26UL);
300 else if (HAL_MIU1_BASE==0x60000000)
301 return (29UL);
302 else
303 {
304 printf("\n[%s] !!!!!! get miu1 base error!!!!!!", __FUNCTION__);
305 return (27UL); //default return case
306 }
307 }
308
_GFXAPI_MIU_ID(MS_U32 ge_fbaddr)309 MS_U8 _GFXAPI_MIU_ID(MS_U32 ge_fbaddr)
310 {
311 #if 1
312 if(ge_fbaddr>=HAL_MIU1_BASE)
313 {
314 return 1;
315 }
316 else
317 {
318 return 0;
319 }
320 #else
321 return ((MS_U8) (((ge_fbaddr)>>_GET_MIU_MASK_SHIFT())&((1UL<<GE_FB_ADDR_MIU_MASK_BIT)-1)));
322
323 #endif
324 }
325
_GFXAPI_PHYS_ADDR_IN_MIU(MS_U32 ge_fbaddr)326 MS_U32 _GFXAPI_PHYS_ADDR_IN_MIU(MS_U32 ge_fbaddr)
327 {
328 #if 1
329 if(ge_fbaddr>=HAL_MIU1_BASE)
330 {
331 return (ge_fbaddr -= HAL_MIU1_BASE);
332 }
333 else
334 {
335 return (ge_fbaddr);
336 }
337 #else
338 return ((ge_fbaddr)&((1UL<<_GET_MIU_MASK_SHIFT())-1));
339 #endif
340 }
341
_GFXAPI_PHYS_ADDR_2_API(MS_U8 u8MIUId,MS_U32 ge_addrInMIU)342 MS_U32 _GFXAPI_PHYS_ADDR_2_API(MS_U8 u8MIUId, MS_U32 ge_addrInMIU)
343 {
344 #if 1
345 if(u8MIUId == 1)
346 {
347
348 return (HAL_MIU1_BASE| (ge_addrInMIU&((1UL<<_GET_MIU_MASK_SHIFT())-1)));
349 }
350 else
351 {
352
353 return (ge_addrInMIU&((1UL<<_GET_MIU_MASK_SHIFT())-1));
354 }
355 #else
356
357 return (((((MS_U32)(u8MIUId))&((1UL<<GE_FB_ADDR_MIU_MASK_BIT)-1))<<_GET_MIU_MASK_SHIFT()) | \
358 (((MS_U32)(ge_addrInMIU))&((1UL<<_GET_MIU_MASK_SHIFT())-1)));
359 #endif
360 }
361
362 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
_GE_InitGE1Regs(GE_CTX_HAL_LOCAL * pGEHalLocal)363 static void _GE_InitGE1Regs( GE_CTX_HAL_LOCAL *pGEHalLocal )
364 {
365 // to support the ge tag interrupt mode
366 // we use ge1 to make a fake fire to manufacture a tag interrupt
367
368 // Set default FMT for avoiding 1st set buffinfo error.
369 GE1_WriteReg(pGEHalLocal, REG_GE_FMT, (GE_FMT_ARGB1555<<GE_SRC_FMT_SHFT)+(GE_FMT_ARGB1555<<GE_DST_FMT_SHFT));
370
371 _GE_SetGeThreshold(pGEHalLocal, 1, GE_THRESHOLD_SETTING);
372
373 // useless dst addr
374 GE1_WriteReg(pGEHalLocal, REG_GE_DST_BASE_L, 0x1234);
375 GE1_WriteReg(pGEHalLocal, REG_GE_DST_BASE_H, 0x5678);
376
377 // for designer suggestion
378 // clip window should on left side of the destination rect for the speed factor
379 GE1_WriteReg(pGEHalLocal, REG_GE_CLIP_L, 0x0);
380 GE1_WriteReg(pGEHalLocal, REG_GE_CLIP_R, 0x1);
381 GE1_WriteReg(pGEHalLocal, REG_GE_CLIP_T, 0x0);
382 GE1_WriteReg(pGEHalLocal, REG_GE_CLIP_B, 0x1);
383 GE1_WriteReg(pGEHalLocal, REG_GE_PRIM_V0_X, 0x10);
384 GE1_WriteReg(pGEHalLocal, REG_GE_PRIM_V0_Y, 0x10);
385 GE1_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, 0x11);
386 GE1_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_Y, 0x11);
387 }
388
_GE_WaitTag_InterruptCbk(InterruptNum eIntNum)389 void _GE_WaitTag_InterruptCbk(InterruptNum eIntNum)
390 {
391 #if defined(MSOS_TYPE_LINUX)
392 MS_S32 s32CurPid = (MS_S32)getpid();
393 #endif
394
395 #if defined(MSOS_TYPE_LINUX)
396 if (s32WaitingTagPid == s32CurPid)
397 #endif
398 {
399 (*((volatile MS_U16 *)(s32HalIomapBaseAddr + GE1_BANK_NUM*2 + ((REG_GE_SRCMASK_GB)<<2) ))) = 0xE0;
400
401 if (s32GeWaitTagEventHandle > 0)
402 {
403 if (FALSE == MsOS_SetEvent(s32GeWaitTagEventHandle, 0x1))
404 {
405 GE_DBG("[%s, %d]: MsOS_ReleaseSemaphore failed\r\n", __FUNCTION__, __LINE__);
406 }
407 }
408 }
409
410 MsOS_EnableInterrupt(E_INT_IRQ_GE);
411 #ifdef MSOS_TYPE_LINUX
412 MsOS_CompleteInterrupt(E_INT_IRQ_GE);
413 #endif
414 }
415
_GE_SetGeThreshold(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8GeIdx,MS_U8 u8Threshold)416 static void _GE_SetGeThreshold(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8GeIdx, MS_U8 u8Threshold)
417 {
418 MS_U16 u16tmp;
419
420 u16tmp = GE_ReadReg(pGEHalLocal, REG_GE_TH);
421
422 u16tmp &= ~(GE_TH_STBB_MASK);
423 u16tmp |= (u8Threshold & GE_TH_STBB_MASK);
424
425 if (0 == u8GeIdx)
426 {
427 GE_WriteReg(pGEHalLocal, REG_GE_TH, u16tmp);
428 }
429 else
430 {
431 GE1_WriteReg(pGEHalLocal, REG_GE_TH, u16tmp);
432 }
433 }
434
_GE_Ctrl_IntMode(GE_CTX_HAL_LOCAL * pGEHalLocal,E_GE_INT_OP int_op)435 static GE_Result _GE_Ctrl_IntMode(GE_CTX_HAL_LOCAL *pGEHalLocal, E_GE_INT_OP int_op)
436 {
437 MS_U16 u16IntReg=0;
438
439 u16IntReg = _GE1_ReadReg(pGEHalLocal, REG_GE_SRCMASK_GB);
440
441 if (E_GE_CLEAR_INT & int_op)
442 {
443 u16IntReg |= GE_INT_MODE_CLEAR;
444 GE1_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, u16IntReg);
445 u16IntReg &= (~GE_INT_MODE_CLEAR);
446 }
447
448 if (E_GE_MASK_INT & int_op)
449 {
450 u16IntReg |= GE_INT_TAG_MASK;
451 }
452
453 if (E_GE_UNMASK_INT & int_op)
454 {
455 u16IntReg &= (~GE_INT_TAG_MASK);
456 }
457
458 if (E_GE_INT_TAG_MODE & int_op)
459 {
460 u16IntReg |= GE_INT_TAG_MODE;
461 }
462
463 if (E_GE_INT_NORMAL_MODE & int_op)
464 {
465 u16IntReg &= (~GE_INT_TAG_MODE);
466 }
467
468 GE1_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, u16IntReg);
469
470 return E_GE_OK;
471 }
472
_GE_IsTagInterruptEnabled(GE_CTX_HAL_LOCAL * pGEHalLocal)473 static MS_BOOL _GE_IsTagInterruptEnabled(GE_CTX_HAL_LOCAL *pGEHalLocal)
474 {
475 MS_BOOL bret;
476 MS_U16 u16IntReg=0;
477
478 u16IntReg = _GE1_ReadReg(pGEHalLocal, REG_GE_SRCMASK_GB);
479
480 bret = FALSE;
481 if ((GE_INT_TAG_MODE & u16IntReg) > 0)
482 {
483 bret = TRUE;
484 }
485
486 return bret;
487 }
488
_GE_Print_GeWaitTagTimeout_Msg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tagID)489 static void _GE_Print_GeWaitTagTimeout_Msg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tagID)
490 {
491 MS_U16 tmp_reg;
492
493 GE_DBG("[%s, %d]: >>>>>>>>>>>>>>>>>> ge wait event timeout <<<<<<<<<<<<<<<<<<<\r\n", __FUNCTION__, __LINE__);
494 GE_DBG("[%s, %d]: current proc id = %ld \r\n", __FUNCTION__, __LINE__, s32WaitingTagPid);
495
496 tmp_reg = _GE1_ReadReg(pGEHalLocal, REG_GE_SRCMASK_GB);
497 GE_DBG("[%s, %d]: ge int status = 0x%x \r\n", __FUNCTION__, __LINE__, tmp_reg);
498
499 tmp_reg = INTR_CTNL_BK(0x56);
500 GE_DBG("[%s, %d]: cpu int mask = 0x%x \r\n", __FUNCTION__, __LINE__, tmp_reg);
501 tmp_reg = INTR_CTNL_BK(0x5E);
502 GE_DBG("[%s, %d]: cpu int status = 0x%x \r\n", __FUNCTION__, __LINE__, tmp_reg);
503
504 tmp_reg = _GE1_ReadReg(pGEHalLocal, REG_GE_INT_TAG_COND_L);
505 GE_DBG("[%s, %d]: int_tag = 0x%x \r\n", __FUNCTION__, __LINE__, tmp_reg);
506
507 tmp_reg = _GE1_ReadReg(pGEHalLocal, REG_GE_TAG_L);
508 GE_DBG("[%s, %d]: tag = 0x%x \r\n", __FUNCTION__, __LINE__, tmp_reg);
509
510 GE_DBG("[%s, %d]: tagID = 0x%x \r\n", __FUNCTION__, __LINE__, tagID);
511 }
512
513 #endif
514
GE_Reset(GE_CTX_HAL_LOCAL * pGEHalLocal)515 static void GE_Reset(GE_CTX_HAL_LOCAL *pGEHalLocal)
516 {
517 MS_U16 reg0, reg1;
518
519 reg0 = GE_REG(REG_GE_EN);
520 reg1 = GE_REG(REG_GE_CFG);
521
522 GE_REG(REG_GE_EN) = 0;
523 GE_REG(REG_GE_CFG) = 0;
524
525 GE_REG(REG_GE_EN) = reg0;
526 GE_REG(REG_GE_CFG) = reg1;
527
528 }
529
GE_MapVQ2Reg(GE_VcmqBufSize enBufSize)530 static MS_U8 GE_MapVQ2Reg(GE_VcmqBufSize enBufSize)
531 {
532 switch(enBufSize)
533 {
534 case E_GE_VCMD_4K:
535 return GE_VQ_4K;
536 case E_GE_VCMD_8K:
537 return GE_VQ_8K;
538 case E_GE_VCMD_16K:
539 return GE_VQ_16K;
540 case E_GE_VCMD_32K:
541 return GE_VQ_32K;
542 case E_GE_VCMD_64K:
543 return GE_VQ_64K;
544 case E_GE_VCMD_128K:
545 return GE_VQ_128K;
546 case E_GE_VCMD_256K:
547 return GE_VQ_256K;
548 case E_GE_VCMD_512K:
549 return GE_VQ_512K;
550 case E_GE_VCMD_1024K:
551 return GE_VQ_1024K;
552 default:
553 return 0;
554 }
555 }
556
GE_WaitCmdQAvail(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U32 u32Count)557 void GE_WaitCmdQAvail(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U32 u32Count)
558 {
559 #if GE_CMDQ_ENABLE
560
561 #ifdef MS_DEBUG
562 MS_U32 waitcount = 0;
563 #endif
564 MS_U16 tmp1 = 0;
565 MS_U32 u32CmdMax;
566
567 /// VCMQ enabled
568 if((GE_REG(REG_GE_CFG) & GE_CFG_VCMDQ) != 0)
569 {
570 // 16 Bytes one command in VCMDQ.
571 u32CmdMax = (512 << (GE_REG(REG_GE_VCMDQ_SIZE) & 0x7));
572 u32Count = MIN(u32CmdMax, u32Count);
573
574 while (GE_CMDQ_FREECNT() < u32Count)
575 {
576 #ifdef MS_DEBUG
577 if (waitcount >= GE_RESET_COUNT)
578 {
579 printf("[GE] V0 Wait command queue: %d : %x, %lx\n", tmp1, GE_CMDQ_FREECNT(), u32Count);
580 waitcount = 0;
581 tmp1++;
582 if(tmp1 > 10)
583 {
584 GE_DumpReg(pGEHalLocal);
585 GE_Reset(pGEHalLocal);
586 }
587 }
588 waitcount++;
589 #endif
590 GE_YIELD();
591 }
592 tmp1 = 0;
593 waitcount = 0;
594
595
596 //If u32Count >= u32CmdMax, It will be dead loop. But since it won't happen, and if match
597 //Full VCMDQ, hw will hang, so keep the logic.
598 while ( (MS_U32)GE_VCMDQ_FREECNT() >= (MS_U32)(u32CmdMax- u32Count))
599 {
600 #ifdef MS_DEBUG
601 if (waitcount >= GE_RESET_COUNT)
602 {
603 printf("[GE] Wait VCMQ : %d : %lx, %lx\n", tmp1, (MS_U32)GE_VCMDQ_FREECNT(), u32Count);
604 waitcount = 0;
605 tmp1++;
606 if(tmp1 > 10)
607 {
608 GE_DumpReg(pGEHalLocal);
609 GE_Reset(pGEHalLocal);
610 }
611 }
612 waitcount++;
613 #endif
614 GE_YIELD();
615 }
616 }
617 else
618 {
619 u32Count = MIN(GE_CMD_SIZE_MAX, u32Count);
620
621 while (GE_CMDQ_FREECNT() < u32Count)
622 {
623 #ifdef MS_DEBUG
624 if (waitcount >= GE_RESET_COUNT)
625 {
626 printf("[GE] Wait command queue: %d : %x, %lx\n", tmp1, GE_CMDQ_FREECNT(), u32Count);
627 waitcount = 0;
628 tmp1++;
629 if(tmp1 > 10)
630 {
631 GE_DumpReg(pGEHalLocal);
632 GE_Reset(pGEHalLocal);
633 }
634 }
635 waitcount++;
636 #endif
637 GE_YIELD();
638 }
639
640 }
641
642 #endif
643 }
644
GE_ConvertAPIAddr2HAL(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8MIUId,MS_U32 u32GE_APIAddrInMIU)645 MS_U32 GE_ConvertAPIAddr2HAL(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8MIUId, MS_U32 u32GE_APIAddrInMIU)
646 {
647 u32GE_APIAddrInMIU &= (1UL<<MIU_SELETE_OFFSET)-1UL;
648 if(u8MIUId)
649 u32GE_APIAddrInMIU |= 1UL<<MIU_SELETE_OFFSET;
650 return u32GE_APIAddrInMIU;
651 }
GE_ConvertHALAddr2API(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8MIUId,MS_U32 u32GE_HALAddr)652 MS_U32 GE_ConvertHALAddr2API(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8MIUId, MS_U32 u32GE_HALAddr)
653 {
654 return _GFXAPI_PHYS_ADDR_2_API(u8MIUId, u32GE_HALAddr&((1UL<<MIU_SELETE_OFFSET)-1));
655 }
656
GE_WaitIdle(GE_CTX_HAL_LOCAL * pGEHalLocal)657 void GE_WaitIdle(GE_CTX_HAL_LOCAL *pGEHalLocal)
658 {
659 #ifdef MS_DEBUG
660 MS_U32 waitcount = 0;
661 #endif
662 MS_U16 tmp1 = 0;
663
664 GE_WriteReg(pGEHalLocal, REG_GE_TAG_H, 0);
665 GE_WriteReg(pGEHalLocal, REG_GE_TAG_L, GE_GetNextTAGID(pGEHalLocal, FALSE)); // write dummy
666 // GE will pack 2 register commands before CMDQ
667 // We need to push fifo if there is one command in the fifo before
668 // CMDQ. Then the GE status register will be consistant after idle.
669 GE_WaitCmdQAvail(pGEHalLocal, GE_STAT_CMDQ_MAX); // Wait CMDQ empty
670
671 // Wait level-2 command queue flush
672 while (((GE_REG(REG_GE_STAT)&GE_STAT_CMDQ2_MASK)>>GE_STAT_CMDQ2_SHFT) != GE_STAT_CMDQ2_MAX)
673 {
674 #ifdef MS_DEBUG
675 if (waitcount >= GE_RESET_COUNT)
676 {
677 printf("[GE] Wait Idle: %u : %x\n", tmp1, GE_CMDQ_FREECNT());
678 waitcount = 0;
679 tmp1++;
680 if(tmp1 > 10)
681 {
682 GE_DumpReg(pGEHalLocal);
683 GE_Reset(pGEHalLocal);
684 }
685 }
686 waitcount++;
687 #endif
688
689 GE_YIELD();
690 }
691
692 #ifdef MS_DEBUG
693 waitcount = 0;
694 tmp1 = 0;
695 #endif
696 // Wait GE idle
697 while (GE_REG(REG_GE_STAT) & GE_STAT_BUSY)
698 {
699 #ifdef MS_DEBUG
700 if (waitcount >= GE_RESET_COUNT)
701 {
702 printf("[GE] Wait Busy: %d : %x\n", tmp1, GE_CMDQ_FREECNT());
703 waitcount = 0;
704 tmp1++;
705 if(tmp1 > 10)
706 {
707 GE_DumpReg(pGEHalLocal);
708 GE_Reset(pGEHalLocal);
709 }
710 }
711 waitcount++;
712 #endif
713
714 GE_YIELD();
715 }
716
717 }
718
GE_Map_Share_Reg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)719 GE_Result GE_Map_Share_Reg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
720 {
721 if(addr == REG_GE_CFG)
722 return E_GE_OK;
723 else
724 return E_GE_FAIL;
725 #if 0
726 switch(addr)
727 {
728 case REG_GE_CFG:
729 return E_GE_OK;
730 default:
731 return E_GE_FAIL;
732 }
733 #endif
734
735 }
736
GE_Map_Share_RegEX(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)737 GE_Result GE_Map_Share_RegEX(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
738 {
739 return E_GE_FAIL;
740 }
741
GE_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)742 MS_U16 GE_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
743 {
744 MS_U16 u16NoFIFOMask;
745
746 if(0x80 <= addr)
747 {
748 GE_WaitIdle(pGEHalLocal);
749 return GE_REG(addr-GE_TABLE_REGNUM);
750 }
751 switch (addr)
752 {//for registers which do not go through command queue
753 case REG_GE_EN:
754 u16NoFIFOMask = GE_EN_GE;
755 break;
756 /*
757 case REG_GE_CFG:
758 //u16NoFIFOMask = ~(GE_CFG_BLT_STRETCH|GE_CFG_EN_CLIPCHK|GE_CFG_BLT_ITALIC|GE_CFG_SRC_TILE|GE_CFG_DST_TILE);
759 return pGEHalLocal->u16RegImage[addr];
760 break;
761 */
762 case REG_GE_DBG:
763 case REG_GE_TH:
764 case REG_GE_BIST_STAT:
765 case REG_GE_STAT:
766 case REG_GE_VCMDQ_STAT:
767 case REG_GE_MIU_PROT_LTH_L(0):
768 case REG_GE_MIU_PROT_LTH_H(0):
769 case REG_GE_MIU_PROT_HTH_L(0):
770 case REG_GE_MIU_PROT_HTH_H(0):
771 case REG_GE_MIU_PROT_LTH_L(1):
772 case REG_GE_MIU_PROT_LTH_H(1):
773 case REG_GE_MIU_PROT_HTH_L(1):
774 case REG_GE_MIU_PROT_HTH_H(1):
775 case REG_GE_TAG_L:
776 case REG_GE_TAG_H:
777 case REG_GE_VCMDQ_BASE_L:
778 case REG_GE_VCMDQ_BASE_H:
779 u16NoFIFOMask = 0xffff;
780 break;
781 case REG_GE_VCMDQ_SIZE:
782 u16NoFIFOMask = GE_VCMDQ_SIZE_MASK;
783 break;
784 default:
785 u16NoFIFOMask = 0;
786 break;
787 }
788
789 if(0 == u16NoFIFOMask)
790 {
791 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
792 return pGEHalLocal->pHALShared->u16ShareRegImage[addr];
793 else
794 {
795 return pGEHalLocal->u16RegGETable[addr];
796 }
797 }
798 return (GE_REG(addr)&u16NoFIFOMask)|(pGEHalLocal->u16RegGETable[addr]&~u16NoFIFOMask);
799 }
800
801
GE_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)802 void GE_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
803 {
804 // CMDQ special command
805 if(addr < GE_TABLE_REGNUM)
806 {
807 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
808 {
809 pGEHalLocal->pHALShared->u16ShareRegImage[addr]= value;
810 }
811
812 pGEHalLocal->u16RegGETable[addr] = value;
813 }
814 else
815 {
816 printf("[%s][%d] Reg Index [%d]is out of GE_TABLE_REGNUM [%d]range!!!!\n",__FUNCTION__,__LINE__, addr, GE_TABLE_REGNUM);
817 }
818 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
819
820 if(pGEHalLocal->pHALShared->bGE_DirectToReg ==TRUE)
821 {
822 GE_REG(addr)= value;
823 return;
824 }
825 else
826 {
827 MS_U16 i=0;
828
829 switch (addr)
830 {
831 case REG_GE_EN:
832 case REG_GE_CFG:
833 case REG_GE_DBG:
834 case REG_GE_TH:
835 case REG_GE_BIST_STAT:
836 case REG_GE_STAT:
837 case REG_GE_VCMDQ_STAT:
838 case REG_GE_MIU_PROT_LTH_L(0):
839 case REG_GE_MIU_PROT_LTH_H(0):
840 case REG_GE_MIU_PROT_HTH_L(0):
841 case REG_GE_MIU_PROT_HTH_H(0):
842 case REG_GE_MIU_PROT_LTH_L(1):
843 case REG_GE_MIU_PROT_LTH_H(1):
844 case REG_GE_MIU_PROT_HTH_L(1):
845 case REG_GE_MIU_PROT_HTH_H(1):
846 case REG_GE_TAG_L:
847 case REG_GE_TAG_H:
848 case REG_GE_VCMDQ_BASE_L:
849 case REG_GE_VCMDQ_BASE_H:
850 case REG_GE_VCMDQ_SIZE:
851
852 //Palette
853 case REG_GE_CLUT_L:
854 case REG_GE_CLUT_H:
855 case REG_GE_CLUT_CTRL:
856 GE_REG(addr) = value;
857 break;
858
859 case REG_GE_CMD:
860 for(i=0; i<GE_TABLE_REGNUM; i++)
861 {
862 //CMQ/Palette
863 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 \
864 || 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)\
865 || 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)\
866 || i==REG_GE_VCMDQ_BASE_L || i==REG_GE_VCMDQ_BASE_H || i==REG_GE_VCMDQ_SIZE \
867 || i==REG_GE_CLUT_L || i==REG_GE_CLUT_H || i==REG_GE_CLUT_CTRL || i==REG_GE_TAG_L || i==REG_GE_TAG_H)
868 {
869 continue;
870 }
871
872 if(i == REG_GE_CMD )
873 {
874 continue;
875 }
876
877 if(i == (GE_TABLE_REGNUM-1))
878 {
879 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
880 GE_REG(i)= pGEHalLocal->u16RegGETable[i];
881 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
882 GE_REG(REG_GE_CMD)= pGEHalLocal->u16RegGETable[REG_GE_CMD];
883 }
884 else
885 {
886 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
887 GE_REG(i)= pGEHalLocal->u16RegGETable[i];
888 }
889
890 }
891 break;
892 default:
893 #if GE_LOG_ENABLE
894 GE_LOG(addr, value);
895 #endif
896 break;
897 }
898
899 }
900
901 }
902
GE2_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)903 MS_U16 GE2_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
904 {
905 MS_U16 u16NoFIFOMask=0;
906
907 if(0x80 <= addr)
908 {
909 GE_WaitIdle(pGEHalLocal);
910 return GE2_REG(addr-GE_TABLE_REGNUM);
911 }
912
913 if(0 == u16NoFIFOMask)
914 {
915 if(GE_Map_Share_RegEX(pGEHalLocal,addr)== E_GE_OK)
916 return pGEHalLocal->pHALShared->u16ShareRegImageEx[addr];
917 else
918 {
919 return pGEHalLocal->u16RegGETableEX[addr];
920 }
921 }
922 return (GE2_REG(addr)&u16NoFIFOMask)|(pGEHalLocal->u16RegGETableEX[addr]&~u16NoFIFOMask);
923
924 }
925
GE2_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)926 void GE2_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
927 {
928 // CMDQ special command
929 if(addr < GE_TABLE_REGNUM)
930 {
931 if(GE_Map_Share_RegEX(pGEHalLocal,addr)== E_GE_OK)
932 {
933 pGEHalLocal->pHALShared->u16ShareRegImageEx[addr]= value;
934 }
935 pGEHalLocal->u16RegGETableEX[addr] = value;
936 }
937 else
938 {
939 printf("[%s][%d] Reg Index [%d]is out of GE_TABLE_REGNUM [%d]range!!!!\n",__FUNCTION__,__LINE__, addr, GE_TABLE_REGNUM);
940 }
941 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
942 GE2_REG(addr)= value;
943 return;
944 }
945
946
_GE1_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr)947 MS_U16 _GE1_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr)
948 {
949 return GE1_REG(addr);
950 }
951
952
GE1_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)953 void GE1_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
954 {
955 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
956 GE1_REG(addr)= value;
957 return;
958 }
959
GE_RestoreReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)960 void GE_RestoreReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
961 {
962 // CMDQ special command
963 switch (addr)
964 {
965 case REG_GE_CMD:
966 break;
967 //[OBSOLETE]
968 default:
969 GE_WriteReg(pGEHalLocal, addr, value);
970 break;
971 }
972 }
973
974
GE_ResetState(GE_CTX_HAL_LOCAL * pGEHalLocal)975 void GE_ResetState(GE_CTX_HAL_LOCAL *pGEHalLocal)
976 {
977 GE_WaitIdle(pGEHalLocal);
978
979 GE_WriteReg(pGEHalLocal, REG_GE_EN, GE_EN_GE);
980 #if GE_DITHER_RAND_ENABLE
981 GE_WriteReg(pGEHalLocal, REG_GE_EN, GE_EN_GE | GE_EN_DITHER_RAND); //fixed random dither by default
982 #endif
983 GE_WriteReg(pGEHalLocal, REG_GE_TH, 0x0000); //0(<half) will be default to be half
984
985 GE_WriteReg(pGEHalLocal, REG_GE_LINE_STYLE, GE_LINEPAT_RST);
986 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SCK_MODE, GE_BLT_SCK_NEAREST);
987 GE_WriteReg(pGEHalLocal, REG_GE_BLEND, GE_ALPHA_ARGB1555); //force alpha constant of ARGB"1"555 to be 1.0 by default
988 }
989
990
GE_Init_RegImage(GE_CTX_HAL_LOCAL * pGEHalLocal)991 void GE_Init_RegImage(GE_CTX_HAL_LOCAL *pGEHalLocal)
992 {
993 MS_U8 addr;
994
995 for(addr = 0; addr<GE_TABLE_REGNUM; addr++)
996 {
997 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
998 pGEHalLocal->pHALShared->u16ShareRegImage[addr]= GE_REG(addr);
999 pGEHalLocal->u16RegGETable[addr] = GE_REG(addr);
1000 }
1001
1002 }
1003
GE_Init(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Config * cfg)1004 void GE_Init(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_Config *cfg)
1005 {
1006 MS_U16 u16temp =0;
1007
1008 GE_WaitIdle(pGEHalLocal);
1009
1010 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
1011
1012 if ((u16temp & BIT(1)) != BIT(1)) //if VQ is Not Enabled
1013 {
1014 #if GE_CMDQ_ENABLE
1015 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
1016 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16temp | GE_CFG_CMDQ); // enable command queue
1017 #endif
1018
1019 // Set default FMT for avoiding 1st set buffinfo error.
1020 GE_WriteReg(pGEHalLocal, REG_GE_FMT, (GE_FMT_ARGB1555<<GE_SRC_FMT_SHFT)+(GE_FMT_ARGB1555<<GE_DST_FMT_SHFT));
1021
1022 if (cfg->u32VCmdQSize >= GE_VCMDQ_SIZE_MIN)
1023 {
1024 MS_PHYADDR u32VQAddr = cfg->u32VCmdQAddr;
1025 MS_U32 u32VcmdqBufSz = cfg->u32VCmdQSize;
1026
1027 GE_SetVCmdBuffer(pGEHalLocal, u32VQAddr, u32VcmdqBufSz);
1028
1029 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
1030 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16temp | GE_CFG_VCMDQ);
1031 }
1032
1033 GE_ResetState(pGEHalLocal);
1034 }
1035 else
1036 {
1037 //No need to set command queue
1038 printf(" warning!!! Virtual Command queue has been activated!! \n");
1039 }
1040 //GE_Init_RegImage(pGEHalLocal);
1041
1042 GE_WriteReg(pGEHalLocal, REG_GE_TH, GE_THRESHOLD_SETTING);
1043
1044 u16temp = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_TYPE_EN)&(~GE_TLB_MODE_MASK);
1045 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TYPE_EN, u16temp);
1046
1047 u16temp = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_EN);
1048 u16temp |= GE_TLB_EN;
1049 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_EN, u16temp);
1050
1051 u16temp = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_TAG)&(~GE_TLB_TAG);
1052 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TAG, u16temp);
1053
1054 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
1055
1056 if (FALSE == bGeIrqInited)
1057 {
1058 _GE_InitGE1Regs(pGEHalLocal);
1059
1060 if (FALSE == _GE_IsTagInterruptEnabled(pGEHalLocal))
1061 {
1062 _GE_Ctrl_IntMode(pGEHalLocal, E_GE_INT_TAG_MODE | E_GE_MASK_INT);
1063 }
1064
1065 if (FALSE == MsOS_AttachInterrupt(E_INT_IRQ_GE, _GE_WaitTag_InterruptCbk))
1066 {
1067 GE_DBG("[%s, %d]: MsOS_AttachInterrupt failed \r\n", __FUNCTION__, __LINE__);
1068 return ;
1069 }
1070 MsOS_EnableInterrupt(E_INT_IRQ_GE);
1071
1072 bGeIrqInited = TRUE;
1073 }
1074
1075 if (s32GeWaitTagEventHandle < 0)
1076 {
1077 s32GeWaitTagEventHandle = MsOS_CreateEventGroup("GE_Wait_Event_Handle");
1078 if (s32GeWaitTagEventHandle < 0)
1079 {
1080 GE_DBG("[%s, %d]: ge_semid_waitTag = %ld", __FUNCTION__, __LINE__, s32GeWaitTagEventHandle);
1081 return;
1082 }
1083 }
1084 #endif
1085
1086 }
1087
GE_SetRotate(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RotateAngle geRotAngle)1088 GE_Result GE_SetRotate(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RotateAngle geRotAngle)
1089 {
1090 MS_U16 u16RegVal;
1091
1092 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_ROT_MODE) & ~REG_GE_ROT_MODE_MASK) | (geRotAngle<<REG_GE_ROT_MODE_SHFT);
1093 GE_WriteReg(pGEHalLocal, REG_GE_ROT_MODE, u16RegVal);
1094
1095 return E_GE_OK;
1096 }
1097
GE_SetOnePixelMode(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1098 GE_Result GE_SetOnePixelMode(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1099 {
1100
1101 MS_U16 u16en;
1102 //GE_DBG("%s\n", __FUNCTION__);
1103
1104 u16en = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1105 if (enable)
1106 {
1107 u16en |= GE_EN_ONE_PIXEL_MODE;
1108 }
1109 else
1110 {
1111 u16en &= (~GE_EN_ONE_PIXEL_MODE);
1112 }
1113 u16en |= GE_EN_BURST;
1114 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en);
1115
1116 return E_GE_OK;
1117 }
1118
GE_SetBlend(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_BlendOp eBlendOp)1119 GE_Result GE_SetBlend(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_BlendOp eBlendOp)
1120 {
1121 MS_U16 u16op;
1122
1123 switch (eBlendOp)
1124 {
1125 case E_GE_BLEND_ONE:
1126 case E_GE_BLEND_CONST:
1127 case E_GE_BLEND_ASRC:
1128 case E_GE_BLEND_ADST:
1129 case E_GE_BLEND_ROP8_ALPHA:
1130 case E_GE_BLEND_ROP8_SRCOVER:
1131 case E_GE_BLEND_ROP8_DSTOVER:
1132 case E_GE_BLEND_ZERO:
1133 case E_GE_BLEND_CONST_INV:
1134 case E_GE_BLEND_ASRC_INV:
1135 case E_GE_BLEND_ADST_INV:
1136 case E_GE_BLEND_ALPHA_ADST:
1137 case E_GE_BLEND_SRC_ATOP_DST:
1138 case E_GE_BLEND_DST_ATOP_SRC:
1139 case E_GE_BLEND_SRC_XOR_DST:
1140 case E_GE_BLEND_INV_CONST:
1141
1142 u16op = eBlendOp;
1143 break;
1144 default:
1145 return E_GE_FAIL_PARAM;
1146 break;
1147 }
1148
1149 u16op = (GE_ReadReg(pGEHalLocal, REG_GE_BLEND) & ~GE_BLEND_MASK) | u16op;
1150 GE_WriteReg(pGEHalLocal, REG_GE_BLEND, u16op);
1151
1152 return E_GE_OK;
1153 }
1154
1155
GE_SetAlpha(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_AlphaSrc eAlphaSrc)1156 GE_Result GE_SetAlpha(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_AlphaSrc eAlphaSrc)
1157 {
1158 MS_U16 u16src;
1159
1160 switch (eAlphaSrc)
1161 {
1162 case E_GE_ALPHA_CONST:
1163 case E_GE_ALPHA_ASRC:
1164 case E_GE_ALPHA_ADST:
1165 case E_GE_ALPHA_ROP8_SRC:
1166 case E_GE_ALPHA_ROP8_IN:
1167 case E_GE_ALPHA_ROP8_DSTOUT:
1168 case E_GE_ALPHA_ROP8_SRCOUT:
1169 case E_GE_ALPHA_ROP8_OVER:
1170 case E_GE_ALPHA_ROP8_INV_CONST:
1171 case E_GE_ALPHA_ROP8_INV_ASRC:
1172 case E_GE_ALPHA_ROP8_INV_ADST:
1173 case E_GE_ALPHA_ROP8_SRC_ATOP_DST:
1174 case E_GE_ALPHA_ROP8_DST_ATOP_SRC:
1175 case E_GE_ALPHA_ROP8_SRC_XOR_DST:
1176 case E_GE_ALPHA_ROP8_INV_SRC_ATOP_DST:
1177 case E_GE_ALPHA_ROP8_INV_DST_ATOP_SRC:
1178
1179 u16src = eAlphaSrc;
1180 break;
1181 default:
1182 return E_GE_FAIL_PARAM;
1183 break;
1184 }
1185
1186 u16src = (GE_ReadReg(pGEHalLocal, REG_GE_ALPHA) & ~GE_ALPHA_MASK) | (u16src<<GE_ALPHA_SHFT);
1187 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA, u16src);
1188
1189 return E_GE_OK;
1190 }
1191
GE_QueryDFBBldCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 * pU16SupportedBldFlags)1192 GE_Result GE_QueryDFBBldCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 *pU16SupportedBldFlags)
1193 {
1194 if(NULL == pU16SupportedBldFlags)
1195 {
1196 return E_GE_FAIL_PARAM;
1197 }
1198
1199 (*pU16SupportedBldFlags) = E_GE_DFB_BLD_FLAG_ALL;
1200
1201 return E_GE_OK;
1202 }
1203
GE_EnableDFBBld(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1204 GE_Result GE_EnableDFBBld(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1205 {
1206 MS_U16 u16RegVal;
1207
1208 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1209
1210 if (enable)
1211 {
1212 u16RegVal |= GE_EN_DFB_BLD;
1213 }
1214 else
1215 {
1216 u16RegVal &= ~GE_EN_DFB_BLD;
1217 }
1218
1219 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16RegVal);
1220
1221 return E_GE_OK;
1222 }
1223
GE_SetDFBBldFlags(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 u16DFBBldFlags)1224 GE_Result GE_SetDFBBldFlags(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 u16DFBBldFlags)
1225 {
1226 MS_U16 u16RegVal;
1227
1228 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_FLAGS) & ~GE_DFB_BLD_FLAGS_MASK);
1229
1230 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_COLORALPHA)
1231 {
1232 u16RegVal |= GE_DFB_BLD_FLAG_COLORALPHA;
1233 }
1234
1235 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_ALPHACHANNEL)
1236 {
1237 u16RegVal |= GE_DFB_BLD_FLAG_ALPHACHANNEL;
1238 }
1239
1240 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_COLORIZE)
1241 {
1242 u16RegVal |= GE_DFB_BLD_FLAG_COLORIZE;
1243 }
1244
1245 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_SRCPREMUL)
1246 {
1247 u16RegVal |= GE_DFB_BLD_FLAG_SRCPREMUL;
1248 }
1249
1250 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_SRCPREMULCOL)
1251 {
1252 u16RegVal |= GE_DFB_BLD_FLAG_SRCPREMULCOL;
1253 }
1254
1255 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_DSTPREMUL)
1256 {
1257 u16RegVal |= GE_DFB_BLD_FLAG_DSTPREMUL;
1258 }
1259
1260 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_XOR)
1261 {
1262 u16RegVal |= GE_DFB_BLD_FLAG_XOR;
1263 }
1264
1265 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_DEMULTIPLY)
1266 {
1267 u16RegVal |= GE_DFB_BLD_FLAG_DEMULTIPLY;
1268 }
1269
1270 GE_WriteReg(pGEHalLocal, REG_GE_DFB_BLD_FLAGS, u16RegVal);
1271
1272
1273 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_OP) & ~GE_DFB_SRC_COLORMASK);
1274
1275 if(u16DFBBldFlags & (E_GE_DFB_BLD_FLAG_SRCCOLORMASK | E_GE_DFB_BLD_FLAG_SRCALPHAMASK))
1276 {
1277 u16RegVal |= (1 << GE_DFB_SRC_COLORMASK_SHIFT);
1278 }
1279
1280
1281
1282 return E_GE_OK;
1283 }
1284
GE_SetDFBBldOP(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_DFBBldOP geSrcBldOP,GE_DFBBldOP geDstBldOP)1285 GE_Result GE_SetDFBBldOP(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_DFBBldOP geSrcBldOP, GE_DFBBldOP geDstBldOP)
1286 {
1287 MS_U16 u16RegVal;
1288
1289 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_OP) & ~(GE_DFB_SRCBLD_OP_MASK|GE_DFB_DSTBLD_OP_MASK));
1290 u16RegVal |= ((geSrcBldOP<<GE_DFB_SRCBLD_OP_SHFT) | (geDstBldOP<<GE_DFB_DSTBLD_OP_SHFT));
1291
1292 GE_WriteReg(pGEHalLocal, REG_GE_DFB_BLD_OP, u16RegVal);
1293
1294 return E_GE_OK;
1295 }
1296
GE_SetDFBBldConstColor(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RgbColor geRgbColor)1297 GE_Result GE_SetDFBBldConstColor(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RgbColor geRgbColor)
1298 {
1299 MS_U16 u16RegVal;
1300
1301 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_ALPHA_CONST) & ~GE_ALPHA_CONST_MASK) | (geRgbColor.a & 0xFF));
1302 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA_CONST, u16RegVal);
1303
1304 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_R_CONST) & ~GE_R_CONST_MASK) | ((geRgbColor.r<<GE_R_CONST_SHIFT) & GE_R_CONST_MASK));
1305 GE_WriteReg(pGEHalLocal, REG_GE_R_CONST, u16RegVal);
1306
1307 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_G_CONST) & ~GE_G_CONST_MASK) | ((geRgbColor.g<<GE_G_CONST_SHIFT) & GE_G_CONST_MASK));
1308 GE_WriteReg(pGEHalLocal, REG_GE_G_CONST, u16RegVal);
1309
1310 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_B_CONST) & ~GE_B_CONST_MASK) | ((geRgbColor.b<<GE_B_CONST_SHIFT) & GE_B_CONST_MASK));
1311 GE_WriteReg(pGEHalLocal, REG_GE_B_CONST, u16RegVal);
1312
1313 return E_GE_OK;
1314 }
1315
GE_SetDFBBldSrcColorMask(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RgbColor geRgbColor)1316 GE_Result GE_SetDFBBldSrcColorMask(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RgbColor geRgbColor)
1317 {
1318 //no more hw function
1319 /*
1320 MS_U16 u16RegVal;
1321
1322 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_ALPHA_CONST) & ~GE_ALPHA_SRCMASK_MASK) | (geRgbColor.a & 0xFF));
1323 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA_CONST, u16RegVal);
1324
1325 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_OP_MODE) & ~GE_SRCCOLOR_MASK_R) | ((geRgbColor.r<<GE_SRCCOLOR_MASK_R_SHIFT) & GE_SRCCOLOR_MASK_R));
1326 GE_WriteReg(pGEHalLocal, REG_GE_OP_MODE, u16RegVal);
1327
1328 u16RegVal = (geRgbColor.g<<GE_SRCCOLOR_MASK_G_SHIFT) | (geRgbColor.b<<GE_SRCCOLOR_MASK_B_SHIFT);
1329 GE_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, u16RegVal);
1330 */
1331 return E_GE_OK;
1332 }
1333
1334
GE_WriteProtect(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 miu,MS_PHYADDR addr_low,MS_PHYADDR addr_high,GE_WPType eWPType)1335 GE_Result GE_WriteProtect(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 miu, MS_PHYADDR addr_low, MS_PHYADDR addr_high, GE_WPType eWPType)
1336 {
1337 MS_U16 u16cfg;
1338
1339 if (miu > 1)
1340 {
1341 return E_GE_FAIL;
1342 }
1343
1344 if ( (eWPType == E_GE_WP_IN_RANGE) || (eWPType == E_GE_WP_OUT_RANGE) )
1345 {
1346 // range setting
1347 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_LTH_L(miu), addr_low & (GE_MIU_ADDR_MASK&0xFFFF));
1348 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_LTH_H(miu), ((addr_low>>16) & (GE_MIU_ADDR_MASK>>16)) | (eWPType<<GE_MIU_PROT_MODE_SHFT));
1349 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_HTH_L(miu), addr_high & (GE_MIU_ADDR_MASK&0xFFFF));
1350 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_HTH_H(miu), (addr_high>>16) & (GE_MIU_ADDR_MASK>>16));
1351 // enable setting
1352 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_CFG) | (GE_CFG_MIU0_PROT << miu);
1353 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16cfg);
1354 }
1355 else if (eWPType == E_GE_WP_DISABLE)
1356 {
1357 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_CFG) & ~(GE_CFG_MIU0_PROT<<miu);
1358 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16cfg);
1359 }
1360 else
1361 {
1362 return E_GE_FAIL;
1363 }
1364
1365 return E_GE_OK;
1366 }
1367
1368
GE_SetSrcTile(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL tile)1369 GE_Result GE_SetSrcTile(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL tile)
1370 {
1371 //GE_DBG("%s\n", __FUNCTION__);
1372
1373 return E_GE_NOT_SUPPORT;
1374
1375 }
1376
1377
GE_SetDstTile(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL tile)1378 GE_Result GE_SetDstTile(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL tile)
1379 {
1380 //GE_DBG("%s\n", __FUNCTION__);
1381
1382 return E_GE_NOT_SUPPORT;
1383
1384 }
GE_SetASCK(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1385 GE_Result GE_SetASCK(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1386 {
1387 MS_U16 u16cfg;
1388
1389 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1390 if (enable)
1391 {
1392 u16cfg |= GE_EN_ASCK;
1393 }
1394 else
1395 {
1396 u16cfg &= ~GE_EN_ASCK;
1397 }
1398 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16cfg);
1399
1400 return E_GE_OK;
1401 }
GE_SetADCK(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1402 GE_Result GE_SetADCK(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1403 {
1404 MS_U16 u16cfg;
1405
1406 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1407 if (enable)
1408 {
1409 u16cfg |= GE_EN_DSCK;
1410 }
1411 else
1412 {
1413 u16cfg &= ~GE_EN_DSCK;
1414 }
1415 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16cfg);
1416
1417 return E_GE_OK;
1418 }
1419
1420
GE_GetFmtCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_BufFmt fmt,GE_BufType type,GE_FmtCaps * caps)1421 GE_Result GE_GetFmtCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_BufFmt fmt, GE_BufType type, GE_FmtCaps *caps)
1422 {
1423 static const MS_U8 _u8GETileWidth[] = {8, 4, 2, 0, 1};
1424
1425 caps->fmt = fmt;
1426 if (type == E_GE_BUF_SRC)
1427 {
1428 switch (fmt)
1429 {
1430 case E_GE_FMT_I1:
1431 case E_GE_FMT_I2:
1432 case E_GE_FMT_I4:
1433 case E_GE_FMT_I8:
1434 caps->u8BaseAlign = 1;
1435 caps->u8PitchAlign = 1;
1436 caps->u8Non1pAlign = 0;
1437 caps->u8HeightAlign = 1;
1438 caps->u8StretchAlign = 1;
1439 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1440 caps->u8TileWidthAlign = _u8GETileWidth[fmt];
1441 caps->u8TileHeightAlign = 16;
1442 break;
1443 case E_GE_FMT_RGB565:
1444 case E_GE_FMT_RGBA5551:
1445 case E_GE_FMT_RGBA4444:
1446 case E_GE_FMT_ARGB1555:
1447 case E_GE_FMT_1ABFgBg12355:
1448 case E_GE_FMT_ARGB4444:
1449 case E_GE_FMT_YUV422:
1450 case E_GE_FMT_FaBaFgBg2266:
1451 caps->u8BaseAlign = 2;
1452 caps->u8PitchAlign = 2;
1453 caps->u8Non1pAlign = 0;
1454 caps->u8HeightAlign = 1;
1455 caps->u8StretchAlign = 2;
1456 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1457 caps->u8TileWidthAlign = 16;
1458 caps->u8TileHeightAlign = 16;
1459 break;
1460 case E_GE_FMT_ABGR8888:
1461 case E_GE_FMT_ARGB8888:
1462 caps->u8BaseAlign = 4;
1463 caps->u8PitchAlign = 4;
1464 caps->u8Non1pAlign = 0;
1465 caps->u8HeightAlign = 1;
1466 caps->u8StretchAlign = 4;
1467 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1468 caps->u8TileWidthAlign = 8;
1469 caps->u8TileHeightAlign = 16;
1470 break;
1471 // Not Support
1472 default:
1473 caps->fmt = E_GE_FMT_GENERIC;
1474 caps->u8BaseAlign = 4;
1475 caps->u8PitchAlign = 4;
1476 caps->u8Non1pAlign = 0;
1477 caps->u8HeightAlign = 1;
1478 caps->u8StretchAlign = 4;
1479 caps->u8TileBaseAlign = 0;
1480 caps->u8TileWidthAlign = 0;
1481 caps->u8TileHeightAlign = 0;
1482 return E_GE_FAIL_FORMAT;
1483 }
1484 }
1485 else
1486 {
1487 switch (fmt)
1488 {
1489 case E_GE_FMT_I8:
1490 caps->u8BaseAlign = 1;
1491 caps->u8PitchAlign = 1;
1492 caps->u8Non1pAlign = 0;
1493 caps->u8HeightAlign = 1;
1494 caps->u8StretchAlign = 1;
1495 caps->u8TileBaseAlign = 8;
1496 caps->u8TileWidthAlign = _u8GETileWidth[fmt];
1497 caps->u8TileHeightAlign = 16;
1498 break;
1499 case E_GE_FMT_RGB565:
1500 case E_GE_FMT_ARGB1555:
1501 case E_GE_FMT_RGBA5551:
1502 case E_GE_FMT_RGBA4444:
1503 case E_GE_FMT_1ABFgBg12355:
1504 case E_GE_FMT_ARGB4444:
1505 case E_GE_FMT_YUV422:
1506 case E_GE_FMT_FaBaFgBg2266:
1507 case E_GE_FMT_ARGB1555_DST:
1508 caps->u8BaseAlign = 2;
1509 caps->u8PitchAlign = 2;
1510 caps->u8Non1pAlign = 0;
1511 caps->u8HeightAlign = 1;
1512 caps->u8StretchAlign = 2;
1513 caps->u8TileBaseAlign = 8;
1514 caps->u8TileWidthAlign = 16;
1515 caps->u8TileHeightAlign = 16;
1516 break;
1517 case E_GE_FMT_ABGR8888:
1518 case E_GE_FMT_ARGB8888:
1519 caps->u8BaseAlign = 4;
1520 caps->u8PitchAlign = 4;
1521 caps->u8Non1pAlign = 0;
1522 caps->u8HeightAlign = 1;
1523 caps->u8StretchAlign = 4;
1524 caps->u8TileBaseAlign = 8;
1525 caps->u8TileWidthAlign = 8;
1526 caps->u8TileHeightAlign = 16;
1527 break;
1528 // Not Support
1529 case E_GE_FMT_I1:
1530 case E_GE_FMT_I2:
1531 case E_GE_FMT_I4:
1532 default:
1533 caps->fmt = E_GE_FMT_GENERIC;
1534 caps->u8BaseAlign = 4;
1535 caps->u8PitchAlign = 4;
1536 caps->u8Non1pAlign = 0;
1537 caps->u8HeightAlign = 1;
1538 caps->u8StretchAlign = 4;
1539 caps->u8TileBaseAlign = 0;
1540 caps->u8TileWidthAlign = 0;
1541 caps->u8TileHeightAlign = 0;
1542 return E_GE_FAIL_FORMAT;
1543 }
1544 }
1545
1546 return E_GE_OK;
1547 }
1548
1549
GE_Set_IOMap_Base(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U32 addr)1550 GE_Result GE_Set_IOMap_Base(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U32 addr)
1551 {
1552 pGEHalLocal->u32_mmio_base = addr;
1553
1554 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
1555 s32HalIomapBaseAddr = addr;
1556 #endif
1557
1558 return E_GE_OK;
1559 }
1560
1561
direct_serial_diff(MS_U16 tagID1,MS_U16 tagID2)1562 static int direct_serial_diff( MS_U16 tagID1, MS_U16 tagID2)
1563 {
1564 if(tagID1 < tagID2)
1565 {
1566 if((tagID2-tagID1)>0x7FFF)
1567 {
1568 return (int)(0xFFFFUL-tagID2+tagID1+1);
1569 }
1570 else
1571 return -(int)(tagID2-tagID1);
1572 }
1573 else
1574 {
1575 if((tagID1-tagID2)>0x7FFF)
1576 {
1577 return -(int)(0xFFFFUL-tagID1+tagID2+1);
1578 }
1579 else
1580 return (int)(tagID1-tagID2);
1581 }
1582 }
1583
1584 //-------------------------------------------------------------------------------------------------
1585 /// Wait GE TagID back
1586 /// @param tagID \b IN: tag id number for wating
1587 /// @return @ref GE_Result
1588 //-------------------------------------------------------------------------------------------------
GE_WaitTAGID(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tagID)1589 GE_Result GE_WaitTAGID(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tagID)
1590 {
1591 MS_U16 tagID_HW;
1592 MS_U32 u32Temp;
1593 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
1594 MS_U8 timeout_count = 0;
1595 MS_U32 event = 0x0;
1596 MS_BOOL bHadPrintOutDbgMsg = FALSE;
1597 #endif
1598
1599 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
1600 tagID_HW = GE_ReadReg(pGEHalLocal, REG_GE_TAG_L);
1601 if (tagID_HW >= tagID)
1602 {
1603 return E_GE_OK;
1604 }
1605
1606 #if defined(MSOS_TYPE_LINUX)
1607 s32WaitingTagPid = (MS_S32)getpid();
1608 #endif
1609
1610 MsOS_ClearEvent(s32GeWaitTagEventHandle, 0x1);
1611
1612 // unmask ge interrupt
1613 _GE_Ctrl_IntMode(pGEHalLocal, E_GE_CLEAR_INT | E_GE_UNMASK_INT);
1614
1615 GE1_WriteReg(pGEHalLocal, REG_GE_INT_TAG_COND_H, 0);
1616 GE1_WriteReg(pGEHalLocal, REG_GE_INT_TAG_COND_L, tagID);
1617
1618 // make a fake busy
1619 GE1_WriteReg(pGEHalLocal, REG_GE_CMD, 0x30);
1620
1621 while (MsOS_WaitEvent(s32GeWaitTagEventHandle, 0x1, &event, E_OR_CLEAR, GE_TAG_INTERRUPT_WAITING_TIME) == FALSE)
1622 {
1623 tagID_HW = GE_ReadReg(pGEHalLocal, REG_GE_TAG_L);
1624 if (direct_serial_diff(tagID_HW, tagID) >= 0)
1625 {
1626 break;
1627 }
1628
1629 timeout_count++;
1630
1631 if ((bHadPrintOutDbgMsg == FALSE) && (timeout_count > GE_TAG_INTERRUPT_DEBUG_PRINT_THRESHOLD))
1632 {
1633 _GE_Print_GeWaitTagTimeout_Msg(pGEHalLocal, tagID);
1634 bHadPrintOutDbgMsg = TRUE;
1635 }
1636
1637 if(GE_ReadReg(pGEHalLocal, REG_GE_STAT) & GE_STAT_BUSY)
1638 continue;
1639
1640 break;
1641 }
1642
1643 // mask ge interrupt
1644 s32WaitingTagPid = 0;
1645 _GE_Ctrl_IntMode(pGEHalLocal, E_GE_MASK_INT);
1646
1647 #endif
1648
1649 while(1)
1650 {
1651 tagID_HW = GE_ReadReg(pGEHalLocal, REG_GE_TAG_L);
1652 if(direct_serial_diff(tagID_HW, tagID) >= 0)
1653 {
1654 //printf("tagIDHW = %04x %04x\n", tagID_HW, tagID);
1655 break;
1656 }
1657
1658 u32Temp = GE_ReadReg(pGEHalLocal, REG_GE_STAT);
1659 if((u32Temp&GE_STAT_CMDQ_MASK) < (16UL<<11))
1660 {
1661 GE_YIELD();
1662 continue;
1663 }
1664 if((u32Temp&GE_STAT_CMDQ2_MASK) < (16UL<<3))
1665 {
1666 GE_YIELD();
1667 continue;
1668 }
1669 if(GE_ReadReg(pGEHalLocal, REG_GE_CFG) & GE_CFG_VCMDQ)
1670 {
1671 u32Temp = GE_ReadReg(pGEHalLocal, REG_GE_VCMDQ_STAT);
1672 u32Temp |= (GE_ReadReg(pGEHalLocal, REG_GE_BIST_STAT)&1)<<16;
1673 if(u32Temp)
1674 continue;
1675 }
1676
1677 if(GE_ReadReg(pGEHalLocal, REG_GE_STAT) & GE_STAT_BUSY)
1678 continue;
1679
1680 break;
1681 }
1682
1683 return E_GE_OK;
1684 }
1685 //-------------------------------------------------------------------------------------------------
1686 /// MDrv_GE_SAVE_CHIP_IMAGE
1687 //-------------------------------------------------------------------------------------------------
GE_Restore_HAL_Context(GE_CTX_HAL_LOCAL * pGEHalLocal)1688 GE_Result GE_Restore_HAL_Context(GE_CTX_HAL_LOCAL *pGEHalLocal)
1689 {
1690 MS_U16 i = 0;
1691 MS_U16 u16RegVal;
1692
1693 //GE_WaitIdle(pGEHalLocal);
1694
1695 while( (_GE_Reg_Backup[i] != 0xFF) )
1696 {
1697 if(_GE_Reg_Backup[i]>= 0x80)
1698 {
1699 break;
1700 }
1701
1702 u16RegVal = GE_ReadReg(pGEHalLocal, _GE_Reg_Backup[i]);
1703 GE_RestoreReg(pGEHalLocal, _GE_Reg_Backup[i], u16RegVal);
1704 i++;
1705 }
1706
1707 //GE_DBG(printf("GE_Restore_HAL_Context finished \n\n"));
1708
1709 return E_GE_OK;
1710 }
1711
1712 //-------------------------------------------------------------------------------------------------
1713 /// Calculate Blit Scale Ratio:
1714 //-------------------------------------------------------------------------------------------------
GE_CalcBltScaleRatio(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 u16SrcWidth,MS_U16 u16SrcHeight,MS_U16 u16DstWidth,MS_U16 u16DstHeight,GE_ScaleInfo * pScaleinfo)1715 GE_Result GE_CalcBltScaleRatio(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 u16SrcWidth, MS_U16 u16SrcHeight, MS_U16 u16DstWidth, MS_U16 u16DstHeight, GE_ScaleInfo *pScaleinfo)
1716 {
1717 if(NULL == pScaleinfo)
1718 {
1719 return E_GE_FAIL_PARAM;
1720 }
1721
1722 if(u16SrcWidth >= (u16DstWidth<< g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1723 {
1724 pScaleinfo->x = 0xFFFFFFFF;
1725 }
1726 else
1727 {
1728 pScaleinfo->x = GE_Divide2Fixed(u16SrcWidth, u16DstWidth, g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin, 12);
1729 }
1730
1731 if(u16SrcHeight >= (u16DstHeight<< g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1732 {
1733 pScaleinfo->y = 0xFFFFFFFF;
1734 }
1735 else
1736 {
1737 pScaleinfo->y = GE_Divide2Fixed(u16SrcHeight, u16DstHeight, g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin, 12);
1738 }
1739
1740 /* HW use format S0.12 which means Bit(12) should be Sign bit
1741 // If overflow, S bit maybe wrong, handle it as actually value we hoped*/
1742 pScaleinfo->init_x = GE_Divide2Fixed(u16SrcWidth-u16DstWidth, 2 * u16DstWidth, 0, 12);
1743 if((u16SrcWidth/4) > u16DstWidth)
1744 {
1745 pScaleinfo->init_x = 0x1000;
1746 }
1747 else if(u16SrcWidth >= u16DstWidth)
1748 {
1749 pScaleinfo->init_x &= (~(1<<12));
1750 }
1751 else
1752 {
1753 pScaleinfo->init_x |= (1<<12);
1754 }
1755
1756 pScaleinfo->init_y = GE_Divide2Fixed(u16SrcHeight-u16DstHeight, 2 * u16DstHeight, 0, 12);
1757 if((u16SrcHeight/4) > u16DstHeight)
1758 {
1759 pScaleinfo->init_y = 0x1000;
1760 }
1761 else if(u16SrcHeight >= u16DstHeight)
1762 {
1763 pScaleinfo->init_y &= (~(1<<12));
1764 }
1765 else
1766 {
1767 pScaleinfo->init_y |= (1<<12);
1768 }
1769
1770 if (pGEHalLocal->bYScalingPatch)
1771 {
1772 if (u16SrcHeight<=5)
1773 pScaleinfo->init_y = (1<<12);
1774 }
1775 return E_GE_OK;
1776 }
1777
1778 //-------------------------------------------------------------------------------------------------
1779 /// Set GE scale register
1780 /// @param GE_Rect *src \b IN: src coordinate setting
1781 /// @param GE_DstBitBltType *dst \b IN: dst coordinate setting
1782 /// @return @ref GE_Result
1783 //-------------------------------------------------------------------------------------------------
GE_SetBltScaleRatio(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Rect * src,GE_DstBitBltType * dst,GE_Flag flags,GE_ScaleInfo * scaleinfo)1784 GE_Result GE_SetBltScaleRatio(GE_CTX_HAL_LOCAL *pGEHalLocal,GE_Rect *src, GE_DstBitBltType *dst, GE_Flag flags, GE_ScaleInfo* scaleinfo)
1785 {
1786 GE_ScaleInfo geScaleinfo, *pGeScaleInfo = scaleinfo;
1787
1788 if(flags & E_GE_FLAG_BYPASS_STBCOEF)
1789 {
1790 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1791 }
1792 else if (flags & E_GE_FLAG_BLT_STRETCH)
1793 {
1794 /* Safe Guard. Prevent set scaling ratio < 1/32. Also prevent 0 h/w */
1795 if ((src->width-1) >= (dst->dstblk.width << g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1796 {
1797 if(pGEHalLocal->bIsComp == FALSE)
1798 {
1799 return E_GE_FAIL_PARAM;
1800 }
1801
1802 dst->dstblk.width = ((src->width-1) >> g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin) + 1;
1803 }
1804 if ((src->height-1) >= (dst->dstblk.height << g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1805 {
1806 if(pGEHalLocal->bIsComp == FALSE)
1807 {
1808 return E_GE_FAIL_PARAM;
1809 }
1810
1811 dst->dstblk.height = ((src->height-1) >> g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin) + 1;
1812 }
1813
1814 pGeScaleInfo = &geScaleinfo;
1815 GE_CalcBltScaleRatio(pGEHalLocal, src->width, src->height, dst->dstblk.width, dst->dstblk.height, pGeScaleInfo);
1816 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1817 }
1818 else
1819 {
1820 pGeScaleInfo = &geScaleinfo;
1821
1822 pGeScaleInfo->x = (1<<12);
1823 pGeScaleInfo->y = (1<<12);
1824 pGeScaleInfo->init_x = 0;
1825 pGeScaleInfo->init_y = 0;
1826
1827 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1828 }
1829
1830 return E_GE_OK;
1831 }
1832
GE_BitBltEX_Trape(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Rect * pSrcRect,GE_Normalized_Trapezoid * pGENormTrapezoid,MS_U32 u32Flags,GE_ScaleInfo * pScaleinfo)1833 GE_Result GE_BitBltEX_Trape(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_Rect *pSrcRect, GE_Normalized_Trapezoid *pGENormTrapezoid, MS_U32 u32Flags, GE_ScaleInfo* pScaleinfo)
1834 {
1835 return E_GE_NOT_SUPPORT;
1836 }
1837
1838 //-------------------------------------------------------------------------------------------------
1839 /// GE Primitive Drawing - TRAPEZOID
1840 /// @param pGENormTrapezoid \b IN: pointer to position of TRAPEZOID
1841 /// @param u32ColorS \b IN: start color of TRAPEZOID when gradient
1842 /// @param u32ColorE \b IN: end color of TRAPEZOID when gradient
1843 /// @param pColorDeltaX \b IN: x gradient color
1844 /// @param pColorDeltaY \b IN: y gradient color
1845 /// @return @ref GE_Result
1846 //-------------------------------------------------------------------------------------------------
GE_FillTrapezoid(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bYTrapezoid,GE_Normalized_Trapezoid * pGENormTrapezoid,MS_U32 u32Color,GE_ColorDelta * pColorDeltaX,GE_ColorDelta * pColorDeltaY)1847 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)
1848 {
1849 return E_GE_NOT_SUPPORT;
1850 }
1851
1852 //-------------------------------------------------------------------------------------------------
1853 /// Set GE DISABLE MIU ACCESS
1854 /// @param enable \b IN: enable and update setting
1855 /// @return @ref GE_Result
1856 //-------------------------------------------------------------------------------------------------
GE_SetDisaMIUAccess(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1857 GE_Result GE_SetDisaMIUAccess(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1858 {
1859 MS_U16 u16en;
1860
1861 GE_DBG("%s\n", __FUNCTION__);
1862
1863 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1864 if (enable)
1865 {
1866 u16en |= GE_CFG_DISABLE_MIU_ACS;
1867 }
1868 else
1869 {
1870 u16en &= ~GE_CFG_DISABLE_MIU_ACS;
1871 }
1872 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1873
1874 return E_GE_OK;
1875 }
1876 //-------------------------------------------------------------------------------------------------
1877 /// Set GE Clear Invalid MIU Flag
1878 /// @param enable \b IN: enable and update setting
1879 /// @return @ref GE_Result
1880 //-------------------------------------------------------------------------------------------------
GE_ClrInvalMIUFlg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1881 GE_Result GE_ClrInvalMIUFlg(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1882 {
1883 MS_U16 u16en;
1884
1885 GE_DBG("%s\n", __FUNCTION__);
1886
1887 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1888 if (enable)
1889 {
1890 u16en |= GE_CFG_CLR_MIU_FLG;
1891 }
1892 else
1893 {
1894 u16en &= ~GE_CFG_CLR_MIU_FLG;
1895 }
1896 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1897
1898 return E_GE_OK;
1899 }
1900
1901 //-------------------------------------------------------------------------------------------------
1902 /// Set Enable Dynamic Clock Gating
1903 /// @param enable \b IN: enable and update setting
1904 /// @return @ref GE_Result
1905 //-------------------------------------------------------------------------------------------------
GE_EnableDynaClkGate(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1906 GE_Result GE_EnableDynaClkGate(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1907 {
1908 MS_U16 u16en;
1909
1910 GE_DBG("%s\n", __FUNCTION__);
1911
1912 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1913 if (enable)
1914 {
1915 u16en |= GE_CFG_EN_DNY_CLK_GATE;
1916 }
1917 else
1918 {
1919 u16en &= ~GE_CFG_EN_DNY_CLK_GATE;
1920 }
1921 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1922
1923 return E_GE_OK;
1924 }
1925
GE_EnableTrapezoidAA(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1926 GE_Result GE_EnableTrapezoidAA(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1927 {
1928 //GE_DBG("%s\n", __FUNCTION__);
1929
1930 return E_GE_NOT_SUPPORT;
1931
1932 }
1933
GE_EnableTrapSubPixCorr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1934 GE_Result GE_EnableTrapSubPixCorr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1935 {
1936 //GE_DBG("%s\n", __FUNCTION__);
1937
1938 return E_GE_NOT_SUPPORT;
1939
1940 }
1941
GE_GetNextTAGID(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bStepTagBefore)1942 MS_U16 GE_GetNextTAGID(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bStepTagBefore)
1943 {
1944 MS_U16 tagID;
1945 if(bStepTagBefore)
1946 {
1947 if(0 == ++pGEHalLocal->pHALShared->global_tagID)
1948 ++pGEHalLocal->pHALShared->global_tagID;
1949 }
1950 tagID =pGEHalLocal->pHALShared->global_tagID;
1951
1952 return tagID;
1953 }
1954
GE_SetVCmdBuffer(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHYADDR u32Addr,GE_VcmqBufSize enBufSize)1955 GE_Result GE_SetVCmdBuffer(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHYADDR u32Addr, GE_VcmqBufSize enBufSize)
1956 {
1957 MS_U16 u16RegVal;
1958 MS_U16 i=0;
1959
1960 if(enBufSize >= E_GE_VCMD_1024K)
1961 {
1962 return E_GE_NOT_SUPPORT;
1963 }
1964
1965 GE_SetVQBufMIUId(pGEHalLocal, _GFXAPI_MIU_ID(u32Addr));
1966 u32Addr = GE_ConvertAPIAddr2HAL(pGEHalLocal, _GFXAPI_MIU_ID(u32Addr), _GFXAPI_PHYS_ADDR_IN_MIU(u32Addr));
1967
1968 #ifdef GE_VQ_MIU_HANG_PATCH
1969 pGEHalLocal->pHALShared->u8VCmdQMiu = _GFXAPI_MIU_ID(u32Addr);
1970 #endif
1971
1972 #if GE_VQADDR_LOCK_PATCH
1973 for (i=0; i<GE_VQADDR_ENHANCE_LOCK_TIMES; i++)
1974 {
1975 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_H, u32Addr >> 16); // Address
1976 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_L, u32Addr & 0xffff); // Address
1977 }
1978 #else
1979 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_L, u32Addr & 0xffff); // Address
1980 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_H, u32Addr >> 16); // Address
1981 #endif
1982
1983 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_VCMDQ_SIZE) & ~GE_VCMDQ_SIZE_MASK) | ((GE_MapVQ2Reg(enBufSize) & GE_VCMDQ_SIZE_MASK));
1984 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_SIZE, u16RegVal);
1985
1986 return E_GE_OK;
1987 }
1988
GE_InitCtxHalPalette(GE_CTX_HAL_LOCAL * pGEHalLocal)1989 GE_Result GE_InitCtxHalPalette(GE_CTX_HAL_LOCAL *pGEHalLocal)
1990 {
1991 MS_U32 u32Idx;
1992
1993 for(u32Idx=0; u32Idx<GE_PALETTE_NUM; u32Idx++)
1994 {
1995 GE_WriteReg(pGEHalLocal, REG_GE_CLUT_CTRL, ((u32Idx) & GE_CLUT_CTRL_IDX_MASK) | GE_CLUT_CTRL_RD);
1996 GE_WaitIdle(pGEHalLocal);
1997 pGEHalLocal->u32Palette[u32Idx] = ByteSwap32(((GE_ReadReg(pGEHalLocal, REG_GE_CLUT_H)<<16) | GE_ReadReg(pGEHalLocal, REG_GE_CLUT_L)));
1998 }
1999
2000 pGEHalLocal->bPaletteDirty = FALSE;
2001
2002 return (E_GE_OK);
2003 }
2004
GE_Init_HAL_Context(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_CTX_HAL_SHARED * pHALShared,MS_BOOL bNeedInitShared)2005 void GE_Init_HAL_Context(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_CTX_HAL_SHARED *pHALShared, MS_BOOL bNeedInitShared)
2006 {
2007 memset(pGEHalLocal, 0, sizeof(*pGEHalLocal));
2008
2009 if(bNeedInitShared)
2010 {
2011 memset(pHALShared, 0, sizeof(*pHALShared));
2012 pHALShared->global_tagID = 1;
2013 }
2014 pGEHalLocal->pHALShared = pHALShared;
2015 pGEHalLocal->bYScalingPatch = FALSE;
2016 }
2017
GE_Set_IOMap_Base2(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U32 addr)2018 GE_Result GE_Set_IOMap_Base2(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U32 addr)
2019 {
2020 pGEHalLocal->u32_mmio_base2 = addr;
2021 return E_GE_OK;
2022 }
2023
GE_SetClock(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bOnOff)2024 GE_Result GE_SetClock(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bOnOff)
2025 {
2026 MS_U8 u8tmp = 0;
2027
2028 u8tmp = READ_BYTE( pGEHalLocal->u32_mmio_base + (CHIP_CLK_BASE) + CHIP_GE_CLK);
2029
2030 if (bOnOff)
2031 {
2032 u8tmp &= ~ BIT(0);
2033 }
2034 else
2035 {
2036 u8tmp |= BIT(0);
2037 }
2038 WRITE_BYTE(pGEHalLocal->u32_mmio_base + (CHIP_CLK_BASE) + CHIP_GE_CLK, u8tmp);
2039 return E_GE_OK;
2040
2041 }
2042
GE_NonOnePixelModeCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,PatchBitBltInfo * patchInfo)2043 MS_BOOL GE_NonOnePixelModeCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, PatchBitBltInfo* patchInfo)
2044 {
2045 GE_ScaleInfo geScaleinfo;
2046 GE_Result ret;
2047
2048 patchInfo->scaleinfo =&geScaleinfo;
2049 ret = GE_CalcBltScaleRatio(pGEHalLocal, patchInfo->src.width , patchInfo->src.height ,patchInfo->dst.dstblk.width , patchInfo->dst.dstblk.height, patchInfo->scaleinfo);
2050
2051 if(ret == E_GE_FAIL_PARAM)
2052 {
2053 return pGEHalLocal->pGeChipPro->bFourPixelModeStable;
2054 }
2055 else if ((patchInfo->scaleinfo->init_x>0xFFF)||(patchInfo->scaleinfo->init_y>0xFFF))
2056 {
2057 return FALSE;
2058 }
2059 else
2060 {
2061 return pGEHalLocal->pGeChipPro->bFourPixelModeStable;
2062 }
2063 }
2064
HAL_GE_EnableCalcSrc_WidthHeight(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)2065 GE_Result HAL_GE_EnableCalcSrc_WidthHeight(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
2066 {
2067 MS_U16 u16en;
2068
2069 u16en = GE_ReadReg(pGEHalLocal, REG_GE_EN);
2070
2071 if(bEnable)
2072 {
2073 if(u16en & GE_EN_BURST)
2074 {
2075 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en | GE_EN_CALC_SRC_WH);
2076 }
2077 }
2078 else
2079 {
2080 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en & (~GE_EN_CALC_SRC_WH));
2081 }
2082
2083 return E_GE_OK;
2084 }
2085
GEWD_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 * value)2086 GE_Result GEWD_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16* value)
2087 {
2088 //For two source buffer read register
2089 return E_GE_NOT_SUPPORT;
2090 }
2091
GEWD_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)2092 GE_Result GEWD_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
2093 {
2094 //For two source buffer write register
2095 return E_GE_NOT_SUPPORT;
2096 }
2097
GE_SetTLBMode(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_TLB_Mode tlb_type)2098 GE_Result GE_SetTLBMode(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_TLB_Mode tlb_type)
2099 {
2100 MS_U16 u16cmd = 0;
2101
2102 u16cmd = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_TYPE_EN)&(~GE_TLB_MODE_MASK);
2103
2104 if(tlb_type == (u16cmd>>1))
2105 {
2106 return E_GE_OK;
2107 }
2108 else
2109 {
2110 switch(tlb_type)
2111 {
2112 case E_GE_TLB_NONE:
2113 break;
2114 case E_GE_TLB_SRC:
2115 u16cmd |= GE_TLB_SRC;
2116 break;
2117 case E_GE_TLB_DST:
2118 u16cmd |= GE_TLB_DST;
2119 break;
2120 case E_GE_TLB_SRC_DST:
2121 u16cmd |= (GE_TLB_SRC|GE_TLB_DST);
2122 break;
2123 default:
2124 printf("[%s,%5d]Do Nothing: Invalid TLB Format\n",__FUNCTION__,__LINE__);
2125 return E_GE_FAIL;
2126 }
2127 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TYPE_EN, u16cmd);
2128 }
2129 return E_GE_OK;
2130 }
2131
GE_GetTLBSRCADDR(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHYADDR * addr)2132 GE_Result GE_GetTLBSRCADDR(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHYADDR* addr)
2133 {
2134 MS_U16 miu=0;
2135
2136 miu= (GE2_ReadReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_H)&0x8000)>>15;
2137 *addr = ((GE2_ReadReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_H)&0x7fff)<<16)|GE2_ReadReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_L);
2138
2139 if(miu==1)
2140 {
2141 *addr += HAL_MIU1_BASE;
2142 }
2143 return E_GE_OK;
2144 }
2145
GE_GetTLBDSTADDR(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHYADDR * addr)2146 GE_Result GE_GetTLBDSTADDR(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHYADDR* addr)
2147 {
2148 MS_U16 miu=0;
2149
2150 miu= (GE2_ReadReg(pGEHalLocal, REG_GE_DST_TLB_BASE_H)&0x8000)>>15;
2151 *addr = ((GE2_ReadReg(pGEHalLocal, REG_GE_DST_TLB_BASE_H)&0x7fff)<<16)|GE2_ReadReg(pGEHalLocal, REG_GE_DST_TLB_BASE_L);
2152
2153 if(miu==1)
2154 {
2155 *addr += HAL_MIU1_BASE;
2156 }
2157
2158 return E_GE_OK;
2159 }
2160
GE_SetTLBSrcBaseAddr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHYADDR addr)2161 GE_Result GE_SetTLBSrcBaseAddr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHYADDR addr)
2162 {
2163 MS_U16 regval=0;
2164 MS_U8 u8miu=0;
2165 MS_U32 u32offset=0;
2166
2167 u8miu= _GFXAPI_MIU_ID(addr);
2168 u32offset=_GFXAPI_PHYS_ADDR_IN_MIU(addr);
2169
2170 if(u8miu==0)
2171 {
2172 GE2_WriteReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_L, u32offset);
2173 GE2_WriteReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_H, (u32offset&0x7fff0000)>>16);
2174 regval= GE2_ReadReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H)&(~GE_SB_TLB_SRC_MIU_SEL_H);
2175 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H, regval);
2176 }
2177 else if(u8miu==1)
2178 {
2179 GE2_WriteReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_L, u32offset);
2180 GE2_WriteReg(pGEHalLocal, REG_GE_SRC_TLB_BASE_H, ((u32offset&0x7fff0000)>>16)|(u8miu<<15));
2181 regval= GE2_ReadReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H)&(~GE_SB_TLB_SRC_MIU_SEL_H);
2182 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H, regval);
2183 }
2184 else
2185 {
2186 return E_GE_FAIL;
2187 }
2188
2189 return E_GE_OK;
2190 }
2191
GE_SetTLBDstBaseAddr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHYADDR addr)2192 GE_Result GE_SetTLBDstBaseAddr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHYADDR addr)
2193 {
2194 MS_U16 regval=0;
2195 MS_U8 u8miu=0;
2196 MS_U32 u32offset=0;
2197
2198 u8miu= _GFXAPI_MIU_ID(addr);
2199 u32offset=_GFXAPI_PHYS_ADDR_IN_MIU(addr);
2200
2201 if(u8miu==0)
2202 {
2203 GE2_WriteReg(pGEHalLocal, REG_GE_DST_TLB_BASE_L, u32offset);
2204 GE2_WriteReg(pGEHalLocal, REG_GE_DST_TLB_BASE_H, ((u32offset&0x7fff0000)>>16));
2205 regval= GE2_ReadReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H)&(~GE_SB_TLB_DST_MIU_SEL_H);
2206 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H, regval);
2207 }
2208 else if(u8miu==1)
2209 {
2210 GE2_WriteReg(pGEHalLocal, REG_GE_DST_TLB_BASE_L, u32offset);
2211 GE2_WriteReg(pGEHalLocal, REG_GE_DST_TLB_BASE_H, ((u32offset&0x7fff0000)>>16)|(u8miu<<15));
2212 regval= GE2_ReadReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H)&(~GE_SB_TLB_DST_MIU_SEL_H);
2213 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_BASE_MIU_H, regval);
2214 }
2215 else
2216 {
2217 return E_GE_FAIL;
2218 }
2219
2220 return E_GE_OK;
2221 }
2222
GE_FlushTLBTable(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)2223 GE_Result GE_FlushTLBTable(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
2224 {
2225 MS_U16 u16en;
2226
2227 u16en = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_TYPE_EN);
2228
2229 if(bEnable)
2230 {
2231 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TYPE_EN, u16en|GE_TLB_FLUSH);
2232 }
2233 else
2234 {
2235 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TYPE_EN, u16en&(~GE_TLB_FLUSH));
2236 }
2237
2238 return E_GE_OK;
2239 }
2240
GE_SetTLBTag(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tag)2241 GE_Result GE_SetTLBTag(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tag)
2242 {
2243 MS_U16 reg_val;
2244
2245 reg_val = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_TAG)&(~GE_TLB_TAG);
2246 reg_val |= tag;
2247
2248 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TAG, reg_val);
2249
2250 return E_GE_OK;
2251 }
2252
GE_StopFlushTLB(GE_CTX_HAL_LOCAL * pGEHalLocal)2253 GE_Result GE_StopFlushTLB(GE_CTX_HAL_LOCAL *pGEHalLocal)
2254 {
2255 MS_U16 u16en;
2256
2257 u16en = GE2_ReadReg(pGEHalLocal, REG_GE_TLB_TYPE_EN);
2258
2259 GE2_WriteReg(pGEHalLocal, REG_GE_TLB_TYPE_EN, u16en & (~GE_TLB_FLUSH));
2260
2261 return E_GE_OK;
2262 }
2263
GE_Get_MIU_INTERVAL(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 miu,MS_U32 * value)2264 GE_Result GE_Get_MIU_INTERVAL(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 miu, MS_U32* value)
2265 {
2266 #ifdef MSOS_TYPE_LINUX
2267 if(miu)
2268 {
2269 *value = MIU_INTERVAL;
2270 }
2271 else
2272 {
2273 *value = 0;
2274 }
2275 #else
2276 *value = 0;
2277 #endif
2278 return E_GE_OK;
2279 }
2280
HAL_GE_AdjustDstWin(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bDstXInv)2281 GE_Result HAL_GE_AdjustDstWin( GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bDstXInv )
2282 {
2283 MS_U16 u16ClipL=0,u16ClipR=0;
2284 MS_U16 u16DstX=0;
2285
2286 u16DstX = GE_ReadReg(pGEHalLocal, REG_GE_PRIM_V1_X);
2287 if( bDstXInv==FALSE )
2288 {
2289 u16ClipR = GE_ReadReg(pGEHalLocal, REG_GE_CLIP_R);
2290 if( u16ClipR < u16DstX )
2291 {
2292 GE_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, u16ClipR);
2293 }
2294 }
2295 else
2296 {
2297 u16ClipL = GE_ReadReg(pGEHalLocal, REG_GE_CLIP_L);
2298 if( u16ClipL > u16DstX )
2299 {
2300 GE_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, u16ClipL);
2301 }
2302 }
2303
2304 return E_GE_OK;
2305 }
2306
HAL_GE_AdjustRotateDstWin(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8Rotate)2307 GE_Result HAL_GE_AdjustRotateDstWin( GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8Rotate )
2308 {
2309 return E_GE_NOT_SUPPORT;
2310 }
2311
2312
HAL_GE_exit(GE_CTX_HAL_LOCAL * pGEHalLocal)2313 GE_Result HAL_GE_exit(GE_CTX_HAL_LOCAL *pGEHalLocal)
2314 {
2315 #if (__GE_WAIT_TAG_MODE == __USE_GE_INT_MODE)
2316 if (TRUE == MsOS_DetachInterrupt(E_INT_IRQ_GE))
2317 {
2318 bGeIrqInited = FALSE;
2319 }
2320
2321 if (s32GeWaitTagEventHandle > 0)
2322 {
2323 if (TRUE == MsOS_DeleteEventGroup(s32GeWaitTagEventHandle))
2324 {
2325 s32GeWaitTagEventHandle = -1;
2326 }
2327 }
2328 #endif
2329
2330 return E_GE_OK;
2331 }
2332
HAL_GE_SetBurstMiuLen(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable,MS_U32 u32BurstLen)2333 GE_Result HAL_GE_SetBurstMiuLen(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL bEnable,MS_U32 u32BurstLen)
2334 {
2335 MS_U16 u16Reg = 0;
2336
2337 u16Reg = GE_ReadReg(pGEHalLocal, REG_GE_DBG);
2338 u16Reg &= ( ~GE_DBG_MIU_MAX_LEG );
2339 u16Reg |= ( ((u32BurstLen - 1)<<8) & GE_DBG_MIU_MAX_LEG );
2340 GE_WriteReg(pGEHalLocal, REG_GE_DBG, u16Reg);
2341
2342 u16Reg = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
2343 if(bEnable)
2344 u16Reg |= GE_CFG_LENGTH_LIMIT;
2345 else
2346 u16Reg &= (~GE_CFG_LENGTH_LIMIT);
2347 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16Reg);
2348
2349 return E_GE_OK;
2350 }
2351
2352