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 // 128MB
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...) GE_H_DBUG(_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 GE_H_INFO("Dump GE register:\n");
252 for (i = 0; i < 0x80; i++)
253 {
254 if(i % 0x08 == 0) {
255 GE_H_INFO(" \n");
256 GE_H_INFO("h%02x ", (MS_U8)i );
257 }
258 GE_H_INFO("%04x ", GE_REG(i) );
259 }
260
261 GE_H_INFO(" \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 GE_H_ERR("\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_4K;
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 GE_H_INFO("[GE] V0 Wait command queue: %d : %tx, %tx\n", tmp1, (ptrdiff_t)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 GE_H_INFO("[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 GE_H_INFO("[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)
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 GE_H_INFO("[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 GE_H_INFO("[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 GE_H_DBUG("[%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 MS_U16 u16NoFIFOMask=0;
725
726 if(GE_TABLE_REGNUM <= addr)
727 {
728 GE_WaitIdle(pGEHalLocal);
729 return GE2_REG(addr-GE_TABLE_REGNUM);
730 }
731
732 if(0 == u16NoFIFOMask)
733 {
734 if(GE_Map_Share_RegEX(pGEHalLocal,addr)== E_GE_OK)
735 return pGEHalLocal->pHALShared->u16ShareRegImageEx[addr];
736 else
737 {
738 if(pGEHalLocal->pHALShared->bGE_DirectToReg ==TRUE)
739 {
740 return (GE_REG(addr)|pGEHalLocal->u16RegGETable[addr]);
741 }
742 else
743 {
744 return pGEHalLocal->u16RegGETableEX[addr];
745 }
746 }
747 }
748 return (GE2_REG(addr)&u16NoFIFOMask)|(pGEHalLocal->u16RegGETableEX[addr]&~u16NoFIFOMask);
749
750 }
751
GE2_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)752 void GE2_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
753 {
754 // CMDQ special command
755 if(addr < GE_TABLE_REGNUM)
756 {
757 if(GE_Map_Share_RegEX(pGEHalLocal,addr)== E_GE_OK)
758 {
759 pGEHalLocal->pHALShared->u16ShareRegImageEx[addr]= value;
760 }
761 pGEHalLocal->u16RegGETableEX[addr] = value;
762 }
763 else
764 {
765 GE_H_DBUG("[%s][%d] Reg Index [%x]is out of GE_TABLE_REGNUM [0x%lx]range!!!!\n",__FUNCTION__,__LINE__, addr, GE_TABLE_REGNUM);
766 }
767 GE_WaitCmdQAvail(pGEHalLocal, GE_CMD_SIZE);
768 GE2_REG(addr)= value;
769 return;
770 }
771
772
GE_RestoreReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)773 void GE_RestoreReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
774 {
775 // CMDQ special command
776 switch (addr)
777 {
778 case REG_GE_CMD:
779 break;
780 //[OBSOLETE]
781 default:
782 GE_WriteReg(pGEHalLocal, addr, value);
783 break;
784 }
785 }
786
787
GE_ResetState(GE_CTX_HAL_LOCAL * pGEHalLocal)788 void GE_ResetState(GE_CTX_HAL_LOCAL *pGEHalLocal)
789 {
790 GE_WaitIdle(pGEHalLocal);
791
792 GE_WriteReg(pGEHalLocal, REG_GE_EN, GE_EN_GE);
793 #if GE_DITHER_RAND_ENABLE
794 GE_WriteReg(pGEHalLocal, REG_GE_EN, GE_EN_GE | GE_EN_DITHER_RAND); //fixed random dither by default
795 #endif
796 GE_WriteReg(pGEHalLocal, REG_GE_TH, 0x0000); //0(<half) will be default to be half
797
798 GE_WriteReg(pGEHalLocal, REG_GE_LINE_STYLE, GE_LINEPAT_RST);
799 GE_WriteReg(pGEHalLocal, REG_GE_BLT_SCK_MODE, GE_BLT_SCK_NEAREST);
800 GE_WriteReg(pGEHalLocal, REG_GE_BLEND, GE_ALPHA_ARGB1555); //force alpha constant of ARGB"1"555 to be 1.0 by default
801 }
802
803
GE_Init_RegImage(GE_CTX_HAL_LOCAL * pGEHalLocal)804 void GE_Init_RegImage(GE_CTX_HAL_LOCAL *pGEHalLocal)
805 {
806 MS_U8 addr;
807
808 for(addr = 0; addr<GE_TABLE_REGNUM; addr++)
809 {
810 if(GE_Map_Share_Reg(pGEHalLocal,addr)== E_GE_OK)
811 pGEHalLocal->pHALShared->u16ShareRegImage[addr]= GE_REG(addr);
812 pGEHalLocal->u16RegGETable[addr] = GE_REG(addr);
813 }
814
815 }
816
GE_Init(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Config * cfg)817 void GE_Init(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_Config *cfg)
818 {
819 MS_U16 u16temp =0;
820
821 GE_WaitIdle(pGEHalLocal);
822
823 GE_SetClock(pGEHalLocal,TRUE);
824
825 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
826
827 if ((u16temp & BIT(1)) != BIT(1)) //if VQ is Not Enabled
828 {
829 #if GE_CMDQ_ENABLE
830 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
831 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16temp | GE_CFG_CMDQ); // enable command queue
832 #endif
833
834 // Set default FMT for avoiding 1st set buffinfo error.
835 GE_WriteReg(pGEHalLocal, REG_GE_FMT, (GE_FMT_ARGB1555<<GE_SRC_FMT_SHFT)+(GE_FMT_ARGB1555<<GE_DST_FMT_SHFT));
836
837 if (cfg->u32VCmdQSize >= GE_VCMDQ_SIZE_MIN)
838 {
839 MS_PHYADDR u32VQAddr = cfg->PhyVCmdQAddr;
840 MS_U32 u32VcmdqBufSz = cfg->u32VCmdQSize;
841
842 GE_SetVCmdBuffer(pGEHalLocal, u32VQAddr, u32VcmdqBufSz);
843
844 u16temp = GE_ReadReg(pGEHalLocal, REG_GE_CFG);
845 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16temp | GE_CFG_VCMDQ);
846 }
847
848 GE_ResetState(pGEHalLocal);
849 }
850 else
851 {
852 //No need to set command queue
853 GE_H_DBUG(" warning!!! Virtual Command queue has been activated!! \n");
854 }
855 //GE_Init_RegImage(pGEHalLocal);
856
857 GE_WriteReg(pGEHalLocal, REG_GE_TH, GE_THRESHOLD_SETTING);
858 //Mask Interrupt
859 GE_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, 0x00C0);
860
861 }
862
GE_SetRotate(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RotateAngle geRotAngle)863 GE_Result GE_SetRotate(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RotateAngle geRotAngle)
864 {
865 MS_U16 u16RegVal;
866
867 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_ROT_MODE) & ~REG_GE_ROT_MODE_MASK) | (geRotAngle<<REG_GE_ROT_MODE_SHFT);
868 GE_WriteReg(pGEHalLocal, REG_GE_ROT_MODE, u16RegVal);
869
870 return E_GE_OK;
871 }
872
GE_SetOnePixelMode(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)873 GE_Result GE_SetOnePixelMode(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
874 {
875
876 MS_U16 u16en;
877 //GE_DBG("%s\n", __FUNCTION__);
878
879 u16en = GE_ReadReg(pGEHalLocal, REG_GE_EN);
880 if (enable)
881 {
882 u16en |= GE_EN_ONE_PIXEL_MODE;
883 }
884 else
885 {
886 u16en &= (~GE_EN_ONE_PIXEL_MODE);
887 }
888 u16en |= GE_EN_BURST;
889 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en);
890
891 return E_GE_OK;
892 }
893
GE_SetBlend(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_BlendOp eBlendOp)894 GE_Result GE_SetBlend(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_BlendOp eBlendOp)
895 {
896 MS_U16 u16op;
897
898 switch (eBlendOp)
899 {
900 case E_GE_BLEND_ONE:
901 case E_GE_BLEND_CONST:
902 case E_GE_BLEND_ASRC:
903 case E_GE_BLEND_ADST:
904 case E_GE_BLEND_ROP8_ALPHA:
905 case E_GE_BLEND_ROP8_SRCOVER:
906 case E_GE_BLEND_ROP8_DSTOVER:
907 case E_GE_BLEND_ZERO:
908 case E_GE_BLEND_CONST_INV:
909 case E_GE_BLEND_ASRC_INV:
910 case E_GE_BLEND_ADST_INV:
911 case E_GE_BLEND_ALPHA_ADST:
912 case E_GE_BLEND_SRC_ATOP_DST:
913 case E_GE_BLEND_DST_ATOP_SRC:
914 case E_GE_BLEND_SRC_XOR_DST:
915 case E_GE_BLEND_INV_CONST:
916
917 u16op = eBlendOp;
918 break;
919 default:
920 return E_GE_FAIL_PARAM;
921 break;
922 }
923
924 u16op = (GE_ReadReg(pGEHalLocal, REG_GE_BLEND) & ~GE_BLEND_MASK) | u16op;
925 GE_WriteReg(pGEHalLocal, REG_GE_BLEND, u16op);
926
927 return E_GE_OK;
928 }
929
930
GE_SetAlpha(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_AlphaSrc eAlphaSrc)931 GE_Result GE_SetAlpha(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_AlphaSrc eAlphaSrc)
932 {
933 MS_U16 u16src;
934
935 switch (eAlphaSrc)
936 {
937 case E_GE_ALPHA_CONST:
938 case E_GE_ALPHA_ASRC:
939 case E_GE_ALPHA_ADST:
940 case E_GE_ALPHA_ROP8_SRC:
941 case E_GE_ALPHA_ROP8_IN:
942 case E_GE_ALPHA_ROP8_DSTOUT:
943 case E_GE_ALPHA_ROP8_SRCOUT:
944 case E_GE_ALPHA_ROP8_OVER:
945 case E_GE_ALPHA_ROP8_INV_CONST:
946 case E_GE_ALPHA_ROP8_INV_ASRC:
947 case E_GE_ALPHA_ROP8_INV_ADST:
948 case E_GE_ALPHA_ROP8_SRC_ATOP_DST:
949 case E_GE_ALPHA_ROP8_DST_ATOP_SRC:
950 case E_GE_ALPHA_ROP8_SRC_XOR_DST:
951 case E_GE_ALPHA_ROP8_INV_SRC_ATOP_DST:
952 case E_GE_ALPHA_ROP8_INV_DST_ATOP_SRC:
953
954 u16src = eAlphaSrc;
955 break;
956 default:
957 return E_GE_FAIL_PARAM;
958 break;
959 }
960
961 u16src = (GE_ReadReg(pGEHalLocal, REG_GE_ALPHA) & ~GE_ALPHA_MASK) | (u16src<<GE_ALPHA_SHFT);
962 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA, u16src);
963
964 return E_GE_OK;
965 }
966
GE_QueryDFBBldCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 * pU16SupportedBldFlags)967 GE_Result GE_QueryDFBBldCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 *pU16SupportedBldFlags)
968 {
969 if(NULL == pU16SupportedBldFlags)
970 {
971 return E_GE_FAIL_PARAM;
972 }
973
974 (*pU16SupportedBldFlags) = E_GE_DFB_BLD_FLAG_ALL;
975
976 return E_GE_OK;
977 }
978
GE_EnableDFBBld(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)979 GE_Result GE_EnableDFBBld(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
980 {
981 MS_U16 u16RegVal;
982
983 u16RegVal = GE_ReadReg(pGEHalLocal, REG_GE_EN);
984
985 if (enable)
986 {
987 u16RegVal |= GE_EN_DFB_BLD;
988 }
989 else
990 {
991 u16RegVal &= ~GE_EN_DFB_BLD;
992 }
993
994 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16RegVal);
995
996 return E_GE_OK;
997 }
998
GE_SetDFBBldFlags(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 u16DFBBldFlags)999 GE_Result GE_SetDFBBldFlags(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 u16DFBBldFlags)
1000 {
1001 MS_U16 u16RegVal;
1002
1003 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_FLAGS) & ~GE_DFB_BLD_FLAGS_MASK);
1004
1005 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_COLORALPHA)
1006 {
1007 u16RegVal |= GE_DFB_BLD_FLAG_COLORALPHA;
1008 }
1009
1010 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_ALPHACHANNEL)
1011 {
1012 u16RegVal |= GE_DFB_BLD_FLAG_ALPHACHANNEL;
1013 }
1014
1015 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_COLORIZE)
1016 {
1017 u16RegVal |= GE_DFB_BLD_FLAG_COLORIZE;
1018 }
1019
1020 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_SRCPREMUL)
1021 {
1022 u16RegVal |= GE_DFB_BLD_FLAG_SRCPREMUL;
1023 }
1024
1025 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_SRCPREMULCOL)
1026 {
1027 u16RegVal |= GE_DFB_BLD_FLAG_SRCPREMULCOL;
1028 }
1029
1030 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_DSTPREMUL)
1031 {
1032 u16RegVal |= GE_DFB_BLD_FLAG_DSTPREMUL;
1033 }
1034
1035 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_XOR)
1036 {
1037 u16RegVal |= GE_DFB_BLD_FLAG_XOR;
1038 }
1039
1040 if(u16DFBBldFlags & E_GE_DFB_BLD_FLAG_DEMULTIPLY)
1041 {
1042 u16RegVal |= GE_DFB_BLD_FLAG_DEMULTIPLY;
1043 }
1044
1045 GE_WriteReg(pGEHalLocal, REG_GE_DFB_BLD_FLAGS, u16RegVal);
1046
1047
1048 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_OP) & ~GE_DFB_SRC_COLORMASK);
1049
1050 if(u16DFBBldFlags & (E_GE_DFB_BLD_FLAG_SRCCOLORMASK | E_GE_DFB_BLD_FLAG_SRCALPHAMASK))
1051 {
1052 u16RegVal |= (1 << GE_DFB_SRC_COLORMASK_SHIFT);
1053 }
1054
1055
1056
1057 return E_GE_OK;
1058 }
1059
GE_SetDFBBldOP(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_DFBBldOP geSrcBldOP,GE_DFBBldOP geDstBldOP)1060 GE_Result GE_SetDFBBldOP(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_DFBBldOP geSrcBldOP, GE_DFBBldOP geDstBldOP)
1061 {
1062 MS_U16 u16RegVal;
1063
1064 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_DFB_BLD_OP) & ~(GE_DFB_SRCBLD_OP_MASK|GE_DFB_DSTBLD_OP_MASK));
1065 u16RegVal |= ((geSrcBldOP<<GE_DFB_SRCBLD_OP_SHFT) | (geDstBldOP<<GE_DFB_DSTBLD_OP_SHFT));
1066
1067 GE_WriteReg(pGEHalLocal, REG_GE_DFB_BLD_OP, u16RegVal);
1068
1069 return E_GE_OK;
1070 }
1071
GE_SetDFBBldConstColor(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RgbColor geRgbColor)1072 GE_Result GE_SetDFBBldConstColor(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RgbColor geRgbColor)
1073 {
1074 MS_U16 u16RegVal;
1075
1076 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_ALPHA_CONST) & ~GE_ALPHA_CONST_MASK) | (geRgbColor.a & 0xFF));
1077 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA_CONST, u16RegVal);
1078
1079 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_R_CONST) & ~GE_R_CONST_MASK) | ((geRgbColor.r<<GE_R_CONST_SHIFT) & GE_R_CONST_MASK));
1080 GE_WriteReg(pGEHalLocal, REG_GE_R_CONST, u16RegVal);
1081
1082 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_G_CONST) & ~GE_G_CONST_MASK) | ((geRgbColor.g<<GE_G_CONST_SHIFT) & GE_G_CONST_MASK));
1083 GE_WriteReg(pGEHalLocal, REG_GE_G_CONST, u16RegVal);
1084
1085 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_B_CONST) & ~GE_B_CONST_MASK) | ((geRgbColor.b<<GE_B_CONST_SHIFT) & GE_B_CONST_MASK));
1086 GE_WriteReg(pGEHalLocal, REG_GE_B_CONST, u16RegVal);
1087
1088 return E_GE_OK;
1089 }
1090
GE_SetDFBBldSrcColorMask(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_RgbColor geRgbColor)1091 GE_Result GE_SetDFBBldSrcColorMask(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_RgbColor geRgbColor)
1092 {
1093 //no more hw function
1094 /*
1095 MS_U16 u16RegVal;
1096
1097 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_ALPHA_CONST) & ~GE_ALPHA_SRCMASK_MASK) | (geRgbColor.a & 0xFF));
1098 GE_WriteReg(pGEHalLocal, REG_GE_ALPHA_CONST, u16RegVal);
1099
1100 u16RegVal = ((GE_ReadReg(pGEHalLocal, REG_GE_OP_MODE) & ~GE_SRCCOLOR_MASK_R) | ((geRgbColor.r<<GE_SRCCOLOR_MASK_R_SHIFT) & GE_SRCCOLOR_MASK_R));
1101 GE_WriteReg(pGEHalLocal, REG_GE_OP_MODE, u16RegVal);
1102
1103 u16RegVal = (geRgbColor.g<<GE_SRCCOLOR_MASK_G_SHIFT) | (geRgbColor.b<<GE_SRCCOLOR_MASK_B_SHIFT);
1104 GE_WriteReg(pGEHalLocal, REG_GE_SRCMASK_GB, u16RegVal);
1105 */
1106 return E_GE_OK;
1107 }
1108
1109
GE_WriteProtect(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 miu,MS_PHY addr_low,MS_PHY addr_high,GE_WPType eWPType)1110 GE_Result GE_WriteProtect(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 miu, MS_PHY addr_low, MS_PHY addr_high, GE_WPType eWPType)
1111 {
1112 MS_U16 u16cfg;
1113
1114 if (miu > 1)
1115 {
1116 return E_GE_FAIL;
1117 }
1118
1119 if ( (eWPType == E_GE_WP_IN_RANGE) || (eWPType == E_GE_WP_OUT_RANGE) )
1120 {
1121 // range setting
1122 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_LTH_L(miu), addr_low & (GE_MIU_ADDR_MASK&0xFFFF));
1123 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_LTH_H(miu), ((addr_low>>16) & (GE_MIU_ADDR_MASK>>16)) | (eWPType<<GE_MIU_PROT_MODE_SHFT));
1124 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_HTH_L(miu), addr_high & (GE_MIU_ADDR_MASK&0xFFFF));
1125 GE_WriteReg(pGEHalLocal, REG_GE_MIU_PROT_HTH_H(miu), (addr_high>>16) & (GE_MIU_ADDR_MASK>>16));
1126 // enable setting
1127 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_CFG) | (GE_CFG_MIU0_PROT << miu);
1128 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16cfg);
1129 }
1130 else if (eWPType == E_GE_WP_DISABLE)
1131 {
1132 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_CFG) & ~(GE_CFG_MIU0_PROT<<miu);
1133 GE_WriteReg(pGEHalLocal, REG_GE_CFG, u16cfg);
1134 }
1135 else
1136 {
1137 return E_GE_FAIL;
1138 }
1139
1140 return E_GE_OK;
1141 }
1142
1143
GE_SetSrcTile(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL tile)1144 GE_Result GE_SetSrcTile(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL tile)
1145 {
1146 //GE_DBG("%s\n", __FUNCTION__);
1147
1148 return E_GE_NOT_SUPPORT;
1149
1150 }
1151
1152
GE_SetDstTile(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL tile)1153 GE_Result GE_SetDstTile(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL tile)
1154 {
1155 //GE_DBG("%s\n", __FUNCTION__);
1156
1157 return E_GE_NOT_SUPPORT;
1158
1159 }
GE_SetASCK(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1160 GE_Result GE_SetASCK(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1161 {
1162 MS_U16 u16cfg;
1163
1164 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1165 if (enable)
1166 {
1167 u16cfg |= GE_EN_ASCK;
1168 }
1169 else
1170 {
1171 u16cfg &= ~GE_EN_ASCK;
1172 }
1173 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16cfg);
1174
1175 return E_GE_OK;
1176 }
GE_SetADCK(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1177 GE_Result GE_SetADCK(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL enable)
1178 {
1179 MS_U16 u16cfg;
1180
1181 u16cfg = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1182 if (enable)
1183 {
1184 u16cfg |= GE_EN_DSCK;
1185 }
1186 else
1187 {
1188 u16cfg &= ~GE_EN_DSCK;
1189 }
1190 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16cfg);
1191
1192 return E_GE_OK;
1193 }
1194
1195
GE_GetFmtCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_BufFmt fmt,GE_BufType type,GE_FmtCaps * caps)1196 GE_Result GE_GetFmtCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_BufFmt fmt, GE_BufType type, GE_FmtCaps *caps)
1197 {
1198 static const MS_U8 _u8GETileWidth[] = {8, 4, 2, 0, 1};
1199
1200 caps->fmt = fmt;
1201 if (type == E_GE_BUF_SRC)
1202 {
1203 switch (fmt)
1204 {
1205 case E_GE_FMT_I1:
1206 case E_GE_FMT_I2:
1207 case E_GE_FMT_I4:
1208 case E_GE_FMT_I8:
1209 caps->u8BaseAlign = 1;
1210 caps->u8PitchAlign = 1;
1211 caps->u8Non1pAlign = 0;
1212 caps->u8HeightAlign = 1;
1213 caps->u8StretchAlign = 1;
1214 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1215 caps->u8TileWidthAlign = _u8GETileWidth[fmt];
1216 caps->u8TileHeightAlign = 16;
1217 break;
1218 case E_GE_FMT_RGB565:
1219 case E_GE_FMT_RGBA5551:
1220 case E_GE_FMT_RGBA4444:
1221 case E_GE_FMT_ARGB1555:
1222 case E_GE_FMT_1ABFgBg12355:
1223 case E_GE_FMT_ARGB4444:
1224 case E_GE_FMT_YUV422:
1225 case E_GE_FMT_FaBaFgBg2266:
1226 caps->u8BaseAlign = 2;
1227 caps->u8PitchAlign = 2;
1228 caps->u8Non1pAlign = 0;
1229 caps->u8HeightAlign = 1;
1230 caps->u8StretchAlign = 2;
1231 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1232 caps->u8TileWidthAlign = 16;
1233 caps->u8TileHeightAlign = 16;
1234 break;
1235 case E_GE_FMT_ABGR8888:
1236 case E_GE_FMT_ARGB8888:
1237 caps->u8BaseAlign = 4;
1238 caps->u8PitchAlign = 4;
1239 caps->u8Non1pAlign = 0;
1240 caps->u8HeightAlign = 1;
1241 caps->u8StretchAlign = 4;
1242 caps->u8TileBaseAlign = 0x80;//[HWBUG] 8;
1243 caps->u8TileWidthAlign = 8;
1244 caps->u8TileHeightAlign = 16;
1245 break;
1246 // Not Support
1247 default:
1248 caps->fmt = E_GE_FMT_GENERIC;
1249 caps->u8BaseAlign = 4;
1250 caps->u8PitchAlign = 4;
1251 caps->u8Non1pAlign = 0;
1252 caps->u8HeightAlign = 1;
1253 caps->u8StretchAlign = 4;
1254 caps->u8TileBaseAlign = 0;
1255 caps->u8TileWidthAlign = 0;
1256 caps->u8TileHeightAlign = 0;
1257 return E_GE_FAIL_FORMAT;
1258 }
1259 }
1260 else
1261 {
1262 switch (fmt)
1263 {
1264 case E_GE_FMT_I8:
1265 caps->u8BaseAlign = 1;
1266 caps->u8PitchAlign = 1;
1267 caps->u8Non1pAlign = 0;
1268 caps->u8HeightAlign = 1;
1269 caps->u8StretchAlign = 1;
1270 caps->u8TileBaseAlign = 8;
1271 caps->u8TileWidthAlign = _u8GETileWidth[fmt];
1272 caps->u8TileHeightAlign = 16;
1273 break;
1274 case E_GE_FMT_RGB565:
1275 case E_GE_FMT_ARGB1555:
1276 case E_GE_FMT_RGBA5551:
1277 case E_GE_FMT_RGBA4444:
1278 case E_GE_FMT_1ABFgBg12355:
1279 case E_GE_FMT_ARGB4444:
1280 case E_GE_FMT_YUV422:
1281 case E_GE_FMT_FaBaFgBg2266:
1282 case E_GE_FMT_ARGB1555_DST:
1283 caps->u8BaseAlign = 2;
1284 caps->u8PitchAlign = 2;
1285 caps->u8Non1pAlign = 0;
1286 caps->u8HeightAlign = 1;
1287 caps->u8StretchAlign = 2;
1288 caps->u8TileBaseAlign = 8;
1289 caps->u8TileWidthAlign = 16;
1290 caps->u8TileHeightAlign = 16;
1291 break;
1292 case E_GE_FMT_ABGR8888:
1293 case E_GE_FMT_ARGB8888:
1294 caps->u8BaseAlign = 4;
1295 caps->u8PitchAlign = 4;
1296 caps->u8Non1pAlign = 0;
1297 caps->u8HeightAlign = 1;
1298 caps->u8StretchAlign = 4;
1299 caps->u8TileBaseAlign = 8;
1300 caps->u8TileWidthAlign = 8;
1301 caps->u8TileHeightAlign = 16;
1302 break;
1303 // Not Support
1304 case E_GE_FMT_I1:
1305 case E_GE_FMT_I2:
1306 case E_GE_FMT_I4:
1307 default:
1308 caps->fmt = E_GE_FMT_GENERIC;
1309 caps->u8BaseAlign = 4;
1310 caps->u8PitchAlign = 4;
1311 caps->u8Non1pAlign = 0;
1312 caps->u8HeightAlign = 1;
1313 caps->u8StretchAlign = 4;
1314 caps->u8TileBaseAlign = 0;
1315 caps->u8TileWidthAlign = 0;
1316 caps->u8TileHeightAlign = 0;
1317 return E_GE_FAIL_FORMAT;
1318 }
1319 }
1320
1321 return E_GE_OK;
1322 }
1323
1324
GE_Set_IOMap_Base(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_VIRT addr)1325 GE_Result GE_Set_IOMap_Base(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_VIRT addr)
1326 {
1327 pGEHalLocal->va_mmio_base = addr;
1328 return E_GE_OK;
1329 }
1330
1331
direct_serial_diff(MS_U16 tagID1,MS_U16 tagID2)1332 static MS_S32 direct_serial_diff( MS_U16 tagID1, MS_U16 tagID2)
1333 {
1334 if(tagID1 < tagID2)
1335 {
1336 if((tagID2-tagID1)>0x7FFF)
1337 {
1338 return (MS_S32)(0xFFFFUL-tagID2+tagID1+1);
1339 }
1340 else
1341 return -(MS_S32)(tagID2-tagID1);
1342 }
1343 else
1344 {
1345 if((tagID1-tagID2)>0x7FFF)
1346 {
1347 return -(MS_S32)(0xFFFF-tagID1+tagID2+1);
1348 }
1349 else
1350 return (MS_S32)(tagID1-tagID2);
1351 }
1352 }
1353
1354 //-------------------------------------------------------------------------------------------------
1355 /// Wait GE TagID back
1356 /// @param tagID \b IN: tag id number for wating
1357 /// @return @ref GE_Result
1358 //-------------------------------------------------------------------------------------------------
GE_WaitTAGID(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tagID)1359 GE_Result GE_WaitTAGID(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tagID)
1360 {
1361 MS_U16 tagID_HW;
1362 MS_U32 u32Temp;
1363
1364
1365 while(1)
1366 {
1367
1368 tagID_HW = GE_ReadReg(pGEHalLocal, REG_GE_TAG);
1369 if(direct_serial_diff(tagID_HW, tagID) >= 0)
1370 {
1371 //printf("tagIDHW = %04x %04x\n", tagID_HW, tagID);
1372 break;
1373 }
1374
1375 u32Temp = GE_ReadReg(pGEHalLocal, REG_GE_STAT);
1376 if((u32Temp&GE_STAT_CMDQ_MASK) < (16UL<<11))
1377 continue;
1378 if((u32Temp&GE_STAT_CMDQ2_MASK) < (16UL<<3))
1379 continue;
1380 if(GE_ReadReg(pGEHalLocal, REG_GE_CFG) & GE_CFG_VCMDQ)
1381 {
1382 u32Temp = GE_ReadReg(pGEHalLocal, REG_GE_VCMDQ_STAT);
1383 u32Temp |= (GE_ReadReg(pGEHalLocal, REG_GE_BIST_STAT)&1)<<16;
1384 if(u32Temp)
1385 continue;
1386
1387 }
1388
1389 if(GE_ReadReg(pGEHalLocal, REG_GE_STAT) & GE_STAT_BUSY)
1390 continue;
1391
1392 break;
1393 GE_YIELD();
1394
1395 }
1396
1397 return E_GE_OK;
1398
1399 }
1400 //-------------------------------------------------------------------------------------------------
1401 /// MDrv_GE_SAVE_CHIP_IMAGE
1402 //-------------------------------------------------------------------------------------------------
GE_Restore_HAL_Context(GE_CTX_HAL_LOCAL * pGEHalLocal)1403 GE_Result GE_Restore_HAL_Context(GE_CTX_HAL_LOCAL *pGEHalLocal)
1404 {
1405 MS_U16 i = 0;
1406 MS_U16 u16RegVal;
1407
1408 //GE_WaitIdle(pGEHalLocal);
1409
1410 while( (_GE_Reg_Backup[i] != 0xFF) )
1411 {
1412 if(_GE_Reg_Backup[i]>= 0x80)
1413 {
1414 break;
1415 }
1416
1417 u16RegVal = GE_ReadReg(pGEHalLocal, _GE_Reg_Backup[i]);
1418 GE_RestoreReg(pGEHalLocal, _GE_Reg_Backup[i], u16RegVal);
1419 i++;
1420 }
1421
1422 //GE_DBG(printf("GE_Restore_HAL_Context finished \n\n"));
1423
1424 return E_GE_OK;
1425 }
1426
1427 //-------------------------------------------------------------------------------------------------
1428 /// Calculate Blit Scale Ratio:
1429 //-------------------------------------------------------------------------------------------------
GE_CalcBltScaleRatio(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 u16SrcWidth,MS_U16 u16SrcHeight,MS_U16 u16DstWidth,MS_U16 u16DstHeight,GE_ScaleInfo * pScaleinfo)1430 GE_Result GE_CalcBltScaleRatio(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 u16SrcWidth, MS_U16 u16SrcHeight, MS_U16 u16DstWidth, MS_U16 u16DstHeight, GE_ScaleInfo *pScaleinfo)
1431 {
1432 if(NULL == pScaleinfo)
1433 {
1434 return E_GE_FAIL_PARAM;
1435 }
1436
1437 if(u16SrcWidth >= (u16DstWidth<< g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1438 {
1439 pScaleinfo->x = 0xFFFFFFFF;
1440 }
1441 else
1442 {
1443 pScaleinfo->x = GE_Divide2Fixed(u16SrcWidth, u16DstWidth, g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin, 12);
1444 }
1445
1446 if(u16SrcHeight >= (u16DstHeight<< g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1447 {
1448 pScaleinfo->y = 0xFFFFFFFF;
1449 }
1450 else
1451 {
1452 pScaleinfo->y = GE_Divide2Fixed(u16SrcHeight, u16DstHeight, g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin, 12);
1453 }
1454
1455 /* HW use format S0.12 which means Bit(12) should be Sign bit
1456 // If overflow, S bit maybe wrong, handle it as actually value we hoped*/
1457 pScaleinfo->init_x = GE_Divide2Fixed(u16SrcWidth-u16DstWidth, 2 * u16DstWidth, 0, 12);
1458 if(u16SrcWidth >= u16DstWidth)
1459 {
1460 pScaleinfo->init_x &= (~(1<<12));
1461 }
1462 else
1463 {
1464 pScaleinfo->init_x |= (1<<12);
1465 }
1466
1467 pScaleinfo->init_y = GE_Divide2Fixed(u16SrcHeight-u16DstHeight, 2 * u16DstHeight, 0, 12);
1468 if(u16SrcHeight >= u16DstHeight)
1469 {
1470 pScaleinfo->init_y &= (~(1<<12));
1471 }
1472 else
1473 {
1474 pScaleinfo->init_y |= (1<<12);
1475 }
1476
1477 if (pGEHalLocal->bYScalingPatch)
1478 {
1479 if (u16SrcHeight<=5)
1480 pScaleinfo->init_y = (1<<12);
1481 }
1482 return E_GE_OK;
1483 }
1484
1485 //-------------------------------------------------------------------------------------------------
1486 /// Set GE scale register
1487 /// @param GE_Rect *src \b IN: src coordinate setting
1488 /// @param GE_DstBitBltType *dst \b IN: dst coordinate setting
1489 /// @return @ref GE_Result
1490 //-------------------------------------------------------------------------------------------------
GE_SetBltScaleRatio(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Rect * src,GE_DstBitBltType * dst,GE_Flag flags,GE_ScaleInfo * scaleinfo)1491 GE_Result GE_SetBltScaleRatio(GE_CTX_HAL_LOCAL *pGEHalLocal,GE_Rect *src, GE_DstBitBltType *dst, GE_Flag flags, GE_ScaleInfo* scaleinfo)
1492 {
1493 GE_ScaleInfo geScaleinfo, *pGeScaleInfo = scaleinfo;
1494
1495 if(flags & E_GE_FLAG_BYPASS_STBCOEF)
1496 {
1497 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1498 }
1499 else if (flags & E_GE_FLAG_BLT_STRETCH)
1500 {
1501 /* Safe Guard. Prevent set scaling ratio < 1/32. Also prevent 0 h/w */
1502 if ((src->width-1) >= (dst->dstblk.width << g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1503 {
1504 if(pGEHalLocal->bIsComp == FALSE)
1505 {
1506 return E_GE_FAIL_PARAM;
1507 }
1508
1509 dst->dstblk.width = ((src->width-1) >> g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin) + 1;
1510 }
1511 if ((src->height-1) >= (dst->dstblk.height << g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin))
1512 {
1513 if(pGEHalLocal->bIsComp == FALSE)
1514 {
1515 return E_GE_FAIL_PARAM;
1516 }
1517
1518 dst->dstblk.height = ((src->height-1) >> g_GeChipPro.BltDownScaleCaps.u8ShiftRangeMin) + 1;
1519 }
1520
1521 pGeScaleInfo = &geScaleinfo;
1522 GE_CalcBltScaleRatio(pGEHalLocal, src->width, src->height, dst->dstblk.width, dst->dstblk.height, pGeScaleInfo);
1523 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1524 }
1525 else
1526 {
1527 pGeScaleInfo = &geScaleinfo;
1528
1529 pGeScaleInfo->x = (1<<12);
1530 pGeScaleInfo->y = (1<<12);
1531 pGeScaleInfo->init_x = 0;
1532 pGeScaleInfo->init_y = 0;
1533
1534 _GE_SetBltScaleRatio2HW(pGEHalLocal, pGeScaleInfo);
1535 }
1536
1537 return E_GE_OK;
1538 }
1539
GE_BitBltEX_Trape(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_Rect * pSrcRect,GE_Normalized_Trapezoid * pGENormTrapezoid,MS_U32 u32Flags,GE_ScaleInfo * pScaleinfo)1540 GE_Result GE_BitBltEX_Trape(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_Rect *pSrcRect, GE_Normalized_Trapezoid *pGENormTrapezoid, MS_U32 u32Flags, GE_ScaleInfo* pScaleinfo)
1541 {
1542 return E_GE_NOT_SUPPORT;
1543 }
1544
1545 //-------------------------------------------------------------------------------------------------
1546 /// GE Primitive Drawing - TRAPEZOID
1547 /// @param pGENormTrapezoid \b IN: pointer to position of TRAPEZOID
1548 /// @param u32ColorS \b IN: start color of TRAPEZOID when gradient
1549 /// @param u32ColorE \b IN: end color of TRAPEZOID when gradient
1550 /// @param pColorDeltaX \b IN: x gradient color
1551 /// @param pColorDeltaY \b IN: y gradient color
1552 /// @return @ref GE_Result
1553 //-------------------------------------------------------------------------------------------------
GE_FillTrapezoid(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bYTrapezoid,GE_Normalized_Trapezoid * pGENormTrapezoid,MS_U32 u32Color,GE_ColorDelta * pColorDeltaX,GE_ColorDelta * pColorDeltaY)1554 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)
1555 {
1556 return E_GE_NOT_SUPPORT;
1557 }
1558
1559 //-------------------------------------------------------------------------------------------------
1560 /// Set GE DISABLE MIU ACCESS
1561 /// @param enable \b IN: enable and update setting
1562 /// @return @ref GE_Result
1563 //-------------------------------------------------------------------------------------------------
GE_SetDisaMIUAccess(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1564 GE_Result GE_SetDisaMIUAccess(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1565 {
1566 MS_U16 u16en;
1567
1568 GE_DBG("%s\n", __FUNCTION__);
1569
1570 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1571 if (enable)
1572 {
1573 u16en |= GE_CFG_DISABLE_MIU_ACS;
1574 }
1575 else
1576 {
1577 u16en &= ~GE_CFG_DISABLE_MIU_ACS;
1578 }
1579 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1580
1581 return E_GE_OK;
1582 }
1583 //-------------------------------------------------------------------------------------------------
1584 /// Set GE Clear Invalid MIU Flag
1585 /// @param enable \b IN: enable and update setting
1586 /// @return @ref GE_Result
1587 //-------------------------------------------------------------------------------------------------
GE_ClrInvalMIUFlg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1588 GE_Result GE_ClrInvalMIUFlg(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1589 {
1590 MS_U16 u16en;
1591
1592 GE_DBG("%s\n", __FUNCTION__);
1593
1594 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1595 if (enable)
1596 {
1597 u16en |= GE_CFG_CLR_MIU_FLG;
1598 }
1599 else
1600 {
1601 u16en &= ~GE_CFG_CLR_MIU_FLG;
1602 }
1603 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1604
1605 return E_GE_OK;
1606 }
1607
1608 //-------------------------------------------------------------------------------------------------
1609 /// Set Enable Dynamic Clock Gating
1610 /// @param enable \b IN: enable and update setting
1611 /// @return @ref GE_Result
1612 //-------------------------------------------------------------------------------------------------
GE_EnableDynaClkGate(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL enable)1613 GE_Result GE_EnableDynaClkGate(GE_CTX_HAL_LOCAL *pGEHalLocal,MS_BOOL enable)
1614 {
1615 MS_U16 u16en;
1616
1617 GE_DBG("%s\n", __FUNCTION__);
1618
1619 u16en = GE_ReadReg(pGEHalLocal,REG_GE_CFG);
1620 if (enable)
1621 {
1622 u16en |= GE_CFG_EN_DNY_CLK_GATE;
1623 }
1624 else
1625 {
1626 u16en &= ~GE_CFG_EN_DNY_CLK_GATE;
1627 }
1628 GE_WriteReg(pGEHalLocal,REG_GE_CFG, u16en);
1629
1630 return E_GE_OK;
1631 }
1632
GE_EnableTrapezoidAA(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1633 GE_Result GE_EnableTrapezoidAA(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1634 {
1635 //GE_DBG("%s\n", __FUNCTION__);
1636
1637 return E_GE_NOT_SUPPORT;
1638
1639 }
1640
GE_EnableTrapSubPixCorr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1641 GE_Result GE_EnableTrapSubPixCorr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1642 {
1643 //GE_DBG("%s\n", __FUNCTION__);
1644
1645 return E_GE_NOT_SUPPORT;
1646
1647 }
1648
GE_GetNextTAGID(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bStepTagBefore)1649 MS_U16 GE_GetNextTAGID(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bStepTagBefore)
1650 {
1651 MS_U16 tagID;
1652 if(bStepTagBefore)
1653 {
1654 if(0 == ++pGEHalLocal->pHALShared->global_tagID)
1655 ++pGEHalLocal->pHALShared->global_tagID;
1656 }
1657 tagID =pGEHalLocal->pHALShared->global_tagID;
1658
1659 return tagID;
1660 }
1661
GE_SetVCmdBuffer(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY PhyAddr,GE_VcmqBufSize enBufSize)1662 GE_Result GE_SetVCmdBuffer(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY PhyAddr, GE_VcmqBufSize enBufSize)
1663 {
1664 MS_U16 u16RegVal;
1665 MS_U16 i=0;
1666
1667 if(enBufSize >= E_GE_VCMD_1024K)
1668 {
1669 return E_GE_NOT_SUPPORT;
1670 }
1671
1672 GE_SetVQBufMIUId(pGEHalLocal, _GFXAPI_MIU_ID(PhyAddr));
1673 PhyAddr = GE_ConvertAPIAddr2HAL(pGEHalLocal, _GFXAPI_MIU_ID(PhyAddr), _GFXAPI_PHYS_ADDR_IN_MIU(PhyAddr));
1674
1675 #ifdef GE_VQ_MIU_HANG_PATCH
1676 pGEHalLocal->pHALShared->u8VCmdQMiu = _GFXAPI_MIU_ID(PhyAddr);
1677 #endif
1678
1679 #if GE_VQADDR_LOCK_PATCH
1680 for (i=0; i<GE_VQADDR_ENHANCE_LOCK_TIMES; i++)
1681 {
1682 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_H, PhyAddr >> 16); // Address
1683 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_L, PhyAddr & 0xffff); // Address
1684 }
1685 #else
1686 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_L, PhyAddr & 0xffff); // Address
1687 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_BASE_H, PhyAddr >> 16); // Address
1688 #endif
1689
1690 u16RegVal = (GE_ReadReg(pGEHalLocal, REG_GE_VCMDQ_SIZE) & ~GE_VCMDQ_SIZE_MASK) | ((GE_MapVQ2Reg(enBufSize) & GE_VCMDQ_SIZE_MASK));
1691 GE_WriteReg(pGEHalLocal, REG_GE_VCMDQ_SIZE, u16RegVal);
1692
1693 return E_GE_OK;
1694 }
1695
GE_InitCtxHalPalette(GE_CTX_HAL_LOCAL * pGEHalLocal)1696 GE_Result GE_InitCtxHalPalette(GE_CTX_HAL_LOCAL *pGEHalLocal)
1697 {
1698 MS_U32 u32Idx;
1699
1700 for(u32Idx=0; u32Idx<GE_PALETTE_NUM; u32Idx++)
1701 {
1702 GE_WriteReg(pGEHalLocal, REG_GE_CLUT_CTRL, ((u32Idx) & GE_CLUT_CTRL_IDX_MASK) | GE_CLUT_CTRL_RD);
1703 GE_WaitIdle(pGEHalLocal);
1704 pGEHalLocal->u32Palette[u32Idx] = ByteSwap32(((GE_ReadReg(pGEHalLocal, REG_GE_CLUT_H)<<16) | GE_ReadReg(pGEHalLocal, REG_GE_CLUT_L)));
1705 }
1706
1707 pGEHalLocal->bPaletteDirty = FALSE;
1708
1709 return (E_GE_OK);
1710 }
1711
GE_Init_HAL_Context(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_CTX_HAL_SHARED * pHALShared,MS_BOOL bNeedInitShared)1712 void GE_Init_HAL_Context(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_CTX_HAL_SHARED *pHALShared, MS_BOOL bNeedInitShared)
1713 {
1714 memset(pGEHalLocal, 0, sizeof(*pGEHalLocal));
1715
1716 if(bNeedInitShared)
1717 {
1718 memset(pHALShared, 0, sizeof(*pHALShared));
1719 pHALShared->global_tagID = 1;
1720 }
1721 pGEHalLocal->pHALShared = pHALShared;
1722 pGEHalLocal->bYScalingPatch = FALSE;
1723 }
1724
GE_Set_IOMap_Base2(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_VIRT addr)1725 GE_Result GE_Set_IOMap_Base2(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_VIRT addr)
1726 {
1727 pGEHalLocal->va_mmio_base2 = addr;
1728 return E_GE_OK;
1729 }
1730
GE_SetClock(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bOnOff)1731 GE_Result GE_SetClock(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bOnOff)
1732 {
1733 MS_U16 u16tmp = 0;
1734
1735 u16tmp = CLK_REG(CHIP_GE_CLK);
1736
1737 if (bOnOff)
1738 {
1739 u16tmp &= ~ BIT(0);
1740 }
1741 else
1742 {
1743 u16tmp |= BIT(0);
1744 }
1745 CLK_REG(CHIP_GE_CLK) = u16tmp;
1746 return E_GE_OK;
1747
1748 }
1749
GE_NonOnePixelModeCaps(GE_CTX_HAL_LOCAL * pGEHalLocal,PatchBitBltInfo * patchInfo)1750 MS_BOOL GE_NonOnePixelModeCaps(GE_CTX_HAL_LOCAL *pGEHalLocal, PatchBitBltInfo* patchInfo)
1751 {
1752 GE_ScaleInfo geScaleinfo;
1753 GE_Result ret;
1754
1755 patchInfo->scaleinfo =&geScaleinfo;
1756 ret = GE_CalcBltScaleRatio(pGEHalLocal, patchInfo->src.width , patchInfo->src.height ,patchInfo->dst.dstblk.width , patchInfo->dst.dstblk.height, patchInfo->scaleinfo);
1757
1758 if(ret == E_GE_FAIL_PARAM)
1759 {
1760 return pGEHalLocal->pGeChipPro->bFourPixelModeStable;
1761 }
1762 else if ((patchInfo->scaleinfo->init_x>0xFFF)||(patchInfo->scaleinfo->init_y>0xFFF))
1763 {
1764 return FALSE;
1765 }
1766 else
1767 {
1768 return pGEHalLocal->pGeChipPro->bFourPixelModeStable;
1769 }
1770 }
1771
HAL_GE_EnableCalcSrc_WidthHeight(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1772 GE_Result HAL_GE_EnableCalcSrc_WidthHeight(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1773 {
1774 MS_U16 u16en;
1775
1776 u16en = GE_ReadReg(pGEHalLocal, REG_GE_EN);
1777
1778 if(bEnable)
1779 {
1780 if(u16en & GE_EN_BURST)
1781 {
1782 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en | GE_EN_CALC_SRC_WH);
1783 }
1784 }
1785 else
1786 {
1787 GE_WriteReg(pGEHalLocal, REG_GE_EN, u16en & (~GE_EN_CALC_SRC_WH));
1788 }
1789
1790 return E_GE_OK;
1791 }
1792
GEWD_ReadReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 * value)1793 GE_Result GEWD_ReadReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16* value)
1794 {
1795 //For two source buffer read register
1796 return E_GE_NOT_SUPPORT;
1797 }
1798
GEWD_WriteReg(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 addr,MS_U16 value)1799 GE_Result GEWD_WriteReg(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 addr, MS_U16 value)
1800 {
1801 //For two source buffer write register
1802 return E_GE_NOT_SUPPORT;
1803 }
1804
GE_SetTLBMode(GE_CTX_HAL_LOCAL * pGEHalLocal,GE_TLB_Mode tlb_type)1805 GE_Result GE_SetTLBMode(GE_CTX_HAL_LOCAL *pGEHalLocal, GE_TLB_Mode tlb_type)
1806 {
1807 return E_GE_NOT_SUPPORT;
1808 }
1809
GE_GetTLBSRCADDR(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY * addr)1810 GE_Result GE_GetTLBSRCADDR(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY* addr)
1811 {
1812 *addr = 0;
1813 return E_GE_NOT_SUPPORT;
1814 }
1815
GE_GetTLBDSTADDR(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY * addr)1816 GE_Result GE_GetTLBDSTADDR(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY* addr)
1817 {
1818 *addr = 0;
1819 return E_GE_NOT_SUPPORT;
1820 }
1821
GE_SetTLBSrcBaseAddr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY addr)1822 GE_Result GE_SetTLBSrcBaseAddr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY addr)
1823 {
1824 return E_GE_NOT_SUPPORT;
1825 }
1826
GE_SetTLBDstBaseAddr(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_PHY addr)1827 GE_Result GE_SetTLBDstBaseAddr(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_PHY addr)
1828 {
1829 return E_GE_NOT_SUPPORT;
1830 }
1831
GE_FlushTLBTable(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bEnable)1832 GE_Result GE_FlushTLBTable(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bEnable)
1833 {
1834 return E_GE_NOT_SUPPORT;
1835 }
1836
GE_SetTLBTag(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U16 tag)1837 GE_Result GE_SetTLBTag(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U16 tag)
1838 {
1839 return E_GE_NOT_SUPPORT;
1840 }
1841
GE_StopFlushTLB(GE_CTX_HAL_LOCAL * pGEHalLocal)1842 GE_Result GE_StopFlushTLB(GE_CTX_HAL_LOCAL *pGEHalLocal)
1843 {
1844 return E_GE_NOT_SUPPORT;
1845 }
1846
GE_Get_MIU_INTERVAL(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 miu,MS_PHY * value)1847 GE_Result GE_Get_MIU_INTERVAL(GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 miu, MS_PHY* value)
1848 {
1849 *value = 0;
1850 return E_GE_NOT_SUPPORT;
1851 }
1852
HAL_GE_AdjustDstWin(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_BOOL bDstXInv)1853 GE_Result HAL_GE_AdjustDstWin( GE_CTX_HAL_LOCAL *pGEHalLocal, MS_BOOL bDstXInv )
1854 {
1855 MS_U16 u16ClipL=0,u16ClipR=0;
1856 MS_U16 u16DstX=0;
1857
1858 u16DstX = GE_ReadReg(pGEHalLocal, REG_GE_PRIM_V1_X);
1859 if( bDstXInv==FALSE )
1860 {
1861 u16ClipR = GE_ReadReg(pGEHalLocal, REG_GE_CLIP_R);
1862 if( u16ClipR < u16DstX )
1863 {
1864 GE_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, u16ClipR);
1865 }
1866 }
1867 else
1868 {
1869 u16ClipL = GE_ReadReg(pGEHalLocal, REG_GE_CLIP_L);
1870 if( u16ClipL > u16DstX )
1871 {
1872 GE_WriteReg(pGEHalLocal, REG_GE_PRIM_V1_X, u16ClipL);
1873 }
1874 }
1875
1876 return E_GE_OK;
1877 }
1878
HAL_GE_AdjustRotateDstWin(GE_CTX_HAL_LOCAL * pGEHalLocal,MS_U8 u8Rotate)1879 GE_Result HAL_GE_AdjustRotateDstWin( GE_CTX_HAL_LOCAL *pGEHalLocal, MS_U8 u8Rotate )
1880 {
1881 return E_GE_OK;
1882 }
1883
1884