1 #include "MsTypes.h"
2 #ifndef MSOS_TYPE_LINUX_KERNEL
3 #include <stdio.h>
4 #include <string.h>
5 #else
6 #include <linux/slab.h>
7 #endif
8 #include "utopia_dapi.h"
9 #include "utopia.h"
10 #include "_apigfx_type.h"
11 #include "apiGFX.h"
12 #include "apiGFX_v2.h"
13 #include "drvGE.h"
14 #include "halGE.h"
15 #include "drvGE_private.h"
16 #include "apiGFX_private.h"
17 #include "MsOS.h"
18 #ifdef MSOS_TYPE_LINUX_KERNEL
19 #include <asm/div64.h>
20 #define do_remain(x,y) do_div(x,y)
21 #else
22 #define do_div(x,y) ((x)/=(y))
23 #define do_remain(x,y) ((x)%(y))
24 #endif
25 #include "ULog.h"
26
27 //==========================================================
28 //Macro and Define
29 //==========================================================
30 #if(GFX_UTOPIA20)
31 #define g_apiGFXLocal psGFXInstPri->GFXPrivate_g_apiGFXLocal
32 #endif
33
34 #if defined(MSOS_TYPE_LINUX_KERNEL)
35 #define CheckSize(u32InputSize, u32StuctSize, eCmd) do{\
36 }while(0)
37 #else
38 #define CheckSize(u32InputSize, u32StuctSize, eCmd) do{\
39 if(u32InputSize != u32StuctSize)\
40 {\
41 GFX_DEBUG_MSG(GFX_ERR("[%s][%d] GE Check Size Error, Invalid input structure size :0x%tx , except structure size is 0x%tx; [eCmd=%d]\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32InputSize, (ptrdiff_t)u32StuctSize, eCmd));\
42 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, UTOPIA_STATUS_FAIL, eCmd);\
43 }\
44 }while(0)
45 #endif
46
47 #define APICheckU02() GFX_INSTANT_PRIVATE* psGFXInstPri =NULL;\
48 UtopiaInstanceGetPrivate(pInstance, (void**)&psGFXInstPri);
49
50 #if (GE_API_MUTEX)
51 static MS_U32 u32CheckMutexCnt=0;
52 #define _GFX_CheckMutex(_ret) do{\
53 if(u32CheckMutexCnt !=0)\
54 {\
55 GFX_DBUG("\33[0;31m [%s][%d] Entry/Return Not pair!!!!! u32CheckMutexCnt=%td \33[m;\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32CheckMutexCnt);\
56 }\
57 }while(0)
58
59
60 #define GET_GE_ENTRY(pGECtx) do{\
61 _GE_MUXTEX_ENTRY(pGECtx, E_GE_POOL_ID_INTERNAL_VARIABLE);\
62 if(u32CheckMutexCnt!=0)\
63 GFX_DBUG("\33[0;31m [%s][%d] Entry not zero!!!! u32CheckMutexCnt=%tu \33[m;\n",__FUNCTION__,__LINE__, (ptrdiff_t)u32CheckMutexCnt);\
64 u32CheckMutexCnt++;\
65 }while(0)
66
67 #define RELEASE_GE_RETURN(pGECtx, _ret) do{\
68 u32CheckMutexCnt--;\
69 _GFX_CheckMutex(_ret);\
70 _GE_MUXTEX_RETURN(pGECtx, E_GE_POOL_ID_INTERNAL_VARIABLE);\
71 }while(0)
72
73
74 #if GE_MUTEX_DBG
75 #define API_GE_ENTRY(pGECtx) do{\
76 GET_GE_ENTRY(pGECtx);\
77 }while(0)
78
79 #define API_GE_RETURN(pGECtx, _ret, cmd) do{\
80 RELEASE_GE_RETURN(pGECtx, _ret);\
81 return _ret;\
82 }while(0)
83 #else/*In order to deduce code size*/
84 #define API_GE_ENTRY(pGECtx) do{\
85 _API_GE_ENTRY(pGECtx);\
86 }while(0)
87
88 #define API_GE_RETURN(pGECtx, _ret , cmd) do{\
89 _API_GE_RETURN(pGECtx, _ret);\
90 return _ret;\
91 }while(0)
92 #endif
93
94 //===========================================================================================================================================
95 #else
96 #define API_GE_ENTRY(pGECtx) do{\
97 }while(0)
98
99 #define API_GE_RETURN(pGECtx, _ret , cmd) do{\
100 return _ret;\
101 }while(0)
102
103 #endif
104 // API level could only contains local parameters
105 #define DYNAMIC_POWER_ON_OFF 0UL
106
107 #define ABS(x) ((x) > 0 ? (x) : -(x))
108
109 #define SETUP_DDA(xs,ys,xe,ye,dda) \
110 do { \
111 int dx = xe - xs; \
112 int dy = ye - ys; \
113 int result = 0; \
114 dda.xi = xs; \
115 if (dy != 0) { \
116 result = dx; \
117 do_div(result,dy); \
118 dda.mi = result; \
119 dda.mf = 2*( do_remain(dx,dy) ); \
120 dda.xf = -dy; \
121 dda._2dy = 2 * dy; \
122 if (dda.mf < 0) { \
123 dda.mf += 2 * ABS(dy); \
124 dda.mi--; \
125 } \
126 } \
127 else { \
128 dda.mi = 0; \
129 dda.mf = 0; \
130 dda.xf = 0; \
131 dda._2dy = 0; \
132 } \
133 } while (0)
134
135
136 #define INC_DDA(dda) \
137 do { \
138 dda.xi += dda.mi; \
139 dda.xf += dda.mf; \
140 if (dda.xf > 0) { \
141 dda.xi++; \
142 dda.xf -= dda._2dy; \
143 } \
144 } while (0)
145
146 typedef struct {
147 int xi;
148 int xf;
149 int mi;
150 int mf;
151 int _2dy;
152 } DDA;
153
154 #if (!GFX_UTOPIA20)
155 GFX_API_LOCAL g_apiGFXLocal =
156 {
157 u32dbglvl: -1,
158 fpGetBMP:NULL,
159 fpGetFont:NULL,
160 _blendcoef:COEF_ASRC,
161 _angle:GEROTATE_0,
162 _bNearest:FALSE,
163 _bPatchMode:FALSE,
164 _bMirrorH:FALSE,
165 _bMirrorV:FALSE,
166 _bDstMirrorH:FALSE,
167 _bDstMirrorV:FALSE,
168 _bItalic:FALSE,
169 _line_enable:FALSE,
170 _line_pattern:0x00,
171 _line_factor:0,
172 #ifdef DBGLOG
173 _bOutFileLog:FALSE,
174 _pu16OutLogAddr:NULL,
175 _u16LogCount:0,
176 #endif
177 g_pGEContext:NULL,
178 pGeChipProperty:NULL,
179 u32LockStatus:0,
180 _bInit:0,
181 u32geRgbColor:0,
182
183 };
184 #endif
185 #ifndef MSOS_TYPE_OPTEE
186 static MS_BOOL GFX_SetFireInfo(void* pInstance,GFX_FireInfo* pFireInfo);
187 #endif
188 #if (GE_API_MUTEX)
_API_GE_ENTRY(GE_Context * pGECtx)189 static void _API_GE_ENTRY(GE_Context* pGECtx)
190 {
191 GET_GE_ENTRY(pGECtx);
192 }
193
_API_GE_RETURN(GE_Context * pGECtx,MS_U16 ret)194 static MS_U16 _API_GE_RETURN(GE_Context* pGECtx, MS_U16 ret)
195 {
196 RELEASE_GE_RETURN(pGECtx, ret);
197 return ret;
198 }
199 #endif
200
MapRet(GFX_Result eGFXResoult)201 static MS_S32 MapRet(GFX_Result eGFXResoult)
202 {
203 MS_U32 u32Ret= UTOPIA_STATUS_FAIL;
204
205 switch(eGFXResoult)
206 {
207 case GFX_FAIL:
208 u32Ret = UTOPIA_STATUS_FAIL;
209 break;
210 case GFX_SUCCESS:
211 u32Ret = UTOPIA_STATUS_SUCCESS;
212 break;
213 case GFX_DRV_NOT_SUPPORT:
214 u32Ret = UTOPIA_STATUS_NOT_SUPPORTED;
215 break;
216 case GFX_NON_ALIGN_ADDRESS:
217 case GFX_NON_ALIGN_PITCH:
218 case GFX_INVALID_PARAMETERS:
219 u32Ret = UTOPIA_STATUS_NOT_SUPPORTED;
220 break;
221 default:
222 break;
223 }
224 return u32Ret;
225 }
226
227 #ifndef MSOS_TYPE_OPTEE
MApi_GFX_MapStrSCKType(MS_U32 gfxOP,MS_U32 * geOP)228 static MS_U32 MApi_GFX_MapStrSCKType(MS_U32 gfxOP, MS_U32* geOP)
229 {
230
231 switch(gfxOP)
232 {
233 case GFX_DONOTHING:
234 *geOP = (MS_U32)E_GE_DONOTHING;
235 break;
236 case GFX_NEAREST:
237 *geOP = (MS_U32)E_GE_NEAREST;
238 break;
239 case GFX_REPLACE_KEY_2_CUS:
240 *geOP = (MS_U32)E_GE_REPLACE_KEY_2_CUS;
241 break;
242
243 default:
244 return (MS_U32)GFX_INVALID_PARAMETERS;
245 break;
246 }
247
248 return (MS_U32)GFX_SUCCESS;
249 }
250
MApi_GFX_MapYUVOp(MS_U32 OpType,MS_U32 gfxOp,MS_U32 * geOP)251 static MS_U32 MApi_GFX_MapYUVOp(MS_U32 OpType, MS_U32 gfxOp, MS_U32* geOP)
252 {
253
254 switch(OpType)
255 {
256 case GFX_YUV_OP1:
257 switch(gfxOp)
258 {
259 case GFX_YUV_RGB2YUV_PC:
260 *geOP = (MS_U32)E_GE_YUV_RGB2YUV_PC;
261 break;
262 case GFX_YUV_RGB2YUV_255:
263 *geOP = (MS_U32)E_GE_YUV_RGB2YUV_255;
264 break;
265 default:
266 return (MS_U32)GFX_INVALID_PARAMETERS;
267 break;
268 }
269 break;
270 case GFX_YUV_OP2:
271 switch(gfxOp)
272 {
273 case GFX_YUV_OUT_255:
274 *geOP = (MS_U32)E_GE_YUV_OUT_255;
275 break;
276 case GFX_YUV_OUT_PC:
277 *geOP = (MS_U32)E_GE_YUV_OUT_PC;
278 break;
279 default:
280 return (MS_U32)GFX_INVALID_PARAMETERS;
281 break;
282 }
283 break;
284 case GFX_YUV_OP3:
285 switch(gfxOp)
286 {
287 case GFX_YUV_IN_255:
288 *geOP = (MS_U32)E_GE_YUV_IN_255;
289 break;
290 case GFX_YUV_IN_127:
291 *geOP = (MS_U32)E_GE_YUV_IN_127;
292 break;
293 default:
294 return (MS_U32)GFX_INVALID_PARAMETERS;
295 break;
296 }
297 break;
298 case GFX_YUV_OP4:
299 switch(gfxOp)
300 {
301 case GFX_YUV_YVYU:
302 *geOP = (MS_U32)E_GE_YUV_YVYU;
303 break;
304 case GFX_YUV_YUYV:
305 *geOP = (MS_U32)E_GE_YUV_YUYV;
306 break;
307 case GFX_YUV_VYUY:
308 *geOP = (MS_U32)E_GE_YUV_VYUY;
309 break;
310 case GFX_YUV_UYVY:
311 *geOP = (MS_U32)E_GE_YUV_UYVY;
312 break;
313 default:
314 return (MS_U32)GFX_INVALID_PARAMETERS;
315 break;
316 }
317 break;
318 default:
319 return (MS_U32)GFX_INVALID_PARAMETERS;
320 break;
321
322 }
323 return (MS_U32)GFX_SUCCESS;
324 }
325
MApi_GFX_MapACmp(MS_U32 gfxACmp,MS_U32 * geACmp)326 static MS_U32 MApi_GFX_MapACmp(MS_U32 gfxACmp, MS_U32* geACmp )
327 {
328
329 switch(gfxACmp)
330 {
331 case GFX_ACMP_OP_MAX:
332 *geACmp = (MS_U32)E_GE_ACMP_OP_MAX;
333 break;
334 case GFX_GE_ACMP_OP_MIN:
335 *geACmp = (MS_U32)E_GE_ACMP_OP_MIN;
336 break;
337 default:
338 return (MS_U32)GFX_INVALID_PARAMETERS;
339 break;
340 }
341
342 return (MS_U32)GFX_SUCCESS;
343 }
344
MApi_GFX_MapBLDCOEF(MS_U32 gfxCOEF,MS_U32 * geCOEF)345 static MS_U32 MApi_GFX_MapBLDCOEF(MS_U32 gfxCOEF, MS_U32* geCOEF )
346 {
347 switch(gfxCOEF)
348 {
349 case COEF_ONE:
350 *geCOEF = (MS_U32)E_GE_BLEND_ONE;
351 break;
352 case COEF_CONST:
353 *geCOEF = (MS_U32)E_GE_BLEND_CONST;
354 break;
355 case COEF_ASRC:
356 *geCOEF = (MS_U32)E_GE_BLEND_ASRC;
357 break;
358 case COEF_ADST:
359 *geCOEF = (MS_U32)E_GE_BLEND_ADST;
360 break;
361 case COEF_ZERO:
362 *geCOEF = (MS_U32)E_GE_BLEND_ZERO;
363 break;
364 case COEF_1_CONST:
365 *geCOEF = (MS_U32)E_GE_BLEND_CONST_INV;
366 break;
367 case COEF_1_ASRC:
368 *geCOEF = (MS_U32)E_GE_BLEND_ASRC_INV;
369 break;
370 case COEF_1_ADST:
371 *geCOEF = (MS_U32)E_GE_BLEND_ADST_INV;
372 break;
373
374 case COEF_ROP8_ALPHA:
375 *geCOEF = (MS_U32)E_GE_BLEND_ROP8_ALPHA;
376 break;
377 case COEF_ROP8_SRCOVER:
378 *geCOEF = (MS_U32)E_GE_BLEND_ROP8_SRCOVER;
379 break;
380 case COEF_ROP8_DSTOVER:
381 *geCOEF = (MS_U32)E_GE_BLEND_ROP8_DSTOVER;
382 break;
383 case COEF_CONST_SRC:
384 *geCOEF = (MS_U32)E_GE_BLEND_ALPHA_ADST;
385 break;
386 case COEF_1_CONST_SRC:
387 *geCOEF = (MS_U32)E_GE_BLEND_INV_CONST;
388 break;
389 case COEF_SRC_ATOP_DST:
390 *geCOEF = (MS_U32)E_GE_BLEND_SRC_ATOP_DST;
391 break;
392 case COEF_DST_ATOP_SRC:
393 *geCOEF = (MS_U32)E_GE_BLEND_DST_ATOP_SRC;
394 break;
395 case COEF_SRC_XOR_DST:
396 *geCOEF = (MS_U32)E_GE_BLEND_SRC_XOR_DST;
397 break;
398 default:
399 return (MS_U32)GFX_INVALID_PARAMETERS;
400 break;
401 }
402
403 return (MS_U32)GFX_SUCCESS;
404 }
405
MApi_GFX_MapABLCOEF(MS_U32 gfxABL,MS_U32 * geABL)406 static MS_U32 MApi_GFX_MapABLCOEF(MS_U32 gfxABL, MS_U32* geABL )
407 {
408
409 switch(gfxABL)
410 {
411 case ABL_FROM_CONST:
412 *geABL = (MS_U32)E_GE_ALPHA_CONST;
413 break;
414 case ABL_FROM_ASRC:
415 *geABL = (MS_U32)E_GE_ALPHA_ASRC;
416 break;
417 case ABL_FROM_ADST:
418 *geABL = (MS_U32)E_GE_ALPHA_ADST;
419 break;
420 case ABL_FROM_ROP8_SRC:
421 *geABL = (MS_U32)E_GE_ALPHA_ROP8_SRC;
422 break;
423 case ABL_FROM_ROP8_IN:
424 *geABL = (MS_U32)E_GE_ALPHA_ROP8_IN;
425 break;
426 case ABL_FROM_ROP8_DSTOUT:
427 *geABL = (MS_U32)E_GE_ALPHA_ROP8_DSTOUT;
428 break;
429 case ABL_FROM_ROP8_SRCOUT:
430 *geABL = (MS_U32)E_GE_ALPHA_ROP8_SRCOUT;
431 break;
432 case ABL_FROM_ROP8_OVER:
433 *geABL = (MS_U32)E_GE_ALPHA_ROP8_OVER;
434 break;
435 case ABL_FROM_ROP8_INV_CONST:
436 *geABL = (MS_U32)E_GE_ALPHA_ROP8_INV_CONST;
437 break;
438 case ABL_FROM_ROP8_INV_ASRC:
439 *geABL = (MS_U32)E_GE_ALPHA_ROP8_INV_ASRC;
440 break;
441 case ABL_FROM_ROP8_INV_ADST:
442 *geABL = (MS_U32)E_GE_ALPHA_ROP8_INV_ADST;
443 break;
444 case ABL_FROM_ROP8_SRC_ATOP_DST:
445 *geABL = (MS_U32)E_GE_ALPHA_ROP8_SRC_ATOP_DST;
446 break;
447 case ABL_FROM_ROP8_DST_ATOP_SRC:
448 *geABL = (MS_U32)E_GE_ALPHA_ROP8_DST_ATOP_SRC;
449 break;
450 case ABL_FROM_ROP8_SRC_XOR_DST:
451 *geABL = (MS_U32)E_GE_ALPHA_ROP8_SRC_XOR_DST;
452 break;
453 case ABL_FROM_ROP8_INV_SRC_ATOP_DST:
454 *geABL = (MS_U32)E_GE_ALPHA_ROP8_INV_SRC_ATOP_DST;
455 break;
456 case ABL_FROM_ROP8_INV_DST_ATOP_SRC:
457 *geABL = (MS_U32)E_GE_ALPHA_ROP8_INV_DST_ATOP_SRC;
458 break;
459 default:
460 return (MS_U32)GFX_INVALID_PARAMETERS;
461 break;
462 }
463
464 return (MS_U32)GFX_SUCCESS;
465 }
466
MApi_GFX_MapROP2(MS_U32 gfxROP,MS_U32 * geROP)467 static MS_U32 MApi_GFX_MapROP2(MS_U32 gfxROP, MS_U32* geROP )
468 {
469
470 switch(gfxROP)
471 {
472 case ROP2_OP_ZERO:
473 *geROP = (MS_U32)E_GE_ROP2_ZERO;
474 break;
475 case ROP2_OP_NOT_PS_OR_PD:
476 *geROP = (MS_U32)E_GE_ROP2_NOT_PS_OR_PD;
477 break;
478 case ROP2_OP_NS_AND_PD:
479 *geROP = (MS_U32)E_GE_ROP2_NS_AND_PD;
480 break;
481 case ROP2_OP_NS:
482 *geROP = (MS_U32)E_GE_ROP2_NS;
483 break;
484 case ROP2_OP_PS_AND_ND:
485 *geROP = (MS_U32)E_GE_ROP2_PS_AND_ND;
486 break;
487 case ROP2_OP_ND:
488 *geROP = (MS_U32)E_GE_ROP2_ND;
489 break;
490 case ROP2_OP_PS_XOR_PD:
491 *geROP = (MS_U32)E_GE_ROP2_PS_XOR_PD;
492 break;
493 case ROP2_OP_NOT_PS_AND_PD:
494 *geROP = (MS_U32)E_GE_ROP2_NOT_PS_AND_PD;
495 break;
496 case ROP2_OP_PS_AND_PD:
497 *geROP = (MS_U32)E_GE_ROP2_PS_AND_PD;
498 break;
499 case ROP2_OP_NOT_PS_XOR_PD:
500 *geROP = (MS_U32)E_GE_ROP2_NOT_PS_XOR_PD;
501 break;
502 case ROP2_OP_PD:
503 *geROP = (MS_U32)E_GE_ROP2_PD;
504 break;
505 case ROP2_OP_NS_OR_PD:
506 *geROP = (MS_U32)E_GE_ROP2_NS_OR_PD;
507 break;
508 case ROP2_OP_PS:
509 *geROP = (MS_U32)E_GE_ROP2_PS;
510 break;
511 case ROP2_OP_PS_OR_ND:
512 *geROP = (MS_U32)E_GE_ROP2_PS_OR_ND;
513 break;
514 case ROP2_OP_PD_OR_PS:
515 *geROP = (MS_U32)E_GE_ROP2_PD_OR_PS;
516 break;
517 case ROP2_OP_ONE:
518 *geROP = (MS_U32)E_GE_ROP2_ONE;
519 break;
520 default:
521 return (MS_U32)GFX_INVALID_PARAMETERS;
522 break;
523 }
524
525 return (MS_U32)GFX_SUCCESS;
526 }
527
528
529
MApi_GFX_MapCKOP(MS_U32 gfxCKOP,MS_U32 * geCKOP)530 static MS_U32 MApi_GFX_MapCKOP(MS_U32 gfxCKOP, MS_U32* geCKOP)
531 {
532
533 switch(gfxCKOP)
534 {
535 case CK_OP_EQUAL:
536 *geCKOP = (MS_U32)E_GE_CK_EQ;
537 break;
538 case CK_OP_NOT_EQUAL:
539 *geCKOP = (MS_U32)E_GE_CK_NE;
540 break;
541 case AK_OP_EQUAL:
542 *geCKOP = (MS_U32)E_GE_ALPHA_EQ;
543 break;
544 case AK_OP_NOT_EQUAL:
545 *geCKOP = (MS_U32)E_GE_ALPHA_NE;
546 break;
547 default:
548 return (MS_U32)GFX_INVALID_PARAMETERS;
549 break;
550 }
551
552 return (MS_U32)GFX_SUCCESS;
553 }
554
GFX_RectBltFlags(void * pInstance)555 static MS_U32 GFX_RectBltFlags(void* pInstance) // for legacy driver BitBlt and FillRect
556 {
557 MS_U32 flags = 0;
558 APICheckU02();
559
560 if (g_apiGFXLocal._bItalic)
561 {
562 flags |= E_GE_FLAG_BLT_ITALIC;
563 }
564 if (g_apiGFXLocal._bMirrorH)
565 {
566 flags |= E_GE_FLAG_BLT_MIRROR_H;
567 }
568 if (g_apiGFXLocal._bMirrorV)
569 {
570 flags |= E_GE_FLAG_BLT_MIRROR_V;
571 }
572 if (g_apiGFXLocal._bDstMirrorH)
573 {
574 flags |= E_GE_FLAG_BLT_DST_MIRROR_H;
575 }
576 if (g_apiGFXLocal._bDstMirrorV)
577 {
578 flags |= E_GE_FLAG_BLT_DST_MIRROR_V;
579 }
580 switch(g_apiGFXLocal._angle)
581 {
582 case GEROTATE_90:
583 flags |= E_GE_FLAG_BLT_ROTATE_90;
584 break;
585 case GEROTATE_180:
586 flags |= E_GE_FLAG_BLT_ROTATE_180;
587 break;
588 case GEROTATE_270:
589 flags |= E_GE_FLAG_BLT_ROTATE_270;
590 break;
591 default:
592 break;
593 }
594 if (g_apiGFXLocal._bNearest)
595 {
596 flags |= E_GE_FLAG_STRETCH_NEAREST;
597 }
598 return flags;
599 }
600
MApi_GFX_MapVCMQSZ(MS_U32 gfxOP,MS_U32 * geOP)601 static MS_U32 MApi_GFX_MapVCMQSZ(MS_U32 gfxOP, MS_U32* geOP)
602 {
603
604 switch(gfxOP)
605 {
606 case GFX_VCMD_4K:
607 *geOP = (MS_U32)E_GE_VCMD_4K;
608 break;
609 case GFX_VCMD_8K:
610 *geOP = (MS_U32)E_GE_VCMD_8K;
611 break;
612 case GFX_VCMD_16K:
613 *geOP = (MS_U32)E_GE_VCMD_16K;
614 break;
615 case GFX_VCMD_32K:
616 *geOP = (MS_U32)E_GE_VCMD_32K;
617 break;
618 case GFX_VCMD_64K:
619 *geOP = (MS_U32)E_GE_VCMD_64K;
620 break;
621 case GFX_VCMD_128K:
622 *geOP = (MS_U32)E_GE_VCMD_128K;
623 break;
624 case GFX_VCMD_256K:
625 *geOP = (MS_U32)E_GE_VCMD_256K;
626 break;
627 case GFX_VCMD_512K:
628 *geOP = (MS_U32)E_GE_VCMD_512K;
629 break;
630 case GFX_VCMD_1024K:
631 *geOP = (MS_U32)E_GE_VCMD_1024K;
632 break;
633 default:
634 return (MS_U32)GFX_INVALID_PARAMETERS;
635 break;
636 }
637
638 return (MS_U32)GFX_SUCCESS;
639 }
640
MApi_GFX_MapDFBBldFlag(MS_U16 gfxBldFlag,MS_U16 * geBldFlag)641 static MS_U32 MApi_GFX_MapDFBBldFlag(MS_U16 gfxBldFlag, MS_U16* geBldFlag)
642 {
643 //the bld flag is one-to-one map:
644 *geBldFlag = gfxBldFlag;
645
646 return (MS_U32)GFX_SUCCESS;
647 }
648
MApi_GFX_MapDFBBldOP(GFX_DFBBldOP gfxBldOP,GE_DFBBldOP * geBldOP)649 static MS_U32 MApi_GFX_MapDFBBldOP(GFX_DFBBldOP gfxBldOP, GE_DFBBldOP* geBldOP)
650 {
651 //the bld op is one-to-one map:
652 *geBldOP = (GE_DFBBldOP)gfxBldOP;
653
654 return (MS_U32)GFX_SUCCESS;
655 }
656
GFX_CheckInClipWindow(MS_U16 u16X1,MS_U16 u16Y1,MS_U16 u16X2,MS_U16 u16Y2)657 static MS_BOOL GFX_CheckInClipWindow(MS_U16 u16X1, MS_U16 u16Y1, MS_U16 u16X2, MS_U16 u16Y2)
658 {
659 GFX_DEBUGINFO(GFX_ERR( "%s Not support\n", __FUNCTION__));
660
661 return TRUE;
662 }
663
664
665 //-------------------------------------------------------------------------------------------------
666 /// GFX tool function: Convert ARGB/index into the color format for intensity register.
667 /// @param Fmt \b IN: type of target color format.
668 /// @param colorinfo \b IN: pointer to color/index structure.
669 /// @param low \b OUT: pointer to 16-bit data to be filled in Intensity low word.
670 /// @param high \b OUT: pointer to 16-bit data to be filled in Intensity high word.
671 /// @return GFX_SUCCESS - Success
672 /// @return GFX_FAIL - Failure
673 //-------------------------------------------------------------------------------------------------
GFX_ConvertRGB2DBFmt(GFX_Buffer_Format Fmt,MS_U32 * colorinfo,MS_U16 * low,MS_U16 * high)674 void GFX_ConvertRGB2DBFmt(GFX_Buffer_Format Fmt, MS_U32 *colorinfo, MS_U16* low, MS_U16* high)
675 {
676 GFX_RgbColor *color = NULL;
677 GFX_BlinkData *blinkData = NULL;
678 //MS_U8 a, r, g, b;
679
680
681 if ((NULL == colorinfo) || (NULL == low) || (NULL == high)){
682 GFX_ERR("Convert RGB2DB FAIL\n");
683 return;
684 }
685
686
687 // @FIXME: Richard uses GFX_FMT_1ABFGBG12355 instead
688 if ( (GFX_FMT_1ABFGBG12355== Fmt) || (GFX_FMT_FABAFGBG2266 == Fmt))
689 // if (Fmt == GFX_FMT_1BAAFGBG123433)
690 {
691 blinkData =(GFX_BlinkData *)colorinfo;
692 }
693 else
694 {
695 color =(GFX_RgbColor *)colorinfo;
696 }
697
698 switch (Fmt)
699 {
700 case GFX_FMT_RGB565 :
701 *low = ((color->b & 0xf8) + (color->b >> 5)) | (((color->g & 0xfc) + (color->g>>6))<<8);
702 *high = ((color->r & 0xf8) + (color->r >> 5)) | ((color->a & 0xff) << 8);
703 break;
704 case GFX_FMT_RGBA5551:
705 if (color->a > 0)
706 {
707 *low = ((color->g & 0xf8) + (color->g >> 5)) | (0xff << 8);
708 }
709 else
710 {
711 *low = ((color->g & 0xf8) + (color->g >> 5));
712 }
713 *high = ((color->g & 0xf8) + (color->g >> 5)) | (((color->r & 0xf8) + (color->r >> 5))<<8);
714 break;
715 case GFX_FMT_ARGB1555 :
716 *low = ((color->b & 0xf8) + (color->b >> 5)) | (((color->g & 0xf8) + (color->g >> 5))<<8);
717 if (color->a > 0)
718 {
719 *high = ((color->r & 0xf8) + (color->r >> 5)) | (0xff << 8);
720 }
721 else
722 {
723 *high = ((color->r & 0xf8) + (color->r >> 5));
724 }
725 break;
726 case GFX_FMT_RGBA4444:
727 *low = ((color->a & 0xf0) + (color->a >> 4)) | (((color->b & 0xf0) + (color->b >> 4))<<8);
728 *high = ((color->g & 0xf0) + (color->g >> 4)) | (((color->r & 0xf0) + (color->r >> 4))<<8);
729 break;
730 case GFX_FMT_ARGB4444 :
731 *low = ((color->b & 0xf0) + (color->b >> 4)) | (((color->g & 0xf0) + (color->g >> 4))<<8);
732 *high = ((color->r & 0xf0) + (color->r >> 4)) | (((color->a & 0xf0) + (color->a >> 4))<<8);
733 break;
734 case GFX_FMT_ABGR8888:
735 *low =(color->r & 0xff) | ((color->g & 0xff) << 8);
736 *high =(color->b & 0xff) | ((color->a & 0xff) << 8);
737 break;
738 case GFX_FMT_ARGB8888 :
739 *low =(color->b & 0xff) | ((color->g & 0xff) << 8);
740 *high =(color->r & 0xff) | ((color->a & 0xff) << 8);
741 break;
742 case GFX_FMT_I8 :
743 *low = (color->b & 0xff)|((color->b & 0xff) << 8);
744 *high = (color->b & 0xff)|((color->b & 0xff) << 8);
745 break;
746 // @FIXME: Richard uses GFX_FMT_1ABFGBG12355 instead
747 // 1 A B Fg Bg
748 // 1 2 3 5 5
749 case GFX_FMT_1ABFGBG12355:
750 *low = (0x1f & blinkData->background) | // Bg: 4..0
751 ((0x1f & blinkData->foreground)<< 5) | // Fg: 9..5
752 ((0x1f & blinkData->ctrl_flag)<< 10) | // [A, B]: [14..13, 12..10]
753 BIT15; // Bit 15
754 *high= (0x1f & blinkData->background) | // Bg: 4..0
755 ((0x1f & blinkData->foreground)<< 5) | // Fg: 9..5
756 ((0x1f & blinkData->ctrl_flag)<< 10) | // [A, B]: [14..13, 12..10]
757 BIT15; // Bit 15
758 break;
759
760 #if 0
761 1 B A A Fg Bg
762 1 2 3 4 3 3
763 case GFX_FMT_1BAAFGBG123433 :
764 *low = ((blinkData->background & 0x7)|((blinkData->foreground & 0x7) << 3)|((blinkData->ctrl_flag & 0x1ff)<<6)|(0x1 << 15));
765 *high = ((blinkData->background & 0x7)|((blinkData->foreground & 0x7) << 3)|((blinkData->ctrl_flag & 0x1ff)<<6)|(0x1 << 15));
766 break;
767 #endif
768 case GFX_FMT_YUV422:
769 //printf("[GE DRV][%06d] Are you sure to draw in YUV?\n", __LINE__);
770 *low =(color->b & 0xff) | ((color->g & 0xff) << 8);
771 *high =(color->r & 0xff) | ((color->a & 0xff) << 8);
772
773 break;
774 case GFX_FMT_FABAFGBG2266:
775 *low = ((blinkData->background & 0x3f)|((blinkData->foreground & 0x3f) << 6)|((blinkData->Bits3.Ba & 0x3)<<12)|((blinkData->Bits3.Fa & 0x3)<<14));
776 *high = *low;
777
778 break;
779 default:
780 GFX_ASSERT(0, GFX_FATAL("[GE DRV][%06d] Bad color format\n", __LINE__));
781 *low =(color->b & 0xff) | ((color->g & 0xff) << 8);
782 *high =(color->r & 0xff) | ((color->a & 0xff) << 8);
783 break;
784 }
785
786 }
787
788 //-------------------------------------------------------------------------------------------------
789 /// GFX tool function: Convert ARGB/index into the color format for Primitive color.
790 /// @param Fmt \b IN: type of target color format.
791 /// @param colorinfo \b IN: pointer to color/index structure.
792 /// @param low \b OUT: pointer to 16-bit data to be filled in Intensity low word.
793 /// @param high \b OUT: pointer to 16-bit data to be filled in Intensity high word.
794 /// @return GFX_SUCCESS - Success
795 /// @return GFX_FAIL - Failure
796 //-------------------------------------------------------------------------------------------------
GFX_ConvertRGB2PCFmt(GFX_Buffer_Format Fmt,MS_U32 * colorinfo,MS_U16 * low,MS_U16 * high)797 void GFX_ConvertRGB2PCFmt(GFX_Buffer_Format Fmt, MS_U32 *colorinfo, MS_U16* low, MS_U16* high)
798 {
799 GFX_RgbColor *color = NULL;
800 GFX_BlinkData *blinkData = NULL;
801 //MS_U8 a, r, g, b;
802
803
804 if ((NULL == colorinfo) || (NULL == low) || (NULL == high)){
805 GFX_ERR("Convert RGB2DB FAIL\n");
806 return;
807 }
808
809
810 // @FIXME: Richard uses GFX_FMT_1ABFGBG12355 instead
811 if ( (GFX_FMT_1ABFGBG12355== Fmt) || (GFX_FMT_FABAFGBG2266 == Fmt))
812 // if (Fmt == GFX_FMT_1BAAFGBG123433)
813 {
814 blinkData =(GFX_BlinkData *)colorinfo;
815 }
816 else
817 {
818 color =(GFX_RgbColor *)colorinfo;
819 }
820
821 switch (Fmt)
822 {
823 case GFX_FMT_RGB565 :
824 *low = ((color->b & 0xf8) + (color->b >> 5)) | (((color->g & 0xfc) + (color->g>>6))<<8);
825 *high = ((color->r & 0xf8) + (color->r >> 5)) | ((color->a & 0xff) << 8);
826 break;
827 case GFX_FMT_RGBA5551:
828 if (color->a > 0)
829 {
830 *low = ((color->g & 0xf8) + (color->g >> 5)) | (0xff << 8);
831 }
832 else
833 {
834 *low = ((color->g & 0xf8) + (color->g >> 5));
835 }
836 *high = ((color->g & 0xf8) + (color->g >> 5)) | (((color->r & 0xf8) + (color->r >> 5))<<8);
837 break;
838 case GFX_FMT_ARGB1555 :
839 *low = ((color->b & 0xf8) + (color->b >> 5)) | (((color->g & 0xf8) + (color->g >> 5))<<8);
840 if (color->a > 0)
841 {
842 *high = ((color->r & 0xf8) + (color->r >> 5)) | (0xff << 8);
843 }
844 else
845 {
846 *high = ((color->r & 0xf8) + (color->r >> 5));
847 }
848 break;
849 case GFX_FMT_RGBA4444:
850 *low = ((color->a & 0xf0) + (color->a >> 4)) | (((color->b & 0xf0) + (color->b >> 4))<<8);
851 *high = ((color->g & 0xf0) + (color->g >> 4)) | (((color->r & 0xf0) + (color->r >> 4))<<8);
852 break;
853 case GFX_FMT_ARGB4444 :
854 *low = ((color->b & 0xf0) + (color->b >> 4)) | (((color->g & 0xf0) + (color->g >> 4))<<8);
855 *high = ((color->r & 0xf0) + (color->r >> 4)) | (((color->a & 0xf0) + (color->a >> 4))<<8);
856 break;
857 case GFX_FMT_ABGR8888:
858 *low =(color->r & 0xff) | ((color->g & 0xff) << 8);
859 *high =(color->b & 0xff) | ((color->a & 0xff) << 8);
860 break;
861 case GFX_FMT_ARGB8888 :
862 *low =(color->b & 0xff) | ((color->g & 0xff) << 8);
863 *high =(color->r & 0xff) | ((color->a & 0xff) << 8);
864 break;
865 case GFX_FMT_I8 :
866 *low = (color->b & 0xff)|((color->b & 0xff) << 8);
867 *high = (color->b & 0xff)|((color->b & 0xff) << 8);
868 break;
869 // @FIXME: Richard uses GFX_FMT_1ABFGBG12355 instead
870 // 1 A B Fg Bg
871 // 1 2 3 5 5
872 case GFX_FMT_1ABFGBG12355:
873 *low = ((0x1f & blinkData->background)<<3) | //Bg
874 (((0x1f & blinkData->foreground)<<3)<<8); //Fg
875
876 *high= ((0x1f & blinkData->ctrl_flag)<<3) | BIT15; //1AB
877 break;
878 #if 0
879 1 B A A Fg Bg
880 1 2 3 4 3 3
881 case GFX_FMT_1BAAFGBG123433 :
882 *low = ((blinkData->background & 0x7)|((blinkData->foreground & 0x7) << 3)|((blinkData->ctrl_flag & 0x1ff)<<6)|(0x1 << 15));
883 *high = ((blinkData->background & 0x7)|((blinkData->foreground & 0x7) << 3)|((blinkData->ctrl_flag & 0x1ff)<<6)|(0x1 << 15));
884 break;
885 #endif
886 case GFX_FMT_YUV422:
887 //printf("[GE DRV][%06d] Are you sure to draw in YUV?\n", __LINE__);
888 *low =(color->b & 0xff) | ((color->g & 0xff) << 8);
889 *high =(color->r & 0xff) | ((color->a & 0xff) << 8);
890
891 break;
892 case GFX_FMT_FABAFGBG2266:
893 *low = ((blinkData->background & 0x3f)<<2)|(((blinkData->foreground & 0x3f)<<2)<<8);
894 *high = ((blinkData->Bits3.Ba & 0x3)<<6)|(((blinkData->Bits3.Fa & 0x3)<<6)<<8);
895
896 break;
897 default:
898 GFX_ASSERT(0, GFX_ASSERT("[GE DRV][%06d] Bad color format\n", __LINE__));
899 *low =(color->b & 0xff) | ((color->g & 0xff) << 8);
900 *high =(color->r & 0xff) | ((color->a & 0xff) << 8);
901 break;
902 }
903
904 }
905
MApi_GFX_GetBufferInfo_U02(void * pInstance,PGFX_BufferInfo srcbufInfo,PGFX_BufferInfo dstbufInfo)906 GFX_Result MApi_GFX_GetBufferInfo_U02(void* pInstance, PGFX_BufferInfo srcbufInfo, PGFX_BufferInfo dstbufInfo)
907 {
908 GE_BufInfo bufinfo;
909 GE_Result ret;
910
911 APICheckU02();
912
913 ret = MDrv_GE_GetBufferInfo(g_apiGFXLocal.g_pGEContext, &bufinfo);
914 srcbufInfo->u32ColorFmt = (GFX_Buffer_Format)bufinfo.srcfmt; // DANGER, need refine.
915 srcbufInfo->u32Pitch = bufinfo.srcpit;
916 srcbufInfo->u32Addr = bufinfo.srcaddr;
917
918 dstbufInfo->u32ColorFmt = (GFX_Buffer_Format)bufinfo.dstfmt;
919 dstbufInfo->u32Pitch = bufinfo.dstpit;
920 dstbufInfo->u32Addr = bufinfo.dstaddr;
921
922 return (GFX_Result)ret; // DANGER, need refine.
923 }
924
MApi_GFX_GetClip_U02(void * pInstance,GFX_Point * v0,GFX_Point * v1)925 GFX_Result MApi_GFX_GetClip_U02(void* pInstance, GFX_Point* v0, GFX_Point* v1)
926 {
927 GE_Rect rect;
928
929 APICheckU02();
930
931 MDrv_GE_GetClipWindow(g_apiGFXLocal.g_pGEContext, &rect);
932
933 v0->x = rect.x ; // dangerous if V0 > V1
934 v0->y = rect.y ;
935 v1->x = rect.width + v0->x - 1;
936 v1->y = rect.height + v0->y - 1;
937
938 return GFX_SUCCESS;
939 }
940
MApi_GFX_GetGECaps_U02(void * pInstance,EN_GFX_CAPS eCapType,MS_U32 * pRet,MS_U32 ret_size)941 GFX_Result MApi_GFX_GetGECaps_U02(void* pInstance, EN_GFX_CAPS eCapType, MS_U32* pRet, MS_U32 ret_size)
942 {
943 APICheckU02();
944
945 switch(eCapType)
946 {
947 case E_GFX_CAP_MULTI_PIXEL:
948 {
949 GFX_CapMultiPixelInfo *pMultiPixelInfo;
950 if(ret_size != sizeof(GFX_CapMultiPixelInfo))
951 {
952 GFX_ERR("[%s] ERROR, invalid input structure size :%td on GFX_CapMultiPixelInfo\n",__FUNCTION__,(ptrdiff_t)ret_size);
953 return GFX_INVALID_PARAMETERS;
954 }
955 pMultiPixelInfo = (GFX_CapMultiPixelInfo *)pRet;
956 pMultiPixelInfo->bSupportMultiPixel = g_apiGFXLocal.pGeChipProperty->bSupportMultiPixel;
957 pMultiPixelInfo->WordUnit = g_apiGFXLocal.pGeChipProperty->WordUnit;
958 }
959 break;
960 case E_GFX_CAP_BLT_DOWN_SCALE:
961 {
962 GFX_BLT_DownScaleInfo *pBltDownScaleInfo;
963 if(ret_size != sizeof(GFX_BLT_DownScaleInfo))
964 {
965 GFX_ERR("[%s] ERROR, invalid input structure size :%td on GFX_BLT_DownScaleInfo\n",__FUNCTION__,(ptrdiff_t)ret_size);
966 return GFX_INVALID_PARAMETERS;
967 }
968 pBltDownScaleInfo = (GFX_BLT_DownScaleInfo *)pRet;
969 pBltDownScaleInfo->bFullRangeSupport = g_apiGFXLocal.pGeChipProperty->BltDownScaleCaps.bFullRangeSupport;
970 pBltDownScaleInfo->u8RangeMax = g_apiGFXLocal.pGeChipProperty->BltDownScaleCaps.u8RangeMax;
971 pBltDownScaleInfo->u8RangeMin = g_apiGFXLocal.pGeChipProperty->BltDownScaleCaps.u8RangeMin;
972 pBltDownScaleInfo->u8ContinuousRangeMin = g_apiGFXLocal.pGeChipProperty->BltDownScaleCaps.u8ContinuousRangeMin;
973 }
974 break;
975 case E_GFX_CAP_DFB_BLENDING:
976 {
977 MS_U16 *pU16SupportedBldFlags;
978 if(ret_size != sizeof(MS_U16))
979 {
980 GFX_ERR("[%s] ERROR, invalid input structure size :%td on GFX_CAP_DFB_BLENDING\n",__FUNCTION__,(ptrdiff_t)ret_size);
981 return GFX_INVALID_PARAMETERS;
982 }
983 pU16SupportedBldFlags = (MS_U16 *)pRet;
984 MDrv_GE_QueryDFBBldCaps(g_apiGFXLocal.g_pGEContext, pU16SupportedBldFlags);
985 }
986 break;
987 case E_GFX_CAP_ALIGN:
988 {
989 GFX_FmtAlignCapsInfo* pAlignCapsInfo;
990 GE_FmtCaps caps;
991 pAlignCapsInfo = (GFX_FmtAlignCapsInfo *)pRet;
992 memset(&caps, 0, sizeof(GE_FmtCaps));
993 MDrv_GE_GetFmtCaps(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)pAlignCapsInfo->u32ColorFmt, (GE_BufType)pAlignCapsInfo->eBufferType, &caps);
994
995 switch(pAlignCapsInfo->eFmtCapsType)
996 {
997 case E_GFX_FMT_CAP_NONE:
998 pAlignCapsInfo->u8BaseAlign = caps.u8BaseAlign;
999 pAlignCapsInfo->u8PitchAlign = caps.u8PitchAlign;
1000 break;
1001 case E_GFX_FMT_CAP_MULTI_PIXEL:
1002 pAlignCapsInfo->u8BaseAlign = caps.u8Non1pAlign;
1003 pAlignCapsInfo->u8PitchAlign = caps.u8Non1pAlign;
1004 if(FALSE == g_apiGFXLocal.pGeChipProperty->bSupportMultiPixel)
1005 {
1006 GFX_ERR("[%s] not support multi-pixel mode\n",__FUNCTION__);
1007 return GFX_INVALID_PARAMETERS;
1008 }
1009 break;
1010 default:
1011 GFX_DBUG("[%s] not support GFX format capability case: %d\n",__FUNCTION__, pAlignCapsInfo->eFmtCapsType);
1012 break;
1013 }
1014 }
1015 break;
1016 case E_GFX_CAP_TLB:
1017 {
1018 MS_BOOL *bSupportTLB;
1019 if(ret_size != sizeof(MS_BOOL))
1020 {
1021 GFX_ERR("[%s] ERROR, invalid input structure size :%td on MS_BOOL\n",__FUNCTION__,(ptrdiff_t)ret_size);
1022 return GFX_INVALID_PARAMETERS;
1023 }
1024 bSupportTLB = (MS_BOOL *)pRet;
1025 *bSupportTLB = g_apiGFXLocal.pGeChipProperty->bSupportTLBMode;
1026 }
1027 break;
1028 default:
1029 GFX_ERR("[%s]not support GFX capability case: %d\n",__FUNCTION__, eCapType);
1030 return GFX_INVALID_PARAMETERS;
1031 }
1032
1033 return GFX_SUCCESS;
1034 }
1035
MApi_GFX_GetDBGInfo_U02(void * pInstance,GFX_DbgInfo * dbg)1036 GFX_Result MApi_GFX_GetDBGInfo_U02(void* pInstance, GFX_DbgInfo *dbg)
1037 {
1038 GE_DbgInfo tGEDBG;
1039
1040 APICheckU02();
1041
1042 memset(&tGEDBG,0,sizeof(GE_DbgInfo));
1043
1044 MDrv_GE_GetInfo(g_apiGFXLocal.g_pGEContext, &tGEDBG);
1045
1046 memcpy(dbg, &tGEDBG, sizeof(GE_DbgInfo));
1047
1048 return GFX_SUCCESS;
1049 }
1050
MApi_GFX_DrawLine_U02(void * pInstance,GFX_DrawLineInfo * pline)1051 GFX_Result MApi_GFX_DrawLine_U02(void* pInstance, GFX_DrawLineInfo *pline)
1052 {
1053 GFX_RgbColor color_s, color_e;
1054 MS_U32 u32data;
1055 MS_U16 u16Color0=0, u16Color1=0;
1056
1057 GE_Point v0, v1;
1058 MS_U32 color, color2;
1059 MS_U32 flags = 0;
1060
1061 APICheckU02();
1062
1063 v0.x = pline->x1;
1064 v0.y = pline->y1;
1065 color_s = pline->colorRange.color_s;
1066 memcpy(&u32data, &color_s, 4);
1067 GFX_ConvertRGB2PCFmt(pline->fmt, (MS_U32*)&u32data, &u16Color0, &u16Color1);
1068 color = (u16Color1<<16) | u16Color0;
1069
1070 v1.x = pline->x2;
1071 v1.y = pline->y2;
1072 color_e = pline->colorRange.color_e;
1073 memcpy(&u32data, &color_e, 4);
1074 GFX_ConvertRGB2PCFmt(pline->fmt, (MS_U32*)&u32data, &u16Color0, &u16Color1);
1075 color2 = (u16Color1<<16) | u16Color0;
1076
1077 if (pline->flag & GFXLINE_FLAG_COLOR_GRADIENT)
1078 {
1079 flags |= E_GE_FLAG_LINE_GRADIENT;
1080 }
1081
1082 return (GFX_Result) MDrv_GE_DrawLine(g_apiGFXLocal.g_pGEContext, &v0, &v1, color, color2, flags, pline->width);
1083 }
1084
1085
MApi_GFX_RectFill_U02(void * pInstance,GFX_RectFillInfo * pfillblock)1086 GFX_Result MApi_GFX_RectFill_U02(void* pInstance, GFX_RectFillInfo *pfillblock)
1087 {
1088 GFX_RgbColor color_s, color_e;
1089 MS_U16 u16Color0=0, u16Color1=0;
1090 GFX_BlinkData blinkData;
1091
1092 GE_Rect rect;
1093 MS_U32 color, color2;
1094 MS_U32 flags = 0;
1095
1096 APICheckU02();
1097
1098 rect.x = pfillblock->dstBlock.x;
1099 rect.y = pfillblock->dstBlock.y;
1100 rect.width = pfillblock->dstBlock.width;
1101 rect.height = pfillblock->dstBlock.height;
1102
1103 color_s = pfillblock->colorRange.color_s;
1104 if(pfillblock->fmt == GFX_FMT_1ABFGBG12355 || pfillblock->fmt == GFX_FMT_FABAFGBG2266)
1105 {
1106 if(pfillblock->fmt == GFX_FMT_1ABFGBG12355)
1107 {
1108 memcpy(&blinkData, &color_s, sizeof(GFX_BlinkData));
1109 u16Color0= (0x1F & blinkData.background)<<3 |
1110 ((0x1F & blinkData.foreground) << 11);
1111 u16Color1= (0x7 & blinkData.Bits.Blink)<<3 |
1112 ((0x3 & blinkData.Bits.Alpha) << 6) |
1113 0xff00;
1114 }
1115 if(pfillblock->fmt == GFX_FMT_FABAFGBG2266)
1116 {
1117 memcpy(&blinkData, &color_s, sizeof(GFX_BlinkData));
1118 u16Color0= ((0x3F & blinkData.background)<<2) |
1119 (((0x3F & blinkData.foreground)<<2) << 8);
1120 u16Color1= ((0x3 & blinkData.Bits3.Ba)<<6) |
1121 (((0x3 & blinkData.Bits3.Fa)<<6) << 8);
1122 }
1123 color = (u16Color1<<16) | u16Color0;
1124 }
1125 else
1126 {
1127 memcpy(&color, &color_s, sizeof(color));
1128 }
1129
1130
1131 color_e = pfillblock->colorRange.color_e;
1132 if(pfillblock->fmt == GFX_FMT_1ABFGBG12355 || pfillblock->fmt == GFX_FMT_FABAFGBG2266)
1133 {
1134 if(pfillblock->fmt == GFX_FMT_1ABFGBG12355)
1135 {
1136 memcpy(&blinkData, &color_e, sizeof(GFX_BlinkData));
1137 u16Color0= (0x1F & blinkData.background)<<3 |
1138 ((0x1F & blinkData.foreground) << 11);
1139 u16Color1= (0x7 & blinkData.Bits.Blink)<<3 |
1140 ((0x3 & blinkData.Bits.Alpha) << 6) |
1141 0xff00;
1142 }
1143 if(pfillblock->fmt == GFX_FMT_FABAFGBG2266)
1144 {
1145 memcpy(&blinkData, &color_e, sizeof(GFX_BlinkData));
1146 u16Color0= ((0x3F & blinkData.background)<<2) |
1147 (((0x3F & blinkData.foreground)<<2) << 8);
1148 u16Color1= ((0x3 & blinkData.Bits3.Ba)<<6) |
1149 (((0x3 & blinkData.Bits3.Fa)<<6) << 8);
1150 }
1151 color2 = (u16Color1<<16) | u16Color0;
1152
1153 }
1154 else
1155 {
1156 memcpy(&color2, &color_e, sizeof(color));
1157 }
1158
1159 flags |= (pfillblock->flag & GFXRECT_FLAG_COLOR_GRADIENT_X) ? E_GE_FLAG_RECT_GRADIENT_X : 0;
1160 flags |= (pfillblock->flag & GFXRECT_FLAG_COLOR_GRADIENT_Y) ? E_GE_FLAG_RECT_GRADIENT_Y : 0;
1161
1162 return (GFX_Result) MDrv_GE_FillRect(g_apiGFXLocal.g_pGEContext, &rect, color, color2, flags);
1163 }
1164
MApi_GFX_TriFill_U02(void * pInstance,GFX_TriFillInfo * pfillblock)1165 GFX_Result MApi_GFX_TriFill_U02(void* pInstance, GFX_TriFillInfo *pfillblock)
1166 {
1167 int y, yend;
1168 DDA dda0 = { .xi = 0 }, dda1 = { .xi = 0 };
1169 int clip_x0 = 0,clip_x1 = 0,clip_y0 = 0,clip_y1 = 0;
1170 MS_BOOL bClip = 0;
1171 GFX_RectFillInfo rectInfo;
1172
1173 if( (pfillblock->clip_box.width != 0) && (pfillblock->clip_box.height != 0) )
1174 {
1175 bClip = 1;
1176 clip_x0 = pfillblock->clip_box.x;
1177 clip_x1 = pfillblock->clip_box.x + pfillblock->clip_box.width;
1178 clip_y0 = pfillblock->clip_box.y;
1179 clip_y1 = pfillblock->clip_box.y + pfillblock->clip_box.height;
1180 }
1181
1182 rectInfo.fmt = pfillblock->fmt;
1183 rectInfo.colorRange.color_s = pfillblock->colorRange.color_s;
1184 rectInfo.colorRange.color_e = pfillblock->colorRange.color_e;
1185 rectInfo.flag = pfillblock->flag;
1186
1187 y = pfillblock->tri.y0;
1188 yend = pfillblock->tri.y2;
1189
1190 if ( (bClip == 1) && (yend > clip_y1))
1191 yend = clip_y1;
1192
1193 SETUP_DDA(pfillblock->tri.x0, pfillblock->tri.y0, pfillblock->tri.x2, pfillblock->tri.y2, dda0);
1194 SETUP_DDA(pfillblock->tri.x0, pfillblock->tri.y0, pfillblock->tri.x1, pfillblock->tri.y1, dda1);
1195
1196 while (y <= yend) {
1197 if (y == pfillblock->tri.y1) {
1198 if (pfillblock->tri.y1 == pfillblock->tri.y2)
1199 return GFX_SUCCESS;
1200 SETUP_DDA(pfillblock->tri.x1, pfillblock->tri.y1, pfillblock->tri.x2, pfillblock->tri.y2, dda1);
1201 }
1202
1203 rectInfo.dstBlock.width = ABS(dda0.xi - dda1.xi);
1204 rectInfo.dstBlock.x = MIN(dda0.xi, dda1.xi);
1205
1206 if ( (bClip == 1) && (clip_x1 < rectInfo.dstBlock.x + rectInfo.dstBlock.width) )
1207 rectInfo.dstBlock.width = clip_x1 - rectInfo.dstBlock.x + 1;
1208
1209 if (rectInfo.dstBlock.width > 0) {
1210 if ( (bClip == 1) && (clip_x0 > rectInfo.dstBlock.x) ) {
1211 rectInfo.dstBlock.width -= (clip_x0 - rectInfo.dstBlock.x);
1212 rectInfo.dstBlock.x = clip_x0;
1213 }
1214 rectInfo.dstBlock.y = y;
1215 rectInfo.dstBlock.height = 1;
1216
1217 if (rectInfo.dstBlock.width > 0) {
1218 if( (bClip == 1) && (rectInfo.dstBlock.y >= clip_y0) )
1219 MApi_GFX_RectFill_U02(pInstance,&rectInfo);
1220 else if(bClip == 0)
1221 MApi_GFX_RectFill_U02(pInstance,&rectInfo);
1222
1223 }
1224 }
1225
1226 INC_DDA(dda0);
1227 INC_DDA(dda1);
1228
1229 y++;
1230 }
1231 return GFX_SUCCESS;
1232 }
1233
clip_rectangle(GFX_Block clip,GFX_Block * dstBlock)1234 MS_BOOL clip_rectangle(GFX_Block clip,GFX_Block *dstBlock)
1235 {
1236 if ((clip.x >= dstBlock->x + dstBlock->width) ||
1237 ((clip.x + clip.width) < dstBlock->x) ||
1238 (clip.y >= dstBlock->y + dstBlock->height) ||
1239 ((clip.y + clip.height) < dstBlock->y))
1240 return FALSE;
1241
1242 if (clip.x > dstBlock->x) {
1243 dstBlock->width += dstBlock->x - clip.x;
1244 dstBlock->x = clip.x;
1245 }
1246
1247 if (clip.y > dstBlock->y) {
1248 dstBlock->height += dstBlock->y - clip.y;
1249 dstBlock->y = clip.y;
1250 }
1251
1252 if ((clip.x + clip.width) < dstBlock->x + dstBlock->width - 1)
1253 dstBlock->width = (clip.x + clip.width) - dstBlock->x + 1;
1254
1255 if ((clip.y + clip.height) < dstBlock->y + dstBlock->height - 1)
1256 dstBlock->height = (clip.y + clip.height) - dstBlock->y + 1;
1257
1258 return TRUE;
1259 }
1260
MApi_GFX_SpanFill_U02(void * pInstance,GFX_SpanFillInfo * pfillblock)1261 GFX_Result MApi_GFX_SpanFill_U02(void* pInstance, GFX_SpanFillInfo *pfillblock)
1262 {
1263 GFX_RectFillInfo rectInfo;
1264 MS_BOOL bClip = 0;
1265 int i;
1266
1267 rectInfo.fmt = pfillblock->fmt;
1268 rectInfo.colorRange.color_s = pfillblock->colorRange.color_s;
1269 rectInfo.colorRange.color_e = pfillblock->colorRange.color_e;
1270 rectInfo.flag = pfillblock->flag;
1271
1272 if( (pfillblock->clip_box.width != 0) && (pfillblock->clip_box.height != 0) ){
1273 bClip = 1;
1274 }
1275
1276 for (i = 0; i<pfillblock->span.num_spans; i++) {
1277 rectInfo.dstBlock.x = pfillblock->span.spans[i].x;
1278 rectInfo.dstBlock.y = pfillblock->span.y+i;
1279 rectInfo.dstBlock.width = pfillblock->span.spans[i].w;
1280 rectInfo.dstBlock.height = 1;
1281
1282
1283 if ( bClip &&
1284 !clip_rectangle( pfillblock->clip_box, &rectInfo.dstBlock))
1285 continue;
1286
1287 MApi_GFX_RectFill_U02(pInstance,&rectInfo);
1288 }
1289
1290 return GFX_SUCCESS;
1291 }
1292
MApi_GFX_BitBlt_U02(void * pInstance,GFX_DrawRect * drawbuf,MS_U32 drawflag,GFX_ScaleInfo * ScaleInfo)1293 GFX_Result MApi_GFX_BitBlt_U02(void* pInstance, GFX_DrawRect * drawbuf, MS_U32 drawflag, GFX_ScaleInfo * ScaleInfo)
1294 {
1295 union
1296 {
1297 GFX_Block drawbufblk;
1298 GE_Rect blk;
1299 GE_DstBitBltType dstblk;
1300 GFX_Trapezoid dsttrapeblk;
1301 }sBltSrcBlk, sBltDstBlk;
1302
1303
1304 GE_ScaleInfo gecaleInfo;
1305 MS_U32 flags = 0;
1306
1307 APICheckU02();
1308
1309 if(drawflag & GFXDRAW_FLAG_SCALE)
1310 {
1311 flags |= E_GE_FLAG_BLT_STRETCH;
1312 }
1313
1314 if(drawflag & GFXDRAW_FLAG_TRAPEZOID_X)
1315 {
1316 flags |= E_GE_FLAG_TRAPEZOID_X;
1317 }
1318
1319 if(drawflag & GFXDRAW_FLAG_TRAPEZOID_Y)
1320 {
1321 flags |= E_GE_FLAG_TRAPEZOID_Y;
1322 }
1323
1324 flags |= GFX_RectBltFlags(pInstance);
1325
1326 if(ScaleInfo != NULL){
1327 if( (ScaleInfo->u32DeltaX != 0 ) && (ScaleInfo->u32DeltaY != 0 ) )
1328 {
1329 gecaleInfo.init_x = ScaleInfo->u32InitDelatX;
1330 gecaleInfo.init_y = ScaleInfo->u32InitDelatY;
1331 gecaleInfo.x = ScaleInfo->u32DeltaX;
1332 gecaleInfo.y = ScaleInfo->u32DeltaY;
1333
1334 flags |= E_GE_FLAG_BYPASS_STBCOEF;
1335 }
1336 }
1337 #if 1 // enable overlap
1338 if ( !(flags & (
1339 E_GE_FLAG_BLT_STRETCH |
1340 E_GE_FLAG_BLT_ITALIC |
1341 E_GE_FLAG_BLT_MIRROR_H |
1342 E_GE_FLAG_BLT_MIRROR_V |
1343 E_GE_FLAG_BLT_ROTATE_90 |
1344 E_GE_FLAG_BLT_ROTATE_180 |
1345 E_GE_FLAG_BLT_ROTATE_270 )) )
1346 {
1347 flags |= E_GE_FLAG_BLT_OVERLAP;
1348 }
1349 #endif
1350 sBltSrcBlk.drawbufblk = drawbuf->srcblk;
1351 sBltDstBlk.dsttrapeblk = drawbuf->dsttrapeblk;
1352 return (GFX_Result) MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext, &sBltSrcBlk.blk, &sBltDstBlk.dstblk, flags, (ScaleInfo==NULL)? NULL: &gecaleInfo);
1353 }
1354
1355 //-------------------------------------------------------------------------------------------------
1356 /// Set GFX destination buffer info in two source buffer mode
1357 /// Attention, when two source buffer mode enable, raw DstBuffer will be one of two source.
1358 /// @param dstbufInfo \b IN: pointer to destination frame buffer infomation.\n
1359 /// @param pdrawbuf \b IN: pointer to two source rects info
1360 /// @param drawflag \b IN: draw flag \n
1361 /// GFXDRAW_FLAG_DEFAULT \n
1362 /// GFXDRAW_FLAG_SCALE \n
1363 /// GFXDRAW_FLAG_DUPLICAPE \n
1364 /// GFXDRAW_FLAG_TRAPEZOID \n
1365 /// @return GFX_SUCCESS - Success
1366 /// @return GFX_FAIL - Failure
1367 //-------------------------------------------------------------------------------------------------
MApi_GFX_BitbltByTwoSourceBuffer_U02(void * pInstance,PGFX_BufferInfo dstbufInfo,GFX_DrawTwoSourceRect * pdrawbuf,MS_U32 drawflag)1368 GFX_Result MApi_GFX_BitbltByTwoSourceBuffer_U02(void* pInstance, PGFX_BufferInfo dstbufInfo, GFX_DrawTwoSourceRect *pdrawbuf, MS_U32 drawflag)
1369 {
1370 GE_Rect bitbltSrc0Rect;
1371 GE_Rect bitbltSrc1Rect;
1372 GE_Rect bitbltDestRect;
1373 MS_U32 flags = 0;
1374 APICheckU02();
1375
1376 if(NULL == dstbufInfo || NULL == pdrawbuf)
1377 {
1378 return GFX_INVALID_PARAMETERS;
1379 }
1380
1381 if (drawflag & GFXDRAW_FLAG_SCALE)
1382 {
1383 if(pdrawbuf->srcblk0.width != pdrawbuf->dstblk.width &&
1384 pdrawbuf->srcblk0.height != pdrawbuf->dstblk.height)
1385 {
1386 flags |= E_GE_FLAG_BLT_STRETCH;
1387 }
1388 }
1389 if(drawflag & GFXDRAW_FLAG_TRAPEZOID_X)
1390 {
1391 flags |= E_GE_FLAG_TRAPEZOID_X;
1392 }
1393 if(drawflag & GFXDRAW_FLAG_TRAPEZOID_Y)
1394 {
1395 flags |= E_GE_FLAG_TRAPEZOID_Y;
1396 }
1397 flags |= GFX_RectBltFlags(pInstance);
1398 #if 1 // enable overlap
1399 if ( !(flags & (
1400 E_GE_FLAG_BLT_STRETCH |
1401 E_GE_FLAG_BLT_ITALIC |
1402 E_GE_FLAG_BLT_MIRROR_H |
1403 E_GE_FLAG_BLT_MIRROR_V |
1404 E_GE_FLAG_BLT_ROTATE_90 |
1405 E_GE_FLAG_BLT_ROTATE_180 |
1406 E_GE_FLAG_BLT_ROTATE_270 )) )
1407 {
1408 flags |= E_GE_FLAG_BLT_OVERLAP;
1409 }
1410 #endif
1411 bitbltSrc0Rect.x = pdrawbuf->srcblk0.x;
1412 bitbltSrc0Rect.y = pdrawbuf->srcblk0.y;
1413 bitbltSrc0Rect.width = pdrawbuf->srcblk0.width;
1414 bitbltSrc0Rect.height = pdrawbuf->srcblk0.height;
1415 bitbltSrc1Rect.x = pdrawbuf->srcblk1.x;
1416 bitbltSrc1Rect.y = pdrawbuf->srcblk1.y;
1417 bitbltSrc1Rect.width = pdrawbuf->dstblk.width; //srcbuf1 width must be the same as dest width
1418 bitbltSrc1Rect.height = pdrawbuf->dstblk.height; //srcbuf1 height must be the same as dest height
1419 bitbltDestRect.x = pdrawbuf->dstblk.x;
1420 bitbltDestRect.y = pdrawbuf->dstblk.y;
1421 bitbltDestRect.width = pdrawbuf->dstblk.width;
1422 bitbltDestRect.height = pdrawbuf->dstblk.height;
1423 return (GFX_Result) MDrv_GE_BitBltByTwoSourceBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)dstbufInfo->u32ColorFmt,
1424 &bitbltSrc0Rect, &bitbltSrc1Rect, &bitbltDestRect, dstbufInfo->u32Addr, dstbufInfo->u32Pitch, flags, NULL);
1425 }
1426
MApi_GFX_SetSrcColorKey_U02(void * pInstance,MS_BOOL enable,GFX_ColorKeyMode opMode,GFX_Buffer_Format fmt,void * ps_color,void * pe_color)1427 GFX_Result MApi_GFX_SetSrcColorKey_U02(void* pInstance, MS_BOOL enable,
1428 GFX_ColorKeyMode opMode,
1429 GFX_Buffer_Format fmt,
1430 void *ps_color,
1431 void *pe_color)
1432 {
1433 MS_U32 ck_low, ck_high, u32op1=0, ret;
1434 MS_U16 u16Color0=0, u16Color1=0;
1435
1436 APICheckU02();
1437
1438 GFX_ConvertRGB2DBFmt(fmt, (MS_U32 *)ps_color, &u16Color0, &u16Color1);
1439 ck_low = (u16Color1<<16) | u16Color0;
1440 GFX_ConvertRGB2DBFmt(fmt, (MS_U32 *)pe_color, &u16Color0, &u16Color1);
1441 ck_high = (u16Color1<<16) | u16Color0;
1442
1443 ret = MApi_GFX_MapCKOP(opMode, &u32op1 );
1444 if(ret != GFX_SUCCESS)
1445 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1446
1447
1448 return (GFX_Result) MDrv_GE_SetSrcColorKey(g_apiGFXLocal.g_pGEContext, enable, (GE_CKOp)u32op1, ck_low, ck_high);
1449 }
1450
MApi_GFX_SetDstColorKey_U02(void * pInstance,MS_BOOL enable,GFX_ColorKeyMode opMode,GFX_Buffer_Format fmt,void * ps_color,void * pe_color)1451 GFX_Result MApi_GFX_SetDstColorKey_U02(void* pInstance, MS_BOOL enable,
1452 GFX_ColorKeyMode opMode,
1453 GFX_Buffer_Format fmt,
1454 void *ps_color,
1455 void *pe_color)
1456 {
1457 MS_U32 ck_low, ck_high, u32op1=0, ret;
1458 MS_U16 u16Color0=0, u16Color1=0;
1459
1460 APICheckU02();
1461
1462 GFX_ConvertRGB2DBFmt(fmt, (MS_U32 *)ps_color, &u16Color0, &u16Color1);
1463 ck_low = (u16Color1<<16) | u16Color0;
1464 GFX_ConvertRGB2DBFmt(fmt, (MS_U32 *)pe_color, &u16Color0, &u16Color1);
1465 ck_high = (u16Color1<<16) | u16Color0;
1466
1467
1468 ret = MApi_GFX_MapCKOP(opMode, &u32op1 );
1469 if(ret != GFX_SUCCESS)
1470 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1471
1472 return (GFX_Result) MDrv_GE_SetDstColorKey(g_apiGFXLocal.g_pGEContext, enable, (GE_CKOp)u32op1, ck_low, ck_high);
1473 }
1474
1475
MApi_GFX_SetROP2_U02(void * pInstance,MS_BOOL enable,GFX_ROP2_Op eRopMode)1476 GFX_Result MApi_GFX_SetROP2_U02(void* pInstance, MS_BOOL enable, GFX_ROP2_Op eRopMode)
1477 {
1478 MS_U32 u32ROPmode=0, ret;
1479
1480 APICheckU02();
1481
1482 ret = MApi_GFX_MapROP2( eRopMode, &u32ROPmode );
1483 if(ret != GFX_SUCCESS)
1484 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1485 return (GFX_Result) MDrv_GE_SetROP2(g_apiGFXLocal.g_pGEContext, enable, (GE_Rop2) u32ROPmode);
1486 }
1487
MApi_GFX_SetIntensity_U02(void * pInstance,MS_U32 id,GFX_Buffer_Format fmt,MS_U32 * pColor)1488 GFX_Result MApi_GFX_SetIntensity_U02(void* pInstance, MS_U32 id, GFX_Buffer_Format fmt, MS_U32 *pColor)
1489 {
1490 MS_U16 u16Color0=0, u16Color1=0;
1491
1492 APICheckU02();
1493
1494 GFX_ConvertRGB2DBFmt(fmt, (MS_U32 *)pColor, &u16Color0, &u16Color1);
1495
1496 return (GFX_Result) MDrv_GE_SetIntensity(g_apiGFXLocal.g_pGEContext, id, (u16Color1<<16)|u16Color0);
1497 }
1498
MApi_GFX_SetDFBBldOP_U02(void * pInstance,GFX_DFBBldOP gfxSrcBldOP,GFX_DFBBldOP gfxDstBldOP)1499 GFX_Result MApi_GFX_SetDFBBldOP_U02(void* pInstance, GFX_DFBBldOP gfxSrcBldOP, GFX_DFBBldOP gfxDstBldOP)
1500 {
1501 GE_DFBBldOP geSrcBldOP, geDstBldOP;
1502 GFX_Result u32Ret;
1503
1504 APICheckU02();
1505
1506 u32Ret = MApi_GFX_MapDFBBldOP(gfxSrcBldOP, &geSrcBldOP);
1507 if(u32Ret != GFX_SUCCESS)
1508 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, u32Ret));
1509
1510 u32Ret = MApi_GFX_MapDFBBldOP(gfxDstBldOP, &geDstBldOP);
1511 if(u32Ret != GFX_SUCCESS)
1512 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, u32Ret));
1513
1514 return (GFX_Result) MDrv_GE_SetDFBBldOP(g_apiGFXLocal.g_pGEContext, geSrcBldOP, geDstBldOP);
1515 }
1516
MApi_GFX_SetDFBBldConstColor_U02(void * pInstance,GFX_RgbColor gfxRgbColor)1517 GFX_Result MApi_GFX_SetDFBBldConstColor_U02(void* pInstance, GFX_RgbColor gfxRgbColor)
1518 {
1519 GE_RgbColor geRgbColor;
1520
1521 APICheckU02();
1522
1523 geRgbColor.a = gfxRgbColor.a;
1524 geRgbColor.r = gfxRgbColor.r;
1525 geRgbColor.g = gfxRgbColor.g;
1526 geRgbColor.b = gfxRgbColor.b;
1527
1528 return (GFX_Result) MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
1529 }
1530
MApi_GFX_SetDFBBldFlags_U02(void * pInstance,MS_U16 u16DFBBldFlags)1531 GFX_Result MApi_GFX_SetDFBBldFlags_U02(void* pInstance, MS_U16 u16DFBBldFlags)
1532 {
1533 MS_U16 u16DrvDFBBldFlags;
1534 GFX_Result u32Ret;
1535
1536 APICheckU02();
1537
1538 u32Ret = MApi_GFX_MapDFBBldFlag(u16DFBBldFlags, &u16DrvDFBBldFlags);
1539 if(u32Ret != GFX_SUCCESS)
1540 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, u32Ret));
1541
1542 return (GFX_Result) MDrv_GE_SetDFBBldFlags(g_apiGFXLocal.g_pGEContext, u16DrvDFBBldFlags);
1543 }
1544
MApi_GFX_SetClip_U02(void * pInstance,GFX_Point * v0,GFX_Point * v1)1545 GFX_Result MApi_GFX_SetClip_U02(void* pInstance, GFX_Point* v0, GFX_Point* v1)
1546 {
1547 GE_Rect rect;
1548
1549 APICheckU02();
1550
1551 rect.x = v0->x; // dangerous if V0 > V1
1552 rect.y = v0->y;
1553 rect.width = v1->x - v0->x + 1;
1554 rect.height = v1->y - v0->y + 1;
1555
1556 return (GFX_Result) MDrv_GE_SetClipWindow(g_apiGFXLocal.g_pGEContext, &rect);
1557 }
1558
MApi_GFX_SetPaletteOpt_U02(void * pInstance,GFX_PaletteEntry * pPalArray,MS_U16 u32PalStart,MS_U16 u32PalEnd)1559 GFX_Result MApi_GFX_SetPaletteOpt_U02( void* pInstance, GFX_PaletteEntry *pPalArray, MS_U16 u32PalStart, MS_U16 u32PalEnd)
1560 {
1561 MS_U16 i;
1562 //----------------------------------------------------------------------
1563 // Write palette
1564 //----------------------------------------------------------------------
1565 //U32 clr;
1566 MS_U16 j=0;
1567 MS_U32 u32data;
1568
1569 APICheckU02();
1570
1571 for(i=u32PalStart; i<=u32PalEnd ; i++)
1572 {
1573
1574 GFX_DEBUGINFO(GFX_INFO("MDrv_GE_SetPaletteOpt : Array[%03d]. u8A %02bX | u8R %02bX | u8G %02bX |u8B %02bX\n",i,
1575 pPalArray[j].RGB.u8A,
1576 pPalArray[j].RGB.u8R,
1577 pPalArray[j].RGB.u8G,
1578 pPalArray[j].RGB.u8B));
1579
1580 memcpy(&u32data, &pPalArray[j], 4);
1581 MDrv_GE_SetPalette(g_apiGFXLocal.g_pGEContext, i, 1, (MS_U32*)&u32data);
1582
1583 j++;
1584
1585 }
1586 return GFX_SUCCESS;
1587
1588 }
1589
MApi_GFX_SetVCmdBuffer_U02(void * pInstance,MS_PHY PhyAddr,GFX_VcmqBufSize enBufSize)1590 GFX_Result MApi_GFX_SetVCmdBuffer_U02(void* pInstance, MS_PHY PhyAddr, GFX_VcmqBufSize enBufSize)
1591 {
1592 MS_U32 u32op1=0, ret;
1593
1594 APICheckU02();
1595
1596 ret = MApi_GFX_MapVCMQSZ(enBufSize, &u32op1 );
1597 if(ret != GFX_SUCCESS)
1598 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1599
1600 if(E_GE_OK != MDrv_GE_SetVCmdBuffer(g_apiGFXLocal.g_pGEContext, PhyAddr, (GE_VcmqBufSize)u32op1))
1601 {
1602 return GFX_FAIL;
1603 }
1604
1605 return GFX_SUCCESS;
1606 }
1607
MApi_GFX_EnableAlphaBlending_U02(void * pInstance,MS_BOOL enable)1608 GFX_Result MApi_GFX_EnableAlphaBlending_U02(void* pInstance, MS_BOOL enable)
1609 {
1610 MS_U32 u32op1 =0, ret;
1611 APICheckU02();
1612
1613 ret = MApi_GFX_MapBLDCOEF(g_apiGFXLocal.pABLInfo.eBldCoef, &u32op1 );
1614 if(ret != GFX_SUCCESS)
1615 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1616
1617 return (GFX_Result) MDrv_GE_SetAlphaBlend(g_apiGFXLocal.g_pGEContext, enable, (GE_BlendOp)u32op1);
1618 }
1619
MApi_GFX_SetAlpha_U02(void * pInstance,MS_BOOL enable,GFX_BlendCoef coef,GFX_AlphaSrcFrom db_abl,MS_U8 abl_const)1620 GFX_Result MApi_GFX_SetAlpha_U02(void* pInstance, MS_BOOL enable, GFX_BlendCoef coef, GFX_AlphaSrcFrom db_abl, MS_U8 abl_const)
1621 {
1622 MS_U32 u32op1=0, u32op2=0, ret;
1623 APICheckU02();
1624
1625 ret = MApi_GFX_MapBLDCOEF(coef, &u32op1 );
1626 if(ret != GFX_SUCCESS)
1627 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1628
1629 ret = MApi_GFX_MapABLCOEF(db_abl, &u32op2 );
1630 if(ret != GFX_SUCCESS)
1631 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
1632
1633 MDrv_GE_SetAlphaConst(g_apiGFXLocal.g_pGEContext, abl_const);
1634 MDrv_GE_SetAlphaSrc(g_apiGFXLocal.g_pGEContext, (GE_AlphaSrc)u32op2);
1635 MDrv_GE_SetAlphaBlend(g_apiGFXLocal.g_pGEContext, enable, (GE_BlendOp)u32op1);
1636
1637 return GFX_SUCCESS;
1638 }
1639
1640
MApi_GFX_DrawBitmap_U02(void * pInstance,GFX_BufferInfo srcbufinfo,GFX_DrawBmpInfo * pbmpfmt)1641 GFX_Result MApi_GFX_DrawBitmap_U02(void* pInstance, GFX_BufferInfo srcbufinfo, GFX_DrawBmpInfo *pbmpfmt)
1642 {
1643 APICheckU02();
1644
1645 GFX_DEBUGINFO( GFX_INFO( "MApi_GFX_DrawBitmap\n" ) );
1646
1647 if (!GFX_CheckInClipWindow(pbmpfmt->x, pbmpfmt->y, pbmpfmt->x+pbmpfmt->width-1, pbmpfmt->y+pbmpfmt->height-1))
1648 {
1649 return GFX_FAIL;
1650 }
1651
1652 #if 1
1653 {
1654 MS_U32 flags = 0;
1655 GE_Rect src;
1656 union
1657 {
1658 GE_Rect dstblk;
1659 GE_DstBitBltType drvdstblk;
1660 }dst;
1661
1662 src.x = 0;
1663 src.y = 0;
1664 src.width = srcbufinfo.u32Width;
1665 src.height = srcbufinfo.u32Height;
1666 dst.dstblk.x = pbmpfmt->x;
1667 dst.dstblk.y = pbmpfmt->y;
1668 dst.dstblk.width = pbmpfmt->width;
1669 dst.dstblk.height = pbmpfmt->height;
1670 if (pbmpfmt->bScale == true)
1671 {
1672 flags |= E_GE_FLAG_BLT_STRETCH;
1673 }
1674
1675 flags |= GFX_RectBltFlags(pInstance);
1676
1677 if (flags & E_GE_FLAG_BLT_MIRROR_H)
1678 {
1679 src.x = src.width;
1680 }
1681
1682 if (flags & E_GE_FLAG_BLT_MIRROR_V)
1683 {
1684 src.y = src.height;
1685 }
1686
1687 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext, &src, &dst.drvdstblk, flags, NULL);
1688 }
1689 #else
1690 /*
1691 MS_U32 u32Width, u32Height;
1692 MS_U32 u32Value, u32Value2, u32Addr, u32Pitch;
1693
1694 GE_WaitCmdQAvail(24);
1695
1696 u32Value = PE_ReadReg(PE_REG_SB_DB_MODE);
1697 u32Value &= ~(PE_MSK_SB_FMT);
1698
1699 PE_WriteReg(PE_REG_SB_DB_MODE, (u32Value|_BitmapTable[handle].fmt));
1700
1701 u32Value2 = PE_ReadReg(PE_REG_FMT_BLT);
1702
1703 u32Addr = (_BitmapTable[handle].addr ) ;
1704 u32Width = _BitmapTable[handle].width;
1705 u32Height = _BitmapTable[handle].height;
1706 u32Pitch = _BitmapTable[handle].pitch;
1707
1708 // Set source address
1709 PE_WriteReg(PE_REG_SB_BASE0, u32Addr & 0xffff);
1710 PE_WriteReg(PE_REG_SB_BASE1, u32Addr >> 16);
1711
1712 // Set source pitch
1713 PE_WriteReg(PE_REG_SB_PIT, u32Pitch);
1714
1715 PE_WriteReg(PE_REG_STBB_WIDTH, u32Width);
1716 PE_WriteReg(PE_REG_STBB_HEIGHT, u32Height);
1717
1718 // Set source coordinate
1719 PE_WriteReg(PE_REG_PRI_V2_X, 0);
1720 PE_WriteReg(PE_REG_PRI_V2_Y, 0);
1721
1722 //------------------------------------------------------------
1723 // BLT scale delta value
1724 //------------------------------------------------------------
1725 if ((u32Width != pbmpfmt->width) || (u32Height != pbmpfmt->height))
1726 {
1727 if (pbmpfmt->bScale == true)
1728 {
1729 u32Value = Divide2Fixed(u32Width, pbmpfmt->width, 1, 12);//<< 2 ; //sc
1730 PE_WriteReg(PE_REG_STBB_DX, u32Value & 0xffff);
1731 u32Value = Divide2Fixed((u32Width - pbmpfmt->width), 2* pbmpfmt->width, 1, 12);// << 2; //sc
1732 PE_WriteReg(PE_REG_STBB_INIT_DX, u32Value);
1733
1734
1735 u32Value = Divide2Fixed(u32Height, pbmpfmt->height, 1, 12);// << 2 ; //sc
1736 PE_WriteReg(PE_REG_STBB_DY, u32Value & 0xffff);
1737 u32Value = Divide2Fixed((u32Height- pbmpfmt->height), 2* pbmpfmt->height, 1, 12);// << 2; //sc
1738 PE_WriteReg(PE_REG_STBB_INIT_DY, u32Value);
1739
1740 u32Width = pbmpfmt->width;
1741 u32Height = pbmpfmt->height;
1742 u32Value2 |= PE_VAL_EN_STRETCH_BITBLT;
1743 }
1744 else
1745 {
1746 u32Width = pbmpfmt->width;
1747 u32Height = pbmpfmt->height;
1748 PE_WriteReg(PE_REG_STBB_DX, 0x1000);
1749 PE_WriteReg(PE_REG_STBB_DY, 0x1000);
1750 PE_WriteReg(PE_REG_STBB_INIT_DX, 0);
1751 PE_WriteReg(PE_REG_STBB_INIT_DY, 0);
1752 u32Value2 |= PE_VAL_EN_STRETCH_BITBLT;
1753 }
1754 }
1755 else
1756 {
1757 PE_WriteReg(PE_REG_STBB_DX, 0x1000);
1758 PE_WriteReg(PE_REG_STBB_DY, 0x1000);
1759 u32Value2 &= ~PE_VAL_EN_STRETCH_BITBLT;
1760 }
1761 PE_WriteReg(PE_REG_FMT_BLT, u32Value2);
1762
1763 if (u32Value2 & PE_VAL_EN_STRETCH_BITBLT)
1764 {
1765 _u32Reg60hFlag |= PE_VAL_STBB_PATCH;
1766 }
1767
1768 //------------------------------------------------------------
1769 // Destination coordinate
1770 //------------------------------------------------------------
1771 PE_WriteReg(PE_REG_PRI_V0_X, pbmpfmt->x);
1772 PE_WriteReg(PE_REG_PRI_V0_Y, pbmpfmt->y);
1773 PE_WriteReg(PE_REG_PRI_V1_X, pbmpfmt->x + u32Width - 1);
1774 PE_WriteReg(PE_REG_PRI_V1_Y, pbmpfmt->y + u32Height - 1);
1775
1776 if (_u32Reg60hFlag & PE_VAL_DRAW_SRC_DIR_X_NEG)
1777 {
1778 PE_WriteReg(PE_REG_PRI_V2_X, _BitmapTable[handle].width - 1);
1779 }
1780
1781 if (_u32Reg60hFlag & PE_VAL_DRAW_SRC_DIR_Y_NEG)
1782 {
1783 PE_WriteReg(PE_REG_PRI_V2_Y, _BitmapTable[handle].height - 1);
1784 }
1785
1786 PE_WriteReg(PE_REG_CMD, (PE_VAL_PRIM_BITBLT|_u32Reg60hFlag));
1787 */
1788 #endif
1789
1790 return GFX_SUCCESS;
1791 }
1792
GFX_TextOutEx(void * pInstance,MS_S32 fhandle,MS_U8 * pindex,MS_U32 strwidth,GFX_TextOutInfo * pfmt,GFX_FontInfo * pFonttable)1793 static GFX_Result GFX_TextOutEx(void* pInstance,MS_S32 fhandle,
1794 MS_U8 *pindex,
1795 MS_U32 strwidth,
1796 GFX_TextOutInfo *pfmt,
1797 GFX_FontInfo * pFonttable)
1798 {
1799 GFX_DEBUGINFO(GFX_INFO( "MApi_GFX_TextOut\n" ));
1800
1801 MS_U32 flags = 0, offset;
1802 MS_PHY addr;
1803 MS_U16 char_idx;
1804 MS_U32 pitch;
1805 MS_S32 dis;
1806 GE_Rect src;
1807 GE_BufFmt fmt;
1808 MS_VIRT ptr_addr;
1809 union
1810 {
1811 GE_Rect dstblk;
1812 GE_DstBitBltType drvdstblk;
1813 }dst;
1814 // OSD_RESOURCE_FONT_INFO osd_fonttable;
1815 APICheckU02();
1816
1817 if (pFonttable == NULL)
1818 {
1819 return GFX_INVALID_FONT_HANDLE;
1820 }
1821
1822 if (!pFonttable->inUsed)
1823 {
1824 return GFX_INVALID_FONT_HANDLE;
1825 }
1826
1827 if (pindex == NULL)
1828 {
1829 return GFX_INVALID_PARAMETERS;
1830 }
1831
1832 if (!GFX_CheckInClipWindow(pfmt->dstblk.x, pfmt->dstblk.y,
1833 pfmt->dstblk.x+pfmt->dstblk.width-1, pfmt->dstblk.y+pfmt->dstblk.height-1))
1834 {
1835 return GFX_FAIL;
1836 }
1837
1838 if(pfmt->flag & GFXFONT_FLAG_COMPACT)
1839 {
1840 dis = pfmt->dis;
1841 }
1842 else if (pfmt->flag & GFXFONT_FLAG_GAP)
1843 {
1844 dis = (0-pfmt->dis);
1845 }
1846 else
1847 {
1848 dis = 0;
1849 }
1850
1851 offset = pFonttable->offset;
1852 addr = pFonttable->addr;
1853 fmt = (GE_BufFmt)pFonttable->fmt;
1854 pitch = pFonttable->pitch;
1855
1856 // first font character
1857 if (strwidth == 2)
1858 {
1859 ptr_addr = (MS_VIRT)pindex;
1860 if(ptr_addr % 2 != 0)
1861 {
1862 GFX_DEBUGINFO(GFX_ERR("%s: %d\n", __FUNCTION__ , __LINE__);)
1863 return GFX_INVALID_PARAMETERS;
1864 }
1865 char_idx = *(MS_U16*)ptr_addr;
1866 pindex += 2;
1867 }
1868 else
1869 {
1870 char_idx = *(MS_U8*)pindex;
1871 pindex += 1;
1872 }
1873 src.x = 0;
1874 src.y = 0;
1875 src.width = pFonttable->width;
1876 src.height = pFonttable->height;
1877 dst.dstblk.x = pfmt->dstblk.x;
1878 dst.dstblk.y = pfmt->dstblk.y;
1879 if (pfmt->flag & GFXFONT_FLAG_SCALE)
1880 {
1881 dst.dstblk.width = pfmt->dstblk.width;
1882 dst.dstblk.height = pfmt->dstblk.height;
1883 flags |= E_GE_FLAG_BLT_STRETCH;
1884 }
1885 else
1886 {
1887 //NOTE: it's because some legacy code does not specify dstblk.width/height
1888 dst.dstblk.width = pFonttable->width;
1889 dst.dstblk.height = pFonttable->height;
1890 }
1891
1892 while (char_idx != '\0')
1893 {
1894 MDrv_GE_SetSrcBuffer(g_apiGFXLocal.g_pGEContext, fmt, src.width, src.height, (addr + char_idx*offset), pitch, 0);
1895
1896 flags |= GFX_RectBltFlags(pInstance);
1897 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext,&src, &dst.drvdstblk, flags, NULL);
1898
1899 if (strwidth == 2)
1900 {
1901 ptr_addr = (MS_VIRT)pindex;
1902 if(ptr_addr % 2 != 0)
1903 {
1904 GFX_DEBUGINFO(GFX_ERR("%s: %d\n", __FUNCTION__ , __LINE__);)
1905 return GFX_INVALID_PARAMETERS;
1906 }
1907 char_idx = *(MS_U16*)ptr_addr;
1908 pindex += 2;
1909 }
1910 else
1911 {
1912 char_idx = *(MS_U8*)pindex;
1913 pindex += 1;
1914 }
1915 dst.dstblk.x += dst.dstblk.width - dis; // next position
1916 }
1917 return GFX_SUCCESS;
1918 }
1919
MApi_GFX_TextOut_U02(void * pInstance,MS_S32 fhandle,MS_U8 * pindex,MS_U32 strwidth,GFX_TextOutInfo * pfmt,GFX_FontInfo * pFonttable)1920 GFX_Result MApi_GFX_TextOut_U02(void* pInstance, MS_S32 fhandle, MS_U8 *pindex, MS_U32 strwidth, GFX_TextOutInfo *pfmt, GFX_FontInfo * pFonttable)
1921 {
1922 GFX_DEBUGINFO(GFX_INFO( "MApi_GFX_TextOut\n" ));
1923 // OSD_RESOURCE_FONT_INFO osd_fonttable;
1924 GFX_GlyphDispInfo *pGlyInfo = pfmt->pGlyphDispInfo;
1925 MS_U16 glyph_index, char_code;
1926 //msAPI_OSD_RESOURCE_GetFontInfo(fhandle, &osd_fonttable);
1927 GFX_RgbColor tmpclr1, tmpclr2;
1928 MS_VIRT ptr_addr;
1929 MS_U16* ptr_u16;
1930 MS_BOOL bTextOutPatch;
1931 // GFX_Result Gfx_Ret = GFX_SUCCESS;
1932
1933 APICheckU02();
1934
1935 if (pFonttable == NULL)
1936 {
1937 return GFX_INVALID_FONT_HANDLE;
1938 }
1939
1940 bTextOutPatch = _GE_TextOutPatch(g_apiGFXLocal.g_pGEContext);
1941
1942 if(bTextOutPatch == TRUE)
1943 {
1944 //This is for A6 U02 alpha constant HW bug, when alpha value = 0x0 in alpha constant mode.It desnt work.
1945 //So we dont use alpha constant mode when color.a = 0x0
1946 if(pfmt->color.a != 0x0)
1947 MApi_GFX_SetAlpha_U02(pInstance, true, COEF_ASRC, ABL_FROM_CONST, pfmt->color.a);
1948 }
1949 else
1950 {
1951 MApi_GFX_SetAlpha_U02(pInstance, true, COEF_ASRC, ABL_FROM_CONST, pfmt->color.a);
1952 pfmt->color.a = 0xff;
1953 }
1954 // Forground color
1955 if (pFonttable->fmt == GFX_FMT_I2)
1956 {
1957 pfmt->color.a?(pfmt->color.a = 0xff) :(pfmt->color.a = 0x0);
1958 MApi_GFX_SetIntensity_U02(pInstance, 3, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1959 pfmt->color.a?(pfmt->color.a = 0xaa) :(pfmt->color.a = 0x0);
1960 MApi_GFX_SetIntensity_U02(pInstance, 2, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1961 pfmt->color.a?(pfmt->color.a = 0x55) :(pfmt->color.a = 0x0);
1962 MApi_GFX_SetIntensity_U02(pInstance, 1, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1963
1964 }
1965 else if (pFonttable->fmt == GFX_FMT_I4)
1966 {
1967 pfmt->color.a?(pfmt->color.a = 0xff) :(pfmt->color.a = 0x0);
1968 MApi_GFX_SetIntensity_U02(pInstance, 15, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1969 pfmt->color.a?(pfmt->color.a = 0xee) :(pfmt->color.a = 0x0);
1970 MApi_GFX_SetIntensity_U02(pInstance, 14, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1971 pfmt->color.a?(pfmt->color.a = 0xdd) :(pfmt->color.a = 0x0);
1972 MApi_GFX_SetIntensity_U02(pInstance, 13, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1973 pfmt->color.a?(pfmt->color.a = 0xcc) :(pfmt->color.a = 0x0);
1974 MApi_GFX_SetIntensity_U02(pInstance, 12, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1975 pfmt->color.a?(pfmt->color.a = 0xbb) :(pfmt->color.a = 0x0);
1976 MApi_GFX_SetIntensity_U02(pInstance, 11, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1977 pfmt->color.a?(pfmt->color.a = 0xaa) :(pfmt->color.a = 0x0);
1978 MApi_GFX_SetIntensity_U02(pInstance, 10, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1979 pfmt->color.a?(pfmt->color.a = 0x99) :(pfmt->color.a = 0x0);
1980 MApi_GFX_SetIntensity_U02(pInstance, 9, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1981 pfmt->color.a?(pfmt->color.a = 0x88) :(pfmt->color.a = 0x0);
1982 MApi_GFX_SetIntensity_U02(pInstance, 8, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1983 pfmt->color.a?(pfmt->color.a = 0x77) :(pfmt->color.a = 0x0);
1984 MApi_GFX_SetIntensity_U02(pInstance, 7, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1985 pfmt->color.a?(pfmt->color.a = 0x66) :(pfmt->color.a = 0x0);
1986 MApi_GFX_SetIntensity_U02(pInstance, 6, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1987 pfmt->color.a?(pfmt->color.a = 0x55) :(pfmt->color.a = 0x0);
1988 MApi_GFX_SetIntensity_U02(pInstance, 5, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1989 pfmt->color.a?(pfmt->color.a = 0x44) :(pfmt->color.a = 0x0);
1990 MApi_GFX_SetIntensity_U02(pInstance, 4, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1991 pfmt->color.a?(pfmt->color.a = 0x33) :(pfmt->color.a = 0x0);
1992 MApi_GFX_SetIntensity_U02(pInstance, 3, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1993 pfmt->color.a?(pfmt->color.a = 0x22) :(pfmt->color.a = 0x0);
1994 MApi_GFX_SetIntensity_U02(pInstance, 2, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1995 pfmt->color.a?(pfmt->color.a = 0x11) :(pfmt->color.a = 0x0);
1996 MApi_GFX_SetIntensity_U02(pInstance, 1, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
1997 }
1998 else
1999 {
2000 pfmt->color.a?(pfmt->color.a = 0xff) :(pfmt->color.a = 0x0);
2001 MApi_GFX_SetIntensity_U02(pInstance, 1, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
2002 }
2003 #if PATCH_T3_SCK_FAIL
2004 pfmt->color.a = 0xff; //[2009.07.02]T3/U3 GE HW issue:set source alpha is max for filtering the background color
2005 pfmt->color.r = pfmt->color.g = pfmt->color.b = 0x01;
2006 #else
2007 pfmt->color.a = pfmt->color.r = pfmt->color.g = pfmt->color.b = 0x01;
2008 #endif
2009 MApi_GFX_SetIntensity_U02(pInstance, 0, (GFX_Buffer_Format)GFX_FMT_ARGB8888, (MS_U32*)&(pfmt->u32data));
2010
2011 // Color key
2012 tmpclr1.a=tmpclr1.r=tmpclr1.g=tmpclr1.b=0;
2013 tmpclr2.a = 0x01;
2014 tmpclr2.r = 0x01;
2015 tmpclr2.g = 0x01;
2016 tmpclr2.b = 0x01;
2017
2018 //MApi_GFX_SetDither(FALSE); // FIXME. Not need to be set here. Need to find root cause.
2019
2020 MApi_GFX_SetSrcColorKey_U02(pInstance, TRUE, CK_OP_EQUAL, GFX_FMT_ARGB8888, &tmpclr1, &tmpclr2);
2021
2022
2023 if ((pfmt->flag & GFXFONT_FLAG_VARWIDTH) &&
2024 (pFonttable->pBBox!= NULL))
2025 {
2026 MS_U32 i;
2027 MS_U32 u32PosX = 0;
2028 MS_U32 u32PosY = 0;
2029 MS_U32 u32Width = 0;
2030 MS_U32 u32Height = 0;
2031 MS_S8 dis;
2032 MS_U16 gap = 0;
2033 MS_U32 start = 0;
2034 GFX_FontInfo* pFont = pFonttable;
2035
2036 GFX_CharInfo Char;
2037 GFX_TextOutInfo fmt;
2038 MS_S32 spoint_overlay_x = 0;
2039 MS_S32 spoint_overlay_y = 0;
2040
2041 if (!pFont->inUsed)
2042 {
2043 return GFX_INVALID_FONT_HANDLE;
2044 }
2045 if (pindex == NULL)
2046 {
2047 return GFX_INVALID_PARAMETERS;
2048 }
2049
2050 if(pfmt->flag & GFXFONT_FLAG_COMPACT)
2051 {
2052 dis = pfmt->dis;
2053 }
2054 else if (pfmt->flag & GFXFONT_FLAG_GAP)
2055 {
2056 gap = pfmt->gap;
2057 dis = 0;
2058 }
2059 else
2060 {
2061 dis = 0;
2062 }
2063
2064
2065 memcpy((void*)&fmt, pfmt, sizeof(GFX_TextOutInfo));
2066 Char.fmt = pFont->fmt;
2067 Char.Voffset = 0;
2068 Char.height = pFont->height;
2069 Char.pitch = pFont->pitch;
2070
2071 i = 0;
2072
2073 //pu16TmpIndex =(MS_U16 *)pindex;
2074 //while (*pu16TmpIndex != '\0')
2075 for( i = 0; i < 250; i++)
2076 {
2077
2078
2079 if (strwidth == 2)
2080 {
2081 ptr_addr = (MS_VIRT)pindex;
2082 if(ptr_addr % 2 != 0)
2083 {
2084 GFX_DEBUGINFO(GFX_DBUG("%s: %d\n", __FUNCTION__ , __LINE__);)
2085 MApi_GFX_SetSrcColorKey_U02(pInstance, FALSE, CK_OP_EQUAL, GFX_FMT_ARGB8888, &tmpclr1, &tmpclr2);
2086 return GFX_INVALID_PARAMETERS;
2087 }
2088 ptr_u16 = (MS_U16*)ptr_addr;
2089 char_code = ((MS_U16*)ptr_u16)[i];
2090 }
2091 else
2092 {
2093 char_code = (MS_U8)pindex[i];
2094 }
2095
2096 if(char_code == 0 )
2097 break;
2098
2099 if (pfmt->pGlyphDispInfo == NULL)
2100 {
2101 glyph_index = char_code;
2102 }
2103 else
2104 {
2105 glyph_index = pGlyInfo[i].u16Index;
2106 }
2107
2108 if (i == 0)
2109 {
2110 u32PosX = pfmt->dstblk.x;
2111 u32PosY = pfmt->dstblk.y;
2112 start = spoint_overlay_x = pfmt->dstblk.x;
2113 spoint_overlay_y = pfmt->dstblk.y;
2114 }
2115
2116 // Move to here: workaround for unicode string end detection issue.
2117 if(pGlyInfo[i].u16Index == ERR_NULL_INDEX)
2118 {
2119 GFX_DEBUGINFO(GFX_DBUG("\npGlyphDispInfo[%d].u16Index error", i););
2120 continue;
2121 }
2122
2123
2124
2125 if (fmt.flag & GFXFONT_FLAG_SCALE)
2126 {
2127 u32Width = (pGlyInfo[i].u8Width)*(pfmt->dstblk.width/pFont->width);
2128 u32Height = (pFont->height)*(pfmt->dstblk.height/pFont->height);
2129 }
2130 else
2131 {
2132 u32Width = pGlyInfo[i].u8Width;
2133 u32Height = pFont->height;
2134 }
2135 fmt.dstblk.x = u32PosX;
2136 fmt.dstblk.y = u32PosY;
2137 fmt.dstblk.width = u32Width;
2138 fmt.dstblk.height = u32Height;
2139
2140 Char.addr = pFont->addr + (glyph_index*pFont->offset);
2141 Char.Hoffset = pGlyInfo[i].u8X0;
2142 Char.width = pGlyInfo[i].u8Width;
2143
2144 if ((pGlyInfo[i].overlap_info.s8Xoffset!=0)||(pGlyInfo[i].overlap_info.s8Yoffset!=0))
2145 {
2146 Char.Hoffset = 0;//pGlyInfo[i].u8X0;
2147 Char.width = pFont->width;//pGlyInfo[i].u8Width;
2148 fmt.dstblk.width = pFont->width;
2149 fmt.dstblk.height = pFont->height;
2150 }
2151
2152 #if 1
2153 {
2154 MS_U32 flags = 0;
2155 GE_Rect src;
2156 union
2157 {
2158 GE_Rect dstblk;
2159 GE_DstBitBltType drvdstblk;
2160 }dst;
2161
2162 MDrv_GE_SetSrcBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)Char.fmt, 0, 0, Char.addr, Char.pitch, 0);
2163
2164 src.x = Char.Hoffset;
2165 src.y = Char.Voffset;
2166 src.width = Char.width;
2167 src.height = Char.height;
2168 if (pfmt->flag & GFXFONT_FLAG_SCALE)
2169 {
2170 flags |= E_GE_FLAG_BLT_STRETCH;
2171 }
2172
2173 if (g_apiGFXLocal._bMirrorH)
2174 {
2175 src.x = pGlyInfo[i].u8X0 + pGlyInfo[i].u8Width - 1;//Char.Hoffset;
2176 }
2177 dst.dstblk.x = fmt.dstblk.x;
2178 dst.dstblk.y = fmt.dstblk.y;
2179 dst.dstblk.width = fmt.dstblk.width;
2180 dst.dstblk.height = fmt.dstblk.height;
2181
2182 flags |= GFX_RectBltFlags(pInstance);
2183
2184 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext,&src, &dst.drvdstblk, flags, NULL);
2185
2186 if (pfmt->flag & GFXFONT_FLAG_BOLD)
2187 {
2188 //left side
2189 dst.dstblk.x -=1;
2190 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext,&src, &dst.drvdstblk, flags, NULL);
2191
2192 //right side
2193 dst.dstblk.x +=2;
2194 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext,&src, &dst.drvdstblk, flags, NULL);
2195
2196 //up side
2197 dst.dstblk.y -=1;
2198 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext,&src, &dst.drvdstblk, flags, NULL);
2199
2200 //down side
2201 dst.dstblk.y +=2;
2202 MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext,&src, &dst.drvdstblk, flags, NULL);
2203 }
2204
2205 }
2206 #else
2207 PE_CharacterOut(&Char, &fmt);
2208 #endif
2209
2210
2211 if ((pGlyInfo[i+1].overlap_info.s8Xoffset==0)&&(pGlyInfo[i+1].overlap_info.s8Yoffset==0))
2212
2213 {
2214 spoint_overlay_x = spoint_overlay_x +u32Width -dis +gap;
2215 u32PosX = spoint_overlay_x ;
2216
2217 u32PosY = pfmt->dstblk.y;
2218
2219 if (u32PosX <= start)
2220 {
2221 spoint_overlay_x = u32PosX = start;
2222 }
2223 }
2224 else
2225 {
2226 u32PosX = spoint_overlay_x; //- dis + gap;
2227 u32PosX += pGlyInfo[i+1].overlap_info.s8Xoffset;
2228 u32PosY = spoint_overlay_y; //- dis + gap;
2229 u32PosY += pGlyInfo[i+1].overlap_info.s8Yoffset;
2230 start = u32PosX + pFont->width;
2231 }
2232 }
2233 MApi_GFX_SetSrcColorKey_U02(pInstance, FALSE, CK_OP_EQUAL, GFX_FMT_ARGB8888, &tmpclr1, &tmpclr2);
2234
2235 return GFX_SUCCESS;
2236 }
2237 else
2238 {
2239 MS_U32 ret;
2240 ret = (MS_U32)GFX_TextOutEx(pInstance,fhandle, pindex, strwidth, pfmt, pFonttable);
2241 MApi_GFX_SetSrcColorKey_U02(pInstance, FALSE, CK_OP_EQUAL, GFX_FMT_ARGB8888, &tmpclr1, &tmpclr2);
2242 return (GFX_Result)ret ;
2243 }
2244
2245 }
2246
MApi_GFX_CharacterOut_U02(void * pInstance,GFX_CharInfo * pChar,GFX_TextOutInfo * pfmt)2247 GFX_Result MApi_GFX_CharacterOut_U02(void* pInstance, GFX_CharInfo* pChar, GFX_TextOutInfo *pfmt)
2248 {
2249 #if 1
2250 {
2251 MS_U32 flags = 0;
2252 GE_Rect src;
2253 union
2254 {
2255 GE_Rect dstblk;
2256 GE_DstBitBltType drvdstblk;
2257 }dst;
2258
2259 APICheckU02();
2260
2261 MDrv_GE_SetSrcBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)pChar->fmt, 0, 0, pChar->addr, pChar->pitch, 0);
2262 src.x = pChar->Hoffset;
2263 src.y = pChar->Voffset;
2264 src.width = pChar->width;
2265 src.height = pChar->height;
2266 if (pfmt->flag & GFXFONT_FLAG_SCALE)
2267 {
2268 flags |= E_GE_FLAG_BLT_STRETCH;
2269 }
2270 dst.dstblk.x = pfmt->dstblk.x;
2271 dst.dstblk.y = pfmt->dstblk.y;
2272 dst.dstblk.width = pfmt->dstblk.width;
2273 dst.dstblk.height = pfmt->dstblk.height;
2274
2275 flags |= GFX_RectBltFlags(pInstance);
2276 return (GFX_Result) MDrv_GE_BitBltEX(g_apiGFXLocal.g_pGEContext, &src, &dst.drvdstblk, flags, NULL);
2277 }
2278 #else
2279 return PE_CharacterOut(pChar, pfmt);
2280 #endif
2281 }
2282 #endif
2283
MApi_GFX_ClearFrameBufferByWord_U02(void * pInstance,MS_PHY StrAddr,MS_U32 length,MS_U32 ClearValue)2284 GFX_Result MApi_GFX_ClearFrameBufferByWord_U02(void* pInstance,MS_PHY StrAddr, MS_U32 length, MS_U32 ClearValue)
2285 {
2286 #define CLRbW_FB_WIDTH 1024UL
2287 #define CLRbW_FB_PITCH (CLRbW_FB_WIDTH*4)
2288 #define CLRbW_FB_HEIGHT 128UL
2289 #define CLRbW_FB_SIZE CLRbW_FB_HEIGHT * CLRbW_FB_PITCH
2290
2291 GE_Rect rect;
2292 MS_U32 color, color2;
2293 MS_PHY tmpaddr;
2294 GE_BufInfo bufinfo;
2295
2296 GE_Rect clip;
2297 MS_U32 flags = 0;
2298 MS_U16 u16RegGEEN=0;
2299
2300 APICheckU02();
2301
2302 if((length % 4) != 0)
2303 return GFX_INVALID_PARAMETERS;
2304
2305 MDrv_GE_RestoreRegInfo(g_apiGFXLocal.g_pGEContext,E_GE_SAVE_REG_GE_EN,&u16RegGEEN);
2306 MDrv_GE_RestoreRegInfo(g_apiGFXLocal.g_pGEContext,E_GE_DISABLE_REG_EN,&u16RegGEEN);
2307
2308 MDrv_GE_GetBufferInfo(g_apiGFXLocal.g_pGEContext, &bufinfo);
2309 MDrv_GE_SetAlphaSrc(g_apiGFXLocal.g_pGEContext, E_GE_ALPHA_ASRC);
2310 MDrv_GE_SetAlphaBlend(g_apiGFXLocal.g_pGEContext, FALSE, E_GE_BLEND_ONE);
2311 clip.x = 0;
2312 clip.y = 0;
2313 clip.width = 1920;
2314 clip.height = 1080;
2315 MDrv_GE_SetClipWindow(g_apiGFXLocal.g_pGEContext, &clip);
2316
2317
2318 color = ClearValue;
2319 color2 = color;
2320
2321 flags = 0;
2322 tmpaddr = StrAddr;
2323
2324 while(length >= CLRbW_FB_PITCH)
2325 {
2326 rect.height = length/CLRbW_FB_PITCH;
2327 if(rect.height > 1080)
2328 rect.height = 1080;
2329
2330 rect.x = 0;
2331 rect.y = 0;
2332 rect.width = CLRbW_FB_WIDTH;
2333 // rect.height = CLR_FB_HEIGHT;
2334 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, E_GE_FMT_ARGB8888, CLRbW_FB_WIDTH, 1, tmpaddr, CLRbW_FB_PITCH, 0);
2335 MDrv_GE_FillRect(g_apiGFXLocal.g_pGEContext, &rect, color, color2, flags);
2336 tmpaddr += (CLRbW_FB_PITCH*rect.height);
2337 length -= (CLRbW_FB_PITCH*rect.height);
2338 }
2339
2340
2341 if( length > 0) {
2342 rect.x = 0;
2343 rect.y = 0;
2344 rect.width = length/4;
2345 rect.height = 1;
2346 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, E_GE_FMT_ARGB8888, CLRbW_FB_WIDTH, 1, tmpaddr, CLRbW_FB_PITCH, 0);
2347 MDrv_GE_FillRect(g_apiGFXLocal.g_pGEContext, &rect, color, color2, flags);
2348 tmpaddr += length;
2349 }
2350
2351 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)bufinfo.dstfmt, 0, 0, bufinfo.dstaddr, bufinfo.dstpit, 0);
2352 //MDrv_GE_WaitIdle();
2353 MDrv_GE_RestoreRegInfo(g_apiGFXLocal.g_pGEContext,E_GE_RESTORE_REG_GE_EN,&u16RegGEEN);
2354
2355 return GFX_SUCCESS;
2356
2357 }
2358
2359 #ifndef MSOS_TYPE_OPTEE
MApi_GFX_ClearFrameBuffer_U02(void * pInstance,MS_PHY StrAddr,MS_U32 length,MS_U8 ClearValue)2360 GFX_Result MApi_GFX_ClearFrameBuffer_U02(void* pInstance,MS_PHY StrAddr, MS_U32 length, MS_U8 ClearValue)
2361 {
2362 #define CLR_FB_PITCH 1024UL
2363 #define CLR_FB_HEIGHT 256UL
2364 #define CLR_FB_SIZE CLR_FB_HEIGHT * CLR_FB_PITCH
2365
2366 GE_Rect rect;
2367 MS_U32 color, color2;
2368 MS_PHY tmpaddr;
2369 GE_BufInfo bufinfo;
2370 GE_Rect clip;
2371 MS_U32 flags = 0;
2372 MS_U16 u16RegGEEN=0;
2373
2374 APICheckU02();
2375
2376 MDrv_GE_RestoreRegInfo(g_apiGFXLocal.g_pGEContext,E_GE_SAVE_REG_GE_EN,&u16RegGEEN);
2377 MDrv_GE_RestoreRegInfo(g_apiGFXLocal.g_pGEContext,E_GE_DISABLE_REG_EN,&u16RegGEEN);
2378
2379 MDrv_GE_GetBufferInfo(g_apiGFXLocal.g_pGEContext, &bufinfo);
2380 MDrv_GE_SetAlphaSrc(g_apiGFXLocal.g_pGEContext, E_GE_ALPHA_ASRC);
2381 MDrv_GE_SetAlphaBlend(g_apiGFXLocal.g_pGEContext, FALSE, E_GE_BLEND_ONE);
2382
2383 clip.x = 0;
2384 clip.y = 0;
2385 clip.width = 1920;
2386 clip.height = 1080;
2387 MDrv_GE_SetClipWindow(g_apiGFXLocal.g_pGEContext, &clip);
2388
2389 color = (ClearValue << 8) + ClearValue;
2390 color2 = color;
2391
2392 flags = 0;
2393 tmpaddr = StrAddr;
2394
2395 while(length >= CLR_FB_PITCH)
2396 {
2397 rect.height = length/CLR_FB_PITCH;
2398 if(rect.height > 1080)
2399 rect.height = 1080;
2400
2401 rect.x = 0;
2402 rect.y = 0;
2403 rect.width = CLR_FB_PITCH;
2404 // rect.height = CLR_FB_HEIGHT;
2405 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, E_GE_FMT_I8, CLR_FB_PITCH, 1, tmpaddr, CLR_FB_PITCH, 0);
2406 MDrv_GE_FillRect(g_apiGFXLocal.g_pGEContext, &rect, color, color2, flags);
2407 tmpaddr += (CLR_FB_PITCH*rect.height);
2408 length -= (CLR_FB_PITCH*rect.height);
2409 }
2410
2411 if( length > 0) {
2412 rect.x = 0;
2413 rect.y = 0;
2414 rect.width = length;
2415 rect.height = 1;
2416 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, E_GE_FMT_I8, CLR_FB_PITCH, 1, tmpaddr, CLR_FB_PITCH, 0);
2417 MDrv_GE_FillRect(g_apiGFXLocal.g_pGEContext, &rect, color, color2, flags);
2418 tmpaddr += length;
2419 }
2420
2421 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)bufinfo.dstfmt, 0, 0, bufinfo.dstaddr, bufinfo.dstpit, 0);
2422 //MDrv_GE_WaitIdle();
2423 MDrv_GE_RestoreRegInfo(g_apiGFXLocal.g_pGEContext,E_GE_RESTORE_REG_GE_EN,&u16RegGEEN);
2424
2425 return GFX_SUCCESS;
2426 }
MApi_GFX_SetAlphaCmp_U02(void * pInstance,MS_BOOL enable,GFX_ACmpOp eMode)2427 GFX_Result MApi_GFX_SetAlphaCmp_U02(void* pInstance,MS_BOOL enable, GFX_ACmpOp eMode)
2428 {
2429 MS_U32 u32op1=0, ret;
2430
2431 APICheckU02();
2432
2433 ret = MApi_GFX_MapACmp(eMode, &u32op1 );
2434 if(ret != GFX_SUCCESS)
2435 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
2436
2437 return (GFX_Result) MDrv_GE_SetAlphaCmp(g_apiGFXLocal.g_pGEContext, enable, (GE_ACmpOp)u32op1);
2438 }
2439
MApi_GFX_Set_Line_Pattern_U02(void * pInstance,MS_BOOL enable,MS_U8 linePattern,MS_U8 repeatFactor)2440 GFX_Result MApi_GFX_Set_Line_Pattern_U02(void* pInstance,MS_BOOL enable, MS_U8 linePattern, MS_U8 repeatFactor)
2441 {
2442 APICheckU02();
2443
2444 g_apiGFXLocal._line_enable = enable;
2445 g_apiGFXLocal._line_pattern = linePattern;
2446 g_apiGFXLocal._line_factor = repeatFactor;
2447 return (GFX_Result) MDrv_GE_SetLinePattern(g_apiGFXLocal.g_pGEContext,
2448 g_apiGFXLocal._line_enable, g_apiGFXLocal._line_pattern,
2449 (GE_LinePatRep)g_apiGFXLocal._line_factor);
2450 }
2451 #endif
MApi_GFX_BeginDraw_U02(void * pInstance)2452 GFX_Result MApi_GFX_BeginDraw_U02(void* pInstance)
2453 {
2454 APICheckU02();
2455
2456 GFX_DEBUGINFO (GFX_INFO( "MApi_GFX_BeginDraw\n"));
2457
2458 #if DYNAMIC_POWER_ON_OFF
2459 MDrv_PWR_ClockTurnOn(E_PWR_MODULE_GE);
2460 #endif
2461
2462 GE_Get_Resource(g_apiGFXLocal.g_pGEContext,TRUE);
2463
2464 g_apiGFXLocal.u32LockStatus++;
2465 return (GFX_Result) E_GE_OK;
2466 }
MApi_GFX_EndDraw_U02(void * pInstance)2467 GFX_Result MApi_GFX_EndDraw_U02(void* pInstance)
2468 {
2469 APICheckU02();
2470
2471 #if DYNAMIC_POWER_ON_OFF
2472 GE_WaitIdle();
2473 MDrv_PWR_ClockTurnOff(E_PWR_MODULE_GE);
2474 #endif
2475
2476 if(g_apiGFXLocal.u32LockStatus==0)
2477 return (GFX_Result)E_GE_FAIL_LOCKED;
2478
2479 GE_Free_Resource(g_apiGFXLocal.g_pGEContext,TRUE);
2480
2481 g_apiGFXLocal.u32LockStatus--;
2482 return (GFX_Result) E_GE_OK;
2483 }
2484
2485 #ifndef MSOS_TYPE_OPTEE
MApi_GFX_SetDbgLevel_U02(void * pInstance,MS_U32 level)2486 void MApi_GFX_SetDbgLevel_U02(void* pInstance,MS_U32 level)
2487 {
2488 APICheckU02();
2489
2490 g_apiGFXLocal.u32dbglvl = level;
2491 MDrv_GE_SetDbgLevel(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.u32dbglvl);
2492 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s, Set DBG LEVEL to %d \n", GFX_DBG_HDR, g_apiGFXLocal.u32dbglvl));
2493 }
2494
MApi_GFX_GetHK_U02(void * pInstance,MS_BOOL * bIsHK)2495 GFX_Result MApi_GFX_GetHK_U02(void* pInstance,MS_BOOL *bIsHK)
2496 {
2497 APICheckU02();
2498
2499 MDrv_GE_Get_GetHK(g_apiGFXLocal.g_pGEContext, bIsHK);
2500 return GFX_SUCCESS;
2501
2502 }
2503
MApi_GFX_SetHK_U02(void * pInstance,MS_BOOL bIsHK)2504 GFX_Result MApi_GFX_SetHK_U02(void* pInstance,MS_BOOL bIsHK)
2505 {
2506 APICheckU02();
2507
2508 MDrv_GE_Set_SetHK(g_apiGFXLocal.g_pGEContext, bIsHK);
2509 return GFX_SUCCESS;
2510
2511 }
2512
MApi_GFX_DrawOval_U02(void * pInstance,GFX_OvalFillInfo * pOval)2513 GFX_Result MApi_GFX_DrawOval_U02(void* pInstance,GFX_OvalFillInfo *pOval)
2514 {
2515 GE_OVAL_FILL_INFO stOval;
2516
2517 APICheckU02();
2518
2519 memcpy(&stOval, pOval, sizeof(GE_OVAL_FILL_INFO));
2520 MDrv_GE_DrawOval(g_apiGFXLocal.g_pGEContext, &stOval);
2521 return GFX_SUCCESS;
2522 }
MApi_GFX_SetDC_CSC_FMT_U02(void * pInstance,GFX_YUV_Rgb2Yuv mode,GFX_YUV_OutRange yuv_out_range,GFX_YUV_InRange uv_in_range,GFX_YUV_422 srcfmt,GFX_YUV_422 dstfmt)2523 GFX_Result MApi_GFX_SetDC_CSC_FMT_U02(void* pInstance,GFX_YUV_Rgb2Yuv mode, GFX_YUV_OutRange yuv_out_range, GFX_YUV_InRange uv_in_range, GFX_YUV_422 srcfmt, GFX_YUV_422 dstfmt)
2524 {
2525 GE_YUVMode yuvmode;
2526 MS_U32 u32op1 =0, ret;
2527
2528 APICheckU02();
2529
2530 ret = MApi_GFX_MapYUVOp(GFX_YUV_OP1, mode, &u32op1 );
2531 if(ret != GFX_SUCCESS)
2532 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
2533
2534 yuvmode.rgb2yuv = (GE_Csc_Rgb2Yuv)u32op1;
2535
2536 ret = MApi_GFX_MapYUVOp(GFX_YUV_OP2, yuv_out_range, &u32op1 );
2537 if(ret != GFX_SUCCESS)
2538 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
2539
2540 yuvmode.out_range = (GE_YUV_OutRange)u32op1;
2541
2542 ret = MApi_GFX_MapYUVOp(GFX_YUV_OP3, uv_in_range, &u32op1 );
2543 if(ret != GFX_SUCCESS)
2544 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
2545
2546 yuvmode.in_range = (GE_YUV_InRange)u32op1;
2547
2548 ret = MApi_GFX_MapYUVOp(GFX_YUV_OP4, dstfmt, &u32op1 );
2549 if(ret != GFX_SUCCESS)
2550 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
2551
2552 yuvmode.dst_fmt = (GE_YUV_422)u32op1;
2553
2554 ret = MApi_GFX_MapYUVOp(GFX_YUV_OP4, srcfmt, &u32op1 );
2555 if(ret != GFX_SUCCESS)
2556 GFX_DEBUGINFO_LEVEL(1, GFX_DBUG("%s%s %d, ERROR: %08lx\n", GFX_DBG_HDR, __FUNCTION__, __LINE__, ret));
2557
2558 yuvmode.src_fmt = (GE_YUV_422)u32op1;
2559
2560 MDrv_GE_SetYUVMode(g_apiGFXLocal.g_pGEContext, &yuvmode);
2561
2562 return GFX_SUCCESS;
2563 }
2564
MApi_GFX_SetStrBltSckType_U02(void * pInstance,GFX_StretchCKType type,GFX_RgbColor * color)2565 GFX_Result MApi_GFX_SetStrBltSckType_U02(void* pInstance,GFX_StretchCKType type, GFX_RgbColor *color)
2566 {
2567 MS_U32 u32tmp=0, ret=0;
2568
2569 APICheckU02();
2570
2571 ret = MApi_GFX_MapStrSCKType(type, &u32tmp);
2572
2573 if (ret == GFX_SUCCESS)
2574 {
2575 ret = (MS_U32)MDrv_GE_SetStrBltSckType(g_apiGFXLocal.g_pGEContext, (GE_StretchCKType)u32tmp, (MS_U32*)(void*)color);
2576 return (GFX_Result)ret;
2577 }
2578 else
2579 {
2580 return GFX_INVALID_PARAMETERS;
2581 }
2582
2583 }
2584
MApi_GFX_SetAlpha_ARGB1555_U02(void * pInstance,MS_U8 coef)2585 GFX_Result MApi_GFX_SetAlpha_ARGB1555_U02(void* pInstance,MS_U8 coef)
2586 {
2587 APICheckU02();
2588
2589 return (GFX_Result)MDrv_GE_SetAlpha_ARGB1555(g_apiGFXLocal.g_pGEContext, coef); // DANGER
2590
2591 }
MApi_GFX_GetAlpha_ARGB1555_U02(void * pInstance,MS_U8 * coef)2592 GFX_Result MApi_GFX_GetAlpha_ARGB1555_U02(void* pInstance,MS_U8* coef)
2593 {
2594 APICheckU02();
2595
2596 return (GFX_Result)MDrv_GE_GetAlpha_ARGB1555(g_apiGFXLocal.g_pGEContext, coef); // DANGER
2597 }
2598
GFX_SetFireInfo(void * pInstance,GFX_FireInfo * pFireInfo)2599 static MS_BOOL GFX_SetFireInfo(void* pInstance,GFX_FireInfo* pFireInfo)
2600 {
2601 APICheckU02();
2602
2603 if(pFireInfo->eFireInfo & GFX_SRC_INFO){
2604 MDrv_GE_SetSrcBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)pFireInfo->SrcbufInfo.u32ColorFmt\
2605 ,pFireInfo->SrcbufInfo.u32Width, pFireInfo->SrcbufInfo.u32Height\
2606 ,pFireInfo->SrcbufInfo.u32Addr\
2607 ,pFireInfo->SrcbufInfo.u32Pitch\
2608 ,pFireInfo->u32SrcOffsetofByte);
2609 }
2610 if(pFireInfo->eFireInfo & GFX_DST_INFO){
2611 MDrv_GE_SetDstBuffer(g_apiGFXLocal.g_pGEContext, (GE_BufFmt)pFireInfo->DstbufInfo.u32ColorFmt\
2612 ,pFireInfo->DstbufInfo.u32Width, pFireInfo->DstbufInfo.u32Height\
2613 ,pFireInfo->DstbufInfo.u32Addr\
2614 ,pFireInfo->DstbufInfo.u32Pitch\
2615 ,pFireInfo->u32DstOffsetofByte);
2616 }
2617 if(pFireInfo->eFireInfo & GFX_CLIP_INFO){
2618 MApi_GFX_SetClip_U02(pInstance,&(pFireInfo->GFXSetClip.V0),&(pFireInfo->GFXSetClip.V1));
2619 }
2620 if(pFireInfo->eFireInfo & GFX_DFB_INFO){
2621 g_apiGFXLocal.u32geRgbColor = (pFireInfo->GFXSetDFB.sRGBColor.a)<<24|(pFireInfo->GFXSetDFB.sRGBColor.r)<<16|(pFireInfo->GFXSetDFB.sRGBColor.g)<<8|(pFireInfo->GFXSetDFB.sRGBColor.b);
2622 MDrv_GE_EnableDFBBlending(g_apiGFXLocal.g_pGEContext, pFireInfo->GFXSetDFB.bEnable);
2623 MApi_GFX_SetDFBBldOP_U02(pInstance, pFireInfo->GFXSetDFB.eSrcBldOP, pFireInfo->GFXSetDFB.eDstBldOP);
2624 MApi_GFX_SetDFBBldConstColor_U02(pInstance, pFireInfo->GFXSetDFB.sRGBColor);
2625 MApi_GFX_SetDFBBldFlags_U02(pInstance, pFireInfo->GFXSetDFB.u16DFBBldFlags);
2626 }
2627 if(pFireInfo->eFireInfo & GFX_ABL_INFO){
2628 MS_U32 u32BLDCOEF = 0;
2629 MS_U32 u32ABLSRC = 0;
2630
2631 g_apiGFXLocal.u32geRgbColor = (g_apiGFXLocal.u32geRgbColor&0x00ffffff)|((pFireInfo->GFXSetABL.u8Alpha_Const)<<24);
2632 MApi_GFX_MapBLDCOEF(pFireInfo->GFXSetABL.eABLCoef, &u32BLDCOEF);
2633 MApi_GFX_MapABLCOEF(pFireInfo->GFXSetABL.eDb_abl, &u32ABLSRC);
2634 g_apiGFXLocal.pABLInfo.eBldCoef = (GE_BlendOp)u32BLDCOEF;
2635 g_apiGFXLocal.pABLInfo.eABLSrc = (GE_AlphaSrc)u32ABLSRC;
2636 g_apiGFXLocal.pABLInfo.u32ABLConstCoef = (MS_U32)pFireInfo->GFXSetABL.u8Alpha_Const;
2637 MApi_GFX_SetAlpha_U02(pInstance, pFireInfo->GFXSetABL.bEnable, pFireInfo->GFXSetABL.eABLCoef, pFireInfo->GFXSetABL.eDb_abl, pFireInfo->GFXSetABL.u8Alpha_Const);
2638 }
2639 if(pFireInfo->eFireInfo & GFX_SRC_CLRKEY_INFO){
2640 MApi_GFX_SetSrcColorKey_U02(pInstance, pFireInfo->GFXSetSrcColorKey.bEnable,
2641 pFireInfo->GFXSetSrcColorKey.eOpMode,
2642 pFireInfo->GFXSetSrcColorKey.eFmt,
2643 &(pFireInfo->GFXSetSrcColorKey.S_color),
2644 &(pFireInfo->GFXSetSrcColorKey.E_color));
2645 }
2646 if(pFireInfo->eFireInfo & GFX_DST_CLRKEY_INFO){
2647 MApi_GFX_SetDstColorKey_U02(pInstance, pFireInfo->GFXSetDstColorKey.bEnable,
2648 pFireInfo->GFXSetDstColorKey.eOpMode,
2649 pFireInfo->GFXSetDstColorKey.eFmt,
2650 &(pFireInfo->GFXSetDstColorKey.S_color),
2651 &(pFireInfo->GFXSetDstColorKey.E_color));
2652 }
2653 if(pFireInfo->eFireInfo & GFX_ALPHA_CMP_INFO){
2654 MApi_GFX_SetAlphaCmp_U02(pInstance,pFireInfo->GFXSetAlphaCmp.enable,pFireInfo->GFXSetAlphaCmp.eMode);
2655 }
2656 if(pFireInfo->eFireInfo & GFX_SRC_MIRROR_INFO){
2657 g_apiGFXLocal._bMirrorH = pFireInfo->GFXSetMirror.bMirrorX;
2658 g_apiGFXLocal._bMirrorV = pFireInfo->GFXSetMirror.bMirrorY;
2659 }
2660 if(pFireInfo->eFireInfo & GFX_DST_MIRROR_INFO){
2661 g_apiGFXLocal._bDstMirrorH = pFireInfo->GFXSetDstMirror.bMirrorX;
2662 g_apiGFXLocal._bDstMirrorV = pFireInfo->GFXSetDstMirror.bMirrorY;
2663 }
2664 if(pFireInfo->eFireInfo & GFX_ROTATE_INFO){
2665 g_apiGFXLocal._angle = pFireInfo->GFXSetAngle;
2666 }
2667 if(pFireInfo->eFireInfo & GFX_CSC_INFO){
2668 MApi_GFX_SetDC_CSC_FMT_U02(pInstance,pFireInfo->GFXSetCSC.mode,pFireInfo->GFXSetCSC.yuv_out_range,pFireInfo->GFXSetCSC.uv_in_range,pFireInfo->GFXSetCSC.srcfmt,pFireInfo->GFXSetCSC.dstfmt);
2669 }
2670 if(pFireInfo->eFireInfo & GFX_STR_BLT_SCK_INFO){
2671 MApi_GFX_SetStrBltSckType_U02(pInstance,pFireInfo->sttype.type, &(pFireInfo->sttype.color));
2672 }
2673 if(pFireInfo->eFireInfo & GFX_NEAREST_INFO){
2674 g_apiGFXLocal._bNearest = pFireInfo->bNearest;
2675 }
2676 if(pFireInfo->eFireInfo & GFX_DITHER_INFO){
2677 g_apiGFXLocal.bDither = pFireInfo->bDither;
2678 MDrv_GE_SetDither(g_apiGFXLocal.g_pGEContext,g_apiGFXLocal.bDither);
2679 }
2680
2681 return 0;
2682 }
2683 #endif
2684
Ioctl_GFX_Init(void * pInstance,void * pArgs)2685 static MS_U16 Ioctl_GFX_Init(void* pInstance, void* pArgs)
2686 {
2687 GFX_INIT_ARGS* pGFXInit =NULL;
2688 GE_Config cfg;
2689
2690 APICheckU02();
2691 pGFXInit = (GFX_INIT_ARGS*)pArgs;
2692
2693 if (NULL == pGFXInit->pGFX_Init){
2694 GFX_CRITIAL_MSG(GFX_ERR("GFX init FAIL\n"));
2695 return UTOPIA_STATUS_FAIL;
2696 }
2697 memset(&cfg, 0 , sizeof(GE_Config));
2698 cfg.bIsCompt = pGFXInit->pGFX_Init->bIsCompt;
2699 cfg.bIsHK= pGFXInit->pGFX_Init->bIsHK;
2700
2701 cfg.u32VCmdQSize = pGFXInit->pGFX_Init->u32VCmdQSize;
2702 cfg.PhyVCmdQAddr = pGFXInit->pGFX_Init->u32VCmdQAddr;
2703
2704 //escape the many thread modify the global variable
2705 if(FALSE == g_apiGFXLocal._bInit)
2706 {
2707 MDrv_GE_Init(pInstance, (GE_Config*)&cfg, &g_apiGFXLocal.g_pGEContext);
2708 g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode= E_GE_TLB_NONE;
2709 }
2710 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2711 CheckSize(pGFXInit->u32Size, sizeof(GFX_Init_Config), 0);
2712 MDrv_GE_Chip_Proprity_Init(g_apiGFXLocal.g_pGEContext, &g_apiGFXLocal.pGeChipProperty);
2713 MDrv_GE_SetOnePixelMode(g_apiGFXLocal.g_pGEContext,!(g_apiGFXLocal.pGeChipProperty->bFourPixelModeStable));
2714 g_apiGFXLocal._bInit = TRUE;
2715
2716 #if (GE_PERFORMANCE_TEST)
2717 MDrv_GE_BitbltPerformance(g_apiGFXLocal.g_pGEContext);
2718 #endif
2719 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(GFX_SUCCESS), 0);
2720 }
2721 #ifndef MSOS_TYPE_OPTEE
Ioctl_GFX_GetCaps(void * pInstance,void * pArgs)2722 static MS_U16 Ioctl_GFX_GetCaps(void* pInstance, void* pArgs)
2723 {
2724 GFX_GETCAPS_ARGS* pGFXGetCaps =NULL;
2725 GFX_Get_CAPS* pGFXGetCAPS =NULL;
2726 GFX_Result u32Ret =GFX_FAIL;
2727
2728 APICheckU02();
2729 CMD(0);
2730 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2731 pGFXGetCaps = (GFX_GETCAPS_ARGS*)pArgs;
2732
2733 pGFXGetCAPS = (GFX_Get_CAPS*)pGFXGetCaps->pGFX_GetCaps;
2734 u32Ret = MApi_GFX_GetGECaps_U02(pInstance, pGFXGetCAPS->eCapType, pGFXGetCAPS->pRet, pGFXGetCAPS->Ret_Size);
2735 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret),0);
2736 }
2737
Ioctl_GFX_GetInfo(void * pInstance,void * pArgs)2738 static MS_U16 Ioctl_GFX_GetInfo(void* pInstance, void* pArgs)
2739 {
2740 EN_GFX_GET_CONFIG eCmd;
2741 GFX_GETINFO_ARGS* pGFXGetInfo =NULL;
2742 GFX_Get_BufferInfo* pGFXGetBufferInfo =NULL;
2743 GFX_Get_NextTagID* pGFXNextTagID =NULL;
2744 GFX_Get_Clip_Property* pGFXGetClip =NULL;
2745 GFX_Get_Intensity* pGFXGetIntensity =NULL;
2746 GFX_DbgInfo* pGFXGetDBGInfo =NULL;
2747 GFX_Result u32Ret =GFX_FAIL;
2748 MS_U16 pu16Val =0;
2749
2750 APICheckU02();
2751 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2752 pGFXGetInfo = (GFX_GETINFO_ARGS*)pArgs;
2753 eCmd = pGFXGetInfo->eGFX_GetConfig;
2754 CMD(eCmd);
2755
2756 switch(eCmd)
2757 {
2758 case E_GFX_GET_BUFFERINFO:
2759 CheckSize(pGFXGetInfo->u32Size, sizeof(GFX_Get_BufferInfo), eCmd);
2760 pGFXGetBufferInfo = (GFX_Get_BufferInfo*)pGFXGetInfo->pGFX_GetInfo;
2761 u32Ret = MApi_GFX_GetBufferInfo_U02(pInstance, pGFXGetBufferInfo->pSrcbufInfo->pBufInfo, pGFXGetBufferInfo->pDstbufInfo->pBufInfo);
2762 break;
2763
2764 case E_GFX_GET_TAGID:
2765 CheckSize(pGFXGetInfo->u32Size, sizeof(MS_U16), eCmd);
2766 u32Ret = MDrv_GE_GetTAGID(g_apiGFXLocal.g_pGEContext, &pu16Val);
2767 pGFXGetInfo->pGFX_GetInfo = (void*)&pu16Val;
2768 break;
2769
2770 case E_GFX_GET_NEXTTAGID:
2771 CheckSize(pGFXGetInfo->u32Size, sizeof(GFX_Get_NextTagID), eCmd);
2772 pGFXNextTagID = (GFX_Get_NextTagID*)pGFXGetInfo->pGFX_GetInfo;
2773 u32Ret = MDrv_GE_GetNextTAGID(g_apiGFXLocal.g_pGEContext, pGFXNextTagID->bStepTagBefore, pGFXNextTagID->pTagID);
2774 break;
2775
2776 case E_GFX_GET_CLIP:
2777 CheckSize(pGFXGetInfo->u32Size, sizeof(GFX_Get_Clip_Property), eCmd);
2778 pGFXGetClip = (GFX_Get_Clip_Property*)pGFXGetInfo->pGFX_GetInfo ;
2779 u32Ret =MApi_GFX_GetClip_U02(pInstance, pGFXGetClip->pV0, pGFXGetClip->pV1);
2780 break;
2781
2782 case E_GFX_GET_INTENSITY:
2783 CheckSize(pGFXGetInfo->u32Size, sizeof(GFX_Get_Intensity), eCmd);
2784 pGFXGetIntensity = (GFX_Get_Intensity*)pGFXGetInfo->pGFX_GetInfo;
2785 u32Ret = MDrv_GE_GetIntensity(g_apiGFXLocal.g_pGEContext, pGFXGetIntensity->u32Id, pGFXGetIntensity->pColor);
2786 break;
2787
2788 case E_GFX_GET_DBGINFO: //Use?
2789 CheckSize(pGFXGetInfo->u32Size, sizeof(GFX_DbgInfo), eCmd);
2790 pGFXGetDBGInfo = (GFX_DbgInfo*)pGFXGetInfo->pGFX_GetInfo;
2791 u32Ret = MApi_GFX_GetDBGInfo_U02(pInstance, pGFXGetDBGInfo);
2792 break;
2793
2794 default:
2795 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
2796 break;
2797 }
2798 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret),eCmd);
2799 }
2800
Ioctl_GFX_LineDraw(void * pInstance,void * pArgs)2801 static MS_S32 Ioctl_GFX_LineDraw(void* pInstance, void* pArgs)
2802 {
2803 GFX_LINEDRAW_ARGS* pGFXLineDraw =NULL;
2804 GFX_Set_DrawLineInfo* pGFXLineInfo =NULL;
2805 GFX_Result u32Ret =GFX_FAIL;
2806 GE_RgbColor geRgbColor;
2807
2808 APICheckU02();
2809 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2810 pGFXLineDraw = (GFX_LINEDRAW_ARGS*)pArgs;
2811 CheckSize(pGFXLineDraw->u32Size, sizeof(GFX_Set_DrawLineInfo), 0);
2812 pGFXLineInfo = (GFX_Set_DrawLineInfo*)pGFXLineDraw->pLineInfo;
2813 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
2814
2815 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2816 {
2817 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
2818 }
2819
2820 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
2821 {
2822 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
2823 }
2824
2825 GFX_SetFireInfo(pInstance,pGFXLineInfo->pFireInfo);
2826
2827 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
2828 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
2829 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
2830 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
2831 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
2832
2833 u32Ret = MApi_GFX_DrawLine_U02(pInstance, pGFXLineInfo->pDrawLineInfo);
2834 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2835 {
2836 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
2837 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
2838 }
2839
2840 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
2841 }
2842
Ioctl_GFX_RectFill(void * pInstance,void * pArgs)2843 static MS_S32 Ioctl_GFX_RectFill(void* pInstance, void* pArgs)
2844 {
2845 GFX_RECTFILL_ARGS* pGFXRectFill =NULL;
2846 GFX_Set_RectFillInfo* pGFXRectInfo =NULL;
2847 GFX_Result u32Ret =GFX_FAIL;
2848 GE_RgbColor geRgbColor;
2849
2850 APICheckU02();
2851 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2852 pGFXRectFill = (GFX_RECTFILL_ARGS*)pArgs;
2853 CheckSize(pGFXRectFill->u32Size, sizeof(GFX_Set_RectFillInfo), 0);
2854 pGFXRectInfo = (GFX_Set_RectFillInfo*)pGFXRectFill->pFillBlock;
2855
2856 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
2857
2858 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2859 {
2860 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
2861 }
2862
2863 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
2864 {
2865 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
2866 }
2867
2868 GFX_SetFireInfo(pInstance,pGFXRectInfo->pFireInfo);
2869
2870 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
2871 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
2872 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
2873 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
2874 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
2875
2876 u32Ret = MApi_GFX_RectFill_U02(pInstance, pGFXRectInfo->pRectFillInfo);
2877 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2878 {
2879 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
2880 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
2881 }
2882
2883
2884 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
2885 }
2886
Ioctl_GFX_TriFill(void * pInstance,void * pArgs)2887 static MS_S32 Ioctl_GFX_TriFill(void* pInstance, void* pArgs)
2888 {
2889 GFX_TRIFILL_ARGS* pGFXTriFill =NULL;
2890 GFX_Set_TriFillInfo* pGFXTriInfo =NULL;
2891 GFX_Result u32Ret =GFX_FAIL;
2892 GE_RgbColor geRgbColor;
2893
2894 APICheckU02();
2895 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2896 pGFXTriFill = (GFX_TRIFILL_ARGS*)pArgs;
2897 CheckSize(pGFXTriFill->u32Size, sizeof(GFX_Set_TriFillInfo), 0);
2898 pGFXTriInfo = (GFX_Set_TriFillInfo*)pGFXTriFill->pFillBlock;
2899
2900 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
2901
2902 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2903 {
2904 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
2905 }
2906
2907 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
2908 {
2909 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
2910 }
2911
2912 GFX_SetFireInfo(pInstance,pGFXTriInfo->pFireInfo);
2913
2914 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
2915 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
2916 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
2917 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
2918 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
2919
2920 u32Ret = MApi_GFX_TriFill_U02(pInstance, pGFXTriInfo->pTriFillInfo);
2921 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2922 {
2923 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
2924 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
2925 }
2926
2927
2928 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
2929 }
2930
Ioctl_GFX_SpanFill(void * pInstance,void * pArgs)2931 static MS_S32 Ioctl_GFX_SpanFill(void* pInstance, void* pArgs)
2932 {
2933 GFX_SPANFILL_ARGS* pGFXSpanFill =NULL;
2934 GFX_Set_SpanFillInfo* pGFXSpanInfo =NULL;
2935 GFX_Result u32Ret =GFX_FAIL;
2936 GE_RgbColor geRgbColor;
2937
2938 APICheckU02();
2939 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2940 pGFXSpanFill = (GFX_SPANFILL_ARGS*)pArgs;
2941 CheckSize(pGFXSpanFill->u32Size, sizeof(GFX_Set_SpanFillInfo), 0);
2942 pGFXSpanInfo = (GFX_Set_SpanFillInfo*)pGFXSpanFill->pFillBlock;
2943
2944 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
2945
2946 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2947 {
2948 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
2949 }
2950
2951 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
2952 {
2953 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
2954 }
2955
2956 GFX_SetFireInfo(pInstance,pGFXSpanInfo->pFireInfo);
2957
2958 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
2959 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
2960 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
2961 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
2962 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
2963
2964 u32Ret = MApi_GFX_SpanFill_U02(pInstance, pGFXSpanInfo->pSpanFillInfo);
2965 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2966 {
2967 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
2968 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
2969 }
2970
2971
2972 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
2973 }
2974
Ioctl_GFX_BitBlt(void * pInstance,void * pArgs)2975 static MS_S32 Ioctl_GFX_BitBlt(void* pInstance, void* pArgs)
2976 {
2977 GFX_BITBLT_ARGS* pGFXBitblt =NULL;
2978 GFX_BitBltInfo* pGFXBitBltInfo =NULL;
2979 GFX_Result u32Ret =GFX_FAIL;
2980 GE_RgbColor geRgbColor;
2981
2982 APICheckU02();
2983 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
2984 pGFXBitblt = (GFX_BITBLT_ARGS*)pArgs;
2985 CheckSize(pGFXBitblt->u32Size, sizeof(GFX_BitBltInfo), 0);
2986 pGFXBitBltInfo = (GFX_BitBltInfo*)pGFXBitblt->pGFX_BitBlt;
2987
2988 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
2989
2990 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
2991 {
2992 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
2993 }
2994
2995 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
2996 {
2997 MDrv_GE_SetTLBSrcBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbsrcaddr);
2998 }
2999
3000 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3001 {
3002 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
3003 }
3004
3005 GFX_SetFireInfo(pInstance,pGFXBitBltInfo->pFireInfo);
3006
3007 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
3008 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
3009 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
3010 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
3011 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
3012
3013 u32Ret = MApi_GFX_BitBlt_U02(pInstance, pGFXBitBltInfo->pDrawRect, pGFXBitBltInfo->u32DrawFlag, pGFXBitBltInfo->pScaleInfo);
3014
3015 /* psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo = pGFXBitBltInfo->pBufInfo->pSrcbufInfo;
3016 printf("\33[0;34m[GFX_INFO]Src BufferInfo [Addr=0x%lx],[Width=0x%lx], [Height=0x%lx], [Pitch=0x%lx], [ColorFmt=0x%x], [OffsetByte=0x%lx] \33[m\n" \
3017 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo->pBufInfo->u32Addr \
3018 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo->pBufInfo->u32Width \
3019 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo->pBufInfo->u32Height \
3020 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo->pBufInfo->u32Pitch \
3021 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo->pBufInfo->u32ColorFmt \
3022 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pSrcbufInfo->u32OffsetByte );
3023 psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo = pGFXBitBltInfo->pBufInfo->pDstbufInfo;
3024 printf("\33[0;34m[GFX_INFO]Dst BufferInfo [Addr=0x%lx],[Width=0x%lx], [Height=0x%lx], [Pitch=0x%lx], [ColorFmt=0x%x], [OffsetByte=0x%lx] \33[m\n" \
3025 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo->pBufInfo->u32Addr \
3026 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo->pBufInfo->u32Width \
3027 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo->pBufInfo->u32Height \
3028 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo->pBufInfo->u32Pitch \
3029 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo->pBufInfo->u32ColorFmt \
3030 ,psGFXInstPri->pGFXBufferInfo->pBufInfo->pDstbufInfo->u32OffsetByte );*/
3031
3032 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3033 {
3034 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
3035 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
3036 }
3037
3038 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
3039
3040 }
3041
Ioctl_GFX_TwoSrcBitBlt(void * pInstance,void * pArgs)3042 static MS_S32 Ioctl_GFX_TwoSrcBitBlt(void* pInstance, void* pArgs)
3043 {
3044 GFX_TWOSRC_BITBLT_ARGS* pGFXTwoSrcBitblt =NULL;
3045 GFX_TwoSrc_BitBltInfo* pGFXTwoSrcBitBltInfo =NULL;
3046 GFX_Result u32Ret =GFX_FAIL;
3047
3048 APICheckU02();
3049 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3050 pGFXTwoSrcBitblt = (GFX_TWOSRC_BITBLT_ARGS*)pArgs;
3051 CheckSize(pGFXTwoSrcBitblt->u32Size, sizeof(GFX_TwoSrc_BitBltInfo), 0);
3052 pGFXTwoSrcBitBltInfo = (GFX_TwoSrc_BitBltInfo*)pGFXTwoSrcBitblt->pGFX_TwoSrc_BitBlt;
3053
3054 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
3055 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3056 {
3057 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
3058 }
3059
3060 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3061 {
3062 MDrv_GE_SetTLBSrcBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbsrcaddr);
3063 }
3064
3065 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3066 {
3067 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
3068 }
3069
3070 GFX_SetFireInfo(pInstance,pGFXTwoSrcBitBltInfo->pFireInfo);
3071
3072 u32Ret = MApi_GFX_BitbltByTwoSourceBuffer_U02(pInstance, pGFXTwoSrcBitBltInfo->pDstbufInfo->pBufInfo, pGFXTwoSrcBitBltInfo->pDrawTwoSrcRect, pGFXTwoSrcBitBltInfo->u32DrawFlag);
3073
3074 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3075 {
3076 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
3077 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
3078 }
3079
3080 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
3081 }
3082
Ioctl_GFX_SetABL(void * pInstance,void * pArgs)3083 static MS_S32 Ioctl_GFX_SetABL(void* pInstance, void* pArgs)
3084 {
3085 EN_GFX_SET_ABL eCmd;
3086 GFX_ABL_ARGS* pGFXABL =NULL;
3087 GFX_Set_ABL* pGFXSetABL =NULL;
3088 GFX_Set_Colorkey* pGFXSetColorKey =NULL;
3089 GFX_Set_ROP* pGFXSetROP =NULL;
3090 GFX_Set_DFB* pGFXSetDFB =NULL;
3091 GFX_Set_Intensity* pGFXSetIntensity =NULL;
3092 GFX_Result u32Ret =GFX_FAIL;
3093 MS_U32 u32BLDCOEF =0;
3094 MS_U32 u32ABLSRC =0;
3095
3096 APICheckU02();
3097 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3098 pGFXABL = (GFX_ABL_ARGS*)pArgs;
3099 eCmd = pGFXABL->eGFX_SetABL;
3100 CMD(eCmd);
3101
3102 switch(eCmd)
3103 {
3104 case E_GFX_SET_ABL:
3105 CheckSize(pGFXABL->u32Size, sizeof(GFX_Set_ABL),eCmd);
3106 pGFXSetABL = (GFX_Set_ABL*)pGFXABL->pGFX_ABL;
3107 g_apiGFXLocal.u32geRgbColor = (g_apiGFXLocal.u32geRgbColor&0x00ffffff)|((pGFXSetABL->u8Alpha_Const)<<24);
3108 u32Ret = MApi_GFX_MapBLDCOEF(pGFXSetABL->eABLCoef, &u32BLDCOEF);
3109 u32Ret = MApi_GFX_MapABLCOEF(pGFXSetABL->eDb_abl, &u32ABLSRC);
3110 g_apiGFXLocal.pABLInfo.eBldCoef = (GE_BlendOp)u32BLDCOEF;
3111 g_apiGFXLocal.pABLInfo.eABLSrc = (GE_AlphaSrc)u32ABLSRC;
3112 g_apiGFXLocal.pABLInfo.u32ABLConstCoef = (MS_U32)pGFXSetABL->u8Alpha_Const;
3113 MApi_GFX_SetAlpha_U02(pInstance, pGFXSetABL->bEnable, pGFXSetABL->eABLCoef, pGFXSetABL->eDb_abl, pGFXSetABL->u8Alpha_Const);
3114 break;
3115
3116 case E_GFX_SET_COLORKEY:
3117 CheckSize(pGFXABL->u32Size, sizeof(GFX_Set_Colorkey), eCmd);
3118 pGFXSetColorKey = (GFX_Set_Colorkey*)pGFXABL->pGFX_ABL;
3119 if( pGFXSetColorKey->ColorKey_Type & E_SRC_COLORKEY)
3120 {
3121 MApi_GFX_SetSrcColorKey_U02(pInstance, pGFXSetColorKey->pSrcbufInfo->bEnable, pGFXSetColorKey->pSrcbufInfo->eOpMode, \
3122 pGFXSetColorKey->pSrcbufInfo->eFmt, pGFXSetColorKey->pSrcbufInfo->pS_color, pGFXSetColorKey->pSrcbufInfo->pE_color);
3123 }
3124 if( pGFXSetColorKey->ColorKey_Type & E_DST_COLORKEY)
3125 {
3126 MApi_GFX_SetDstColorKey_U02(pInstance, pGFXSetColorKey->pDstbufInfo->bEnable, pGFXSetColorKey->pDstbufInfo->eOpMode, \
3127 pGFXSetColorKey->pDstbufInfo->eFmt, pGFXSetColorKey->pDstbufInfo->pS_color, pGFXSetColorKey->pDstbufInfo->pE_color);
3128 }
3129 u32Ret = GFX_SUCCESS;
3130 break;
3131
3132 case E_GFX_SET_ROP:
3133 CheckSize(pGFXABL->u32Size, sizeof(GFX_Set_ROP), eCmd);
3134 pGFXSetROP = (GFX_Set_ROP*)pGFXABL->pGFX_ABL;
3135 MApi_GFX_SetROP2_U02(pInstance, pGFXSetROP->bEnable, pGFXSetROP->eRopMode);
3136 u32Ret = GFX_SUCCESS;
3137 break;
3138
3139 case E_GFX_SET_DFB:
3140 CheckSize(pGFXABL->u32Size, sizeof(GFX_Set_DFB), eCmd);
3141 pGFXSetDFB = (GFX_Set_DFB*)pGFXABL->pGFX_ABL;
3142 g_apiGFXLocal.u32geRgbColor = (pGFXSetDFB->sRGBColor.a)<<24|(pGFXSetDFB->sRGBColor.r)<<16|(pGFXSetDFB->sRGBColor.g)<<8|(pGFXSetDFB->sRGBColor.b);
3143 MDrv_GE_EnableDFBBlending(g_apiGFXLocal.g_pGEContext, pGFXSetDFB->bEnable);
3144 MApi_GFX_SetDFBBldOP_U02(pInstance, pGFXSetDFB->eSrcBldOP, pGFXSetDFB->eDstBldOP);
3145 MApi_GFX_SetDFBBldConstColor_U02(pInstance, pGFXSetDFB->sRGBColor);
3146 MApi_GFX_SetDFBBldFlags_U02(pInstance, pGFXSetDFB->u16DFBBldFlags);
3147 u32Ret = GFX_SUCCESS;
3148 break;
3149
3150 case E_GFX_SET_INTENSITY:
3151 CheckSize(pGFXABL->u32Size, sizeof(GFX_Set_Intensity), eCmd);
3152 pGFXSetIntensity = (GFX_Set_Intensity*)pGFXABL->pGFX_ABL;
3153 MApi_GFX_SetIntensity_U02(pInstance, pGFXSetIntensity->u32Id, pGFXSetIntensity->eFmt, pGFXSetIntensity->pColor);
3154 u32Ret = GFX_SUCCESS;
3155 break;
3156 default:
3157 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3158 u32Ret = GFX_FAIL;
3159 break;
3160
3161 }
3162 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), eCmd);
3163 }
3164 #endif
3165
Ioctl_GFX_SetConfig(void * pInstance,void * pArgs)3166 static MS_S32 Ioctl_GFX_SetConfig(void* pInstance, void* pArgs)
3167 {
3168 EN_GFX_SET_CONFIG eCmd;
3169 GFX_SETCONFIG_ARGS* pGFXSetConfig =NULL;
3170 #ifndef MSOS_TYPE_OPTEE
3171 GFX_Set_VQ* pGFXSetVQ =NULL;
3172 GFX_Set_Mirror* pGFXSetMirror =NULL;
3173 GFX_Set_Italic* pGFXSetItalic =NULL;
3174 GFX_Set_PaletteOpt* pGFXSetPaletteOpt =NULL;
3175 GFX_Set_Clip_Property* pGFXSetClip =NULL;
3176 GFX_Set_WriteProtect* pGFXSetWP =NULL;
3177 GFX_Set_AlphaCompare* pGFXSetCMP =NULL;
3178 GFX_Set_CSC* pGFXSetCSC =NULL;
3179 GFX_Set_BurstMiuLen* pGFXSetBurstMiuLen =NULL;
3180 MS_BOOL* pbVal =NULL;
3181 #endif
3182 MS_U32* pu32Val =NULL;
3183 GFX_Result u32Ret =GFX_FAIL;
3184
3185 APICheckU02();
3186 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3187 pGFXSetConfig = (GFX_SETCONFIG_ARGS*)pArgs;
3188 eCmd = pGFXSetConfig->eGFX_SetConfig;
3189 CMD(eCmd);
3190
3191 switch(eCmd)
3192 {
3193 #ifndef MSOS_TYPE_OPTEE
3194 case E_GFX_SET_POWERON:
3195 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_BOOL), eCmd);
3196 pbVal = (MS_BOOL*)pGFXSetConfig->pGFX_ConfigInfo;
3197 MDrv_GE_SetClock(g_apiGFXLocal.g_pGEContext, *pbVal);
3198 u32Ret = GFX_SUCCESS;
3199 break;
3200
3201 case E_GFX_SET_FLUSHQUEUE:
3202 MDrv_GE_WaitIdle(g_apiGFXLocal.g_pGEContext);
3203 u32Ret = GFX_SUCCESS;
3204 break;
3205
3206 case E_GFX_SET_TAGID:
3207 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_U32), eCmd);
3208 pu32Val = (MS_U32*)pGFXSetConfig->pGFX_ConfigInfo;
3209 //psGFXInstPri->pGFXSetConfig->u32TagID = *pu32Val;
3210 MDrv_GE_SetTAGID(g_apiGFXLocal.g_pGEContext, (MS_U16)*pu32Val);
3211 u32Ret = GFX_SUCCESS;
3212 break;
3213 #endif
3214 case E_GFX_SET_NEXTTAGID:
3215 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_U32), eCmd);
3216 MDrv_GE_SetNextTAGID(g_apiGFXLocal.g_pGEContext, (MS_U16*)pGFXSetConfig->pGFX_ConfigInfo);
3217 u32Ret = GFX_SUCCESS;
3218 break;
3219
3220 case E_GFX_SET_WAITFORTAGID:
3221 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_U32), eCmd);
3222 pu32Val = (MS_U32*)pGFXSetConfig->pGFX_ConfigInfo;
3223 MDrv_GE_WaitTAGID(g_apiGFXLocal.g_pGEContext, (MS_U16)*pu32Val);
3224 u32Ret = GFX_SUCCESS;
3225 break;
3226 case E_GFX_SET_POLLINGTAGID:
3227 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_U32), eCmd);
3228 pu32Val = (MS_U32*)pGFXSetConfig->pGFX_ConfigInfo;
3229 u32Ret = MDrv_GE_PollingTAGID(g_apiGFXLocal.g_pGEContext, (MS_U16)*pu32Val);
3230 if (E_GE_OK == u32Ret)
3231 {
3232 u32Ret = GFX_SUCCESS;
3233 }
3234 else
3235 {
3236 u32Ret = GFX_FAIL;
3237 }
3238 break;
3239 #ifndef MSOS_TYPE_OPTEE
3240 case E_GFX_SET_ONEPIXELMODE:
3241 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_BOOL), eCmd);
3242 pbVal = (MS_BOOL*)pGFXSetConfig->pGFX_ConfigInfo;
3243 //psGFXInstPri->pGFXSetConfig->bOnePixelMode = *pbVal;
3244 MDrv_GE_SetOnePixelMode(g_apiGFXLocal.g_pGEContext, *pbVal);
3245 u32Ret = GFX_SUCCESS;
3246 break;
3247
3248 case E_GFX_SET_DITHER:
3249 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_BOOL), eCmd);
3250 pbVal = (MS_BOOL*)pGFXSetConfig->pGFX_ConfigInfo;
3251 //psGFXInstPri->pGFXSetConfig->bDither = *pbVal;
3252 g_apiGFXLocal.bDither = *pbVal;
3253 MDrv_GE_SetDither(g_apiGFXLocal.g_pGEContext,g_apiGFXLocal.bDither);
3254 u32Ret = GFX_SUCCESS;
3255 break;
3256
3257 //VQ switch can't dynamic disablb, cause of cmd losing.
3258 case E_GFX_SET_VQ:
3259 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_VQ), eCmd);
3260 pGFXSetVQ = (GFX_Set_VQ*)pGFXSetConfig->pGFX_ConfigInfo;
3261 //psGFXInstPri->pGFXSetConfig->bVQEnable = pGFXSetVQ->bEnable;
3262 MDrv_GE_EnableVCmdQueue(g_apiGFXLocal.g_pGEContext, pGFXSetVQ->bEnable);
3263 MApi_GFX_SetVCmdBuffer_U02(pInstance, pGFXSetVQ->u32Addr, pGFXSetVQ->enBufSize);
3264 MDrv_GE_SetVCmd_R_Thread(g_apiGFXLocal.g_pGEContext, pGFXSetVQ->u8R_Threshold);
3265 MDrv_GE_SetVCmd_W_Thread(g_apiGFXLocal.g_pGEContext, pGFXSetVQ->u8W_Threshold);
3266 u32Ret = GFX_SUCCESS;
3267 break;
3268
3269 case E_GFX_SET_MIRROR:
3270 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_Mirror), eCmd);
3271 pGFXSetMirror=(GFX_Set_Mirror*)pGFXSetConfig->pGFX_ConfigInfo;
3272 //psGFXInstPri->pGFXSetConfig->pMirror->bMirrorX = pGFXSetMirror->bMirrorX;
3273 //psGFXInstPri->pGFXSetConfig->pMirror->bMirrorY = pGFXSetMirror->bMirrorY;
3274
3275 g_apiGFXLocal._bMirrorH = pGFXSetMirror->bMirrorX;
3276 g_apiGFXLocal._bMirrorV = pGFXSetMirror->bMirrorY;
3277 u32Ret = GFX_SUCCESS;
3278 break;
3279
3280 case E_GFX_SET_DST_MIRROR:
3281 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_Mirror), eCmd);
3282 pGFXSetMirror=(GFX_Set_Mirror*)pGFXSetConfig->pGFX_ConfigInfo;
3283 g_apiGFXLocal._bDstMirrorH = pGFXSetMirror->bMirrorX;
3284 g_apiGFXLocal._bDstMirrorV = pGFXSetMirror->bMirrorY;
3285 u32Ret = GFX_SUCCESS;
3286 break;
3287
3288 case E_GFX_SET_ROTATE:
3289 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_RotateAngle), eCmd);
3290 pu32Val = (MS_U32*)pGFXSetConfig->pGFX_ConfigInfo;
3291 //psGFXInstPri->pGFXSetConfig->eRotate = pGFXSetRotate;
3292
3293 g_apiGFXLocal._angle = (GFX_RotateAngle)*pu32Val;
3294 u32Ret = GFX_SUCCESS;
3295 break;
3296
3297 case E_GFX_SET_ITALIC:
3298 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_Italic), eCmd);
3299 pGFXSetItalic = (GFX_Set_Italic*)pGFXSetConfig->pGFX_ConfigInfo;
3300 MDrv_GE_SetItalic(g_apiGFXLocal.g_pGEContext, pGFXSetItalic->u8Ini_dis, pGFXSetItalic->u8Ini_line, pGFXSetItalic->u8Delta);
3301 u32Ret = GFX_SUCCESS;
3302 break;
3303
3304 case E_GFX_SET_NEARESTMODE:
3305 CheckSize(pGFXSetConfig->u32Size, sizeof(MS_BOOL), eCmd);
3306 pbVal = (MS_BOOL*)pGFXSetConfig->pGFX_ConfigInfo;
3307 g_apiGFXLocal._bNearest = *pbVal;
3308 u32Ret = GFX_SUCCESS;
3309 break;
3310
3311 case E_GFX_SET_PALETTEOPT:
3312 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_PaletteOpt), eCmd);
3313 pGFXSetPaletteOpt = (GFX_Set_PaletteOpt*)pGFXSetConfig->pGFX_ConfigInfo;
3314 MApi_GFX_SetPaletteOpt_U02(pInstance, pGFXSetPaletteOpt->pPalArray, pGFXSetPaletteOpt->u32PalStart, pGFXSetPaletteOpt->u32PalEnd);
3315 u32Ret = GFX_SUCCESS;
3316 break;
3317
3318 case E_GFX_SET_CLIP:
3319 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_Clip_Property), eCmd);
3320 pGFXSetClip = (GFX_Set_Clip_Property*)pGFXSetConfig->pGFX_ConfigInfo;
3321 //psGFXInstPri->pGFXSetConfig->pClip->pV0 = pGFXSetClip->pV0;
3322 //psGFXInstPri->pGFXSetConfig->pClip->pV1 = pGFXSetClip->pV1;
3323 MApi_GFX_SetClip_U02(pInstance, pGFXSetClip->pV0, pGFXSetClip->pV1);
3324 u32Ret = GFX_SUCCESS;
3325 break;
3326
3327 case E_GFX_SET_WRITEPROTECT:
3328 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_WriteProtect), eCmd);
3329 pGFXSetWP = (GFX_Set_WriteProtect*)pGFXSetConfig->pGFX_ConfigInfo;
3330 MDrv_GE_WriteProtect(g_apiGFXLocal.g_pGEContext, pGFXSetWP->u8Miu, pGFXSetWP->u32Addr_Low, pGFXSetWP->u32Addr_High, (GE_WPType)pGFXSetWP->eWPType);
3331 u32Ret = GFX_SUCCESS;
3332 break;
3333 case E_GFX_SET_ALPHA_COMPARE:
3334 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_AlphaCompare), eCmd);
3335 pGFXSetCMP = (GFX_Set_AlphaCompare*)pGFXSetConfig->pGFX_ConfigInfo;
3336 MApi_GFX_SetAlphaCmp_U02(pInstance,pGFXSetCMP->enable,pGFXSetCMP->eMode);
3337 u32Ret = GFX_SUCCESS;
3338 break;
3339 case E_GFX_SET_CSC:
3340 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_CSC), eCmd);
3341 pGFXSetCSC = (GFX_Set_CSC*)pGFXSetConfig->pGFX_ConfigInfo;
3342 MApi_GFX_SetDC_CSC_FMT_U02(pInstance,pGFXSetCSC->mode,pGFXSetCSC->yuv_out_range,pGFXSetCSC->uv_in_range,pGFXSetCSC->srcfmt,pGFXSetCSC->dstfmt);
3343 u32Ret = GFX_SUCCESS;
3344 break;
3345 case E_GFX_SET_BURSTMIULEN:
3346 CheckSize(pGFXSetConfig->u32Size, sizeof(GFX_Set_BurstMiuLen), eCmd);
3347 pGFXSetBurstMiuLen = (GFX_Set_BurstMiuLen*)pGFXSetConfig->pGFX_ConfigInfo;
3348 MDrv_GE_SetBurstMiuLen(g_apiGFXLocal.g_pGEContext,pGFXSetBurstMiuLen->bEnable,pGFXSetBurstMiuLen->u32BurstLen);
3349 u32Ret = GFX_SUCCESS;
3350 break;
3351 #endif
3352 default:
3353 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3354 u32Ret = GFX_FAIL;
3355 break;
3356 }
3357 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, u32Ret, eCmd);
3358 }
3359
Ioctl_GFX_GetConfig(void * pInstance,void * pArgs)3360 static MS_U16 Ioctl_GFX_GetConfig(void* pInstance, void* pArgs)
3361 {
3362 EN_GFX_GET_CONFIG eCmd;
3363 GFX_GETCONFIG_ARGS* pGFXGetConfig =NULL;
3364 GFX_Config* stGFXcfg =NULL;
3365 GE_Config cfg;
3366 GFX_Result u32Ret =GFX_FAIL;
3367
3368 pGFXGetConfig = (GFX_GETCONFIG_ARGS*)pArgs;
3369 eCmd = pGFXGetConfig->eGFX_GetConfig;
3370 CMD(eCmd);
3371
3372 switch(eCmd)
3373 {
3374 case E_GFX_GET_INIT:
3375 memset(&cfg, 0 , sizeof(GE_Config));
3376 if(FALSE==MDrv_GE_GetConfig((GE_Config*)&cfg))
3377 return UTOPIA_STATUS_FAIL;
3378 stGFXcfg = (GFX_Config*)pGFXGetConfig->pGFX_ConfigInfo;
3379 stGFXcfg->bIsCompt = cfg.bIsCompt;
3380 stGFXcfg->bIsHK = cfg.bIsHK;
3381 stGFXcfg->u32VCmdQSize = cfg.u32VCmdQSize;
3382 stGFXcfg->u32VCmdQAddr = cfg.PhyVCmdQAddr;
3383
3384 u32Ret = GFX_SUCCESS;
3385 break;
3386 default:
3387 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3388 u32Ret = GFX_FAIL;
3389 break;
3390 }
3391 return u32Ret;
3392 }
3393
3394
3395 #ifndef MSOS_TYPE_OPTEE
Ioctl_GFX_Bitmap(void * pInstance,void * pArgs)3396 static MS_S32 Ioctl_GFX_Bitmap(void* pInstance, void* pArgs)
3397 {
3398 GFX_BITMAP_ARGS* pGFXBitmap =NULL;
3399 GFX_Result u32Ret =GFX_FAIL;
3400 GE_RgbColor geRgbColor;
3401
3402 APICheckU02();
3403 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3404 pGFXBitmap = (GFX_BITMAP_ARGS*)pArgs;
3405 CheckSize(pGFXBitmap->u32Size, sizeof(GFX_Bitmap), 0);
3406
3407 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
3408
3409 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3410 {
3411 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
3412 }
3413
3414 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3415 {
3416 MDrv_GE_SetTLBSrcBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbsrcaddr);
3417 }
3418
3419 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3420 {
3421 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
3422 }
3423
3424 GFX_SetFireInfo(pInstance,pGFXBitmap->pGFX_Bitmap->pFireInfo);
3425
3426 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
3427 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
3428 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
3429 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
3430 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
3431
3432 u32Ret = MApi_GFX_DrawBitmap_U02(pInstance,pGFXBitmap->pGFX_Bitmap->pFireInfo->SrcbufInfo, pGFXBitmap->pGFX_Bitmap->pBmpInfo);
3433 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3434 {
3435 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
3436 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
3437 }
3438 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
3439 }
3440
Ioctl_GFX_Font(void * pInstance,void * pArgs)3441 static MS_S32 Ioctl_GFX_Font(void* pInstance, void* pArgs)
3442 {
3443 GFX_TEXTTYPE eCmd;
3444 GFX_TEXTOUT_ARGS* pGFXTextOutArg =NULL;
3445 GFX_TextOut_V2* pGFXTextOut =NULL;
3446 GFX_CharacterOut* pGFXCharacterOut =NULL;
3447 GFX_Result u32Ret =GFX_FAIL;
3448 GE_RgbColor geRgbColor;
3449
3450 APICheckU02();
3451 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3452 pGFXTextOutArg = (GFX_TEXTOUT_ARGS*)pArgs;
3453 eCmd = pGFXTextOutArg->eGFX_TextType;
3454 CMD(eCmd);
3455
3456 switch(eCmd)
3457 {
3458 case E_LOADTEXTOUT:
3459 CheckSize(pGFXTextOutArg->u32Size, sizeof(GFX_TextOut_V2), eCmd);
3460 pGFXTextOut = (GFX_TextOut_V2*)pGFXTextOutArg->pGFX_TextOut;
3461
3462 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
3463
3464 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3465 {
3466 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
3467 }
3468
3469 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3470 {
3471 MDrv_GE_SetTLBSrcBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbsrcaddr);
3472 }
3473
3474 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3475 {
3476 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
3477 }
3478
3479 GFX_SetFireInfo(pInstance,pGFXTextOut->pFireInfo);
3480
3481 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
3482 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
3483 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
3484 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
3485 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
3486
3487 MApi_GFX_TextOut_U02(pInstance, pGFXTextOut->fHandle, (MS_U8*)pGFXTextOut->charArray, pGFXTextOut->u32StrWidth, pGFXTextOut->pTextInfo, pGFXTextOut->pFonttable);
3488 u32Ret = GFX_SUCCESS;
3489 break;
3490
3491 case E_CHARACTEROUT:
3492 CheckSize(pGFXTextOutArg->u32Size, sizeof(GFX_CharacterOut), eCmd);
3493 pGFXCharacterOut = (GFX_CharacterOut*)pGFXTextOutArg->pGFX_TextOut;
3494
3495 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
3496
3497 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3498 {
3499 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
3500 }
3501
3502 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3503 {
3504 MDrv_GE_SetTLBSrcBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbsrcaddr);
3505 }
3506
3507 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3508 {
3509 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
3510 }
3511
3512 GFX_SetFireInfo(pInstance,pGFXCharacterOut->pFireInfo);
3513
3514 geRgbColor.a= (g_apiGFXLocal.u32geRgbColor&0xff000000)>>24;
3515 geRgbColor.r= (g_apiGFXLocal.u32geRgbColor&0x00ff0000)>>16;
3516 geRgbColor.g= (g_apiGFXLocal.u32geRgbColor&0x0000ff00)>>8;
3517 geRgbColor.b= (g_apiGFXLocal.u32geRgbColor&0x000000ff);
3518 MDrv_GE_SetDFBBldConstColor(g_apiGFXLocal.g_pGEContext, geRgbColor);
3519
3520 MApi_GFX_CharacterOut_U02(pInstance, pGFXCharacterOut->pChar, pGFXCharacterOut->pTextInfo);
3521 u32Ret = GFX_SUCCESS;
3522 break;
3523
3524 default:
3525 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3526 u32Ret = GFX_FAIL;
3527 break;
3528 }
3529 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3530 {
3531 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
3532 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
3533 }
3534
3535 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), eCmd);
3536 }
3537
Ioctl_GFX_PowerState(void * pInstance,void * pArgs)3538 static MS_S32 Ioctl_GFX_PowerState(void* pInstance, void* pArgs)
3539 {
3540 EN_POWER_MODE eCmd;
3541 GFX_POWERSTATE_ARGS* pGFXPowerStateArg =NULL;
3542 GFX_Result u32Ret =GFX_FAIL;
3543 void* pModule =NULL;
3544
3545 APICheckU02();
3546 pGFXPowerStateArg = (GFX_POWERSTATE_ARGS*)pArgs;
3547 eCmd = pGFXPowerStateArg->eGFX_PowerStateType;
3548 CMD(eCmd);
3549
3550 switch(eCmd)
3551 {
3552 case E_POWER_SUSPEND:
3553 GFX_DEBUG_MSG(GFX_INFO(" [%s][%d] E_POWER_SUSPEND Start\n",__FUNCTION__,__LINE__));
3554 GE_Get_Resource(g_apiGFXLocal.g_pGEContext,FALSE);
3555 MDrv_GE_WaitIdle(g_apiGFXLocal.g_pGEContext);
3556 MDrv_GE_SetPowerState(g_apiGFXLocal.g_pGEContext ,pGFXPowerStateArg->eGFX_PowerStateType, pModule);
3557 GFX_DEBUG_MSG(GFX_INFO(" [%s][%d] E_POWER_SUSPEND End\n",__FUNCTION__,__LINE__));
3558 u32Ret = GFX_SUCCESS;
3559 break;
3560
3561 case E_POWER_RESUME:
3562 GFX_DEBUG_MSG(GFX_INFO(" [%s][%d] E_POWER_RESUME Start\n",__FUNCTION__,__LINE__));
3563 MDrv_GE_SetClock(g_apiGFXLocal.g_pGEContext, TRUE);
3564 UtopiaInstanceGetModule(pInstance, &pModule);
3565 // HW Init
3566 MDrv_GE_SetPowerState(g_apiGFXLocal.g_pGEContext ,pGFXPowerStateArg->eGFX_PowerStateType, pModule);
3567 // Default setting : To avoid GE issues commands too frequently when VC in enabled
3568 MDrv_GE_SetVCmd_W_Thread(g_apiGFXLocal.g_pGEContext, 0x4);
3569 MDrv_GE_SetVCmd_R_Thread(g_apiGFXLocal.g_pGEContext, 0x4);
3570 MDrv_GE_SetOnePixelMode(g_apiGFXLocal.g_pGEContext,!(g_apiGFXLocal.pGeChipProperty->bFourPixelModeStable));
3571 #if(defined(CrossThreadReleaseMutex) && (GE_LOCK_SUPPORT)) //for GE AN7.0
3572 GE_CTX_LOCAL *pGECtxLocal = (GE_CTX_LOCAL*)g_apiGFXLocal.g_pGEContext;
3573 pGECtxLocal->s32GELock=MsOS_GetOSThreadID();
3574 MsOS_EnableCrossThreadReleaseMutex(pGECtxLocal->s32GEMutex,TRUE);
3575 GE_Free_Resource(g_apiGFXLocal.g_pGEContext,FALSE);
3576 MsOS_EnableCrossThreadReleaseMutex(pGECtxLocal->s32GEMutex,FALSE);
3577 #else
3578 GE_Free_Resource(g_apiGFXLocal.g_pGEContext,FALSE);
3579 #endif
3580 GFX_DEBUG_MSG(GFX_INFO(" [%s][%d] E_POWER_RESUME End\n",__FUNCTION__,__LINE__));
3581 u32Ret = GFX_SUCCESS;
3582 break;
3583
3584 default:
3585 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3586 u32Ret = GFX_FAIL;
3587 break;
3588 }
3589 return u32Ret;
3590 }
3591
Ioctl_GFX_CB(void * pInstance,void * pArgs)3592 static MS_S32 Ioctl_GFX_CB(void* pInstance, void* pArgs)
3593 {
3594 EN_GFX_CB_MODE eCmd;
3595 GFX_CB_ARGS* pGFXCBArg =NULL;
3596 GFX_Result u32Ret =GFX_FAIL;
3597
3598 APICheckU02();
3599 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3600 pGFXCBArg = (GFX_CB_ARGS*)pArgs;
3601 eCmd = pGFXCBArg->eGFX_CBType;
3602 CMD(eCmd);
3603
3604 switch(eCmd)
3605 {
3606 case E_CB_GETFONT:
3607 g_apiGFXLocal.fpGetFont = pGFXCBArg->pGFX_CBInfo;
3608 u32Ret = GFX_SUCCESS;
3609 break;
3610
3611 case E_CB_GETBMP:
3612 g_apiGFXLocal.fpGetBMP = pGFXCBArg->pGFX_CBInfo;
3613 u32Ret = GFX_SUCCESS;
3614 break;
3615
3616 default:
3617 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3618 u32Ret = GFX_FAIL;
3619 break;
3620 }
3621 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), eCmd);
3622 }
3623 #endif
3624
Ioctl_GFX_MISC(void * pInstance,void * pArgs)3625 static MS_S32 Ioctl_GFX_MISC(void* pInstance, void* pArgs)
3626 {
3627 EN_GFX_MISC_MODE eCmd;
3628 GFX_MISC_ARGS* pGFXMISCArg =NULL;
3629 GFX_ClearFrameBuffer* pGFXClearFrame =NULL;
3630 #ifndef MSOS_TYPE_OPTEE
3631 GFX_SetLinePattern* pGFXSetLinePattern =NULL;
3632 GFX_SetStrBltSckType* pStrBltSckType =NULL;
3633 MS_U32* pLevel =NULL;
3634 MS_BOOL* pIsHK =NULL;
3635 MS_BOOL* pbPatch =NULL;
3636 MS_U8* pALB1555 =NULL;
3637 #endif
3638 GFX_Result u32Ret =GFX_FAIL;
3639
3640 APICheckU02();
3641
3642 pGFXMISCArg = (GFX_MISC_ARGS*)pArgs;
3643 eCmd = pGFXMISCArg->eGFX_MISCType;
3644 CMD(eCmd);
3645 if(eCmd == E_MISC_EXIT)
3646 {
3647 MDrv_GE_Exit(pInstance);
3648 return GFX_SUCCESS;
3649 }
3650
3651 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3652 switch(eCmd)
3653 {
3654 case E_MISC_CLEAR_FRAME_BY_WORLD:
3655 CheckSize(pGFXMISCArg->u32Size, sizeof(GFX_ClearFrameBuffer),eCmd);
3656 pGFXClearFrame = (GFX_ClearFrameBuffer*)pGFXMISCArg->pGFX_Info;
3657 MApi_GFX_ClearFrameBufferByWord_U02(pInstance,pGFXClearFrame->StrAddr,pGFXClearFrame->length,pGFXClearFrame->ClearValue);
3658 u32Ret = GFX_SUCCESS;
3659 break;
3660 #ifndef MSOS_TYPE_OPTEE
3661 case E_MISC_CLEAR_FRAME:
3662 CheckSize(pGFXMISCArg->u32Size, sizeof(GFX_ClearFrameBuffer),eCmd);
3663 pGFXClearFrame = (GFX_ClearFrameBuffer*)pGFXMISCArg->pGFX_Info;
3664 MApi_GFX_ClearFrameBuffer_U02(pInstance,pGFXClearFrame->StrAddr,pGFXClearFrame->length,pGFXClearFrame->ClearValue);
3665 u32Ret = GFX_SUCCESS;
3666 break;
3667 case E_MISC_LINE_PATTERN_RESET:
3668 MDrv_GE_ResetLinePattern(g_apiGFXLocal.g_pGEContext);
3669 u32Ret = GFX_SUCCESS;
3670 break;
3671 case E_MISC_LINE_PATTERN:
3672 CheckSize(pGFXMISCArg->u32Size, sizeof(GFX_SetLinePattern),eCmd);
3673 pGFXSetLinePattern = (GFX_SetLinePattern*)pGFXMISCArg->pGFX_Info;
3674 MApi_GFX_Set_Line_Pattern_U02(pInstance,pGFXSetLinePattern->enable,pGFXSetLinePattern->linePattern,pGFXSetLinePattern->repeatFactor);
3675 u32Ret = GFX_SUCCESS;
3676 break;
3677 #endif
3678 case E_MISC_BEGINE_DRAW:
3679 MApi_GFX_BeginDraw_U02(pInstance);
3680 u32Ret = GFX_SUCCESS;
3681 break;
3682 case E_MISC_END_DRAW:
3683 MApi_GFX_EndDraw_U02(pInstance);
3684 u32Ret = GFX_SUCCESS;
3685 break;
3686 #ifndef MSOS_TYPE_OPTEE
3687 case E_MISC_DEBUG_LEVEL:
3688 CheckSize(pGFXMISCArg->u32Size, sizeof(MS_U32),eCmd);
3689 pLevel = (MS_U32*)pGFXMISCArg->pGFX_Info;
3690 MApi_GFX_SetDbgLevel_U02(pInstance,*pLevel);
3691 u32Ret = GFX_SUCCESS;
3692 break;
3693 case E_MISC_SET_HK:
3694 CheckSize(pGFXMISCArg->u32Size, sizeof(MS_BOOL),eCmd);
3695 pIsHK = (MS_BOOL*)pGFXMISCArg->pGFX_Info;
3696 MApi_GFX_SetHK_U02(pInstance,*pIsHK);
3697 u32Ret = GFX_SUCCESS;
3698 break;
3699 case E_MISC_GET_HK:
3700 CheckSize(pGFXMISCArg->u32Size, sizeof(MS_BOOL),eCmd);
3701 pIsHK = (MS_BOOL*)pGFXMISCArg->pGFX_Info;
3702 MApi_GFX_GetHK_U02(pInstance,pIsHK);
3703 u32Ret = GFX_SUCCESS;
3704 break;
3705 case E_MISC_PATCH_MODE:
3706 CheckSize(pGFXMISCArg->u32Size, sizeof(MS_BOOL),eCmd);
3707 pbPatch = (MS_BOOL*)pGFXMISCArg->pGFX_Info;
3708 g_apiGFXLocal._bPatchMode = *pbPatch;
3709 u32Ret = GFX_SUCCESS;
3710 break;
3711 case E_MISC_STR_BLT_SCK_TYPE:
3712 CheckSize(pGFXMISCArg->u32Size, sizeof(GFX_SetStrBltSckType),eCmd);
3713 pStrBltSckType = (GFX_SetStrBltSckType*)pGFXMISCArg->pGFX_Info;
3714 MApi_GFX_SetStrBltSckType_U02(pInstance,pStrBltSckType->type, &(pStrBltSckType->color));
3715 u32Ret = GFX_SUCCESS;
3716 break;
3717 case E_MISC_SET_ALB_1555:
3718 CheckSize(pGFXMISCArg->u32Size, sizeof(MS_U8),eCmd);
3719 pALB1555 = (MS_U8*)pGFXMISCArg->pGFX_Info;
3720 MApi_GFX_SetAlpha_ARGB1555_U02(pInstance,*pALB1555);
3721 u32Ret = GFX_SUCCESS;
3722 break;
3723 case E_MISC_GET_ALB_1555:
3724 CheckSize(pGFXMISCArg->u32Size, sizeof(MS_U8),eCmd);
3725 pALB1555 = (MS_U8*)pGFXMISCArg->pGFX_Info;
3726 MApi_GFX_GetAlpha_ARGB1555_U02(pInstance,pALB1555);
3727 u32Ret = GFX_SUCCESS;
3728 break;
3729 #endif
3730 default:
3731 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, eCmd);
3732 u32Ret = GFX_FAIL;
3733 break;
3734 }
3735 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), eCmd);
3736
3737 }
3738
3739 #ifndef MSOS_TYPE_OPTEE
Ioctl_GFX_TLB(void * pInstance,void * pArgs)3740 static MS_S32 Ioctl_GFX_TLB(void* pInstance, void* pArgs)
3741 {
3742 GFX_TLB_ARGS* pGFXTLB =NULL;
3743 EN_GFX_TLB_CMD en_cmd;
3744 GFX_Result u32Ret =GFX_FAIL;
3745 GFX_SetTLB_Addr* pGFX_SetTLB_Addr =NULL;
3746 MS_BOOL* tlb_flush =FALSE;
3747 MS_U16* u16tag =0;
3748
3749 APICheckU02();
3750 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3751
3752 pGFXTLB = (GFX_TLB_ARGS*)pArgs;
3753 en_cmd = pGFXTLB->en_cmd;
3754 CMD(en_cmd);
3755
3756 switch(en_cmd)
3757 {
3758 case E_GFX_TLB_SET_MODE:
3759 CheckSize(pGFXTLB->u32Size, sizeof(GFX_TLB_ARGS), 0);
3760 g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode = (GE_TLB_Mode)pGFXTLB->TLB_mode;
3761 u32Ret = GFX_SUCCESS;
3762 break;
3763
3764 case E_GFX_TLB_SET_ADDR:
3765 CheckSize(pGFXTLB->u32Size, sizeof(GFX_SetTLB_Addr), 0);
3766 pGFX_SetTLB_Addr = (GFX_SetTLB_Addr*)pGFXTLB->psetting;
3767 g_apiGFXLocal.g_pGEContext->pBufInfo.tlbsrcaddr = pGFX_SetTLB_Addr->tlb_src_addr;
3768 g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr = pGFX_SetTLB_Addr->tlb_dst_addr;
3769 u32Ret = GFX_SUCCESS;
3770 break;
3771
3772 case E_GFX_TLB_FLUSH_TABLE:
3773 CheckSize(pGFXTLB->u32Size, sizeof(MS_BOOL), 0);
3774 tlb_flush = (MS_BOOL*)pGFXTLB->psetting;
3775 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable= *tlb_flush;
3776 break;
3777
3778 case E_GFX_TLB_TAG:
3779 CheckSize(pGFXTLB->u32Size, sizeof(MS_U16), 0);
3780 u16tag = (MS_U16*)pGFXTLB->psetting;
3781 MDrv_GE_SetTLBTag(g_apiGFXLocal.g_pGEContext,*u16tag);
3782 break;
3783
3784 default:
3785 GFX_ERR("[%s][%d] Error Cmd=%d \n",__FUNCTION__,__LINE__, en_cmd);
3786 u32Ret = UTOPIA_STATUS_FAIL;
3787 break;
3788 }
3789
3790 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
3791 }
Ioctl_GFX_DrawOval(void * pInstance,void * pArgs)3792 static MS_S32 Ioctl_GFX_DrawOval(void* pInstance, void* pArgs)
3793 {
3794 GFX_DRAW_OVAL_ARGS* pGFXOvalDraw =NULL;
3795 GFX_Set_DrawOvalInfo* pGFXOvalInfo =NULL;
3796 GFX_Result u32Ret =GFX_FAIL;
3797
3798 APICheckU02();
3799 API_GE_ENTRY(g_apiGFXLocal.g_pGEContext);
3800
3801 pGFXOvalDraw = (GFX_DRAW_OVAL_ARGS*)pArgs;
3802 CheckSize(pGFXOvalDraw->u32Size, sizeof(GFX_Set_DrawOvalInfo), 0);
3803 pGFXOvalInfo = (GFX_Set_DrawOvalInfo*)pGFXOvalDraw->psetting;
3804
3805 MDrv_GE_SetTLBMode(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode);
3806
3807 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3808 {
3809 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,TRUE);
3810 }
3811
3812 if((g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_DST)||(g_apiGFXLocal.g_pGEContext->pBufInfo.tlbmode==E_GE_TLB_SRC_DST))
3813 {
3814 MDrv_GE_SetTLBDstBaseAddr(g_apiGFXLocal.g_pGEContext, g_apiGFXLocal.g_pGEContext->pBufInfo.tlbdstaddr);
3815 }
3816
3817 GFX_SetFireInfo(pInstance,pGFXOvalInfo->pFireInfo);
3818
3819 u32Ret = MApi_GFX_DrawOval_U02(pInstance, pGFXOvalInfo->pDrawOvalInfo);
3820
3821 if(g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable)
3822 {
3823 MDrv_GE_TLBFlushTable(g_apiGFXLocal.g_pGEContext,FALSE);
3824 g_apiGFXLocal.g_pGEContext->pBufInfo.bEnflushtlbtable=FALSE;
3825 }
3826 API_GE_RETURN(g_apiGFXLocal.g_pGEContext, MapRet(u32Ret), 0);
3827 }
3828 #endif
3829
3830 #if defined(MSOS_TYPE_LINUX_KERNEL)
GFXStr(MS_U32 u32PowerState,void * pModule)3831 MS_U32 GFXStr(MS_U32 u32PowerState, void* pModule)
3832 {
3833 MS_U32 u32Return=UTOPIA_STATUS_FAIL;
3834
3835 switch(u32PowerState)
3836 {
3837 case E_POWER_SUSPEND:
3838 GFX_INFO("[%s][%d] Kernel STR Suspend Start!!!!!\n",__FUNCTION__,__LINE__);
3839 MDrv_GE_STR_SetPowerState((EN_POWER_MODE)u32PowerState, pModule);
3840 GFX_INFO("[%s][%d] Kernel STR Suspend End!!!!!\n",__FUNCTION__,__LINE__);
3841 u32Return=UTOPIA_STATUS_SUCCESS;
3842 break;
3843 case E_POWER_RESUME:
3844 GFX_INFO("[%s][%d] Kernel STR Resume Start!!!!!\n",__FUNCTION__,__LINE__);
3845 MDrv_GE_STR_SetPowerState((EN_POWER_MODE)u32PowerState, pModule);
3846 GFX_INFO("[%s][%d] Kernel STR Resume End!!!!!\n",__FUNCTION__,__LINE__);
3847 u32Return=UTOPIA_STATUS_SUCCESS;
3848 break;
3849 default:
3850 GFX_ERR("[%s][%d] PowerState:%tx not Implement now!!!\n",__FUNCTION__,__LINE__,(ptrdiff_t)u32PowerState);
3851 break;
3852 }
3853 return u32Return;
3854 }
3855 #endif
3856
3857 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
GFXMdbIoctl(MS_U32 u32Cmd,const void * const pArgs)3858 MS_U32 GFXMdbIoctl(MS_U32 u32Cmd, const void* const pArgs)
3859 {
3860 void *pInstance = NULL;
3861 pInstance = UtopiaModuleGetLocalInstantList(MODULE_GFX, pInstance);
3862 APICheckU02();
3863
3864 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
3865 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
3866 switch(u32Cmd)
3867 {
3868 case MDBCMD_CMDLINE:
3869 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
3870 break;
3871 case MDBCMD_GETINFO:
3872 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
3873 MDrv_GE_GetGFXMdbInfo(g_apiGFXLocal.g_pGEContext,paraGetInfo->u64ReqHdl);
3874 break;
3875 default:
3876 break;
3877 }
3878 return 0;
3879 }
3880 #endif
3881
GFXRegisterToUtopia(FUtopiaOpen ModuleType)3882 void GFXRegisterToUtopia(FUtopiaOpen ModuleType)
3883 {
3884 // 1. deal with module
3885 void* pUtopiaModule = NULL;
3886 UtopiaModuleCreate(MODULE_GFX, 8, &pUtopiaModule);
3887 UtopiaModuleRegister(pUtopiaModule);
3888 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)GFXOpen, (FUtopiaClose)GFXClose, (FUtopiaIOctl)GFXIoctl);
3889 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
3890 UtopiaModuleRegisterMdbNode("gfx", (FUtopiaMdbIoctl)GFXMdbIoctl);
3891 #endif
3892 #if defined(MSOS_TYPE_LINUX_KERNEL)
3893 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule, (FUtopiaSTR)GFXStr);
3894 UtopiaModuleSetSTRPrivate(pUtopiaModule, sizeof(GE_STR_SAVE_AREA));
3895 #endif
3896
3897 // 2. deal with resource
3898 void* psResource = NULL;
3899 UtopiaModuleAddResourceStart(pUtopiaModule, E_GE_POOL_ID_INTERNAL_REGISTER);
3900 UtopiaResourceCreate("ge0", sizeof(GFX_Resource_PRIVATE), &psResource);
3901 UtopiaResourceRegister(pUtopiaModule, psResource, E_GE_POOL_ID_INTERNAL_REGISTER);
3902 UtopiaModuleAddResourceEnd(pUtopiaModule, E_GE_POOL_ID_INTERNAL_REGISTER);
3903 }
3904
GFXOpen(void ** ppInstance,const void * const pAttribute)3905 MS_U32 GFXOpen(void** ppInstance, const void* const pAttribute)
3906 {
3907 UtopiaInstanceCreate(sizeof(GFX_INSTANT_PRIVATE), ppInstance);
3908 return UTOPIA_STATUS_SUCCESS;
3909 }
3910
GFXIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)3911 MS_U32 GFXIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
3912 {
3913 if(pInstance == NULL)
3914 {
3915 GFX_ERR("[%s:%s:%d]GFXIoctl's pInstance =NULL\n",__FILE__,__FUNCTION__,__LINE__);
3916 return UTOPIA_STATUS_ERR_NOT_AVAIL;
3917 }
3918
3919 switch(u32Cmd)
3920 {
3921 case MAPI_CMD_GFX_INIT:
3922 Ioctl_GFX_Init(pInstance, pArgs);
3923 break;
3924
3925 #ifndef MSOS_TYPE_OPTEE
3926 case MAPI_CMD_GFX_GET_INFO:
3927 Ioctl_GFX_GetInfo(pInstance, pArgs);
3928 break;
3929
3930 case MAPI_CMD_GFX_GET_CAPS:
3931 Ioctl_GFX_GetCaps(pInstance, pArgs);
3932 break;
3933
3934 case MAPI_CMD_GFX_LINEDRAW:
3935 Ioctl_GFX_LineDraw(pInstance, pArgs);
3936 break;
3937
3938 case MAPI_CMD_GFX_RECTFILL:
3939 Ioctl_GFX_RectFill(pInstance, pArgs);
3940 break;
3941
3942 case MAPI_CMD_GFX_TRIFILL:
3943 Ioctl_GFX_TriFill(pInstance, pArgs);
3944 break;
3945
3946 case MAPI_CMD_GFX_SPANFILL:
3947 Ioctl_GFX_SpanFill(pInstance, pArgs);
3948 break;
3949
3950 case MAPI_CMD_GFX_BITBLT:
3951 Ioctl_GFX_BitBlt(pInstance, pArgs);
3952 break;
3953
3954 case MAPI_CMD_GFX_TWOSRCBITBLT:
3955 Ioctl_GFX_TwoSrcBitBlt(pInstance, pArgs);
3956 break;
3957
3958 case MAPI_CMD_GFX_SET_ABL:
3959 Ioctl_GFX_SetABL(pInstance, pArgs);
3960 break;
3961 #endif
3962 case MAPI_CMD_GFX_SET_CONFIG:
3963 if (GFX_FAIL == Ioctl_GFX_SetConfig(pInstance, pArgs))
3964 {
3965 return UTOPIA_STATUS_FAIL;
3966 }
3967 break;
3968 case MAPI_CMD_GFX_GET_CONFIG:
3969 if(GFX_FAIL==Ioctl_GFX_GetConfig(pInstance, pArgs))
3970 {
3971 return UTOPIA_STATUS_FAIL;
3972 }
3973 break;
3974 #ifndef MSOS_TYPE_OPTEE
3975 case MAPI_CMD_GFX_BITMAP:
3976 Ioctl_GFX_Bitmap(pInstance, pArgs);
3977 break;
3978
3979 case MAPI_CMD_GFX_FONT:
3980 Ioctl_GFX_Font(pInstance, pArgs);
3981 break;
3982
3983 case MAPI_CMD_GFX_POWERSTATE:
3984 Ioctl_GFX_PowerState(pInstance, pArgs);
3985 break;
3986
3987 case MAPI_CMD_GFX_CB:
3988 Ioctl_GFX_CB(pInstance, pArgs);
3989 break;
3990 #endif
3991 case MAPI_CMD_GFX_MISC:
3992 Ioctl_GFX_MISC(pInstance, pArgs);
3993 break;
3994 #ifndef MSOS_TYPE_OPTEE
3995 case MAPI_CMD_GFX_TLB:
3996 Ioctl_GFX_TLB(pInstance, pArgs);
3997 break;
3998 case MAPI_CMD_GFX_DRAW_OVAL:
3999 Ioctl_GFX_DrawOval(pInstance, pArgs);
4000 break;
4001 #endif
4002 default:
4003 GFX_DBUG("[%s][%d]\n",__FUNCTION__,__LINE__);
4004 break;
4005 }
4006 return UTOPIA_STATUS_SUCCESS;
4007 }
4008
GFXClose(void * pInstance)4009 MS_U32 GFXClose(void* pInstance)
4010 {
4011 GFX_INFO("\n[GFX INFO] GFX close");
4012 UtopiaInstanceDelete(pInstance);
4013 return TRUE;
4014 }
4015
4016
4017
4018