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