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