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