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