1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2006-2007 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file apiGFX.c
98 /// @brief MStar Graphics API
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 //----------------------------------------------------------------------------
103 // Include Files
104 //----------------------------------------------------------------------------
105 #ifndef MSOS_TYPE_LINUX_KERNEL
106 #include <stdio.h>
107 #include <stdlib.h>
108 #include <string.h>
109 #include <pthread.h>
110 #endif
111 #include "MsOS.h"
112 #include "MsCommon.h"
113 #include "MsTypes.h"
114 #include "MsVersion.h"
115 #include "_apigfx_type.h"
116 #include "utopia.h"
117 #include "utopia_dapi.h"
118 #include "apiGFX.h"
119 #include "apiGFX_v2.h"
120 #include "apiGFX_private.h"
121
122 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
123 #ifndef GFX_UTOPIA2K
124 #define GFX_UTOPIA2K
125 #endif
126 #endif
127 //----------------------------------------------------------------------------
128 // Compile options
129 //----------------------------------------------------------------------------
130 // #define GFX Utopia2.0 capibility
131 void* pGEInstance=NULL;
132
133 static MS_S32 s32GEWrapperMutex;
134 static void (*fpGFX_CBGetFont)(MS_S8, GFX_FontInfo*)=NULL;
135 static void (*fpGFX_CBGetBMP)(MS_S16, GFX_BitmapInfo*)=NULL;
136
137 #ifdef MSOS_TYPE_LINUX
138 static pthread_mutex_t GFXFireInfoMutex = PTHREAD_MUTEX_INITIALIZER;
139 #endif
140 GFX_FireInfo GFXFireInfo;
141 GFX_Set_VQ GFXSerVQ;
142 //----------------------------------------------------------------------------
143 // Local Defines
144 //----------------------------------------------------------------------------
145 //----------------------------------------------------------------------------
146 // Debug Macros
147 //----------------------------------------------------------------------------
148 //#define GFX_UNIT_TEST(fmt, ...) printf(fmt, ##__VA_ARGS__)
149
150 #ifdef GFX_DEBUG
151
152 #define _GFX_CHECK_BUFFER_ALIGN0(addr, color_fmt) \
153 switch ((color_fmt)){ \
154 case GFX_FMT_I1: \
155 case GFX_FMT_I2: \
156 case GFX_FMT_I4: \
157 case GFX_FMT_I8: \
158 break; \
159 case GFX_FMT_YUV422: \
160 case GFX_FMT_1ABFGBG12355: \
161 case GFX_FMT_RGB565 : \
162 case GFX_FMT_FABAFGBG2266: \
163 case GFX_FMT_ARGB1555 : \
164 case GFX_FMT_ARGB4444 : \
165 case GFX_FMT_RGBA5551: \
166 case GFX_FMT_RGBA4444: \
167 case GFX_FMT_BGRA5551: \
168 case GFX_FMT_ABGR1555 : \
169 case GFX_FMT_ABGR4444: \
170 case GFX_FMT_BGRA4444 : \
171 case GFX_FMT_BGR565 : \
172 GFX_ASSERT(!(0x1 & (addr)), GFX_FATAL("[GE DRV][%06d] Bad buffer address (0x%08x, %d)\n", (addr), (color_fmt))); \
173 break; \
174 case GFX_FMT_ARGB8888 : \
175 case GFX_FMT_ABGR8888: \
176 case GFX_FMT_RGBA8888 : \
177 case GFX_FMT_BGRA8888: \
178 GFX_ASSERT(!(0x3 & (addr)), GFX_FATAL("[GE DRV][%06d] Bad buffer address (0x%08x, %d)\n", (addr), (color_fmt))); \
179 break; \
180 default: \
181 GFX_ASSERT(0, GFX_FATAL("[GE DRV][%06d] Invalid color format\n")); \
182 break; \
183 }
184
185
186 #define _GFX_CHECK_BUFFER_ALIGN1(addr, width, height, pitch, color_fmt) \
187 switch ((color_fmt)){ \
188 case GFX_FMT_I1: \
189 case GFX_FMT_I2: \
190 case GFX_FMT_I4: \
191 case GFX_FMT_I8: \
192 break; \
193 case GFX_FMT_YUV422: \
194 case GFX_FMT_1ABFGBG12355: \
195 case GFX_FMT_FABAFGBG2266: \
196 case GFX_FMT_RGB565 : \
197 case GFX_FMT_ARGB1555 : \
198 case GFX_FMT_ARGB4444 : \
199 case GFX_FMT_RGBA5551: \
200 case GFX_FMT_RGBA4444: \
201 case GFX_FMT_BGRA5551: \
202 case GFX_FMT_ABGR1555 : \
203 case GFX_FMT_ABGR4444: \
204 case GFX_FMT_BGRA4444 : \
205 case GFX_FMT_BGR565 : \
206 GFX_ASSERT(!(0x1 & (addr)), GFX_FATAL("[GE DRV][%06d] Bad buffer address (0x%08x, %d)\n", (addr), (color_fmt))); \
207 GFX_ASSERT(!(0x1 & (pitch)), GFX_FATAL("[GE DRV][%06d] Bad buffer pitch (%d, %d)\n", (pitch), (color_fmt))); \
208 GFX_ASSERT(((pitch)>>1)== (width), GFX_FATAL("[GE DRV][%06d] Bad buffer pitch/width (%d, %d)\n", (pitch), (width))); \
209 break; \
210 case GFX_FMT_ARGB8888 : \
211 case GFX_FMT_ABGR8888: \
212 case GFX_FMT_RGBA8888 : \
213 case GFX_FMT_BGRA8888: \
214 GFX_ASSERT(!(0x3 & (addr)), GFX_FATAL("[GE DRV][%06d] Bad buffer address (0x%08x, %d)\n", (addr), (color_fmt))); \
215 GFX_ASSERT(!(0x3 & (pitch)), GFX_FATAL("[GE DRV][%06d] Bad buffer pitch (%d, %d)\n", (pitch), (color_fmt))); \
216 GFX_ASSERT(((pitch)>>2)== (width), GFX_FATAL("[GE DRV][%06d] Bad buffer pitch/width (%d, %d)\n", (pitch), (width))); \
217 break; \
218 default: \
219 GFX_ASSERT(0, GFX_FATAL("[GE DRV][%06d] Invalid color format\n")); \
220 break; \
221 }
222
223
224
225
226 #else // #ifdef GFX_DEBUG
227
228 #define _GFX_CHECK_BUFFER_ALIGN0(addr, color_fmt) while (0);
229 #define _GFX_CHECK_BUFFER_ALIGN1(addr, width, height, pitch, color_fmt) while (0);
230
231 #endif // #ifdef GFX_DEBUG
232
233 //----------------------------------------------------------------------------
234 // Macros
235 //----------------------------------------------------------------------------
236 //#define CHECK_IDLE() while(BLT_Reg(BLT_REG_STATUS)&BLT_VAL_BUSY) { MsOS_DelayTask(1);}
237 // #define CHECK_IDLE() while(BLT_Reg(BLT_REG_STATUS)&BLT_VAL_BUSY) { MsOS_YieldTask();}
238 #define delay(ms)
239 //#define delay(ms) MsOS_DelayTask(ms)
240
241 #define MAKE_PRIMITIVE_COLOR_12355(_bg, _fg, _blink, _alpha) (((((0x7 & (_blink))<<3)|((0x3 & (_alpha))<<6)|0xFF00)<<16) | \
242 (((0x1F & (_bg))<<3)|((0x1F & (_fg))<<11)))
243 #define MAKE_PRIMITIVE_COLOR_2266(_bg, _fg, _ba, _fa) ((((0x3 & (_ba)) | ((0x3 & (_fa))<<8))<<16) |\
244 ((0x1F & (_bg))|((0x1F & (_fg))<<8)))
245
246 //----------------------------------------------------------------------------
247 // Global Variables
248 //----------------------------------------------------------------------------
249 //static MS_U32 _u32FrameWidth, _u32FrameHeight, _u32FramePitch;
250
251
252 #ifndef MSOS_TYPE_OPTEE
253 //-------------------------------------------------------------------------------------------------
254 // Local Variables
255 //-------------------------------------------------------------------------------------------------
256 static MSIF_Version _drv_gfx_version = {
257 .DDI = { GFX_DRV_VERSION },
258 };
259 #endif
260
261
262 /// 0: No DBG msg at all
263 /// 1: Default development level (All ERROR)
264 /// 2: Verbose level
265
266
267 #define APIGFX_CHECK_NULL(pParameter) \
268 { \
269 if(pParameter == NULL) \
270 { \
271 GFX_ERR("\n Input Parameter is NULL, please to check! \n");\
272 return GFX_INIT_FAIL; \
273 } \
274 }
275 #define APIGFX_CHECK_INIT() \
276 { \
277 if(pGEInstance == NULL)\
278 { \
279 GFX_ERR("\nshould call MApi_GFX_Init first\n");\
280 return GFX_INIT_FAIL; \
281 } \
282 }
283 //----------------------------------------------------------------------------
284 // Local Function Prototypes
285 //----------------------------------------------------------------------------
286
287 //-------------------------------------------------------------------------------------------------
288
289 //-------------------------------------------------------------------------------------------------
290
291 //-------------------------------------------------------------------------------------------------
292 //[OBSOLETE]
293
294 #define GFXDRIVER_BASE 0UL
295
296
297 #define CheckGFXInstanceOpen() do{\
298 if(NULL == pGEInstance)\
299 {\
300 if(UtopiaOpen(MODULE_GFX | GFXDRIVER_BASE, &pGEInstance, 0, NULL))\
301 {\
302 GFX_ERR("%s fail [LINE:%d] GFXOpen Fail\n",__FUNCTION__, __LINE__);\
303 return ;\
304 }\
305 }\
306 }while(0)
307 #ifndef MSOS_TYPE_OPTEE
GFX_FireInfoLock(void)308 static void GFX_FireInfoLock(void)
309 {
310
311 #ifdef MSOS_TYPE_LINUX
312 pthread_mutex_lock(&GFXFireInfoMutex);
313 #endif
314
315 }
316
GFX_FireInfoUnLock(void)317 static void GFX_FireInfoUnLock(void)
318 {
319
320 #ifdef MSOS_TYPE_LINUX
321 pthread_mutex_unlock(&GFXFireInfoMutex);
322 #endif
323
324 }
325 #endif
_GFX_RegisterAllCBFunc(void)326 static GFX_Result _GFX_RegisterAllCBFunc(void)
327 {
328 GFX_Result eRet = GFX_SUCCESS;
329
330 #ifdef GFX_UTOPIA2K
331 #else
332 GFX_CB_ARGS GFXCBInfo;
333 memset(&GFXCBInfo, 0, sizeof(GFX_CB_ARGS));
334
335 if(fpGFX_CBGetFont!=NULL)
336 {
337 GFXCBInfo.eGFX_CBType =E_CB_GETFONT;
338 GFXCBInfo.pGFX_CBInfo =fpGFX_CBGetFont;
339 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_CB, (void*)&GFXCBInfo) != UTOPIA_STATUS_SUCCESS)
340 {
341 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
342 eRet = GFX_FAIL;
343 }
344 }
345 if(fpGFX_CBGetBMP!=NULL)
346 {
347 GFXCBInfo.eGFX_CBType =E_CB_GETBMP;
348 GFXCBInfo.pGFX_CBInfo =fpGFX_CBGetBMP;
349 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_CB, (void*)&GFXCBInfo) != UTOPIA_STATUS_SUCCESS)
350 {
351 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
352 eRet = GFX_FAIL;
353 }
354 }
355 #endif
356 return eRet;
357 }
358 #ifndef MSOS_TYPE_OPTEE
359 /******************************************************************************/
360 ///This function will register callback for GetFont function.
361 ///
362 ///@param *fpGFX_CB \b IN: Pointer to a callback function for GetFont.
363 ///@return GFX_SUCCESS if sucess.
364 /******************************************************************************/
MApi_GFX_RegisterGetFontCB(MS_PHY (* fpGFX_CB)(MS_S8,GFX_FontInfo *))365 GFX_Result MApi_GFX_RegisterGetFontCB(MS_PHY (*fpGFX_CB)(MS_S8, GFX_FontInfo*) )
366 {
367 GFX_Result eRet = GFX_SUCCESS;
368
369 if(fpGFX_CB == NULL)
370 {
371 return GFX_INVALID_PARAMETERS;
372 }
373
374 fpGFX_CBGetFont = (void*)fpGFX_CB;
375 #ifdef GFX_UTOPIA2K
376 #else
377 if(pGEInstance !=NULL)
378 {
379 GFX_CB_ARGS GFXCBInfo;
380 memset(&GFXCBInfo, 0, sizeof(GFX_CB_ARGS));
381
382 GFXCBInfo.eGFX_CBType =E_CB_GETFONT;
383 GFXCBInfo.pGFX_CBInfo =fpGFX_CB;
384 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_CB, (void*)&GFXCBInfo) != UTOPIA_STATUS_SUCCESS)
385 {
386 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
387 eRet = GFX_FAIL;
388 }
389 }
390 #endif
391 return eRet;
392 }
393
394 /******************************************************************************/
395 ///This function will register callback for GetBMP function.
396 ///
397 ///@param *fpGFX_CB \b IN: Pointer to a callback function for GetBMP.
398 ///@return GFX_SUCCESS if sucess.
399 /******************************************************************************/
MApi_GFX_RegisterGetBMPCB(MS_PHY (* fpGFX_CB)(MS_S16,GFX_BitmapInfo *))400 GFX_Result MApi_GFX_RegisterGetBMPCB(MS_PHY (*fpGFX_CB)(MS_S16, GFX_BitmapInfo*) )
401 {
402 GFX_Result eRet = GFX_SUCCESS;
403
404 if(fpGFX_CB == NULL)
405 {
406 return GFX_INVALID_PARAMETERS;
407 }
408 fpGFX_CBGetBMP = (void*)fpGFX_CB;
409 #ifdef GFX_UTOPIA2K
410 #else
411 if(pGEInstance !=NULL)
412 {
413 GFX_CB_ARGS GFXCBInfo;
414 memset(&GFXCBInfo, 0, sizeof(GFX_CB_ARGS));
415
416 GFXCBInfo.eGFX_CBType =E_CB_GETBMP;
417 GFXCBInfo.pGFX_CBInfo =fpGFX_CB;
418 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_CB, (void*)&GFXCBInfo) != UTOPIA_STATUS_SUCCESS)
419 {
420 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
421 eRet = GFX_FAIL;
422 }
423 }
424 #endif
425 return eRet;
426 }
427 #endif
428
429 /******************************************************************************/
430 ///This function will fill a specific 32-bit pattern in a specific buffer.
431 ///
432 ///@param StrAddr \b IN: Start address of the buffer to be filled with specific value. 4-Byte alignment.
433 ///@param length \b IN: Length of the value pattern to be filled. 4-Byte alignment
434 ///@param ClearValue \b IN: 32-bit pattern to be filled in the specified space.
435 ///@return GFX_SUCCESS if sucess.
436 /******************************************************************************/
MApi_GFX_ClearFrameBufferByWord(MS_PHY StrAddr,MS_U32 length,MS_U32 ClearValue)437 GFX_Result MApi_GFX_ClearFrameBufferByWord(MS_PHY StrAddr, MS_U32 length, MS_U32 ClearValue)
438 {
439 GFX_MISC_ARGS GFXInfo;
440 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
441
442 GFX_ClearFrameBuffer Info;
443 memset(&Info, 0, sizeof(GFX_ClearFrameBuffer));
444
445 Info.StrAddr = StrAddr;
446 Info.length = length;
447 Info.ClearValue = ClearValue;
448
449 GFXInfo.eGFX_MISCType = E_MISC_CLEAR_FRAME_BY_WORLD;
450 GFXInfo.pGFX_Info = (void*)&Info;
451 GFXInfo.u32Size = sizeof(GFX_ClearFrameBuffer);
452
453 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
454 {
455 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
456 }
457 return GFX_SUCCESS;
458
459 }
460 #ifndef MSOS_TYPE_OPTEE
461
462 #if 1
463 /******************************************************************************/
464 ///This function will fill a specific 8-bit pattern in a specific buffer.
465 ///
466 ///@param StrAddr \b IN: Start address of the buffer to be filled with specific value. Byte alignment.
467 ///@param length \b IN: Length of the value pattern to be filled. Byte alignment
468 ///@param ClearValue \b IN: 8 bit pattern to be filled in the specified space.
469 ///@return GFX_SUCCESS if sucess.
470 /******************************************************************************/
MApi_GFX_ClearFrameBuffer(MS_PHY StrAddr,MS_U32 length,MS_U8 ClearValue)471 GFX_Result MApi_GFX_ClearFrameBuffer(MS_PHY StrAddr, MS_U32 length, MS_U8 ClearValue)
472 {
473 GFX_MISC_ARGS GFXInfo;
474 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
475
476 GFX_ClearFrameBuffer Info;
477 memset(&Info, 0, sizeof(GFX_ClearFrameBuffer));
478
479 Info.StrAddr = StrAddr;
480 Info.length = length;
481 Info.ClearValue = ClearValue;
482
483 GFXInfo.eGFX_MISCType = E_MISC_CLEAR_FRAME;
484 GFXInfo.pGFX_Info = (void*)&Info;
485 GFXInfo.u32Size = sizeof(GFX_ClearFrameBuffer);
486
487 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
488 {
489 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
490 }
491 return GFX_SUCCESS;
492 }
493 #endif
494
495 /******************************************************************************/
496 ///This function will draw a Rectangle Frame (Framework) on screen
497 ///
498 ///@param *pblock \b IN: Pointer to a structure containing the rectangle coordinates, size and color information
499 ///@param *plinefmt \b IN: Pointer to a structure containing the border format (using bolder line)
500 ///@return GFX_SUCCESS if sucess.
501 /******************************************************************************/
MApi_GFX_RectFrame(GFX_RectFillInfo * pblock,GFX_DrawLineInfo * plinefmt)502 void MApi_GFX_RectFrame(GFX_RectFillInfo *pblock, GFX_DrawLineInfo *plinefmt)
503 {
504 GFX_DrawLineInfo pline;
505
506 //GE_GET_ReSource();
507
508 //printf("MDrv_GE_RectFrame \n");
509
510 memset(&pline, 0, sizeof(GFX_DrawLineInfo));
511 memcpy(&pline.colorRange.color_s, &pblock->colorRange.color_s, 4);
512 memcpy(&pline.colorRange.color_e, &pblock->colorRange.color_e, 4);
513
514 // Top line
515 #if 0
516 clrline.x1 = pblock->x;
517 clrline.x2 = pblock->x + pblock->width ;
518 clrline.y1 =
519 clrline.y2 = pblock->y;
520 MDrv_GE_LineTo( &clrline, plinefmt );
521 #endif
522 pline.x1 = pblock->dstBlock.x;
523 pline.x2 = pblock->dstBlock.x + pblock->dstBlock.width ;
524 pline.y1 =
525 pline.y2 = pblock->dstBlock.y;
526 pline.flag = 0;
527 MApi_GFX_DrawLine(&pline);
528
529 // Bottom line
530 #if 0
531 clrline.y1 =
532 clrline.y2 = pblock->y + pblock->height -1;
533 MDrv_GE_LineTo( &clrline, plinefmt );
534 #endif
535
536 pline.y1 = pblock->dstBlock.y + pblock->dstBlock.height -1;
537 pline.y2 = pblock->dstBlock.y + pblock->dstBlock.height -1;
538 MApi_GFX_DrawLine(&pline);
539
540 // Left line
541 #if 0
542 clrline.x2 = pblock->x;
543 clrline.y1 = pblock->y;
544 clrline.y2 = pblock->y + pblock->height ;
545 MDrv_GE_LineTo( &clrline, plinefmt );
546 #endif
547
548 pline.x2 = pblock->dstBlock.x;
549 pline.y1 = pblock->dstBlock.y;
550 pline.y2 = pblock->dstBlock.y + pblock->dstBlock.height;
551 MApi_GFX_DrawLine(&pline);
552
553
554 // Right line
555 #if 0
556 clrline.x1 = pblock->x + pblock->width -1;
557 clrline.x2 = clrline.x1;
558 MDrv_GE_LineTo( &clrline, plinefmt );
559 #endif
560 pline.x1 = pblock->dstBlock.x + pblock->dstBlock.width -1;
561 pline.x2 = pline.x1;
562 MApi_GFX_DrawLine(&pline);
563
564
565 //GE_Free_ReSource();
566
567 }
568
569 //-------------------------------------------------------------------------------------------------
570 /// GFX text out function for drawing characters in one line.
571 /// The function invokes the callback registered through MApi_GFX_RegisterGetFontCB for restrieving font info.
572 /// @param fhandle \b IN: font handle
573 /// @param pindex \b IN: pointer of character index array
574 /// @param strwidth \b IN: character index length(1:ONE_BYTE_CHAR, 2: TWO_BYTE_CHAR)
575 /// @param pfmt \b IN: pointer to text out info
576 /// @return GFX_SUCCESS - Success
577 /// @return GFX_INVALID_FONT_HANDLE - Invalid font handle
578 /// @return GFX_INVALID_PARAMETERS - Inavlid input parameters
579 //-------------------------------------------------------------------------------------------------
MApi_GFX_TextOut(MS_S32 fhandle,MS_U8 * pindex,MS_U32 strwidth,GFX_TextOutInfo * pfmt)580 GFX_Result MApi_GFX_TextOut(MS_S32 fhandle, MS_U8 *pindex, MS_U32 strwidth, GFX_TextOutInfo *pfmt)
581 {
582 GFX_FontInfo tfontTable;
583 GFX_Result eRet = GFX_SUCCESS;
584 MS_U16 i;
585
586 if(fpGFX_CBGetFont != NULL)
587 fpGFX_CBGetFont(fhandle, &tfontTable);
588 else
589 return GFX_INVALID_FONT_HANDLE;
590
591 if (!tfontTable.inUsed)
592 {
593 return GFX_INVALID_FONT_HANDLE;
594 }
595
596 if(pindex==NULL || pfmt ==NULL)
597 {
598 return GFX_FAIL;
599 }
600 APIGFX_CHECK_INIT();
601
602 GFX_TEXTOUT_ARGS GFXTextArgs;
603 GFX_TextOut_V2 GFXTextOut;
604
605 memset(&GFXTextArgs, 0 , sizeof(GFX_TEXTOUT_ARGS));
606 memset(&GFXTextOut , 0 ,sizeof(GFX_TextOut_V2));
607
608 GFX_FireInfoLock();
609 GFXTextOut.fHandle =fhandle;
610
611 if (strwidth == 2)
612 {
613 MS_U16 * pCharAr = (MS_U16 *)(&GFXTextOut.charArray[0]);
614 MS_U16 * pUnicodeChar = (MS_U16 *)pindex;
615 for (i=0; i<128; i++)
616 {
617 *(pCharAr + i) = *(pUnicodeChar + i);
618 if (*(pUnicodeChar + i) == '\0')
619 {
620 break;
621 }
622 }
623 }
624 else
625 {
626 for (i=0; i<256; i++)
627 {
628 GFXTextOut.charArray[i] = *(pindex + i);
629 if (*(pindex + i) == '\0')
630 {
631 break;
632 }
633 }
634 }
635
636 GFXTextOut.u32StrWidth =strwidth;
637 GFXTextOut.pTextInfo =pfmt;
638 GFXTextOut.pFonttable =&tfontTable;
639 GFXTextArgs.eGFX_TextType =E_LOADTEXTOUT;
640 GFXTextArgs.pGFX_TextOut =(void*)&GFXTextOut;
641 GFXTextArgs.u32Size =sizeof(GFX_TextOut_V2);
642 GFXTextOut.pFireInfo = &GFXFireInfo;
643 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_FONT, (void*)&GFXTextArgs) != UTOPIA_STATUS_SUCCESS)
644 {
645 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
646 eRet = GFX_FAIL;
647 }
648 GFXFireInfo.eFireInfo = 0;
649 GFX_FireInfoUnLock();
650
651 return eRet;
652 }
653
654
655
656
657 //-------------------------------------------------------------------------------------------------
658 /// Query text display length
659 /// The function invokes the callback registered through MApi_GFX_RegisterGetFontCB for restrieving font info.
660 /// @param fhandle \b IN: font handle
661 /// @param pu8index \b IN: pointer of character index array
662 /// @param u32strwidth \b IN: character index length(1:ONE_BYTE_CHAR, 2: TWO_BYTE_CHAR)
663 /// @param pfmt \b IN: pointer to text out info
664 /// @param pu32DispLength \b OUT: pointer to display length.
665 /// @return GFX_SUCCESS - Success
666 /// @return GFX_INVALID_FONT_HANDLE - Invalid font handle
667 /// @return GFX_INVALID_PARAMETERS - Inavlid input parameters
668 //-------------------------------------------------------------------------------------------------
MApi_GFX_QueryTextDispLength(MS_S32 fhandle,MS_U8 * pu8index,MS_U32 u32strwidth,GFX_TextOutInfo * pfmt,MS_U32 * pu32DispLength)669 GFX_Result MApi_GFX_QueryTextDispLength(MS_S32 fhandle, MS_U8 *pu8index, MS_U32 u32strwidth,
670 GFX_TextOutInfo *pfmt, MS_U32* pu32DispLength)
671 {
672 MS_U16* pu16TmpIndex;
673 MS_U8* pu8TmpIndex;
674 MS_U32 u32Length = 0;
675 MS_S8 dis;
676
677 // OSD_RESOURCE_FONT_INFO osd_fonttable;
678 GFX_FontInfo fonttable;
679 GFX_FontInfo* pFont = &fonttable;
680 MS_VIRT ptr_addr;
681
682 APIGFX_CHECK_INIT();
683
684 //msAPI_OSD_RESOURCE_GetFontInfo(fhandle, &osd_fonttable);
685 if(fpGFX_CBGetFont != NULL)
686 fpGFX_CBGetFont(fhandle, &fonttable);
687 else
688 return GFX_INVALID_FONT_HANDLE;
689 #if 0
690 fonttable.addr = osd_fonttable.glyph_addr;
691 fonttable.fmt = osd_fonttable.fmt;
692 fonttable.height = osd_fonttable.height;
693 fonttable.len = osd_fonttable.char_glyph_bytes;
694 fonttable.offset = osd_fonttable.char_glyph_bytes;
695 fonttable.pBBox = (GFX_GlyphBbox*)osd_fonttable.bbox_addr;
696 fonttable.pitch = osd_fonttable.pitch;
697 fonttable.width = osd_fonttable.width;
698 fonttable.inUsed = osd_fonttable.inUsed;
699 #endif
700 if (!pFont->inUsed)
701 {
702 return GFX_INVALID_FONT_HANDLE;
703 }
704 if (pu8index == NULL)
705 {
706 return GFX_INVALID_PARAMETERS;
707 }
708
709 if(pfmt->flag & GFXFONT_FLAG_COMPACT)
710 {
711 dis = pfmt->dis;
712 }
713 else if (pfmt->flag & GFXFONT_FLAG_GAP)
714 {
715 dis = (0-pfmt->dis);
716 }
717 else
718 {
719 dis = 0;
720 }
721
722
723 if (u32strwidth == 1)
724 {
725 pu8TmpIndex = (MS_U8*)pu8index;
726 while(*pu8TmpIndex != 0)
727 {
728 if (pfmt->flag & GFXFONT_FLAG_SCALE)
729 {
730 u32Length = u32Length + pfmt->dstblk.width - dis;
731 }
732 else
733 {
734 if ((pfmt->flag & GFXFONT_FLAG_VARWIDTH) &&
735 (pFont->pBBox != NULL))
736 {
737 u32Length = u32Length + pFont->pBBox[*pu8TmpIndex].u8Width - dis;
738 }
739 else
740 {
741 u32Length = u32Length + pFont->width - dis;
742 }
743 }
744 pu8TmpIndex++;
745 }
746 *pu32DispLength = u32Length + dis;
747 }
748 else if (u32strwidth == 2)
749 {
750 ptr_addr = (MS_VIRT)pu8index;
751 if(ptr_addr % 2 != 0)
752 {
753 GFX_ERR("%s: %d\n", __FUNCTION__ , __LINE__);
754 return GFX_INVALID_PARAMETERS;
755 }
756
757 pu16TmpIndex = (MS_U16*)ptr_addr;
758 while(*pu16TmpIndex != 0)
759 {
760 if (pfmt->flag & GFXFONT_FLAG_SCALE)
761 {
762 u32Length = u32Length + pfmt->dstblk.width - dis;
763 }
764 else
765 {
766 if ((pfmt->flag & GFXFONT_FLAG_VARWIDTH) &&
767 (pFont->pBBox != NULL))
768 {
769 u32Length = u32Length + pFont->pBBox[*pu16TmpIndex].u8Width - dis;
770 }
771 else
772 {
773 u32Length = u32Length + pFont->width - dis;
774 }
775 }
776 pu16TmpIndex++;
777 }
778 *pu32DispLength = u32Length + dis;
779 }
780 else
781 {
782 *pu32DispLength = u32Length;
783 return GFX_INVALID_PARAMETERS;
784 }
785
786 return GFX_SUCCESS;
787 }
788
789
790 //-------------------------------------------------------------------------------------------------
791 /// GFX text out one character without load font.
792 /// @param pChar \b IN: pointer to character information
793 /// @param pfmt \b IN: pointer to text out info
794 /// @return GFX_SUCCESS - Success
795 /// @return GFX_FAIL - Failure
796 //-------------------------------------------------------------------------------------------------
MApi_GFX_CharacterOut(GFX_CharInfo * pChar,GFX_TextOutInfo * pfmt)797 GFX_Result MApi_GFX_CharacterOut(GFX_CharInfo* pChar, GFX_TextOutInfo *pfmt)
798 {
799 GFX_Result eRet = GFX_SUCCESS;
800
801 if(pChar==NULL || pfmt ==NULL)
802 {
803 return GFX_FAIL;
804 }
805 APIGFX_CHECK_INIT();
806 GFX_TEXTOUT_ARGS GFXTextArgs;
807 GFX_CharacterOut GFXCharacterout;
808
809 memset(&GFXTextArgs, 0 , sizeof(GFX_TEXTOUT_ARGS));
810 memset(&GFXCharacterout , 0 ,sizeof(GFX_CharacterOut));
811
812 GFX_FireInfoLock();
813 GFXCharacterout.pChar =pChar;
814 GFXCharacterout.pTextInfo =pfmt;
815 GFXTextArgs.eGFX_TextType =E_CHARACTEROUT;
816 GFXTextArgs.pGFX_TextOut =(void*)&GFXCharacterout;
817 GFXTextArgs.u32Size =sizeof(GFX_CharacterOut);
818 GFXCharacterout.pFireInfo = &GFXFireInfo;
819 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_FONT, (void*)&GFXTextArgs) != UTOPIA_STATUS_SUCCESS)
820 {
821 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
822 eRet = GFX_FAIL;
823 }
824 GFXFireInfo.eFireInfo = 0;
825 GFX_FireInfoUnLock();
826
827 return eRet;
828 }
829
830 //-------------------------------------------------------------------------------------------------
831 /// GFX draw bitmap function
832 /// The function invokes the callback registered through MApi_GFX_RegisterGetBMPCB for restrieving BMP info.
833 /// @param handle \b IN: handle of bitmap
834 /// @param pbmpfmt \b IN: bitmap format
835 /// @return GFX_SUCCESS - Success
836 /// @return GFX_FAIL - Failure
837 /// @return GFX_INVALID_BMP_HANDLE - Invalid bitmap handle
838 //-------------------------------------------------------------------------------------------------
MApi_GFX_DrawBitmap(MS_S32 handle,GFX_DrawBmpInfo * pbmpfmt)839 GFX_Result MApi_GFX_DrawBitmap(MS_S32 handle, GFX_DrawBmpInfo *pbmpfmt)
840 {
841 GFX_Result eRet = GFX_SUCCESS;
842 GFX_BitmapInfo bmpinfo;
843 GFX_BufferInfo srcinfo;
844
845 if(pbmpfmt ==NULL)
846 {
847 return GFX_FAIL;
848 }
849
850 APIGFX_CHECK_INIT();
851 GFX_BITMAP_ARGS pGFXBitmap;
852 GFX_Bitmap pGFXBitmapInfo;
853
854 memset(&pGFXBitmap, 0 , sizeof(GFX_BITMAP_ARGS));
855 memset(&pGFXBitmapInfo , 0 ,sizeof(GFX_Bitmap));
856
857 if(fpGFX_CBGetBMP != NULL)
858 fpGFX_CBGetBMP(handle, &bmpinfo);
859 else
860 return GFX_INVALID_BMP_HANDLE;
861
862 if (!bmpinfo.inUsed)
863 {
864 return GFX_INVALID_BMP_HANDLE;
865 }
866
867 srcinfo.u32Addr = bmpinfo.addr;
868 srcinfo.u32Width = bmpinfo.width;
869 srcinfo.u32Height = bmpinfo.height;
870 srcinfo.u32Pitch = bmpinfo.pitch;
871 srcinfo.u32ColorFmt = bmpinfo.fmt;
872
873 MApi_GFX_SetSrcBufferInfo(&srcinfo,0);
874
875 GFX_FireInfoLock();
876 pGFXBitmapInfo.handle =handle;
877 pGFXBitmapInfo.pBmpInfo =pbmpfmt;
878 pGFXBitmap.pGFX_Bitmap =(void*)&pGFXBitmapInfo;
879 pGFXBitmap.u32Size =sizeof(GFX_Bitmap);
880 pGFXBitmapInfo.pFireInfo = &GFXFireInfo;
881 GFXFireInfo.eFireInfo |= GFX_DST_INFO;
882 if(UtopiaIoctl(pGEInstance , MAPI_CMD_GFX_BITMAP, (void*)&pGFXBitmap) != UTOPIA_STATUS_SUCCESS)
883 {
884 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
885 eRet = GFX_FAIL;
886 }
887 else
888 {
889 eRet = GFX_SUCCESS;
890 }
891 GFXFireInfo.eFireInfo = 0;
892 GFX_FireInfoUnLock();
893
894 return eRet;
895
896 }
897 #endif
898
899 //-------------------------------------------------------------------------------------------------
900 /// Initial PE engine
901 /// @return None
902 //-------------------------------------------------------------------------------------------------
MApi_GFX_Init(GFX_Config * geConfig)903 void MApi_GFX_Init(GFX_Config *geConfig)
904 {
905 GFX_INIT_ARGS GFXInit;
906 GFX_Init_Config GFXInitInfo;
907
908 memset(&GFXInit , 0 , sizeof(GFX_INIT_ARGS));
909 GFXInitInfo.u32VCmdQSize = geConfig->u32VCmdQSize;
910 GFXInitInfo.u32VCmdQAddr = geConfig->u32VCmdQAddr;
911 GFXInitInfo.bIsHK = geConfig->bIsHK;
912 GFXInitInfo.bIsCompt = geConfig->bIsCompt;
913
914 GFXInit.pGFX_Init = (void*)&GFXInitInfo;
915 GFXInit.u32Size = sizeof(GFX_Init_Config);
916
917 CheckGFXInstanceOpen();
918 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_INIT, (void*)&GFXInit) != UTOPIA_STATUS_SUCCESS)
919 {
920 GFX_ERR("%s fail [LINE:%d] GFXIoctl Fail\n",__FUNCTION__, __LINE__);
921 }
922 _GFX_RegisterAllCBFunc();
923
924 s32GEWrapperMutex = MsOS_CreateMutex(E_MSOS_FIFO, "GEWrapper_Mutex", MSOS_PROCESS_SHARED);
925 #ifdef MSOS_TYPE_LINUX
926 atexit(MApi_GE_Exit);
927 #endif
928
929 }
930
931 #ifndef MSOS_TYPE_OPTEE
932 //-------------------------------------------------------------------------------------------------
933 /// Set GFX Engine dither
934 /// @param enable \b IN: true/false
935 /// @return GFX_SUCCESS - Success
936 /// @return GFX_FAIL - Failure
937 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDither(MS_BOOL enable)938 GFX_Result MApi_GFX_SetDither(MS_BOOL enable)
939 {
940 APIGFX_CHECK_INIT();
941
942 GFX_FireInfoLock();
943 GFXFireInfo.bDither = enable;
944 GFXFireInfo.eFireInfo |= GFX_DITHER_INFO;
945 GFX_FireInfoUnLock();
946
947 return GFX_SUCCESS;
948 }
949
950 //-------------------------------------------------------------------------------------------------
951 /// Set GFX Engine dither
952 /// @param enable \b IN: true/false
953 /// @return GFX_SUCCESS - Success
954 /// @return GFX_FAIL - Failure
955 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetOnePixelMode(MS_BOOL enable)956 GFX_Result MApi_GFX_SetOnePixelMode(MS_BOOL enable)
957 {
958 GFX_Result eRet = GFX_SUCCESS;
959
960 APIGFX_CHECK_INIT();
961 GFX_SETCONFIG_ARGS GFXSetConfig;
962
963 memset(&GFXSetConfig, 0 , sizeof(GFX_SETCONFIG_ARGS));
964
965 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_ONEPIXELMODE;
966 GFXSetConfig.pGFX_ConfigInfo =(void*)&enable;
967 GFXSetConfig.u32Size =sizeof(MS_BOOL);
968
969 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
970 {
971 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
972 eRet= GFX_FAIL;
973 }
974
975 return eRet;
976 }
977
978 //-------------------------------------------------------------------------------------------------
979 /// Set PE source color key
980 /// @param enable \b IN: true/false\n
981 /// When enable is FALSE, do not care the other parameters.\n
982 /// @param opMode \b IN: source color key mode
983 /// The alpha channel does not matter\n
984 /// @param fmt \b IN: source color key format
985 /// @param ps_color \b IN: pointer of source color key start (GFX_RgbColor or GFX_BlinkData depend on color format).\n
986 /// For all RGB color, the color set as the ARGB8888 format.\n
987 /// Each color component need to shift to high bit.\n
988 /// Use ARGB1555 as the example, the source color key as the following:\n
989 /// ARGB1555 --> ARRRRRGGGGGBBBBB (every character represents one bit)\n
990 /// *ps_color --> A0000000RRRRR000GGGGG000BBBBB000 (every character represents one bit)\n\n
991 /// For GFX_FMT_I8 format, the index set to b component (ps_color->b = b).\n
992 /// For GFX_FMT_1BAAFGBG123433 foramt, the foramt set as the GFX_BlinkData.\n
993 /// @param pe_color \b IN: pointer of source color key end (GFX_RgbColor or GFX_BlinkData depend on color format).\n
994 /// @return GFX_SUCCESS - Success
995 /// @return GFX_FAIL - Failure
996 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetSrcColorKey(MS_BOOL enable,GFX_ColorKeyMode opMode,GFX_Buffer_Format fmt,void * ps_color,void * pe_color)997 GFX_Result MApi_GFX_SetSrcColorKey(MS_BOOL enable,
998 GFX_ColorKeyMode opMode,
999 GFX_Buffer_Format fmt,
1000 void *ps_color,
1001 void *pe_color)
1002 {
1003 GFX_Result eRet = GFX_SUCCESS;
1004 MS_U32 *pS_color = (MS_U32 *)ps_color;
1005 MS_U32 *pE_color = (MS_U32 *)pe_color;
1006
1007 if(ps_color ==NULL || pe_color ==NULL)
1008 {
1009 return GFX_FAIL;
1010 }
1011
1012 APIGFX_CHECK_INIT();
1013
1014 GFX_FireInfoLock();
1015 GFXFireInfo.GFXSetSrcColorKey.bEnable =enable;
1016 GFXFireInfo.GFXSetSrcColorKey.eOpMode =opMode;
1017 GFXFireInfo.GFXSetSrcColorKey.eFmt =fmt;
1018 GFXFireInfo.GFXSetSrcColorKey.S_color =*pS_color;
1019 GFXFireInfo.GFXSetSrcColorKey.E_color =*pE_color;
1020 GFXFireInfo.eFireInfo |= GFX_SRC_CLRKEY_INFO;
1021 GFX_FireInfoUnLock();
1022
1023 return eRet;
1024
1025 }
1026
1027 //-------------------------------------------------------------------------------------------------
1028 /// Set PE destination color key
1029 /// @param enable \b IN: true/false\n
1030 /// When enable is FALSE, do not care the other parameters.\n
1031 /// @param opMode \b IN: destination color key mode\n
1032 /// The alpha channel does not matter\n
1033 /// @param fmt \b IN: destination color key format
1034 /// @param ps_color \b IN: pointer of destination color key start (GFX_RgbColor or GFX_BlinkData depend on color format).\n
1035 /// For all RGB color, the color set as the ARGB8888 format.\n
1036 /// Each color component need to shift to high bit.\n
1037 /// Use ARGB1555 as the example, the source color key as the following:\n
1038 /// ARGB1555 --> ARRRRRGGGGGBBBBB (every character represents one bit)\n
1039 /// *ps_color --> A0000000RRRRR000GGGGG000BBBBBB000 (every character represents one bit)\n\n
1040 /// For GFX_FMT_I8 format, the index set to b component (ps_color->b = b).\n
1041 /// For GFX_FMT_1BAAFGBG123433 foramt, the foramt set as the GFX_BlinkData.\n
1042 /// @param pe_color \b IN: pointer of destination color key end (GFX_RgbColor or GFX_BlinkData depend on color format).\n
1043 /// @return GFX_SUCCESS - Success
1044 /// @return GFX_FAIL - Failure
1045 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDstColorKey(MS_BOOL enable,GFX_ColorKeyMode opMode,GFX_Buffer_Format fmt,void * ps_color,void * pe_color)1046 GFX_Result MApi_GFX_SetDstColorKey(MS_BOOL enable,
1047 GFX_ColorKeyMode opMode,
1048 GFX_Buffer_Format fmt,
1049 void *ps_color,
1050 void *pe_color)
1051 {
1052 GFX_Result eRet = GFX_SUCCESS;
1053 MS_U32 *pS_color = (MS_U32 *)ps_color;
1054 MS_U32 *pE_color = (MS_U32 *)pe_color;
1055
1056 if(ps_color ==NULL || pe_color ==NULL)
1057 {
1058 return GFX_FAIL;
1059 }
1060
1061 APIGFX_CHECK_INIT();
1062
1063 GFX_FireInfoLock();
1064 GFXFireInfo.GFXSetDstColorKey.bEnable =enable;
1065 GFXFireInfo.GFXSetDstColorKey.eOpMode =opMode;
1066 GFXFireInfo.GFXSetDstColorKey.eFmt =fmt;
1067 GFXFireInfo.GFXSetDstColorKey.S_color =*pS_color;
1068 GFXFireInfo.GFXSetDstColorKey.E_color =*pE_color;
1069 GFXFireInfo.eFireInfo |= GFX_DST_CLRKEY_INFO;
1070 GFX_FireInfoUnLock();
1071
1072 return eRet;
1073
1074 }
1075
1076 //-------------------------------------------------------------------------------------------------
1077 /// Set PE intensity : total 16 color Palette in PE
1078 /// @param id \b IN: id of intensity
1079 /// @param fmt \b IN: intensity color format (GFX_FMT_ARGB8888 , GFX_FMT_1BAAFGBG123433 or GFX_FMT_I8)
1080 /// @param pColor \b IN: pointer of intensity (GFX_RgbColor or GFX_BlinkData depend on color format)
1081 /// @return GFX_SUCCESS - Success
1082 /// @return GFX_FAIL - Failure
1083 /// @return GFX_Result_INVALID_INTENSITY_ID - Inavlid index (id >= 16)
1084 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetIntensity(MS_U32 id,GFX_Buffer_Format fmt,MS_U32 * pColor)1085 GFX_Result MApi_GFX_SetIntensity(MS_U32 id, GFX_Buffer_Format fmt, MS_U32 *pColor)
1086 {
1087 GFX_Result eRet = GFX_SUCCESS;
1088
1089 if(pColor ==NULL)
1090 {
1091 return GFX_FAIL;
1092 }
1093 APIGFX_CHECK_INIT();
1094
1095 GFX_ABL_ARGS GFXSetABL_ARGS;
1096 GFX_Set_Intensity GFXSetIntensity;
1097
1098 memset(&GFXSetABL_ARGS, 0 , sizeof(GFX_ABL_ARGS));
1099 memset(&GFXSetIntensity , 0 ,sizeof(GFX_Set_Intensity));
1100
1101 GFXSetABL_ARGS.eGFX_SetABL =E_GFX_SET_INTENSITY;
1102 GFXSetABL_ARGS.pGFX_ABL =(void*)&GFXSetIntensity;
1103 GFXSetABL_ARGS.u32Size =sizeof(GFX_Set_Intensity);
1104
1105 GFXSetIntensity.u32Id = id;
1106 GFXSetIntensity.eFmt = fmt;
1107 GFXSetIntensity.pColor = pColor;
1108 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_ABL, (void*)&GFXSetABL_ARGS) != UTOPIA_STATUS_SUCCESS)
1109 {
1110 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1111 eRet= GFX_FAIL;
1112 }
1113
1114 return eRet;
1115
1116 }
1117
1118 //-------------------------------------------------------------------------------------------------
1119 /// Get GFX intensity : total 16 color Palette in GFX for I1/I2/I4 mode.
1120 /// @param idx \b IN: id of intensity
1121 /// @param color \b IN: Pointer of start of intensity point to
1122 /// @return GFX_SUCCESS - Success
1123 /// @return GFX_FAIL - Failure
1124 /// @return GFX_Result_INVALID_INTENSITY_ID - Inavlid index (id >= 16)
1125 //-------------------------------------------------------------------------------------------------
MApi_GFX_GetIntensity(MS_U32 idx,MS_U32 * color)1126 GFX_Result MApi_GFX_GetIntensity(MS_U32 idx, MS_U32 *color)
1127 {
1128 GFX_Result eRet = GFX_SUCCESS;
1129
1130 if(color == NULL)
1131 {
1132 return GFX_FAIL;
1133 }
1134
1135 APIGFX_CHECK_INIT();
1136 GFX_GETINFO_ARGS GFXGetInfo;
1137 GFX_Get_Intensity GFXGetIntensity;
1138
1139 memset(&GFXGetInfo, 0 , sizeof(GFX_GETINFO_ARGS));
1140 memset(&GFXGetIntensity , 0 ,sizeof(GFX_Get_Intensity));
1141
1142 GFXGetInfo.eGFX_GetConfig =E_GFX_GET_INTENSITY;
1143 GFXGetInfo.pGFX_GetInfo =(void*)&GFXGetIntensity;
1144 GFXGetInfo.u32Size =sizeof(GFX_Get_Intensity);
1145
1146 GFXGetIntensity.u32Id =idx;
1147 GFXGetIntensity.pColor =color;
1148 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_GET_INFO, (void*)&GFXGetInfo) != UTOPIA_STATUS_SUCCESS)
1149 {
1150 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1151 eRet = GFX_FAIL;
1152 }
1153
1154 return eRet;
1155
1156 }
1157
1158 //-------------------------------------------------------------------------------------------------
1159 /// Set GFX raster operation
1160 /// @param enable \b IN: true/false
1161 /// @param eRopMode \b IN: raster operation
1162 /// @return GFX_SUCCESS - Success
1163 /// @return GFX_FAIL - Failure
1164 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetROP2(MS_BOOL enable,GFX_ROP2_Op eRopMode)1165 GFX_Result MApi_GFX_SetROP2(MS_BOOL enable, GFX_ROP2_Op eRopMode)
1166 {
1167 GFX_Result eRet = GFX_SUCCESS;
1168
1169 APIGFX_CHECK_INIT();
1170 GFX_ABL_ARGS GFXSetABL_ARGS;
1171 GFX_Set_ROP GFXSetROP;
1172
1173 memset(&GFXSetABL_ARGS, 0 , sizeof(GFX_ABL_ARGS));
1174 memset(&GFXSetROP , 0 ,sizeof(GFX_Set_ROP));
1175
1176 GFXSetABL_ARGS.eGFX_SetABL =E_GFX_SET_ROP;
1177 GFXSetABL_ARGS.pGFX_ABL =(void*)&GFXSetROP;
1178 GFXSetABL_ARGS.u32Size =sizeof(GFX_Set_ROP);
1179
1180 GFXSetROP.bEnable =enable;
1181 GFXSetROP.eRopMode =eRopMode;
1182
1183 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_ABL, (void*)&GFXSetABL_ARGS) != UTOPIA_STATUS_SUCCESS)
1184 {
1185 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1186 eRet = GFX_FAIL;
1187 }
1188
1189 return eRet;
1190
1191 }
1192
1193 //-------------------------------------------------------------------------------------------------
1194 /// GFX draw line
1195 /// @param pline \b IN: pointer to line info
1196 /// @return GFX_SUCCESS - Success
1197 /// @return GFX_FAIL - Failure
1198 //-------------------------------------------------------------------------------------------------
MApi_GFX_DrawLine(GFX_DrawLineInfo * pline)1199 GFX_Result MApi_GFX_DrawLine(GFX_DrawLineInfo *pline)
1200 {
1201 GFX_Result eRet = GFX_SUCCESS;
1202
1203 if(pline == NULL)
1204 {
1205 return GFX_FAIL;
1206 }
1207
1208 APIGFX_CHECK_INIT();
1209 GFX_LINEDRAW_ARGS GFXDrawLine;
1210 GFX_Set_DrawLineInfo GFXDrawLineInfo;
1211
1212 memset(&GFXDrawLine, 0 , sizeof(GFX_LINEDRAW_ARGS));
1213 memset(&GFXDrawLineInfo, 0 ,sizeof(GFX_Set_DrawLineInfo));
1214
1215 GFX_FireInfoLock();
1216 GFXDrawLineInfo.pFireInfo = &GFXFireInfo;
1217 GFXDrawLineInfo.pDrawLineInfo = pline;
1218 GFXDrawLine.pLineInfo =(void*)&GFXDrawLineInfo;
1219 GFXDrawLine.u32Size =sizeof(GFX_Set_DrawLineInfo);
1220 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_LINEDRAW, (void*)&GFXDrawLine) != UTOPIA_STATUS_SUCCESS)
1221 {
1222 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1223 eRet= GFX_FAIL;
1224 }
1225 GFXFireInfo.eFireInfo = 0;
1226 GFX_FireInfoUnLock();
1227
1228 return eRet;
1229 }
1230
1231 //-------------------------------------------------------------------------------------------------
1232 /// GFX rectangle fill
1233 /// @param pfillblock \b IN: pointer to block info
1234 /// @return GFX_SUCCESS - Success
1235 /// @return GFX_FAIL - Failure
1236 //-------------------------------------------------------------------------------------------------
MApi_GFX_RectFill(GFX_RectFillInfo * pfillblock)1237 GFX_Result MApi_GFX_RectFill(GFX_RectFillInfo *pfillblock)
1238 {
1239 GFX_Result eRet = GFX_SUCCESS;
1240
1241 APIGFX_CHECK_NULL(pfillblock);
1242 APIGFX_CHECK_INIT();
1243
1244 GFX_RECTFILL_ARGS GFXRectFill;
1245 GFX_Set_RectFillInfo GFXRectFillInfo;
1246
1247 memset(&GFXRectFill, 0 , sizeof(GFX_RECTFILL_ARGS));
1248 memset(&GFXRectFillInfo, 0 ,sizeof(GFX_Set_RectFillInfo));
1249
1250 GFX_FireInfoLock();
1251 GFXRectFillInfo.pFireInfo = &GFXFireInfo;
1252 GFXRectFillInfo.pRectFillInfo = pfillblock;
1253 GFXRectFill.pFillBlock =(void*)&GFXRectFillInfo;
1254 GFXRectFill.u32Size =sizeof(GFX_Set_RectFillInfo);
1255 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_RECTFILL, (void*)&GFXRectFill) != UTOPIA_STATUS_SUCCESS)
1256 {
1257 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1258 eRet= GFX_FAIL;
1259 }
1260 GFXFireInfo.eFireInfo = 0;
1261 GFX_FireInfoUnLock();
1262
1263 return eRet;
1264 }
1265
1266 //-------------------------------------------------------------------------------------------------
1267 /// GFX triangle fill
1268 /// @param ptriblock \b IN: pointer to block info
1269 /// @return GFX_SUCCESS - Success
1270 /// @return GFX_FAIL - Failure
1271 //-------------------------------------------------------------------------------------------------
MApi_GFX_TriFill(GFX_TriFillInfo * ptriblock)1272 GFX_Result MApi_GFX_TriFill(GFX_TriFillInfo *ptriblock)
1273 {
1274 GFX_Result eRet = GFX_SUCCESS;
1275
1276 APIGFX_CHECK_NULL(ptriblock);
1277 APIGFX_CHECK_INIT();
1278
1279 GFX_TRIFILL_ARGS GFXTriFill;
1280 GFX_Set_TriFillInfo GFXTriFillInfo;
1281
1282 memset(&GFXTriFill, 0 , sizeof(GFX_TRIFILL_ARGS));
1283 memset(&GFXTriFillInfo, 0 ,sizeof(GFX_Set_TriFillInfo));
1284
1285 GFX_FireInfoLock();
1286 GFXTriFillInfo.pFireInfo = &GFXFireInfo;
1287 GFXTriFillInfo.pTriFillInfo = ptriblock;
1288 GFXTriFill.pFillBlock =(void*)&GFXTriFillInfo;
1289 GFXTriFill.u32Size =sizeof(GFX_Set_TriFillInfo);
1290
1291 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_TRIFILL, (void*)&GFXTriFill) != UTOPIA_STATUS_SUCCESS)
1292 {
1293 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1294 eRet= GFX_FAIL;
1295 }
1296 GFXFireInfo.eFireInfo = 0;
1297 GFX_FireInfoUnLock();
1298
1299 return eRet;
1300 }
1301
1302 //-------------------------------------------------------------------------------------------------
1303 /// GFX span fill
1304 /// @param pspanblock \b IN: pointer to block info
1305 /// @return GFX_SUCCESS - Success
1306 /// @return GFX_FAIL - Failure
1307 //-------------------------------------------------------------------------------------------------
MApi_GFX_SpanFill(GFX_SpanFillInfo * pspanblock)1308 GFX_Result MApi_GFX_SpanFill(GFX_SpanFillInfo *pspanblock)
1309 {
1310 GFX_Result eRet = GFX_SUCCESS;
1311
1312 APIGFX_CHECK_NULL(pspanblock);
1313 APIGFX_CHECK_INIT();
1314
1315 GFX_SPANFILL_ARGS GFXSpanFill;
1316 GFX_Set_SpanFillInfo GFXSpanFillInfo;
1317
1318 memset(&GFXSpanFill, 0 , sizeof(GFX_SPANFILL_ARGS));
1319 memset(&GFXSpanFillInfo, 0 ,sizeof(GFX_Set_SpanFillInfo));
1320
1321 GFX_FireInfoLock();
1322 GFXSpanFillInfo.pFireInfo = &GFXFireInfo;
1323 GFXSpanFillInfo.pSpanFillInfo = pspanblock;
1324 GFXSpanFill.pFillBlock =(void*)&GFXSpanFillInfo;
1325 GFXSpanFill.u32Size =sizeof(GFX_Set_SpanFillInfo);
1326
1327 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SPANFILL, (void*)&GFXSpanFill) != UTOPIA_STATUS_SUCCESS)
1328 {
1329 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1330 eRet= GFX_FAIL;
1331 }
1332 GFXFireInfo.eFireInfo = 0;
1333 GFX_FireInfoUnLock();
1334
1335 return eRet;
1336 }
1337
1338 //-------------------------------------------------------------------------------------------------
1339 /// GFX trapezoid fill
1340 /// @param pGfxFillInfo \b IN: pointer to GFX_RectFillInfo which is union with Trapezoid struct.
1341 /// @return GFX_SUCCESS - Success
1342 /// @return GFX_FAIL - Failure
1343 //-------------------------------------------------------------------------------------------------
MApi_GFX_TrapezoidFill(GFX_RectFillInfo * pGfxFillInfo)1344 GFX_Result MApi_GFX_TrapezoidFill(GFX_RectFillInfo *pGfxFillInfo)
1345 {
1346 #if 0
1347 GE_Trapezoid geTrapezoid;
1348 MS_U32 u32ColorS, u32ColorE;
1349 MS_U32 flags = 0;
1350
1351 APIGFX_CHECK_INIT();
1352
1353 //Prepare Fill Block:
1354 geTrapezoid.u16X0 = pGfxFillInfo->dstTrapezoidBlk.u16X0;
1355 geTrapezoid.u16Y0 = pGfxFillInfo->dstTrapezoidBlk.u16Y0;
1356 geTrapezoid.u16X1 = pGfxFillInfo->dstTrapezoidBlk.u16X1;
1357 geTrapezoid.u16Y1 = pGfxFillInfo->dstTrapezoidBlk.u16Y1;
1358 geTrapezoid.u16DeltaTop = pGfxFillInfo->dstTrapezoidBlk.u16DeltaTop;
1359 geTrapezoid.u16DeltaBottom = pGfxFillInfo->dstTrapezoidBlk.u16DeltaBottom;
1360
1361 //Prepare Color:
1362 u32ColorS = (pGfxFillInfo->colorRange.color_s.a<<24) | (pGfxFillInfo->colorRange.color_s.r<<16)
1363 | (pGfxFillInfo->colorRange.color_s.g<<8) | (pGfxFillInfo->colorRange.color_s.b);
1364 u32ColorE = (pGfxFillInfo->colorRange.color_e.a<<24) | (pGfxFillInfo->colorRange.color_e.r<<16)
1365 | (pGfxFillInfo->colorRange.color_e.g<<8) | (pGfxFillInfo->colorRange.color_e.b);
1366
1367 if(GFX_FMT_1ABFGBG12355 == pGfxFillInfo->fmt)
1368 {
1369 u32ColorS = MAKE_PRIMITIVE_COLOR_12355(pGfxFillInfo->blkDataRange.blink_data_s.background, pGfxFillInfo->blkDataRange.blink_data_s.foreground,
1370 pGfxFillInfo->blkDataRange.blink_data_s.Bits.Blink, pGfxFillInfo->blkDataRange.blink_data_s.Bits.Alpha);
1371 u32ColorE = MAKE_PRIMITIVE_COLOR_12355(pGfxFillInfo->blkDataRange.blink_data_e.background, pGfxFillInfo->blkDataRange.blink_data_e.foreground,
1372 pGfxFillInfo->blkDataRange.blink_data_e.Bits.Blink, pGfxFillInfo->blkDataRange.blink_data_e.Bits.Alpha);
1373 }
1374
1375 if(GFX_FMT_FABAFGBG2266 == pGfxFillInfo->fmt)
1376 {
1377 u32ColorS = MAKE_PRIMITIVE_COLOR_2266(pGfxFillInfo->blkDataRange.blink_data_s.background, pGfxFillInfo->blkDataRange.blink_data_s.foreground,
1378 pGfxFillInfo->blkDataRange.blink_data_s.Bits3.Ba, pGfxFillInfo->blkDataRange.blink_data_s.Bits3.Fa);
1379 u32ColorE = MAKE_PRIMITIVE_COLOR_2266(pGfxFillInfo->blkDataRange.blink_data_e.background, pGfxFillInfo->blkDataRange.blink_data_e.foreground,
1380 pGfxFillInfo->blkDataRange.blink_data_e.Bits3.Ba, pGfxFillInfo->blkDataRange.blink_data_e.Bits3.Fa);
1381 }
1382
1383 flags |= (pGfxFillInfo->flag & GFXRECT_FLAG_COLOR_GRADIENT_X) ? E_GE_FLAG_TRAPEZOID_GRADIENT_X : 0;
1384 flags |= (pGfxFillInfo->flag & GFXRECT_FLAG_COLOR_GRADIENT_Y) ? E_GE_FLAG_TRAPEZOID_GRADIENT_Y : 0;
1385 flags |= (pGfxFillInfo->flag & GFXRECT_FLAG_TRAPE_DIRECTION_X) ? E_GE_FLAG_TRAPEZOID_X : 0;
1386 flags |= (pGfxFillInfo->flag & GFXRECT_FLAG_TRAPE_DIRECTION_Y) ? E_GE_FLAG_TRAPEZOID_Y : 0;
1387
1388 if((flags & E_GE_FLAG_TRAPEZOID_X) && (flags & E_GE_FLAG_TRAPEZOID_Y))
1389 {
1390 return GFX_INVALID_PARAMETERS;
1391 }
1392
1393 return (GFX_Result) MDrv_GE_FillTrapezoid(g_apiGFXLocal.g_pGEContext, &geTrapezoid, u32ColorS, u32ColorE, flags);
1394 #endif
1395 return GFX_SUCCESS;
1396 }
1397
1398 //-------------------------------------------------------------------------------------------------
1399 /// Enable Trapezoid Antialiasing
1400 /// @param bEnable \b IN: Enable or Not
1401 /// @return GFX_SUCCESS - Success
1402 //-------------------------------------------------------------------------------------------------
MApi_GFX_EnableTrapezoidAA(MS_BOOL bEnable)1403 GFX_Result MApi_GFX_EnableTrapezoidAA(MS_BOOL bEnable)
1404 {
1405 #if 0
1406
1407 APIGFX_CHECK_INIT();
1408
1409 return (GFX_Result) MDrv_GE_EnableTrapezoidAA(g_apiGFXLocal.g_pGEContext, bEnable);
1410 #endif
1411 return GFX_SUCCESS;
1412 }
1413
1414 //-------------------------------------------------------------------------------------------------
1415 /// Enable Trapezoid Subpixel Correction
1416 /// @param bEnable \b IN: Enable or Not
1417 /// @return GFX_SUCCESS - Success
1418 //-------------------------------------------------------------------------------------------------
MApi_GFX_EnableTrapSubPixCorr(MS_BOOL bEnable)1419 GFX_Result MApi_GFX_EnableTrapSubPixCorr(MS_BOOL bEnable)
1420 {
1421 #if 0
1422 APIGFX_CHECK_INIT();
1423
1424 return (GFX_Result) MDrv_GE_EnableTrapSubPixCorr(g_apiGFXLocal.g_pGEContext, bEnable);
1425 #endif
1426 return GFX_SUCCESS;
1427 }
1428
1429 //-------------------------------------------------------------------------------------------------
1430 /// Set GFX clipping window
1431 /// @param v0 \b IN: left-top position
1432 /// @param v1 \b IN: right-down position
1433 /// @return GFX_SUCCESS - Success
1434 /// @return GFX_FAIL - Failure
1435 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetClip(GFX_Point * v0,GFX_Point * v1)1436 GFX_Result MApi_GFX_SetClip(GFX_Point* v0, GFX_Point* v1)
1437 {
1438 GFX_Result eRet = GFX_SUCCESS;
1439
1440 if((v0==NULL) || (v1==NULL))
1441 {
1442 return GFX_FAIL;
1443 }
1444 APIGFX_CHECK_INIT();
1445
1446 GFX_FireInfoLock();
1447 GFXFireInfo.GFXSetClip.V0.x =v0->x;
1448 GFXFireInfo.GFXSetClip.V0.y =v0->y;
1449 GFXFireInfo.GFXSetClip.V1.x =v1->x;
1450 GFXFireInfo.GFXSetClip.V1.y =v1->y;
1451 GFXFireInfo.eFireInfo |= GFX_CLIP_INFO;
1452 GFX_FireInfoUnLock();
1453
1454 return eRet;
1455
1456 }
1457
1458 //-------------------------------------------------------------------------------------------------
1459 /// Get GFX clipping window
1460 /// @param v0 \b IN: left-top position
1461 /// @param v1 \b IN: right-down position
1462 /// @return GFX_SUCCESS - Success
1463 /// @return GFX_FAIL - Failure
1464 //-------------------------------------------------------------------------------------------------
MApi_GFX_GetClip(GFX_Point * v0,GFX_Point * v1)1465 GFX_Result MApi_GFX_GetClip(GFX_Point* v0, GFX_Point* v1)
1466 {
1467 GFX_Result eRet = GFX_SUCCESS;
1468
1469 if(v0 ==NULL || v1==NULL)
1470 {
1471 return GFX_FAIL;
1472 }
1473
1474 APIGFX_CHECK_INIT();
1475
1476 GFX_FireInfoLock();
1477 v0->x = GFXFireInfo.GFXSetClip.V0.x;
1478 v0->y = GFXFireInfo.GFXSetClip.V0.y;
1479 v1->x = GFXFireInfo.GFXSetClip.V1.x;
1480 v1->y = GFXFireInfo.GFXSetClip.V1.y;
1481 GFX_FireInfoUnLock();
1482
1483 return eRet;
1484 }
1485
1486
1487
1488 //-------------------------------------------------------------------------------------------------
1489 /// Set GFX alpha source
1490 /// @param eMode \b IN: alpha source come from , this indicate alpha channel output source
1491 /// @return GFX_SUCCESS - Success
1492 /// @return GFX_FAIL - Failure
1493 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetAlphaSrcFrom(GFX_AlphaSrcFrom eMode)1494 GFX_Result MApi_GFX_SetAlphaSrcFrom(GFX_AlphaSrcFrom eMode)
1495 {
1496 GFX_Result eRet = GFX_SUCCESS;
1497
1498 APIGFX_CHECK_INIT();
1499
1500 GFX_FireInfoLock();
1501 GFXFireInfo.GFXSetABL.eDb_abl = eMode;
1502 GFXFireInfo.eFireInfo |= GFX_ABL_INFO;
1503 GFX_FireInfoUnLock();
1504
1505 return eRet;
1506 }
1507
1508
1509 //-------------------------------------------------------------------------------------------------
1510 /// Set GFX alpha compare OP
1511 /// @param enable \b IN: true: enable alpha compare, false: disable.
1512 /// @param eMode \b IN: alpha source come from MIN/MAX compare between source/dst,
1513 /// this indicate alpha channel output source
1514 /// @return GFX_SUCCESS - Success
1515 /// @return GFX_FAIL - Failure
1516 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetAlphaCmp(MS_BOOL enable,GFX_ACmpOp eMode)1517 GFX_Result MApi_GFX_SetAlphaCmp(MS_BOOL enable, GFX_ACmpOp eMode)
1518 {
1519 GFX_Result eRet = GFX_SUCCESS;
1520 APIGFX_CHECK_INIT();
1521
1522 GFX_FireInfoLock();
1523 GFXFireInfo.GFXSetAlphaCmp.enable = enable;
1524 GFXFireInfo.GFXSetAlphaCmp.eMode = eMode;
1525 GFXFireInfo.eFireInfo |= GFX_ALPHA_CMP_INFO;
1526 GFX_FireInfoUnLock();
1527
1528 return eRet;
1529
1530 }
1531 #endif
1532
1533 //-------------------------------------------------------------------------------------------------
1534 /// Begin GFX Engine drawing, this function should be called before all PE drawing function,
1535 /// and it will lock PE engine resource, reset all PE register and static variable.
1536 /// @return GFX_SUCCESS - Success
1537 /// @return GFX_FAIL - Failure
1538 //-------------------------------------------------------------------------------------------------
MApi_GFX_BeginDraw(void)1539 GFX_Result MApi_GFX_BeginDraw(void)
1540 {
1541 GFX_MISC_ARGS GFXInfo;
1542 MS_U32 value = 0;
1543 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
1544
1545 GFXInfo.eGFX_MISCType = E_MISC_BEGINE_DRAW;
1546 GFXInfo.pGFX_Info = (void*)&value;
1547 GFXInfo.u32Size = sizeof(GFX_MISC_ARGS);
1548
1549 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
1550 {
1551 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1552 }
1553 return (GFX_Result) GFX_SUCCESS;
1554 }
1555
1556
1557 //-------------------------------------------------------------------------------------------------
1558 /// End GFX engine drawing (pair with MApi_GFX_BeginDraw), this function should be called after
1559 /// all PE drawing function. And it will release PE engine resource.
1560 /// @return GFX_SUCCESS - Success
1561 /// @return GFX_FAIL - Failure
1562 //-------------------------------------------------------------------------------------------------
MApi_GFX_EndDraw(void)1563 GFX_Result MApi_GFX_EndDraw(void)
1564 {
1565 GFX_MISC_ARGS GFXInfo;
1566 MS_U32 value = 0;
1567 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
1568
1569 GFXInfo.eGFX_MISCType = E_MISC_END_DRAW;
1570 GFXInfo.pGFX_Info = (void*)&value;
1571 GFXInfo.u32Size = sizeof(GFX_MISC_ARGS);
1572
1573 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
1574 {
1575 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1576 }
1577
1578 return (GFX_Result) GFX_SUCCESS;
1579 }
1580
1581 #ifndef MSOS_TYPE_OPTEE
1582 //-------------------------------------------------------------------------------------------------
1583 /// Reset GFX line pattern
1584 /// @return GFX_SUCCESS - Success
1585 /// @return GFX_FAIL - Failure
1586 //-------------------------------------------------------------------------------------------------
MApi_GFX_Line_Pattern_Reset(void)1587 GFX_Result MApi_GFX_Line_Pattern_Reset(void)
1588 {
1589 GFX_MISC_ARGS GFXInfo;
1590 MS_U32 value = 0;
1591 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
1592
1593 GFXInfo.eGFX_MISCType = E_MISC_LINE_PATTERN_RESET;
1594 GFXInfo.pGFX_Info = (void*)&value;
1595 GFXInfo.u32Size = sizeof(GFX_MISC_ARGS);
1596
1597 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
1598 {
1599 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1600 }
1601 return GFX_SUCCESS;
1602 }
1603
1604
1605 //-------------------------------------------------------------------------------------------------
1606 /// Set GFX line pattern
1607 /// @param enable \b IN: true/false
1608 /// @param linePattern \b IN: p0-0x3F one bit represent draw(1) or not draw(0)
1609 /// @param repeatFactor \b IN: 0 : repeat once, 1 : repeat twice, 2: repeat 3, 3: repeat 4
1610 /// @return GFX_SUCCESS - Success
1611 /// @return GFX_FAIL - Failure
1612 //-------------------------------------------------------------------------------------------------
MApi_GFX_Set_Line_Pattern(MS_BOOL enable,MS_U8 linePattern,MS_U8 repeatFactor)1613 GFX_Result MApi_GFX_Set_Line_Pattern(MS_BOOL enable, MS_U8 linePattern, MS_U8 repeatFactor)
1614 {
1615 GFX_MISC_ARGS GFXInfo;
1616 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
1617
1618 GFX_SetLinePattern Info;
1619 memset(&Info, 0, sizeof(GFX_SetLinePattern));
1620
1621 Info.enable = enable;
1622 Info.linePattern = linePattern;
1623 Info.repeatFactor = repeatFactor;
1624
1625 GFXInfo.eGFX_MISCType = E_MISC_LINE_PATTERN;
1626 GFXInfo.pGFX_Info = (void*)&Info;
1627 GFXInfo.u32Size = sizeof(GFX_SetLinePattern);
1628
1629 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
1630 {
1631 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1632 }
1633 return GFX_SUCCESS;
1634 }
1635
1636
1637 //-------------------------------------------------------------------------------------------------
1638 /// Set GFX italic
1639 /// @param enable \b IN: true/false
1640 /// @param ini_line \b IN: initial line : default is 0, indicate which line start to get italic effect
1641 /// @param ini_dis \b IN: initial distance : default is 0, indicate which pixel start to get italic effect
1642 /// @param delta \b IN: italic delta 0-0x1f
1643 /// - D[4]: 0/1 left/right italic
1644 /// - D[3]-D[0] : delta value of italic
1645 /// @return GFX_SUCCESS - Success
1646 /// @return GFX_FAIL - Failure
1647 /// @note
1648 /// The italic process can't perform with rotate process or mirror process.
1649 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetItalic(MS_BOOL enable,MS_U8 ini_line,MS_U8 ini_dis,MS_U8 delta)1650 GFX_Result MApi_GFX_SetItalic(MS_BOOL enable,MS_U8 ini_line, MS_U8 ini_dis, MS_U8 delta)
1651 {
1652 GFX_Result eRet = GFX_SUCCESS;
1653
1654 APIGFX_CHECK_INIT();
1655 GFX_SETCONFIG_ARGS GFXSetConfig;
1656 GFX_Set_Italic GFXSetItalic;
1657
1658 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
1659 memset(&GFXSetItalic, 0 ,sizeof(GFX_Set_Italic));
1660
1661 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_ITALIC;
1662 GFXSetConfig.pGFX_ConfigInfo =(void*)&GFXSetItalic;
1663 GFXSetConfig.u32Size =sizeof(GFX_Set_Italic);
1664
1665 GFXSetItalic.bEnable =enable;
1666 GFXSetItalic.u8Ini_line =ini_line;
1667 GFXSetItalic.u8Ini_dis =ini_dis;
1668 GFXSetItalic.u8Delta =delta;
1669
1670 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
1671 {
1672 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
1673 return GFX_FAIL;
1674 }
1675
1676 return eRet;
1677 }
1678
1679
1680 //-------------------------------------------------------------------------------------------------
1681 /// Set GFX rotate
1682 /// @param angle \b IN: rotate angle
1683 /// @return GFX_SUCCESS - Success
1684 /// @return GFX_FAIL - Failure
1685 /// @note
1686 /// The rotate process can't perform with italic process.
1687 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetRotate(GFX_RotateAngle angle)1688 GFX_Result MApi_GFX_SetRotate(GFX_RotateAngle angle)
1689 {
1690 APIGFX_CHECK_INIT();
1691
1692 GFX_FireInfoLock();
1693 GFXFireInfo.GFXSetAngle = angle;
1694 GFXFireInfo.eFireInfo |= GFX_ROTATE_INFO;
1695 GFX_FireInfoUnLock();
1696
1697 return GFX_SUCCESS;
1698 }
1699
1700
1701 //-------------------------------------------------------------------------------------------------
1702 // Description:
1703 // Arguments: eMode : ABL_FROM_CONST, ABL_FROM_ASRC, ABL_FROM_ADST
1704 // blendcoef : COEF_ONE, COEF_CONST, COEF_ASRC, COEF_ADST
1705 // COEF_ZERO, COEF_1_CONST, COEF_1_ASRC, COEF_1_ADST
1706 // blendfactor : value : [0,0xff]
1707 // Return: NONE
1708 //
1709 // Notes: if any
1710 //-------------------------------------------------------------------------------------------------
1711 //-------------------------------------------------------------------------------------------------
1712 /// Set PE alpha blending. Dst = A * Src + (1 - A) Dst
1713 /// @param blendcoef \b IN: alpha source from
1714 /// @param u8ConstantAlpha \b IN: Contant alpha when blendcoef is equal to COEF_CONST
1715 /// or COEF_1_CONST.
1716 /// @return GFX_SUCCESS - Success
1717 /// @return GFX_FAIL - Failure
1718 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetAlphaBlending(GFX_BlendCoef blendcoef,MS_U8 u8ConstantAlpha)1719 GFX_Result MApi_GFX_SetAlphaBlending(GFX_BlendCoef blendcoef, MS_U8 u8ConstantAlpha)
1720 {
1721 GFX_Result eRet = GFX_SUCCESS;
1722
1723 APIGFX_CHECK_INIT();
1724
1725 GFX_FireInfoLock();
1726 GFXFireInfo.GFXSetABL.eABLCoef = blendcoef;
1727 GFXFireInfo.GFXSetABL.u8Alpha_Const = u8ConstantAlpha;
1728 #ifndef MSOS_TYPE_NOS
1729 GFXFireInfo.GFXSetDFB.sRGBColor.a = u8ConstantAlpha;
1730 GFXFireInfo.eFireInfo |= GFX_DFB_INFO;
1731 #endif
1732 GFXFireInfo.eFireInfo |= GFX_ABL_INFO;
1733 GFX_FireInfoUnLock();
1734
1735 return eRet;
1736 }
1737
1738 //-------------------------------------------------------------------------------------------------
1739 /// Enable GFX alpha blending
1740 /// @param enable \b IN: true/false
1741 /// @return GFX_SUCCESS - Success
1742 /// @return GFX_FAIL - Failure
1743 //-------------------------------------------------------------------------------------------------
MApi_GFX_EnableAlphaBlending(MS_BOOL enable)1744 GFX_Result MApi_GFX_EnableAlphaBlending(MS_BOOL enable)
1745 {
1746 GFX_Result eRet = GFX_SUCCESS;
1747
1748 APIGFX_CHECK_INIT();
1749
1750 GFX_FireInfoLock();
1751 GFXFireInfo.GFXSetABL.bEnable = enable;
1752 GFXFireInfo.eFireInfo |= GFX_ABL_INFO;
1753 GFX_FireInfoUnLock();
1754
1755 return eRet;
1756
1757 }
1758
1759
1760 //-------------------------------------------------------------------------------------------------
1761 /// Query GFX supported DFB blending functions/flags.
1762 /// @param pU16SupportedBldFlags \b OUT: DFB Blending Functions/Flags supported by GFX.
1763 /// @return GFX_SUCCESS - Success
1764 /// @return GFX_FAIL - Failure
1765 //-------------------------------------------------------------------------------------------------
MApi_GFX_QueryDFBBldCaps(MS_U16 * pU16SupportedBldFlags)1766 GFX_Result MApi_GFX_QueryDFBBldCaps(MS_U16 *pU16SupportedBldFlags)
1767 {
1768 GFX_Result gfxResult=GFX_FAIL;
1769 gfxResult = MApi_GFX_GetGECaps(E_GFX_CAP_DFB_BLENDING,(MS_U32*)(void*)pU16SupportedBldFlags,sizeof(MS_U16));
1770 return gfxResult;
1771 }
1772
1773 //-------------------------------------------------------------------------------------------------
1774 /// Enable GFX DFB blending
1775 /// @param enable \b IN: true/false
1776 /// @return GFX_SUCCESS - Success
1777 /// @return GFX_FAIL - Failure
1778 //-------------------------------------------------------------------------------------------------
MApi_GFX_EnableDFBBlending(MS_BOOL enable)1779 GFX_Result MApi_GFX_EnableDFBBlending(MS_BOOL enable)
1780 {
1781 GFX_Result eRet = GFX_SUCCESS;
1782
1783 APIGFX_CHECK_INIT();
1784
1785 GFX_FireInfoLock();
1786 GFXFireInfo.GFXSetDFB.bEnable =enable;
1787 GFXFireInfo.eFireInfo |= GFX_DFB_INFO;
1788 GFX_FireInfoUnLock();
1789 return eRet;
1790 }
1791
1792 //-------------------------------------------------------------------------------------------------
1793 /// Set GE DFB blending Flags.
1794 /// @param u16DFBBldFlag \b IN: DFB Blending Flags. The Flags will be
1795 /// The combination of Flags
1796 /// [GFX_DFB_BLD_FLAG_COLORALPHA, GFX_DFB_BLD_FLAG_ALPHACHANNEL,
1797 /// GFX_DFB_BLD_FLAG_COLORIZE, GFX_DFB_BLD_FLAG_SRCPREMUL,
1798 /// GFX_DFB_BLD_FLAG_SRCPREMULCOL, GFX_DFB_BLD_FLAG_DSTPREMUL,
1799 /// GFX_DFB_BLD_FLAG_XOR, GFX_DFB_BLD_FLAG_DEMULTIPLY,
1800 /// GFX_DFB_BLD_FLAG_SRCALPHAMASK, GFX_DFB_BLD_FLAG_SRCCOLORMASK]
1801 /// @return GFX_SUCCESS - Success
1802 /// @return GFX_FAIL - Failure
1803 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDFBBldFlags(MS_U16 u16DFBBldFlags)1804 GFX_Result MApi_GFX_SetDFBBldFlags(MS_U16 u16DFBBldFlags)
1805 {
1806 GFX_Result eRet = GFX_SUCCESS;
1807
1808 APIGFX_CHECK_INIT();
1809
1810 GFX_FireInfoLock();
1811 GFXFireInfo.GFXSetDFB.u16DFBBldFlags =u16DFBBldFlags;
1812 GFXFireInfo.eFireInfo |= GFX_DFB_INFO;
1813 GFX_FireInfoUnLock();
1814
1815 return eRet;
1816 }
1817
1818
1819 //-------------------------------------------------------------------------------------------------
1820 /// Set GFX DFB blending Functions/Operations.
1821 /// @param gfxSrcBldOP \b IN: source blending op
1822 /// @param gfxDstBldOP \b IN: dst blending op
1823 /// @return GFX_SUCCESS - Success
1824 /// @return GFX_FAIL - Failure
1825 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDFBBldOP(GFX_DFBBldOP gfxSrcBldOP,GFX_DFBBldOP gfxDstBldOP)1826 GFX_Result MApi_GFX_SetDFBBldOP(GFX_DFBBldOP gfxSrcBldOP, GFX_DFBBldOP gfxDstBldOP)
1827 {
1828 GFX_Result eRet = GFX_SUCCESS;
1829
1830 APIGFX_CHECK_INIT();
1831
1832 GFX_FireInfoLock();
1833 GFXFireInfo.GFXSetDFB.eSrcBldOP =gfxSrcBldOP;
1834 GFXFireInfo.GFXSetDFB.eDstBldOP =gfxDstBldOP;
1835 GFXFireInfo.eFireInfo |= GFX_DFB_INFO;
1836 GFX_FireInfoUnLock();
1837
1838 return eRet;
1839 }
1840
1841
1842 //-------------------------------------------------------------------------------------------------
1843 /// Set GFX DFB blending const color.
1844 /// @param u32ConstColor \b IN: DFB Blending constant color
1845 /// @return GFX_SUCCESS - Success
1846 /// @return GFX_FAIL - Failure
1847 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDFBBldConstColor(GFX_RgbColor gfxRgbColor)1848 GFX_Result MApi_GFX_SetDFBBldConstColor(GFX_RgbColor gfxRgbColor)
1849 {
1850 GFX_Result eRet = GFX_SUCCESS;
1851
1852 APIGFX_CHECK_INIT();
1853
1854 GFX_FireInfoLock();
1855 memcpy(&(GFXFireInfo.GFXSetDFB.sRGBColor), &gfxRgbColor, sizeof(GFX_RgbColor));
1856 #ifndef MSOS_TYPE_NOS
1857 GFXFireInfo.GFXSetABL.u8Alpha_Const = gfxRgbColor.a;
1858 GFXFireInfo.eFireInfo |= GFX_ABL_INFO;
1859 #endif
1860 GFXFireInfo.eFireInfo |= GFX_DFB_INFO;
1861 GFX_FireInfoUnLock();
1862
1863 return eRet;
1864
1865 }
1866
1867 //-------------------------------------------------------------------------------------------------
1868 /// Set GFX DFB blending source color mask.
1869 /// @param u32ConstColor \b IN: DFB Blending constant color
1870 /// @return GFX_SUCCESS - Success
1871 /// @return GFX_FAIL - Failure
1872 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDFBBldSrcColorMask(GFX_RgbColor gfxRgbColor)1873 GFX_Result MApi_GFX_SetDFBBldSrcColorMask(GFX_RgbColor gfxRgbColor)
1874 {
1875 #if 0
1876 GE_RgbColor geRgbColor;
1877
1878 APIGFX_CHECK_INIT();
1879
1880 geRgbColor.a = gfxRgbColor.a;
1881 geRgbColor.r = gfxRgbColor.r;
1882 geRgbColor.g = gfxRgbColor.g;
1883 geRgbColor.b = gfxRgbColor.b;
1884
1885 return (GFX_Result) MDrv_GE_SetDFBBldSrcColorMask(g_apiGFXLocal.g_pGEContext, geRgbColor);
1886 #endif
1887 return GFX_SUCCESS;
1888 }
1889
1890
1891 /******************************************************************************/
1892 ///Disable/Enable and set Alpha Blending parameters.
1893 ///
1894 ///Alpha blending function will mix the source color and destination color.
1895 ///The alpha constant are applied to determine the ratio of source color and destination color.
1896 ///The operation mode will depends on the source/destination coefficient.
1897 ///
1898 ///@param enable \b IN :
1899 ///- 0: Disable
1900 ///- 1: Enable
1901 ///@param coef \b IN Source coefficient for blending. (source blending mode)
1902 ///@param db_abl \b IN Source of Destination Alpha.
1903 ///@param abl_const \b IN Alpha Blending constant
1904 ///@par Function Actions:
1905 /******************************************************************************/
MApi_GFX_SetAlpha(MS_BOOL enable,GFX_BlendCoef coef,GFX_AlphaSrcFrom db_abl,MS_U8 abl_const)1906 GFX_Result MApi_GFX_SetAlpha(MS_BOOL enable, GFX_BlendCoef coef, GFX_AlphaSrcFrom db_abl, MS_U8 abl_const)
1907 {
1908 GFX_Result eRet = GFX_SUCCESS;
1909
1910 APIGFX_CHECK_INIT();
1911
1912 GFX_FireInfoLock();
1913 GFXFireInfo.GFXSetABL.bEnable = enable;
1914 GFXFireInfo.GFXSetABL.eABLCoef = coef;
1915 GFXFireInfo.GFXSetABL.eDb_abl = db_abl;
1916 GFXFireInfo.GFXSetABL.u8Alpha_Const = abl_const;
1917 #ifndef MSOS_TYPE_NOS
1918 GFXFireInfo.GFXSetDFB.sRGBColor.a = abl_const;
1919 GFXFireInfo.eFireInfo |= GFX_DFB_INFO;
1920 #endif
1921 GFXFireInfo.eFireInfo |= GFX_ABL_INFO;
1922 GFX_FireInfoUnLock();
1923
1924 return eRet;
1925 }
1926
1927 //-------------------------------------------------------------------------------------------------
1928 /// Enable GFX mirror
1929 /// @param isMirrorX \b IN: true/false
1930 /// @param isMirrorY \b IN: true/false
1931 /// @return GFX_SUCCESS - Success
1932 /// @return GFX_FAIL - Failure
1933 /// @note
1934 /// The mirror process can't perform on the source format is GFX_FMT_I1, GFX_FMT_I2 or GFX_FMT_I4.
1935 /// The mirror process can't perform with italic process.
1936 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetMirror(MS_BOOL isMirrorX,MS_BOOL isMirrorY)1937 GFX_Result MApi_GFX_SetMirror(MS_BOOL isMirrorX, MS_BOOL isMirrorY)
1938 {
1939 APIGFX_CHECK_INIT();
1940
1941 GFX_FireInfoLock();
1942 GFXFireInfo.GFXSetMirror.bMirrorX =isMirrorX;
1943 GFXFireInfo.GFXSetMirror.bMirrorY =isMirrorY;
1944 GFXFireInfo.eFireInfo |= GFX_SRC_MIRROR_INFO;
1945 GFX_FireInfoUnLock();
1946
1947 return GFX_SUCCESS;
1948 }
1949
1950 //-------------------------------------------------------------------------------------------------
1951 /// Enable GFX destination mirror
1952 /// @param isMirrorX \b IN: true/false
1953 /// @param isMirrorY \b IN: true/false
1954 /// @return GFX_SUCCESS - Success
1955 /// @return GFX_FAIL - Failure
1956 /// @note
1957 /// The mirror process can't perform on the source format is GFX_FMT_I1, GFX_FMT_I2 or GFX_FMT_I4.
1958 /// The mirror process can't perform with italic process.
1959 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDstMirror(MS_BOOL isMirrorX,MS_BOOL isMirrorY)1960 GFX_Result MApi_GFX_SetDstMirror(MS_BOOL isMirrorX, MS_BOOL isMirrorY)
1961 {
1962 APIGFX_CHECK_INIT();
1963
1964 GFX_FireInfoLock();
1965 GFXFireInfo.GFXSetDstMirror.bMirrorX =isMirrorX;
1966 GFXFireInfo.GFXSetDstMirror.bMirrorY =isMirrorY;
1967 GFXFireInfo.eFireInfo |= GFX_DST_MIRROR_INFO;
1968 GFX_FireInfoUnLock();
1969
1970 return GFX_SUCCESS;
1971 }
1972
1973 //-------------------------------------------------------------------------------------------------
1974 /// Enable GFX NearestMode
1975 /// @param enable \b IN: true/false
1976 /// @return GFX_SUCCESS - Success
1977 /// @return GFX_FAIL - Failure
1978 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetNearestMode(MS_BOOL enable)1979 GFX_Result MApi_GFX_SetNearestMode(MS_BOOL enable)
1980 {
1981 APIGFX_CHECK_INIT();
1982
1983 GFX_FireInfoLock();
1984 GFXFireInfo.bNearest = enable;
1985 GFXFireInfo.eFireInfo |= GFX_NEAREST_INFO;
1986 GFX_FireInfoUnLock();
1987
1988 return GFX_SUCCESS;
1989 }
1990
1991
1992 //-------------------------------------------------------------------------------------------------
1993 /// Configure GFX Patch mode
1994 /// @param enable \b IN: true/false
1995 /// @return GFX_SUCCESS - Success
1996 /// @return GFX_FAIL - Failure
1997 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetPatchMode(MS_BOOL enable)1998 GFX_Result MApi_GFX_SetPatchMode(MS_BOOL enable)
1999 {
2000 GFX_MISC_ARGS GFXInfo;
2001
2002 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
2003 GFXInfo.eGFX_MISCType = E_MISC_PATCH_MODE;
2004 GFXInfo.pGFX_Info = (void*)&enable;
2005 GFXInfo.u32Size = sizeof(MS_BOOL);
2006
2007 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
2008 {
2009 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2010 }
2011 return GFX_SUCCESS;
2012 }
2013
2014 /******************************************************************************/
2015 ///Set GFX TLB
2016 /// @param TLBmode \b IN: TLB mode
2017 ///@return GFX_SUCCESS - Success
2018 ///@return GFX_FAIL - Failure
2019 /******************************************************************************/
MApi_GFX_SetTLBMode(EN_GFX_TLB_Mode TLBmode)2020 GFX_Result MApi_GFX_SetTLBMode(EN_GFX_TLB_Mode TLBmode)
2021 {
2022 GFX_Result eRet = GFX_SUCCESS;
2023 MS_U32 value = 0;
2024 APIGFX_CHECK_INIT();
2025
2026 GFX_TLB_ARGS GFXSetTLBConfig;
2027
2028 memset(&GFXSetTLBConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2029
2030 GFXSetTLBConfig.en_cmd =E_GFX_TLB_SET_MODE;
2031 GFXSetTLBConfig.psetting =(void*)&value;
2032 GFXSetTLBConfig.TLB_mode =TLBmode;
2033 GFXSetTLBConfig.u32Size =sizeof(GFX_TLB_ARGS);
2034
2035 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_TLB, (void*)&GFXSetTLBConfig) != UTOPIA_STATUS_SUCCESS)
2036 {
2037 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2038 return GFX_FAIL;
2039 }
2040
2041 return eRet;
2042 }
2043
2044 /******************************************************************************/
2045 ///Set GFX TLB
2046 ///@param u32TLBSrcMiuAddr \b IN: TLB Source base address
2047 ///@param u32TLBDstMiuAddr \b IN: TLB Destination base address
2048 ///@return GFX_SUCCESS - Success
2049 ///@return GFX_FAIL - Failure
2050 /******************************************************************************/
MApi_GFX_SetTLBBaseADDR(MS_PHY phyTLBSrcMiuAddr,MS_PHY phyTLBDstMiuAddr)2051 GFX_Result MApi_GFX_SetTLBBaseADDR(MS_PHY phyTLBSrcMiuAddr,MS_PHY phyTLBDstMiuAddr)
2052 {
2053 GFX_Result eRet = GFX_SUCCESS;
2054
2055 APIGFX_CHECK_INIT();
2056
2057 GFX_TLB_ARGS GFXTLBARGS;
2058 GFX_SetTLB_Addr GFXSetTLBAddr;
2059
2060 memset(&GFXTLBARGS, 0 ,sizeof(GFX_TLB_ARGS));
2061 memset(&GFXSetTLBAddr, 0 ,sizeof(GFX_SetTLB_Addr));
2062
2063 GFXTLBARGS.en_cmd =E_GFX_TLB_SET_ADDR;
2064 GFXTLBARGS.psetting =(void*)&GFXSetTLBAddr;
2065 GFXTLBARGS.u32Size =sizeof(GFX_SetTLB_Addr);
2066
2067 GFXSetTLBAddr.tlb_src_addr =phyTLBSrcMiuAddr;
2068 GFXSetTLBAddr.tlb_dst_addr =phyTLBDstMiuAddr;
2069
2070 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_TLB, (void*)&GFXTLBARGS) != UTOPIA_STATUS_SUCCESS)
2071 {
2072 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2073 return GFX_FAIL;
2074 }
2075
2076 return eRet;
2077 }
2078
2079 /******************************************************************************/
2080 ///Set GFX TLB
2081 ///@param enable \b IN: TLB Flush Enable
2082 ///@return GFX_SUCCESS - Success
2083 ///@return GFX_FAIL - Failure
2084 /******************************************************************************/
MApi_GFX_SetTLBFlushTable(MS_BOOL enable)2085 GFX_Result MApi_GFX_SetTLBFlushTable(MS_BOOL enable)
2086 {
2087 GFX_Result eRet = GFX_SUCCESS;
2088
2089 APIGFX_CHECK_INIT();
2090
2091 GFX_TLB_ARGS GFXTLBARGS;
2092
2093 memset(&GFXTLBARGS, 0 ,sizeof(GFX_TLB_ARGS));
2094
2095 GFXTLBARGS.en_cmd =E_GFX_TLB_FLUSH_TABLE;
2096 GFXTLBARGS.psetting =(void*)&enable;
2097 GFXTLBARGS.u32Size =sizeof(MS_BOOL);
2098
2099 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_TLB, (void*)&GFXTLBARGS) != UTOPIA_STATUS_SUCCESS)
2100 {
2101 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2102 return GFX_FAIL;
2103 }
2104
2105 return eRet;
2106 }
2107
2108 /******************************************************************************/
2109 ///Set GFX TLB
2110 ///@param tag \b IN: TLB TAG
2111 ///@return GFX_SUCCESS - Success
2112 ///@return GFX_FAIL - Failure
2113 /******************************************************************************/
MApi_GFX_SetTLBTag(MS_U16 tag)2114 GFX_Result MApi_GFX_SetTLBTag(MS_U16 tag)
2115 {
2116 GFX_Result eRet = GFX_SUCCESS;
2117
2118 APIGFX_CHECK_INIT();
2119
2120 GFX_TLB_ARGS GFXTLBARGS;
2121
2122 memset(&GFXTLBARGS, 0 ,sizeof(GFX_TLB_ARGS));
2123
2124 GFXTLBARGS.en_cmd =E_GFX_TLB_TAG;
2125 GFXTLBARGS.psetting =(void*)&tag;
2126 GFXTLBARGS.u32Size =sizeof(MS_U16);
2127
2128 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_TLB, (void*)&GFXTLBARGS) != UTOPIA_STATUS_SUCCESS)
2129 {
2130 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2131 return GFX_FAIL;
2132 }
2133
2134 return eRet;
2135 }
2136
2137 //-------------------------------------------------------------------------------------------------
2138 /// Set GFX source buffer info
2139 /// @param bufInfo \b IN: buffer handle
2140 /// @param offsetofByte \b IN: start offset (should be 128 bit aligned)
2141 /// @return GFX_SUCCESS - Success
2142 /// @return GFX_FAIL - Failure
2143 /// @return GFX_Result_NON_ALIGN_PITCH - The pitch is not 16 bytes alignment
2144 /// @return GFX_Result_NON_ALIGN_ADDRESS - The address is not 16 bytes alignment
2145 /// @note
2146 /// The buffer start address must be 128 bits alignment.
2147 /// In GFX_FMT_I1, GFX_FMT_I2 and GFX_FMT_I4 format, the pitch must be 8 bits alignment.
2148 /// In other format, the pitch must be 128 bits alignment.
2149 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetSrcBufferInfo(PGFX_BufferInfo bufInfo,MS_U32 offsetofByte)2150 GFX_Result MApi_GFX_SetSrcBufferInfo(PGFX_BufferInfo bufInfo, MS_U32 offsetofByte)
2151 {
2152 GFX_Result eRet = GFX_SUCCESS;
2153
2154 APIGFX_CHECK_NULL(bufInfo);
2155 APIGFX_CHECK_INIT();
2156
2157 //Utopia2 not support this function. Only stroed in wrapper.
2158 GFX_FireInfoLock();
2159 memcpy(&(GFXFireInfo.SrcbufInfo), bufInfo, sizeof(GFX_BufferInfo));
2160 GFXFireInfo.u32SrcOffsetofByte =offsetofByte;
2161 GFXFireInfo.eFireInfo |= GFX_SRC_INFO;
2162 GFX_FireInfoUnLock();
2163
2164 return eRet;
2165 }
2166 //-------------------------------------------------------------------------------------------------
2167 /// Set GFX destination buffer info
2168 /// @param bufInfo \b IN: buffer handle
2169 /// @param offsetofByte \b IN: start offset (should be 128 bit aligned)
2170 /// @return GFX_SUCCESS - Success
2171 /// @return GFX_FAIL - Failure
2172 /// @return GFX_Result_NON_ALIGN_PITCH - The pitch is not 16 bytes alignment
2173 /// @return GFX_Result_NON_ALIGN_ADDRESS - The address is not 16 bytes alignment
2174 /// @note
2175 /// The buffer start address and pitch smust be 128 bits alignment.
2176 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDstBufferInfo(PGFX_BufferInfo bufInfo,MS_U32 offsetofByte)2177 GFX_Result MApi_GFX_SetDstBufferInfo(PGFX_BufferInfo bufInfo, MS_U32 offsetofByte)
2178 {
2179 GFX_Result eRet = GFX_SUCCESS;
2180
2181 APIGFX_CHECK_NULL(bufInfo);
2182 APIGFX_CHECK_INIT();
2183
2184 //Utopia2 not support this function. Only stroed in wrapper.
2185 GFX_FireInfoLock();
2186 memcpy(&(GFXFireInfo.DstbufInfo), bufInfo, sizeof(GFX_BufferInfo));
2187 GFXFireInfo.u32DstOffsetofByte =offsetofByte;
2188 GFXFireInfo.eFireInfo |= GFX_DST_INFO;
2189 GFX_FireInfoUnLock();
2190
2191 return eRet;
2192 }
2193
2194 //-------------------------------------------------------------------------------------------------
2195 /// Get GFX SRC/DST buffer info
2196 /// @param srcbufInfo \b IN: Pointer of src buffer info.
2197 /// @param dstbufInfo \b IN: Pointer of dst buffer info.
2198 /// @return GFX_SUCCESS - Success
2199 /// @return GFX_FAIL - Failure
2200 /// @note
2201 /// none
2202 //-------------------------------------------------------------------------------------------------
MApi_GFX_GetBufferInfo(PGFX_BufferInfo srcbufInfo,PGFX_BufferInfo dstbufInfo)2203 GFX_Result MApi_GFX_GetBufferInfo(PGFX_BufferInfo srcbufInfo, PGFX_BufferInfo dstbufInfo)
2204 {
2205 GFX_Result eRet = GFX_SUCCESS;
2206 APIGFX_CHECK_NULL(srcbufInfo);
2207 APIGFX_CHECK_NULL(dstbufInfo);
2208 APIGFX_CHECK_INIT();
2209
2210 GFX_FireInfoLock();
2211 memcpy(srcbufInfo, &(GFXFireInfo.SrcbufInfo), sizeof(GFX_BufferInfo));
2212 memcpy(dstbufInfo, &(GFXFireInfo.DstbufInfo), sizeof(GFX_BufferInfo));
2213 GFX_FireInfoUnLock();
2214
2215 return eRet;
2216
2217 }
2218
2219 //-------------------------------------------------------------------------------------------------
2220 /// Set GFX Bit blt
2221 /// @param drawbuf \b IN: pointer to drawbuf info
2222 /// @param drawflag \b IN: draw flag \n
2223 /// GFXDRAW_FLAG_DEFAULT \n
2224 /// GFXDRAW_FLAG_SCALE \n
2225 /// GFXDRAW_FLAG_DUPLICAPE \n
2226 /// GFXDRAW_FLAG_TRAPEZOID \n
2227 /// @return GFX_SUCCESS - Success
2228 /// @return GFX_FAIL - Failure
2229 //-------------------------------------------------------------------------------------------------
MApi_GFX_BitBlt(GFX_DrawRect * drawbuf,MS_U32 drawflag)2230 GFX_Result MApi_GFX_BitBlt(GFX_DrawRect *drawbuf,MS_U32 drawflag)
2231 {
2232 GFX_Result eRet = GFX_SUCCESS;
2233 GFX_ScaleInfo ScaleInfo;
2234
2235 APIGFX_CHECK_NULL(drawbuf);
2236 APIGFX_CHECK_INIT();
2237
2238 GFX_BITBLT_ARGS GFXBitBlt;
2239 GFX_BitBltInfo GFXBitBltInfo;
2240
2241 memset(&GFXBitBlt, 0 , sizeof(GFX_BITBLT_ARGS));
2242 memset(&GFXBitBltInfo, 0 , sizeof(GFX_BitBltInfo));
2243 memset(&ScaleInfo, 0 , sizeof(GFX_ScaleInfo));
2244
2245 GFX_FireInfoLock();
2246 GFXBitBlt.pGFX_BitBlt =(void*)&GFXBitBltInfo;
2247 GFXBitBlt.u32Size =sizeof(GFX_BitBltInfo);
2248 GFXBitBltInfo.pFireInfo = &GFXFireInfo;
2249 GFXBitBltInfo.pDrawRect =drawbuf;
2250 GFXBitBltInfo.u32DrawFlag =drawflag;
2251 GFXBitBltInfo.pScaleInfo = &ScaleInfo;
2252 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_BITBLT, (void*)&GFXBitBlt) != UTOPIA_STATUS_SUCCESS)
2253 {
2254 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2255 eRet= GFX_FAIL;
2256 }
2257 GFXFireInfo.eFireInfo = 0;
2258 GFX_FireInfoUnLock();
2259
2260 return eRet;
2261 }
2262
2263 //-------------------------------------------------------------------------------------------------
2264 /// Set GFX Bit blt with explicitly scale info.
2265 /// @param drawbuf \b IN: pointer to drawbuf info
2266 /// @param drawflag \b IN: draw flag \n
2267 /// GFXDRAW_FLAG_DEFAULT \n
2268 /// GFXDRAW_FLAG_SCALE \n
2269 /// GFXDRAW_FLAG_DUPLICAPE \n
2270 /// GFXDRAW_FLAG_TRAPEZOID \n
2271 /// @param ScaleInfo \b IN: pointer to GFX_ScaleInfo assigned by AP.
2272 /// @return GFX_SUCCESS - Success
2273 /// @return GFX_FAIL - Failure
2274 //-------------------------------------------------------------------------------------------------
MApi_GFX_BitBltEx(GFX_DrawRect * drawbuf,MS_U32 drawflag,GFX_ScaleInfo * ScaleInfo)2275 GFX_Result MApi_GFX_BitBltEx(GFX_DrawRect * drawbuf, MS_U32 drawflag, GFX_ScaleInfo * ScaleInfo)
2276 {
2277 GFX_Result eRet = GFX_SUCCESS;
2278
2279 APIGFX_CHECK_NULL(drawbuf);
2280 APIGFX_CHECK_NULL(ScaleInfo);
2281 APIGFX_CHECK_INIT();
2282
2283 GFX_BITBLT_ARGS GFXBitBlt;
2284 GFX_BitBltInfo GFXBitBltInfo;
2285
2286 memset(&GFXBitBlt, 0 , sizeof(GFX_BITBLT_ARGS));
2287 memset(&GFXBitBltInfo, 0 , sizeof(GFX_BitBltInfo));
2288
2289 GFX_FireInfoLock();
2290 GFXBitBlt.pGFX_BitBlt =(void*)&GFXBitBltInfo;
2291 GFXBitBlt.u32Size =sizeof(GFX_BitBltInfo);
2292 GFXBitBltInfo.pFireInfo = &GFXFireInfo;
2293 GFXBitBltInfo.pDrawRect = drawbuf;
2294 GFXBitBltInfo.u32DrawFlag = drawflag;
2295 GFXBitBltInfo.pScaleInfo = ScaleInfo;
2296 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_BITBLT, (void*)&GFXBitBlt) != UTOPIA_STATUS_SUCCESS)
2297 {
2298 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2299 eRet= GFX_FAIL;
2300 }
2301 GFXFireInfo.eFireInfo = 0;
2302 GFX_FireInfoUnLock();
2303
2304 return eRet;
2305 }
2306
2307 //-------------------------------------------------------------------------------------------------
2308 /// Set GFX destination buffer info in two source buffer mode
2309 /// Attention, when two source buffer mode enable, raw DstBuffer will be one of two source.
2310 /// @param dstbufInfo \b IN: pointer to destination frame buffer infomation.\n
2311 /// @param pdrawbuf \b IN: pointer to two source rects info
2312 /// @param drawflag \b IN: draw flag \n
2313 /// GFXDRAW_FLAG_DEFAULT \n
2314 /// GFXDRAW_FLAG_SCALE \n
2315 /// GFXDRAW_FLAG_DUPLICAPE \n
2316 /// GFXDRAW_FLAG_TRAPEZOID \n
2317 /// @return GFX_SUCCESS - Success
2318 /// @return GFX_FAIL - Failure
2319 //-------------------------------------------------------------------------------------------------
MApi_GFX_BitbltByTwoSourceBuffer(PGFX_BufferInfo dstbufInfo,GFX_DrawTwoSourceRect * pdrawbuf,MS_U32 drawflag)2320 GFX_Result MApi_GFX_BitbltByTwoSourceBuffer(PGFX_BufferInfo dstbufInfo, GFX_DrawTwoSourceRect *pdrawbuf, MS_U32 drawflag)
2321 {
2322 GFX_Result eRet = GFX_SUCCESS;
2323
2324 APIGFX_CHECK_NULL(dstbufInfo);
2325 APIGFX_CHECK_NULL(pdrawbuf);
2326 APIGFX_CHECK_INIT();
2327
2328 GFX_TWOSRC_BITBLT_ARGS GFXTwoSrcBitBlt;
2329 GFX_TwoSrc_BitBltInfo GFXTwoSrcBitBltInfo;
2330 GFX_Src_BufferInfo GFXDstBufferInfo;
2331
2332 memset(&GFXTwoSrcBitBlt, 0 , sizeof(GFX_TWOSRC_BITBLT_ARGS));
2333 memset(&GFXTwoSrcBitBltInfo, 0 , sizeof(GFX_TwoSrc_BitBltInfo));
2334 memset(&GFXDstBufferInfo, 0 , sizeof(GFX_Dst_BufferInfo));
2335
2336 GFX_FireInfoLock();
2337 GFXTwoSrcBitBlt.pGFX_TwoSrc_BitBlt =&GFXTwoSrcBitBltInfo;
2338 GFXTwoSrcBitBlt.u32Size =sizeof(GFX_TwoSrc_BitBltInfo);
2339 GFXTwoSrcBitBltInfo.pDstbufInfo = &GFXDstBufferInfo;
2340 GFXTwoSrcBitBltInfo.pFireInfo = &GFXFireInfo;
2341 GFXTwoSrcBitBltInfo.pDstbufInfo->pBufInfo = dstbufInfo;
2342 GFXTwoSrcBitBltInfo.pDstbufInfo->u32OffsetByte = 0;
2343 GFXTwoSrcBitBltInfo.pDrawTwoSrcRect = pdrawbuf;
2344 GFXTwoSrcBitBltInfo.u32DrawFlag = drawflag;
2345
2346 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_TWOSRCBITBLT, (void*)&GFXTwoSrcBitBlt) != UTOPIA_STATUS_SUCCESS)
2347 {
2348 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2349 eRet= GFX_FAIL;
2350 }
2351 GFXFireInfo.eFireInfo = 0;
2352 GFX_FireInfoUnLock();
2353
2354 return eRet;
2355
2356 }
2357
2358 //-------------------------------------------------------------------------------------------------
2359 /// Set GFX palette table
2360 /// Palette entries started from u32PalStart to u32PalEnd will be updated according to the data pointed by pPalArray
2361 /// @param pPalArray \b IN: pointer to an array of GFX_PaletteEntry
2362 /// @param u32PalStart \b IN: Palette index from which the palette will be updated.
2363 /// @param u32PalEnd \b IN: Palette index to which the palette will be updated.
2364 /// @return GFX_SUCCESS - Success
2365 /// @return GFX_FAIL - Failure
2366 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetPaletteOpt(GFX_PaletteEntry * pPalArray,MS_U16 u32PalStart,MS_U16 u32PalEnd)2367 GFX_Result MApi_GFX_SetPaletteOpt( GFX_PaletteEntry *pPalArray, MS_U16 u32PalStart, MS_U16 u32PalEnd)
2368 {
2369 GFX_Result eRet = GFX_SUCCESS;
2370
2371 if(pPalArray == NULL)
2372 {
2373 GFX_ERR("[%s][%d] pPalArray =NULL\n",__FUNCTION__,__LINE__);
2374 return GFX_FAIL;
2375 }
2376 APIGFX_CHECK_INIT();
2377
2378 GFX_SETCONFIG_ARGS GFXSetConfig;
2379 GFX_Set_PaletteOpt GFXSetPaletteOpt;
2380
2381 memset(&GFXSetConfig, 0 , sizeof(GFX_SETCONFIG_ARGS));
2382 memset(&GFXSetPaletteOpt , 0 ,sizeof(GFX_Set_PaletteOpt));
2383
2384 GFXSetPaletteOpt.pPalArray = pPalArray;
2385 GFXSetPaletteOpt.u32PalStart = u32PalStart;
2386 GFXSetPaletteOpt.u32PalEnd = u32PalEnd;
2387
2388 GFXSetConfig.eGFX_SetConfig = E_GFX_SET_PALETTEOPT;
2389 GFXSetConfig.pGFX_ConfigInfo = (void*)&GFXSetPaletteOpt;
2390 GFXSetConfig.u32Size = sizeof(GFX_Set_PaletteOpt);
2391
2392 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2393 {
2394 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2395 eRet= GFX_FAIL;
2396 }
2397 return eRet;
2398 }
2399
2400 //-------------------------------------------------------------------------------------------------
2401 /// Set GFX CSC format
2402 /// YUV/RGB conversion will be performed according to the spec specified in this function.
2403 /// @param mode \b IN: YUV mode: PC or 0~255
2404 /// @param yuv_out_range \b IN: output YUV mode: PC or 0~255
2405 /// @param uv_in_range \b IN: input YUV mode: 0~255 or -126~127
2406 /// @param srcfmt \b IN: YUV packing format for source
2407 /// @param dstfmt \b IN: YUV packing format for destination
2408 /// @return GFX_SUCCESS - Success
2409 /// @return GFX_FAIL - Failure
2410 //-------------------------------------------------------------------------------------------------
MApi_GFX_SetDC_CSC_FMT(GFX_YUV_Rgb2Yuv mode,GFX_YUV_OutRange yuv_out_range,GFX_YUV_InRange uv_in_range,GFX_YUV_422 srcfmt,GFX_YUV_422 dstfmt)2411 GFX_Result MApi_GFX_SetDC_CSC_FMT(GFX_YUV_Rgb2Yuv mode, GFX_YUV_OutRange yuv_out_range, GFX_YUV_InRange uv_in_range, GFX_YUV_422 srcfmt, GFX_YUV_422 dstfmt)
2412 {
2413 GFX_Result eRet = GFX_SUCCESS;
2414
2415 APIGFX_CHECK_INIT();
2416
2417 GFX_FireInfoLock();
2418 GFXFireInfo.GFXSetCSC.mode = mode;
2419 GFXFireInfo.GFXSetCSC.yuv_out_range = yuv_out_range;
2420 GFXFireInfo.GFXSetCSC.uv_in_range = uv_in_range;
2421 GFXFireInfo.GFXSetCSC.srcfmt = srcfmt;
2422 GFXFireInfo.GFXSetCSC.dstfmt = dstfmt;
2423 GFXFireInfo.eFireInfo |= GFX_CSC_INFO;
2424 GFX_FireInfoUnLock();
2425
2426 return eRet;
2427 }
2428
2429 /******************************************************************************/
2430 ///Set alpha parameter for ARGB1555.
2431 ///@param coef \b IN alpha coefficient for ARGB1555
2432 ///@par Function Actions:
2433 /// @return GFX_SUCCESS - Success
2434 /// @return GFX_FAIL - Failure
2435 /******************************************************************************/
MApi_GFX_SetAlpha_ARGB1555(MS_U8 coef)2436 GFX_Result MApi_GFX_SetAlpha_ARGB1555(MS_U8 coef)
2437 {
2438 GFX_Result eRet = GFX_SUCCESS;
2439 GFX_MISC_ARGS GFXInfo;
2440
2441 APIGFX_CHECK_INIT();
2442 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
2443
2444 GFXInfo.eGFX_MISCType = E_MISC_SET_ALB_1555;
2445 GFXInfo.pGFX_Info = (void*)&coef;
2446 GFXInfo.u32Size = sizeof(MS_U8);
2447
2448 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
2449 {
2450 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2451 }
2452 return eRet;
2453 }
2454
2455
2456 /******************************************************************************/
2457 ///Get alpha parameter for ARGB1555.
2458 ///@param coef \b IN alpha coefficient for ARGB1555
2459 ///@par Function Actions:
2460 /// @return GFX_SUCCESS - Success
2461 /// @return GFX_FAIL - Failure
2462 /******************************************************************************/
MApi_GFX_GetAlpha_ARGB1555(MS_U8 * coef)2463 GFX_Result MApi_GFX_GetAlpha_ARGB1555(MS_U8* coef)
2464 {
2465 GFX_Result eRet = GFX_SUCCESS;
2466 GFX_MISC_ARGS GFXInfo;
2467
2468 APIGFX_CHECK_INIT();
2469 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
2470
2471 GFXInfo.eGFX_MISCType = E_MISC_GET_ALB_1555;
2472 GFXInfo.pGFX_Info = (void*)coef;
2473 GFXInfo.u32Size = sizeof(MS_U8);
2474
2475 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
2476 {
2477 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2478 }
2479 return eRet;
2480 }
2481
2482
2483 /******************************************************************************/
2484 ///Set TAGID
2485 ///@param tagID \b IN 16-bit TAGID
2486 ///@par Function Actions:
2487 /******************************************************************************/
MApi_GFX_SetTAGID(MS_U16 tagID)2488 GFX_Result MApi_GFX_SetTAGID(MS_U16 tagID)
2489 {
2490 GFX_Result eRet = GFX_SUCCESS;
2491
2492 APIGFX_CHECK_INIT();
2493
2494 GFX_SETCONFIG_ARGS GFXSetConfig;
2495
2496 memset(&GFXSetConfig, 0 , sizeof(GFX_SETCONFIG_ARGS));
2497
2498 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_TAGID;
2499 GFXSetConfig.pGFX_ConfigInfo =(void*)&tagID;
2500 GFXSetConfig.u32Size =sizeof(MS_U32);
2501
2502 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2503 {
2504 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2505 eRet= GFX_FAIL;
2506 }
2507 return eRet;
2508 }
2509
2510 /******************************************************************************/
2511 ///Get TAGID
2512 ///@param tagID \b IN Pointer to 16-bit TAGID.
2513 ///@par Function Actions:
2514 /******************************************************************************/
2515
MApi_GFX_GetTAGID(MS_U16 * tagID)2516 GFX_Result MApi_GFX_GetTAGID(MS_U16 *tagID)
2517 {
2518 GFX_Result eRet = GFX_SUCCESS;
2519
2520 if(tagID ==NULL)
2521 {
2522 eRet = GFX_FAIL;
2523 }
2524 APIGFX_CHECK_INIT();
2525
2526 GFX_GETINFO_ARGS GFXGetInfo;
2527
2528 memset(&GFXGetInfo, 0 ,sizeof(GFX_GETINFO_ARGS));
2529
2530 GFXGetInfo.eGFX_GetConfig =E_GFX_GET_TAGID;
2531 GFXGetInfo.u32Size =sizeof(MS_U16);
2532
2533 GFXGetInfo.pGFX_GetInfo =tagID;
2534
2535 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_GET_INFO, (void*)&GFXGetInfo) != UTOPIA_STATUS_SUCCESS)
2536 {
2537 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2538 eRet = GFX_FAIL;
2539 }
2540
2541 return eRet;
2542 }
2543 #endif
2544
2545 /******************************************************************************/
2546 ///Wait for TagID.
2547 ///@param tagID \b IN: tag to wait
2548 ///@par Function Actions:
2549 /******************************************************************************/
MApi_GFX_WaitForTAGID(MS_U16 tagID)2550 GFX_Result MApi_GFX_WaitForTAGID(MS_U16 tagID)
2551 {
2552 GFX_Result eRet = GFX_SUCCESS;
2553
2554 APIGFX_CHECK_INIT();
2555 GFX_SETCONFIG_ARGS GFXSetConfig;
2556
2557 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2558
2559 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_WAITFORTAGID;
2560 GFXSetConfig.pGFX_ConfigInfo =(void*)&tagID;
2561 GFXSetConfig.u32Size =sizeof(MS_U32);
2562
2563 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2564 {
2565 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2566 eRet= GFX_FAIL;
2567 }
2568 return eRet;
2569 }
2570
2571 /******************************************************************************/
2572 ///Polling TagID.
2573 ///@param tagID \b IN: tag to polling
2574 ///@par Function Actions:
2575 /******************************************************************************/
MApi_GFX_PollingTAGID(MS_U16 tagID)2576 GFX_Result MApi_GFX_PollingTAGID(MS_U16 tagID)
2577 {
2578 GFX_Result eRet = GFX_SUCCESS;
2579
2580 APIGFX_CHECK_INIT();
2581 GFX_SETCONFIG_ARGS GFXSetConfig;
2582
2583 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2584
2585 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_POLLINGTAGID;
2586 GFXSetConfig.pGFX_ConfigInfo =(void*)&tagID;
2587 GFXSetConfig.u32Size =sizeof(MS_U32);
2588
2589 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2590 {
2591 //GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2592 eRet= GFX_FAIL;
2593 }
2594 return eRet;
2595 }
2596 #ifndef MSOS_TYPE_OPTEE
2597 /******************************************************************************/
2598 ///Retrieve next TagID.
2599 ///@param bStepTagBefore \b IN: steps to the tagID.
2600 ///@par Function Actions:
2601 /******************************************************************************/
MApi_GFX_GetNextTAGID(MS_BOOL bStepTagBefore)2602 MS_U16 MApi_GFX_GetNextTAGID(MS_BOOL bStepTagBefore)
2603 {
2604 MS_U16 u16Ret;
2605
2606 APIGFX_CHECK_INIT();
2607
2608 GFX_GETINFO_ARGS GFXGetInfo;
2609 GFX_Get_NextTagID GFXGetNextID;
2610
2611 memset(&GFXGetInfo, 0 , sizeof(GFX_GETINFO_ARGS));
2612 memset(&GFXGetNextID, 0 , sizeof(GFX_Get_NextTagID));
2613
2614 GFXGetInfo.eGFX_GetConfig =E_GFX_GET_NEXTTAGID;
2615 GFXGetInfo.pGFX_GetInfo =(void*)&GFXGetNextID;
2616 GFXGetInfo.u32Size =sizeof(GFX_Get_NextTagID);
2617
2618 GFXGetNextID.bStepTagBefore = bStepTagBefore;
2619 GFXGetNextID.pTagID = &u16Ret;
2620
2621 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_GET_INFO, (void*)&GFXGetInfo) != UTOPIA_STATUS_SUCCESS)
2622 {
2623 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2624 }
2625
2626 return u16Ret;
2627 }
2628 #endif
2629
2630 /******************************************************************************/
2631 ///Set next TagID Auto to HW.
2632 ///@par The Tage ID which has been set to HW
2633 /******************************************************************************/
MApi_GFX_SetNextTAGID(void)2634 MS_U16 MApi_GFX_SetNextTAGID(void)
2635 {
2636 MS_U16 tagID=0xFF;
2637
2638 APIGFX_CHECK_INIT();
2639
2640 GFX_SETCONFIG_ARGS GFXSetConfig;
2641
2642 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2643
2644 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_NEXTTAGID;
2645 GFXSetConfig.pGFX_ConfigInfo =(void*)&tagID;
2646 GFXSetConfig.u32Size =sizeof(MS_U32);
2647
2648 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2649 {
2650 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2651 }
2652
2653 return tagID;
2654 }
2655
2656 #ifndef MSOS_TYPE_OPTEE
2657 /******************************************************************************/
2658 ///Enable GFX Virtual Command Queue
2659 ///@param blEnable \b IN: true: Enable, false: Disable
2660 ///@par Function Actions:
2661 ///@return GFX_SUCCESS - Success
2662 ///@return GFX_FAIL - Failure
2663 /******************************************************************************/
MApi_GFX_EnableVCmdQueue(MS_U16 blEnable)2664 GFX_Result MApi_GFX_EnableVCmdQueue(MS_U16 blEnable)
2665 {
2666 GFX_Result eRet = GFX_SUCCESS;
2667
2668 APIGFX_CHECK_INIT();
2669 GFX_SETCONFIG_ARGS GFXSetConfig;
2670
2671 memset(&GFXSetConfig, 0 , sizeof(GFX_SETCONFIG_ARGS));
2672
2673 GFXSerVQ.bEnable =blEnable;
2674
2675 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_VQ;
2676 GFXSetConfig.pGFX_ConfigInfo =(void*)&GFXSerVQ;
2677 GFXSetConfig.u32Size =sizeof(GFX_Set_VQ);
2678
2679 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2680 {
2681 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2682 eRet= GFX_FAIL;
2683 }
2684
2685 return eRet;
2686 }
2687
2688 /******************************************************************************/
2689 ///Configure GFX Virtual Command Queue buffer spec
2690 ///@param u32Addr \b IN: base adress for VCMQ buffer
2691 ///@param enBufSize \b IN: buffer size of VCMQ buffer
2692 ///@par Function Actions:
2693 ///@return GFX_SUCCESS - Success
2694 ///@return GFX_FAIL - Failure
2695 /******************************************************************************/
MApi_GFX_SetVCmdBuffer(MS_PHY PhyAddr,GFX_VcmqBufSize enBufSize)2696 GFX_Result MApi_GFX_SetVCmdBuffer(MS_PHY PhyAddr, GFX_VcmqBufSize enBufSize)
2697 {
2698 GFX_Result eRet = GFX_SUCCESS;
2699
2700 APIGFX_CHECK_INIT();
2701 GFX_SETCONFIG_ARGS GFXSetConfig;
2702
2703 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2704
2705 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_VQ;
2706 GFXSetConfig.pGFX_ConfigInfo =(void*)&GFXSerVQ;
2707 GFXSetConfig.u32Size =sizeof(GFX_Set_VQ);
2708
2709 GFXSerVQ.u32Addr =PhyAddr;
2710 GFXSerVQ.enBufSize =enBufSize;
2711
2712 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2713 {
2714 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2715 eRet= GFX_FAIL;
2716 }
2717
2718 return eRet;
2719
2720 }
2721
2722 /******************************************************************************/
2723 ///Configure GFX Virtual Command Queue Write Threshold
2724 ///@param u8W_Threshold \b IN: Write threshold
2725 ///@par Function Actions:
2726 ///@return GFX_SUCCESS - Success
2727 ///@return GFX_FAIL - Failure
2728 /******************************************************************************/
MApi_GE_SetVCmd_W_Thread(MS_U8 u8W_Threshold)2729 GFX_Result MApi_GE_SetVCmd_W_Thread(MS_U8 u8W_Threshold)
2730 {
2731 GFX_Result eRet = GFX_SUCCESS;
2732
2733 APIGFX_CHECK_INIT();
2734 GFX_SETCONFIG_ARGS GFXSetConfig;
2735
2736 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2737
2738 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_VQ;
2739 GFXSetConfig.pGFX_ConfigInfo =(void*)&GFXSerVQ;
2740 GFXSetConfig.u32Size =sizeof(GFX_Set_VQ);
2741
2742 GFXSerVQ.u8W_Threshold =u8W_Threshold;
2743 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2744 {
2745 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2746 eRet= GFX_FAIL;
2747 }
2748
2749 return eRet;
2750 }
2751
2752 /******************************************************************************/
2753 ///Configure GFX Virtual Command Queue Read Threshold
2754 ///@param u8R_Threshold \b IN: Read threshold
2755 ///@par Function Actions:
2756 ///@return GFX_SUCCESS - Success
2757 ///@return GFX_FAIL - Failure
2758 /******************************************************************************/
MApi_GE_SetVCmd_R_Thread(MS_U8 u8R_Threshold)2759 GFX_Result MApi_GE_SetVCmd_R_Thread(MS_U8 u8R_Threshold)
2760 {
2761 GFX_Result eRet = GFX_SUCCESS;
2762
2763 APIGFX_CHECK_INIT();
2764 GFX_SETCONFIG_ARGS GFXSetConfig;
2765
2766 memset(&GFXSetConfig, 0, sizeof(GFX_SETCONFIG_ARGS));
2767
2768 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_VQ;
2769 GFXSetConfig.pGFX_ConfigInfo =(void*)&GFXSerVQ;
2770 GFXSetConfig.u32Size =sizeof(GFX_Set_VQ);
2771
2772 GFXSerVQ.u8R_Threshold =u8R_Threshold;
2773 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2774 {
2775 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2776 eRet= GFX_FAIL;
2777 }
2778
2779 return eRet;
2780 }
2781
2782
2783 /******************************************************************************/
2784 ///Configure GFX DBG level
2785 ///@param level \b IN: debug level. 0 => no dbg.
2786 ///@par Function Actions:
2787 /******************************************************************************/
MApi_GFX_SetDbgLevel(MS_U32 level)2788 void MApi_GFX_SetDbgLevel(MS_U32 level)
2789 {
2790 GFX_MISC_ARGS GFXInfo;
2791 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
2792 MS_U32 u32level;
2793
2794 u32level = level;
2795 GFXInfo.eGFX_MISCType = E_MISC_DEBUG_LEVEL;
2796 GFXInfo.pGFX_Info = (void*)&u32level;
2797 GFXInfo.u32Size = sizeof(MS_U32);
2798
2799 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
2800 {
2801 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2802 }
2803 }
2804
2805
2806 /******************************************************************************/
2807 ///Explicitly wait for GFX queue empty
2808 ///@return GFX_SUCCESS - Success
2809 ///@return GFX_FAIL - Failure
2810 /******************************************************************************/
MApi_GFX_FlushQueue(void)2811 GFX_Result MApi_GFX_FlushQueue(void)
2812 {
2813 GFX_Result eRet = GFX_SUCCESS;
2814 MS_U32 value = 0;
2815 APIGFX_CHECK_INIT();
2816
2817 GFX_SETCONFIG_ARGS GFXSetConfig;
2818
2819 memset(&GFXSetConfig, 0 ,sizeof(GFX_SETCONFIG_ARGS));
2820
2821 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_FLUSHQUEUE;
2822 GFXSetConfig.u32Size =sizeof(0);
2823 GFXSetConfig.pGFX_ConfigInfo =&value;
2824 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
2825 {
2826 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2827 eRet = GFX_FAIL;
2828 }
2829
2830 return eRet;
2831 }
2832
2833 /******************************************************************************/
2834 ///Configure the Color Key edge refine function.
2835 ///@param type \b IN: type of refine.
2836 ///@param color \b IN: when type is GFX_REPLACE_KEY_2_CUS, color of the customized color.
2837 ///@par Function Actions:
2838 ///@return GFX_SUCCESS - Success
2839 ///@return GFX_FAIL - Failure
2840 /******************************************************************************/
MApi_GFX_SetStrBltSckType(GFX_StretchCKType type,GFX_RgbColor * color)2841 GFX_Result MApi_GFX_SetStrBltSckType(GFX_StretchCKType type, GFX_RgbColor *color)
2842 {
2843
2844 GFX_FireInfoLock();
2845 GFXFireInfo.sttype.type = type;
2846 GFXFireInfo.sttype.color = *color;
2847 GFXFireInfo.eFireInfo |= GFX_STR_BLT_SCK_INFO;
2848 GFX_FireInfoUnLock();
2849
2850 return GFX_SUCCESS;
2851 }
2852
2853
2854 /******************************************************************************/
2855 ///Check if GFX lib is running as HouseKeeping.
2856 ///@param bIsHK \b IN: pointer to a bool denoting true/false
2857 ///@par Function Actions:
2858 ///@return GFX_SUCCESS - Success
2859 ///@return GFX_FAIL - Failure
2860 /******************************************************************************/
MApi_GFX_GetHK(MS_BOOL * bIsHK)2861 GFX_Result MApi_GFX_GetHK(MS_BOOL *bIsHK)
2862 {
2863 GFX_MISC_ARGS GFXInfo;
2864 MS_BOOL IsHK;
2865 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
2866
2867 GFXInfo.eGFX_MISCType = E_MISC_GET_HK;
2868 GFXInfo.pGFX_Info = (void*)&IsHK;
2869 GFXInfo.u32Size = sizeof(MS_BOOL);
2870
2871 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
2872 {
2873 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2874 }
2875 *bIsHK = IsHK;
2876 return GFX_SUCCESS;
2877 }
2878
2879 /******************************************************************************/
2880 ///Set the GFX lib running as HouseKeeping
2881 ///@param bIsHK \b IN: true => As HK, false => Not HK
2882 ///@par Function Actions:
2883 ///@return GFX_SUCCESS - Success
2884 ///@return GFX_FAIL - Failure
2885 /******************************************************************************/
MApi_GFX_SetHK(MS_BOOL bIsHK)2886 GFX_Result MApi_GFX_SetHK(MS_BOOL bIsHK)
2887 {
2888 GFX_MISC_ARGS GFXInfo;
2889 MS_BOOL IsHK;
2890 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
2891 IsHK = bIsHK;
2892 GFXInfo.eGFX_MISCType = E_MISC_SET_HK;
2893 GFXInfo.pGFX_Info = (void*)&IsHK;
2894 GFXInfo.u32Size = sizeof(MS_BOOL);
2895
2896 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
2897 {
2898 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2899 }
2900 return GFX_SUCCESS;
2901 }
2902
2903
2904 /******************************************************************************/
2905 ///Draw Oval. Oval is not directly supported by HW. Software implemented by DrawLine.
2906 ///@param pOval \b IN: Oval info
2907 ///@par Function Actions:
2908 ///@return GFX_SUCCESS - Success
2909 ///@return GFX_FAIL - Failure
2910 /******************************************************************************/
MApi_GFX_DrawOval(GFX_OvalFillInfo * pOval)2911 GFX_Result MApi_GFX_DrawOval(GFX_OvalFillInfo *pOval)
2912 {
2913 GFX_Result eRet = GFX_SUCCESS;
2914 APIGFX_CHECK_INIT();
2915
2916 GFX_DRAW_OVAL_ARGS GFXDrawOval;
2917 GFX_Set_DrawOvalInfo GFXDrawOvalInfo;
2918
2919 memset(&GFXDrawOval, 0 ,sizeof(GFX_DRAW_OVAL_ARGS));
2920 memset(&GFXDrawOvalInfo, 0 ,sizeof(GFX_Set_DrawOvalInfo));
2921
2922 GFX_FireInfoLock();
2923 GFXDrawOvalInfo.pFireInfo = &GFXFireInfo;
2924 GFXDrawOvalInfo.pDrawOvalInfo = pOval;
2925 GFXDrawOval.psetting =(void*)&GFXDrawOvalInfo;
2926 GFXDrawOval.u32Size =sizeof(GFX_Set_DrawOvalInfo);
2927 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_DRAW_OVAL, (void*)&GFXDrawOval) != UTOPIA_STATUS_SUCCESS)
2928 {
2929 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2930 eRet = GFX_FAIL;
2931 }
2932 GFXFireInfo.eFireInfo = 0;
2933 GFX_FireInfoUnLock();
2934
2935 return eRet;
2936 }
2937
2938
2939 /******************************************************************************/
2940 ///Get GFX version string
2941 ///@param ppVersion \b IN: version string
2942 ///@par Function Actions:
2943 ///@return GFX_SUCCESS - Success
2944 ///@return GFX_FAIL - Failure
2945 /******************************************************************************/
MApi_GFX_GetLibVer(const MSIF_Version ** ppVersion)2946 GFX_Result MApi_GFX_GetLibVer(const MSIF_Version **ppVersion)
2947 {
2948 APIGFX_CHECK_INIT();
2949
2950 if (!ppVersion)
2951 {
2952 return GFX_FAIL;
2953 }
2954
2955 *ppVersion = &_drv_gfx_version;
2956
2957 return GFX_SUCCESS;
2958 }
2959
2960 /******************************************************************************/
2961 ///Get GFX debug information
2962 ///@param dbg \b IN: pointer to debug struct.
2963 ///@par Function Actions:
2964 ///@return GFX_SUCCESS - Success
2965 ///@return GFX_FAIL - Failure
2966 /******************************************************************************/
MApi_GFX_GetInfo(GFX_DbgInfo * dbg)2967 GFX_Result MApi_GFX_GetInfo( GFX_DbgInfo *dbg )
2968 {
2969 GFX_Result eRet = GFX_SUCCESS;
2970
2971 if(dbg == NULL)
2972 {
2973 return GFX_FAIL;
2974 }
2975
2976 APIGFX_CHECK_INIT();
2977 GFX_GETINFO_ARGS GFXGetInfo;
2978 GFX_DbgInfo GFXDbgInfo;
2979
2980 memset(&GFXGetInfo, 0, sizeof(GFX_GETINFO_ARGS));
2981 memset(&GFXDbgInfo, 0 ,sizeof(GFX_DbgInfo));
2982
2983 GFXGetInfo.eGFX_GetConfig =E_GFX_GET_DBGINFO;
2984 GFXGetInfo.pGFX_GetInfo =(void*)&GFXDbgInfo;
2985 GFXGetInfo.u32Size =sizeof(GFX_DbgInfo);
2986
2987 GFXGetInfo.pGFX_GetInfo =dbg;
2988 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_GET_INFO, (void*)&GFXGetInfo) != UTOPIA_STATUS_SUCCESS)
2989 {
2990 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
2991 eRet = GFX_FAIL;
2992 }
2993 return eRet;
2994 }
2995
2996 /******************************************************************************/
2997 ///Get GFX internal status
2998 ///@param pStatus \b IN: pointer to debug struct.
2999 ///@par Function Actions:
3000 ///@return GFX_SUCCESS - Success
3001 ///@return GFX_FAIL - Failure
3002 /******************************************************************************/
MApi_GFX_GetStatus(MS_BOOL * pStatus)3003 GFX_Result MApi_GFX_GetStatus( MS_BOOL *pStatus )
3004 {
3005 #if 0
3006 APIGFX_CHECK_INIT();
3007
3008 MDrv_GE_GetStatus(g_apiGFXLocal.g_pGEContext, pStatus);
3009 #endif
3010 *pStatus = TRUE;
3011 return GFX_SUCCESS;
3012 }
3013
3014
3015 /******************************************************************************/
3016 ///Set GFX Power On
3017 ///@return GFX_SUCCESS - Success
3018 ///@return GFX_FAIL - Failure
3019 /******************************************************************************/
MApi_GFX_PowerOn(void)3020 GFX_Result MApi_GFX_PowerOn(void)
3021 {
3022 GFX_Result eRet = GFX_SUCCESS;
3023
3024 APIGFX_CHECK_INIT();
3025
3026 MS_BOOL bVal =TRUE;
3027 GFX_SETCONFIG_ARGS GFXSetConfig;
3028
3029 memset(&GFXSetConfig, 0, sizeof(GFX_SETCONFIG_ARGS));
3030
3031 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_POWERON;
3032 GFXSetConfig.pGFX_ConfigInfo =(void*)&bVal;
3033 GFXSetConfig.u32Size =sizeof(MS_BOOL);
3034
3035 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
3036 {
3037 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3038 eRet= GFX_FAIL;
3039 }
3040 return eRet;
3041 }
3042
3043
3044 /******************************************************************************/
3045 ///Set GFX Power Off
3046 ///@return GFX_SUCCESS - Success
3047 ///@return GFX_FAIL - Failure
3048 /******************************************************************************/
MApi_GFX_PowerOff(void)3049 GFX_Result MApi_GFX_PowerOff(void)
3050 {
3051 GFX_Result eRet = GFX_SUCCESS;
3052
3053 APIGFX_CHECK_INIT();
3054
3055 MS_BOOL bVal =FALSE;
3056 GFX_SETCONFIG_ARGS GFXSetConfig;
3057
3058 memset(&GFXSetConfig, 0 , sizeof(GFX_SETCONFIG_ARGS));
3059
3060 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_POWERON;
3061 GFXSetConfig.pGFX_ConfigInfo =(void*)&bVal;
3062 GFXSetConfig.u32Size =sizeof(MS_BOOL);
3063
3064 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
3065 {
3066 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3067 eRet= GFX_FAIL;
3068 }
3069
3070 return eRet;
3071 }
3072
3073 /******************************************************************************/
3074 ///Set GFX Write Protect
3075 /// @param miu \b IN: miu being procted
3076 /// @param addr_low \b IN: low address of specified area
3077 /// @param addr_high \b IN: high address of specified area
3078 /// @param eWPType \b IN: GE protect operator
3079 ///@return GFX_SUCCESS - Success
3080 ///@return GFX_FAIL - Failure
3081 /******************************************************************************/
MApi_GFX_WriteProtect(MS_U8 miu,MS_PHY addr_low,MS_PHY addr_high,GFX_WPType eWPType)3082 GFX_Result MApi_GFX_WriteProtect(MS_U8 miu,MS_PHY addr_low,MS_PHY addr_high,GFX_WPType eWPType)
3083 {
3084 GFX_Result eRet = GFX_SUCCESS;
3085
3086 APIGFX_CHECK_INIT();
3087 GFX_SETCONFIG_ARGS GFXSetConfig;
3088 GFX_Set_WriteProtect GFXSetMiuProtect;
3089
3090 memset(&GFXSetConfig, 0, sizeof(GFX_SETCONFIG_ARGS));
3091 memset(&GFXSetMiuProtect, 0 ,sizeof(GFX_Set_WriteProtect));
3092
3093 GFXSetConfig.eGFX_SetConfig =E_GFX_SET_WRITEPROTECT;
3094 GFXSetConfig.pGFX_ConfigInfo =(void*)&GFXSetMiuProtect;
3095 GFXSetConfig.u32Size =sizeof(GFX_Set_WriteProtect);
3096
3097 GFXSetMiuProtect.u8Miu =miu;
3098 GFXSetMiuProtect.u32Addr_Low =addr_low;
3099 GFXSetMiuProtect.u32Addr_High =addr_high;
3100 GFXSetMiuProtect.eWPType =eWPType;
3101
3102 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
3103 {
3104 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3105 eRet= GFX_FAIL;
3106 }
3107 return eRet;
3108 }
3109
MApi_GFX_GetAlignCaps(GFX_FmtAlignCapsInfo * pAlignCapsInfo)3110 GFX_Result MApi_GFX_GetAlignCaps(GFX_FmtAlignCapsInfo* pAlignCapsInfo)
3111 {
3112 MApi_GFX_GetGECaps(E_GFX_CAP_ALIGN,(MS_U32* )(void*)pAlignCapsInfo,sizeof(GFX_FmtAlignCapsInfo));
3113 return GFX_SUCCESS;
3114 }
3115
3116 /******************************************************************************/
3117 ///Set GFX Config
3118 /// @param enType \b IN: enType
3119 /// @param plist \b IN: plist
3120 /// @param u32Len \b IN: u32Len
3121 ///@return GFX_SUCCESS - Success
3122 ///@return GFX_FAIL - Failure
3123 /******************************************************************************/
MApi_GFX_SetConfig(EN_GFX_CONFIG_TYPE enType,void * plist,MS_U32 u32Len)3124 GFX_Result MApi_GFX_SetConfig(EN_GFX_CONFIG_TYPE enType,void *plist,MS_U32 u32Len)
3125 {
3126 GFX_Result eRet = GFX_SUCCESS;
3127
3128 APIGFX_CHECK_INIT();
3129 GFX_SETCONFIG_ARGS GFXSetConfig;
3130
3131 memset(&GFXSetConfig, 0, sizeof(GFX_SETCONFIG_ARGS));
3132 switch(enType)
3133 {
3134 case E_GFX_CONFIG_BURST_MIU_LENGTH:
3135 {
3136 if( u32Len != sizeof(GFX_Set_BurstMiuLen) )
3137 return GFX_INVALID_PARAMETERS;
3138
3139 GFXSetConfig.eGFX_SetConfig = E_GFX_SET_BURSTMIULEN;
3140 GFXSetConfig.pGFX_ConfigInfo = plist;
3141 GFXSetConfig.u32Size = u32Len;
3142 break;
3143 }
3144 default:
3145 return GFX_INVALID_PARAMETERS;
3146 }
3147
3148 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_SET_CONFIG, (void*)&GFXSetConfig) != UTOPIA_STATUS_SUCCESS)
3149 {
3150 printf("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3151 eRet= GFX_FAIL;
3152 }
3153 return eRet;
3154 }
3155
MApi_GFX_GetConfig(EN_GFX_CONFIG_INIT enType,void * plist,MS_U32 u32Len)3156 GFX_Result MApi_GFX_GetConfig(EN_GFX_CONFIG_INIT enType,void *plist,MS_U32 u32Len)
3157 {
3158 GFX_Result eRet = GFX_SUCCESS;
3159 GFX_GETCONFIG_ARGS GFXGetConfig;
3160
3161 if(NULL == pGEInstance)
3162 {
3163 if(UtopiaOpen(MODULE_GFX | GFXDRIVER_BASE, &pGEInstance, 0, NULL))
3164 {
3165 GFX_ERR("%s fail [LINE:%d] GFXOpen Fail\n",__FUNCTION__, __LINE__);
3166 return GFX_FAIL;
3167 }
3168 }
3169 memset(&GFXGetConfig, 0, sizeof(GFX_GETCONFIG_ARGS));
3170 switch(enType)
3171 {
3172 case E_GFX_CONFIG_INIT:
3173 {
3174 if( u32Len != sizeof(GFX_GETCONFIG_ARGS) )
3175 return GFX_INVALID_PARAMETERS;
3176
3177 GFXGetConfig.eGFX_GetConfig = E_GFX_GET_INIT;
3178 GFXGetConfig.pGFX_ConfigInfo = plist;
3179 GFXGetConfig.u32Size = u32Len;
3180 break;
3181 }
3182 default:
3183 return GFX_INVALID_PARAMETERS;
3184 }
3185
3186 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_GET_CONFIG, (void*)&GFXGetConfig) != UTOPIA_STATUS_SUCCESS)
3187 {
3188 printf("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3189 return GFX_FAIL;
3190 }
3191
3192 return eRet;
3193 }
3194
3195 //-------------------------------------------------------------------------------------------------
3196 /// GE Exit
3197 /// @param void \b IN: none
3198 //-------------------------------------------------------------------------------------------------
MApi_GE_Exit(void)3199 void MApi_GE_Exit(void)
3200 {
3201
3202 GFX_MISC_ARGS GFXInfo;
3203 MS_U32 value = 0;
3204 memset(&GFXInfo, 0, sizeof(GFX_MISC_ARGS));
3205
3206 GFXInfo.eGFX_MISCType = E_MISC_EXIT;
3207 GFXInfo.pGFX_Info = (void*)&value;
3208 GFXInfo.u32Size = sizeof(GFX_MISC_ARGS);
3209
3210 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_MISC, (void*)&GFXInfo) != UTOPIA_STATUS_SUCCESS)
3211 {
3212 GFX_DBUG("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3213 }
3214 }
3215
MApi_GFX_GetGECaps(EN_GFX_CAPS eCapType,MS_U32 * pRet,MS_U32 ret_size)3216 GFX_Result MApi_GFX_GetGECaps(EN_GFX_CAPS eCapType, MS_U32* pRet, MS_U32 ret_size)
3217 {
3218 GFX_Result eRet = GFX_SUCCESS;
3219
3220 if(pRet ==NULL)
3221 {
3222 return GFX_FAIL;
3223 }
3224
3225 APIGFX_CHECK_INIT();
3226
3227 GFX_GETCAPS_ARGS GFXGetCaps;
3228 GFX_Get_CAPS GetCaps;
3229
3230 memset(&GFXGetCaps, 0 ,sizeof(GFX_GETCAPS_ARGS));
3231 memset(&GetCaps, 0 ,sizeof(GFX_Get_CAPS));
3232
3233 GFXGetCaps.eCaps = eCapType;
3234 GFXGetCaps.pGFX_GetCaps =(void*)&GetCaps;
3235 GFXGetCaps.u32Size =sizeof(GFX_Get_CAPS);
3236
3237 GetCaps.eCapType =eCapType;
3238 GetCaps.pRet =pRet;
3239 GetCaps.Ret_Size =ret_size;
3240
3241 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_GET_CAPS, (void*)&GFXGetCaps) != UTOPIA_STATUS_SUCCESS)
3242 {
3243 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3244 eRet = GFX_FAIL;
3245 }
3246
3247 return eRet;
3248 }
3249
3250 /// Wrapper ///
3251
3252 #if 1
3253
3254 /******************************************************************************/
3255 ///Wrapper of MApi_GFX_ClearFrameBuffer for backward compatibility.
3256 ///Please see MApi_GFX_ClearFrameBuffer section for detail.
3257 /******************************************************************************/
MDrv_GE_ClearFrameBuffer(MS_PHY StrAddr,MS_U32 length,MS_U8 ClearValue)3258 void MDrv_GE_ClearFrameBuffer( MS_PHY StrAddr, MS_U32 length, MS_U8 ClearValue) //jupiter no miu
3259 {
3260 MApi_GFX_ClearFrameBuffer( StrAddr, length, ClearValue);
3261 }
3262 #endif
3263
3264 /******************************************************************************/
3265 ///Wrapper of MApi_GFX_SetPaletteOpt for backward compatibility.
3266 ///Please see MApi_GFX_SetPaletteOpt section for detail.
3267 /******************************************************************************/
MDrv_GE_SetPaletteOpt(GFX_PaletteEntry * pPalArray,MS_U16 u32PalStart,MS_U16 u32PalEnd)3268 void MDrv_GE_SetPaletteOpt( GFX_PaletteEntry *pPalArray, MS_U16 u32PalStart, MS_U16 u32PalEnd)
3269 {
3270 MApi_GFX_SetPaletteOpt( pPalArray, u32PalStart, u32PalEnd);
3271 }
3272
3273
3274 /******************************************************************************/
3275 ///Wrapper of MApi_GFX_SetAlpha for backward compatibility.
3276 ///Please see MApi_GFX_SetAlpha section for detail.
3277 /******************************************************************************/
MDrv_GE_SetAlpha(MS_BOOL enable,MS_U8 coef,MS_U8 db_abl,MS_U8 abl_const)3278 void MDrv_GE_SetAlpha(MS_BOOL enable, MS_U8 coef, MS_U8 db_abl, MS_U8 abl_const)
3279 {
3280 MApi_GFX_SetAlpha(enable, (GFX_BlendCoef)coef, (GFX_AlphaSrcFrom)db_abl, abl_const); // DANGER
3281 }
3282
3283 /******************************************************************************/
3284 ///Wrapper of MApi_GFX_SetPatchMode for backward compatibility.
3285 ///Please see MApi_GFX_SetPatchMode section for detail.
3286 /******************************************************************************/
MDrv_GE_SetPatchMode(MS_BOOL repeat)3287 void MDrv_GE_SetPatchMode(MS_BOOL repeat)
3288 {
3289 MApi_GFX_SetPatchMode(repeat);
3290 }
3291
3292 /******************************************************************************/
3293 ///Wrapper of MApi_GFX_SetNearestMode for backward compatibility.
3294 ///Please see MApi_GFX_SetNearestMode section for detail.
3295 /******************************************************************************/
MDrv_GE_SetNearestMode(MS_BOOL enable)3296 void MDrv_GE_SetNearestMode(MS_BOOL enable)
3297 {
3298 MApi_GFX_SetNearestMode(enable);
3299 }
3300
3301 /******************************************************************************/
3302 ///Wrapper of MApi_GFX_EnableAlphaBlending for backward compatibility.
3303 ///Please see MApi_GFX_EnableAlphaBlending section for detail.
3304 /******************************************************************************/
MDrv_GE_EnableAlphaBlending(MS_BOOL enable)3305 GFX_Result MDrv_GE_EnableAlphaBlending(MS_BOOL enable)
3306 {
3307 APIGFX_CHECK_INIT();
3308
3309 return MApi_GFX_EnableAlphaBlending(enable);
3310 }
3311
3312 /******************************************************************************/
3313 ///Wrapper of MApi_GFX_SetAlphaBlending for backward compatibility.
3314 ///Please see MApi_GFX_SetAlphaBlending section for detail.
3315 /******************************************************************************/
MDrv_GE_SetAlphaBlending(GFX_BlendCoef blendcoef,MS_U8 u8ConstantAlpha)3316 GFX_Result MDrv_GE_SetAlphaBlending(GFX_BlendCoef blendcoef, MS_U8 u8ConstantAlpha)
3317 {
3318 APIGFX_CHECK_INIT();
3319
3320 return MApi_GFX_SetAlphaBlending( blendcoef, u8ConstantAlpha); // DANGER
3321 }
3322
3323 /******************************************************************************/
3324 ///Wrapper of MApi_GFX_ClearFrameBufferByWord for backward compatibility.
3325 ///Please see MApi_GFX_ClearFrameBufferByWord section for detail.
3326 /******************************************************************************/
msAPI_GE_ClearFrameBufferByWord(MS_PHY StrAddr,MS_U32 length,MS_U32 ClearValue)3327 void msAPI_GE_ClearFrameBufferByWord (MS_PHY StrAddr, MS_U32 length, MS_U32 ClearValue)
3328 {
3329 MApi_GFX_ClearFrameBufferByWord( StrAddr, length, ClearValue);
3330 }
3331
3332
3333 /******************************************************************************/
3334 ///Wrapper of MApi_GFX_SetIntensity for backward compatibility.
3335 ///Please see MApi_GFX_SetIntensity section for detail.
3336 /******************************************************************************/
MDrv_GE_PE_SetIntensity(MS_U8 id,GFX_Buffer_Format fmt,MS_U32 * pcolor)3337 void MDrv_GE_PE_SetIntensity(MS_U8 id, GFX_Buffer_Format fmt, MS_U32* pcolor)
3338 {
3339 MApi_GFX_SetIntensity( id, fmt, pcolor);
3340 }
3341
3342 /******************************************************************************/
3343 ///GFX STR Mode
3344 /******************************************************************************/
MApi_GFX_SetPowerState(EN_POWER_MODE u16PowerState)3345 MS_U32 MApi_GFX_SetPowerState(EN_POWER_MODE u16PowerState)
3346 {
3347 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
3348 APIGFX_CHECK_INIT();
3349
3350 GFX_POWERSTATE_ARGS pGFXPowerStateArg;
3351
3352 memset(&pGFXPowerStateArg, 0 , sizeof(GFX_POWERSTATE_ARGS));
3353 pGFXPowerStateArg.eGFX_PowerStateType = u16PowerState;
3354
3355 if(UtopiaIoctl(pGEInstance, MAPI_CMD_GFX_POWERSTATE, (void*)&pGFXPowerStateArg) != UTOPIA_STATUS_SUCCESS)
3356 {
3357 GFX_ERR("%s fail [LINE:%d]\n",__FUNCTION__, __LINE__);
3358 u32Return= UTOPIA_STATUS_FAIL;
3359 }
3360 else
3361 {
3362 u32Return= UTOPIA_STATUS_SUCCESS;
3363 }
3364
3365 return u32Return;
3366
3367 }
3368 #endif
3369
3370 EXPORT_SYMBOL(MApi_GFX_Init);
3371 EXPORT_SYMBOL(MApi_GFX_SetDFBBldOP);
3372 EXPORT_SYMBOL(MApi_GFX_SetRotate);
3373 EXPORT_SYMBOL(MApi_GFX_SetSrcColorKey);
3374 EXPORT_SYMBOL(MApi_GFX_SetDC_CSC_FMT);
3375 EXPORT_SYMBOL(MApi_GFX_SetSrcBufferInfo);
3376 EXPORT_SYMBOL(MApi_GFX_SetDstBufferInfo);
3377 EXPORT_SYMBOL(MApi_GFX_EndDraw);
3378 EXPORT_SYMBOL(MApi_GFX_SetClip);
3379 EXPORT_SYMBOL(MApi_GFX_SetMirror);
3380 EXPORT_SYMBOL(MApi_GFX_EnableAlphaBlending);
3381 EXPORT_SYMBOL(MApi_GFX_WaitForTAGID);
3382 EXPORT_SYMBOL(MApi_GFX_BeginDraw);
3383 EXPORT_SYMBOL(MApi_GFX_EnableDFBBlending);
3384 EXPORT_SYMBOL(MApi_GFX_BitBlt);
3385 EXPORT_SYMBOL(MApi_GFX_SetROP2);
3386 EXPORT_SYMBOL(MApi_GFX_RectFill);
3387 EXPORT_SYMBOL(MApi_GFX_SetDstColorKey);
3388 EXPORT_SYMBOL(MApi_GFX_SetNextTAGID);
3389 EXPORT_SYMBOL(MApi_GFX_PollingTAGID);
3390 EXPORT_SYMBOL(MApi_GFX_EnableVCmdQueue);
3391 EXPORT_SYMBOL(MApi_GFX_SetVCmdBuffer);
3392