1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file apiXC_Adc.c
98 /// brief Scaler API layer Interface
99 /// author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 #ifndef _API_XC_DWIN_C_
103 #define _API_XC_DWIN_C_
104 #endif
105 //-------------------------------------------------------------------------------------------------
106 // Include Files
107 //-------------------------------------------------------------------------------------------------
108 // Common Definition
109 #ifdef MSOS_TYPE_LINUX_KERNEL
110 #include <linux/string.h>
111 #include <linux/slab.h>
112 #else
113 #include <string.h>
114 #endif
115 #include "MsCommon.h"
116 #include "MsOS.h"
117 #ifdef UTOPIA_V2
118 #include "utopia.h"
119 #include "utopia_driver_id.h"
120 #include "apiXC_DWIN_v2.h"
121 #endif
122 #include "drvXC_IOPort.h"
123 #include "apiXC.h"
124 #include "apiXC_DWIN.h"
125 #include "mvideo_context.h"
126 #include "drv_sc_DIP_scaling.h"
127 #include "mhal_dip.h"
128 #ifdef GOPD_DIP
129 #include "apiGOP.h"
130 #ifdef MSOS_TYPE_LINUX
131 #include <pthread.h>
132 #endif
133 #endif
134
135 // Internal Definition
136
137 //-------------------------------------------------------------------------------------------------
138 // Driver Compiler Options
139 //-------------------------------------------------------------------------------------------------
140
141
142 //-------------------------------------------------------------------------------------------------
143 // Local Defines
144 //-------------------------------------------------------------------------------------------------
145 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL)
146 #ifndef DIP_UTOPIA2K
147 #define DIP_UTOPIA2K
148 #endif
149 #endif
150
151 #ifndef UNUSED
152 #define UNUSED(x) ((x)=(x))
153 #endif
154 //#define TRACE_ADC_INPUT(x) //x
155 #define msg_video(x) //x
156
157 #define DIPDRIVER_BASE 0
158 //-------------------------------------------------------------------------------------------------
159 // Local Structurs
160 //-------------------------------------------------------------------------------------------------
161
162
163 //-------------------------------------------------------------------------------------------------
164 // Global Variables
165 //-------------------------------------------------------------------------------------------------
166 #ifdef UTOPIA_V2
167 void* pInstantDip[MAX_DIP_WINDOW] = {NULL};
168 #endif
169 //-------------------------------------------------------------------------------------------------
170 // Local Variables
171 //-------------------------------------------------------------------------------------------------
172 //MS_XC_MEM_FMT s_DIPeMemFmt[MAX_WINDOW] = {E_MS_XC_MEM_FMT_AUTO, E_MS_XC_MEM_FMT_AUTO};
173 #ifdef GOPD_DIP
174 GOP_DwinProperty GopD_property;
175 EN_XC_DIP_DATA_FMT DataFmt = DIP_DATA_FMT_YUV422;
176 extern SCALER_DIP_WIN Gopd_dip;
177 static InterruptCb pGopd_CB;
178 #ifdef MSOS_TYPE_LINUX
179 #define FRAME_DELAY 15
180 static MS_BOOL bDeAttached = TRUE;
181 static pthread_t id;
182 #endif
183 #endif
184
185 //-------------------------------------------------------------------------------------------------
186 // Debug Functions
187 //-------------------------------------------------------------------------------------------------
188
189 //-------------------------------------------------------------------------------------------------
190 // Local Functions
191 //-------------------------------------------------------------------------------------------------
192
193 /////////////////////////////////////////
194 // Configuration
195 /////////////////////////////////////////
196 #if 0
197 // Path
198 typedef struct s_Data_Path
199 {
200
201 //////////////////////////////
202 // Path Type
203 //////////////////////////////
204 E_PATH_TYPE e_PathType;
205
206 //////////////////////////////
207 // Path Status
208 //////////////////////////////
209
210 /*
211 Make the signal go through the path. If this flag is not enabled,
212 synchronous_event_handler and source_monitor are useless.
213 */
214 #define DATA_PATH_ENABLE BIT(0)
215
216 /*
217 Used to identify a path is created or not. ( 1: path created )
218 */
219 #define DATA_PATH_USING BIT(1)
220
221 /*
222 Used to identify the priodic handler enabled or disabled
223 */
224 #define ENABLE_PERIODIC_HANDLER BIT(2)
225
226 MS_U8 u8PathStatus;
227
228 //////////////////////////////
229 // A path has a format like Src -> Dest
230 //////////////////////////////
231 INPUT_SOURCE_TYPE_t src;
232 E_DEST_TYPE dest;
233
234 //////////////////////////////
235 // thread for source.
236 //////////////////////////////
237 void (*path_thread)(INPUT_SOURCE_TYPE_t src, MS_BOOL bRealTimeMonitorOnly);
238
239 ///////////////////////////////////////
240 // Customize function.
241 // This will be executed automatically when synchronous event triggered.
242 ///////////////////////////////////////
243 void (* synchronous_event_handler )(INPUT_SOURCE_TYPE_t src, void* para);
244
245 ///////////////////////////////////////
246 // Customize function.
247 // This will be executed automatically when destination on/off event triggered.
248 ///////////////////////////////////////
249 void (* dest_on_off_event_handler )(INPUT_SOURCE_TYPE_t src, void* para);
250
251 ///////////////////////////////////////
252 // Customize function.
253 // This will be executed periodically after enabled destinatio period handler
254 ///////////////////////////////////////
255 void (* dest_periodic_handler )(INPUT_SOURCE_TYPE_t src, MS_BOOL bRealTimeMonitorOnly);
256 }MUX_DATA_PATH;
257 #endif
258
259 #if 0
260 // Path Collection
261 typedef struct s_Mux_InputSource_Attr
262 {
263 // The number of pathes which is used right now.
264 MS_U8 u8PathCount;
265
266 void (*input_source_to_input_port)(INPUT_SOURCE_TYPE_t src_ids , E_MUX_INPUTPORT* port_ids , MS_U8* u8port_count );
267 // Pathes.
268 // Path array in MAPP_MUX is constructed [Sync path, Sync path, ..., Async path, Async path]
269 MUX_DATA_PATH Mux_DataPaths[MAX_DATA_PATH_SUPPORTED];
270
271 // indicate how many times the src created
272 MS_U16 u16SrcCreateTime[INPUT_SOURCE_NUM];
273 }InputSource_Mux_Attr;
274
275 #endif
MApi_XC_DIP_QueryResource(SCALER_DIP_WIN eWindow)276 E_APIXC_ReturnValue MApi_XC_DIP_QueryResource(SCALER_DIP_WIN eWindow)
277 {
278 #ifndef DISABLE_DIP_FUNCTION
279
280 #ifdef UTOPIA_V2
281 DIP_RESOURCE* pResource = NULL;
282 pResource = (DIP_RESOURCE*)utopia_malloc(sizeof(DIP_RESOURCE));
283 if (pResource == NULL)
284 {
285 XC_ERR("%s alloc fail\n",__FUNCTION__);
286 return E_APIXC_RET_FAIL;
287 }
288 if(pInstantDip[eWindow] == NULL)
289 {
290 if(UtopiaOpen(MODULE_DIP|DIPDRIVER_BASE,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
291 {
292 XC_ERR("Open DIP fail\n");
293 utopia_free(pResource);
294 return E_APIXC_RET_FAIL;
295 }
296 }
297 //Query Resource
298 pResource->eWindow = eWindow;
299 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_QUERY_RESOURCE,(void* )pResource) == UTOPIA_STATUS_NO_RESOURCE)
300 {
301 utopia_free(pResource);
302 return E_APIXC_RET_FAIL;
303 }
304 utopia_free(pResource);
305 #else
306
307 #endif
308 return E_APIXC_RET_OK;
309 #else
310 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
311 #endif
312
313 }
314
MApi_XC_DIP_GetResource(SCALER_DIP_WIN eWindow)315 E_APIXC_ReturnValue MApi_XC_DIP_GetResource(SCALER_DIP_WIN eWindow)
316 {
317 #ifndef DISABLE_DIP_FUNCTION
318
319 #ifdef UTOPIA_V2
320 DIP_RESOURCE* pResource = NULL;
321 pResource = (DIP_RESOURCE*)utopia_malloc(sizeof(DIP_RESOURCE));
322 if (pResource == NULL)
323 {
324 XC_ERR("%s alloc fail\n",__FUNCTION__);
325 return E_APIXC_RET_FAIL;
326 }
327 if(pInstantDip[eWindow] == NULL)
328 {
329 if(UtopiaOpen(MODULE_DIP|DIPDRIVER_BASE,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
330 {
331 XC_ERR("Open DIP fail\n");
332 utopia_free(pResource);
333 return E_APIXC_RET_FAIL;
334 }
335 }
336 //Get Resource
337 pResource->eWindow = eWindow;
338 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_GET_RESOURCE,(void*)pResource) != UTOPIA_STATUS_SUCCESS)
339 {
340 XC_ERR("Ioctl MDrv_CMD_DIP_GET_RESOURCE fail\n");
341 utopia_free(pResource);
342 return E_APIXC_RET_FAIL;
343 }
344 utopia_free(pResource);
345 #else
346
347 #endif
348 return E_APIXC_RET_OK;
349 #else
350 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
351 #endif
352 }
353
MApi_XC_DIP_ReleaseResource(SCALER_DIP_WIN eWindow)354 E_APIXC_ReturnValue MApi_XC_DIP_ReleaseResource(SCALER_DIP_WIN eWindow)
355 {
356 #ifndef DISABLE_DIP_FUNCTION
357
358 #ifdef UTOPIA_V2
359 DIP_RESOURCE* pResource = NULL;
360 pResource = (DIP_RESOURCE*)utopia_malloc(sizeof(DIP_RESOURCE));
361 if (pResource == NULL)
362 {
363 XC_ERR("%s alloc fail\n",__FUNCTION__);
364 return E_APIXC_RET_FAIL;
365 }
366 if(pInstantDip[eWindow] == NULL)
367 {
368 if(UtopiaOpen(MODULE_DIP|DIPDRIVER_BASE,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
369 {
370 XC_ERR("Open DIP fail\n");
371 utopia_free(pResource);
372 return E_APIXC_RET_FAIL;
373 }
374 }
375 //Free Resource
376 pResource->eWindow = eWindow;
377 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_RELEASE_RESOURCE,(void*)pResource) != UTOPIA_STATUS_SUCCESS)
378 {
379 XC_ERR("Ioctl MDrv_CMD_DIP_GET_RESOURCE fail\n");
380 utopia_free(pResource);
381 return E_APIXC_RET_FAIL;
382 }
383 utopia_free(pResource);
384 #else
385
386 #endif
387 return E_APIXC_RET_OK;
388 #else
389 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
390 #endif
391
392 }
393
MApi_XC_DIP_CMDQ_SetAction(EN_XC_DIP_CMDQ_ACTION eAction,SCALER_DIP_WIN eWindow)394 E_APIXC_ReturnValue MApi_XC_DIP_CMDQ_SetAction(EN_XC_DIP_CMDQ_ACTION eAction, SCALER_DIP_WIN eWindow)
395 {
396 #ifndef DISABLE_DIP_FUNCTION
397
398 #ifdef UTOPIA_V2
399 DIP_CMDQ_SET_ACTION* pResource = NULL;
400 pResource = (DIP_CMDQ_SET_ACTION*)utopia_malloc(sizeof(DIP_CMDQ_SET_ACTION));
401 if (pResource == NULL)
402 {
403 printf("%s alloc fail\n",__FUNCTION__);
404 return E_APIXC_RET_FAIL;
405 }
406
407 if(pInstantDip[eWindow] == NULL)
408 {
409 if(UtopiaOpen(MODULE_DIP,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
410 {
411 printf("Open DIP fail\n");
412 utopia_free(pResource);
413 return E_APIXC_RET_FAIL;
414 }
415 }
416
417 pResource->eWindow = eWindow;
418 pResource->eAction = eAction;
419 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_CMDQ_SETACTION,(void*)pResource) != UTOPIA_STATUS_SUCCESS)
420 {
421 printf("Ioctl MDrv_CMD_DIP_GET_RESOURCE fail\n");
422 utopia_free(pResource);
423 return E_APIXC_RET_FAIL;
424 }
425 utopia_free(pResource);
426 #else
427 MDrv_XC_DIP_CMDQ_SetAction(NULL, eAction, eWindow);
428 #endif
429 return E_APIXC_RET_OK;
430 #else
431 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
432 #endif
433
434 }
MApi_XC_DIP_CMDQ_SetOperations(cmd_mload_utopia_interface * pOps,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)435 E_APIXC_ReturnValue MApi_XC_DIP_CMDQ_SetOperations(cmd_mload_utopia_interface *pOps, MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
436 {
437 #ifndef DISABLE_DIP_FUNCTION
438
439 #ifdef UTOPIA_V2
440 DIP_CMDQ_SET_OPERATIONS* pResource = NULL;
441 pResource = (DIP_CMDQ_SET_OPERATIONS*)utopia_malloc(sizeof(DIP_CMDQ_SET_OPERATIONS));
442 if (pResource == NULL)
443 {
444 printf("%s alloc fail\n",__FUNCTION__);
445 return E_APIXC_RET_FAIL;
446 }
447
448 if(pInstantDip[eWindow] == NULL)
449 {
450 if(UtopiaOpen(MODULE_DIP,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
451 {
452 printf("Open DIP fail\n");
453 utopia_free(pResource);
454 return E_APIXC_RET_FAIL;
455 }
456 }
457
458 pResource->pOps = pOps;
459 pResource->bEnable = bEnable;
460 pResource->eWindow = eWindow;
461 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_CMDQ_SETOPERATIONS,(void*)pResource) != UTOPIA_STATUS_SUCCESS)
462 {
463 printf("Ioctl MDrv_CMD_DIP_GET_RESOURCE fail\n");
464 utopia_free(pResource);
465 return E_APIXC_RET_FAIL;
466 }
467 utopia_free(pResource);
468 #else
469 //MDrv_XC_DIP_CMDQ_SetAction(NULL, eAction, eWindow);
470 MDrv_XC_DIP_CMDQ_SetOperations(NULL, pOps, bEnable, eWindow);
471 #endif
472 return E_APIXC_RET_OK;
473 #else
474 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
475 #endif
476 }
477
478 //MS_BOOL PreScaling = FALSE;
479 //-------------------------------------------------------------------------------------------------
480 /// Reset DIP for restart capture from buffer 0
481 /// @return E_APIXC_RET_OK - Success
482 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SWReset(SCALER_DIP_WIN eWindow)483 E_APIXC_ReturnValue MApi_XC_DIP_SWReset(SCALER_DIP_WIN eWindow)
484 {
485 #ifndef DISABLE_DIP_FUNCTION
486
487 #ifdef UTOPIA_V2
488 DIP_TRIGGER_MODE* pTrigMode = NULL;
489
490 #ifdef GOPD_DIP
491 if(eWindow == Gopd_dip){
492 return E_APIXC_RET_OK;
493 }
494 #endif
495 if(pInstantDip[eWindow] == NULL)
496 {
497 XC_ERR("DIP not Opened\n");
498 return E_APIXC_RET_FAIL;
499 }
500
501 pTrigMode = (DIP_TRIGGER_MODE*)utopia_malloc(sizeof(DIP_TRIGGER_MODE));
502 if (pTrigMode == NULL)
503 {
504 XC_ERR("%s alloc fail\n",__FUNCTION__);
505 return E_APIXC_RET_FAIL;
506 }
507 pTrigMode->eTrigMode = DIP_TRIG_RESET;
508 pTrigMode->eWindow = eWindow;
509 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_TRIGGER,(void*)pTrigMode) != UTOPIA_STATUS_SUCCESS)
510 {
511 XC_ERR("Ioctl MDrv_CMD_DIP_TRIGGER DIP_TRIG_RESET fail\n");
512 utopia_free(pTrigMode);
513 return E_APIXC_RET_FAIL;
514 }
515 utopia_free(pTrigMode);
516 #else
517 MDrv_XC_DIP_SWReset(NULL,eWindow);
518 #endif
519 return E_APIXC_RET_OK;
520 #else
521 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
522 #endif
523
524 }
525
526
527 //-------------------------------------------------------------------------------------------------
528 /// Init the status for DIP path
529 /// @return E_APIXC_RET_OK - Success
530 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_InitByDIP(SCALER_DIP_WIN eWindow)531 E_APIXC_ReturnValue MApi_XC_DIP_InitByDIP(SCALER_DIP_WIN eWindow)
532 {
533 #ifndef DISABLE_DIP_FUNCTION
534
535 #ifdef UTOPIA_V2
536 DIP_RESOURCE* pResource = NULL;
537 #ifdef GOPD_DIP
538 if(eWindow == Gopd_dip){
539 MApi_GOP_DWIN_Init();
540 return E_APIXC_RET_OK;
541 }
542 #endif
543 pResource = (DIP_RESOURCE*)utopia_malloc(sizeof(DIP_RESOURCE));
544 if (pResource == NULL)
545 {
546 XC_ERR("%s alloc fail\n",__FUNCTION__);
547 return E_APIXC_RET_FAIL;
548 }
549 if(pInstantDip[eWindow] == NULL)
550 {
551 if(UtopiaOpen(MODULE_DIP|DIPDRIVER_BASE,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
552 {
553 XC_ERR("Open DIP fail\n");
554 utopia_free(pResource);
555 return E_APIXC_RET_FAIL;
556 }
557 }
558 //init
559 pResource->eWindow = eWindow;
560 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_INIT,(void*)pResource) != UTOPIA_STATUS_SUCCESS)
561 {
562 XC_ERR("Ioctl MDrv_CMD_DIP_INIT fail\n");
563 utopia_free(pResource);
564 return E_APIXC_RET_FAIL;
565 }
566
567 utopia_free(pResource);
568 #else
569 MDrv_XC_DIP_Init(NULL,eWindow);
570 #endif
571 return E_APIXC_RET_OK;
572 #else
573 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
574 #endif
575
576 }
577
578 //-------------------------------------------------------------------------------------------------
579 ///Set the frame buffer address for specific window
580 /// @param u32FBAddress \b IN: the frame buffer address
581 /// @param u32FBSize \b IN: the frame buffer size
582 /// @param eWindow \b IN: set address for which window(DIP_WINDOW)
583 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetFrameBufferAddress(MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_DIP_WIN eWindow)584 E_APIXC_ReturnValue MApi_XC_DIP_SetFrameBufferAddress(MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_DIP_WIN eWindow)
585 {
586 #ifndef DISABLE_DIP_FUNCTION
587
588 #ifdef UTOPIA_V2
589
590 #else
591 MDrv_XC_DWIN_Disable_IPM_ReadWriteRequest(NULL,DISABLE, eWindow);
592 MDrv_XC_DWIN_SetFrameBufferAddress(NULL,u32FBAddress, u32FBSize, eWindow);
593 #endif
594 return E_APIXC_RET_OK;
595 #else
596 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
597 #endif
598
599 }
600
601 //******************************************************************************
602 /// API for specify input source type for DIP path
603 /// @param enInputSourceType \b IN: the inputsource type
604 /// @param eWindow \b IN: for which window(DIP_WINDOW)
605 /// @return E_APIXC_RET_OK - Success
606 //******************************************************************************
MApi_XC_DIP_SetInputSource(INPUT_SOURCE_TYPE_t enInputSourceType,SCALER_DIP_WIN eWindow)607 E_APIXC_ReturnValue MApi_XC_DIP_SetInputSource(INPUT_SOURCE_TYPE_t enInputSourceType, SCALER_DIP_WIN eWindow)
608 {
609 #ifndef DISABLE_DIP_FUNCTION
610
611 #ifdef UTOPIA_V2
612
613 #else
614 MDrv_XC_DWIN_SetInputSource(NULL,enInputSourceType, eWindow);
615 #endif
616 return E_APIXC_RET_OK;
617 #else
618 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
619 #endif
620
621 }
622
623 //******************************************************************************
624 /// API for get input source type for DIP path
625 /// @param enInputSourceType \b OUT: the inputsource type
626 /// @param eWindow \b IN: for which window(DIP_WINDOW)
627 /// @return E_APIXC_RET_OK - Success
628 //******************************************************************************
MApi_XC_DIP_GetInputSource(INPUT_SOURCE_TYPE_t * enInputSourceType,SCALER_DIP_WIN eWindow)629 E_APIXC_ReturnValue MApi_XC_DIP_GetInputSource(INPUT_SOURCE_TYPE_t *enInputSourceType, SCALER_DIP_WIN eWindow)
630 {
631 #ifndef DISABLE_DIP_FUNCTION
632
633 #ifdef UTOPIA_V2
634
635 #else
636 MDrv_XC_DWIN_GetInputSource(NULL,enInputSourceType,eWindow);
637 #endif
638 return E_APIXC_RET_OK;
639 #else
640 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
641 #endif
642
643 }
644
645 //******************************************************************************
646 /// API for enable or disable input source for DIP path
647 /// @param bEnable \b IN: enable or disable inputsource
648 /// @param eWindow \b IN: for which window(DIP_WINDOW)
649 /// @return E_APIXC_RET_OK - Success
650 //******************************************************************************
MApi_XC_DIP_DisableInputSource(MS_BOOL bDisable,SCALER_DIP_WIN eWindow)651 E_APIXC_ReturnValue MApi_XC_DIP_DisableInputSource(MS_BOOL bDisable, SCALER_DIP_WIN eWindow)
652 {
653 #ifndef DISABLE_DIP_FUNCTION
654
655 #ifdef UTOPIA_V2
656
657 #else
658 MDrv_XC_DWIN_DisableInputSource(NULL,bDisable, eWindow);
659 #endif
660 return E_APIXC_RET_OK;
661 #else
662 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
663 #endif
664
665 }
666
667 //-------------------------------------------------------------------------------------------------
668 /// Set the specific window
669 /// @param pstXC_SetWin_Info \b IN: the information of the window setting
670 /// @param u32InitDataLen \b IN: the length of the pstXC_SetWin_Info
671 /// @param eWindow \b IN: which window we are going to set
672 /// @return @ref E_APIXC_ReturnValue
673 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetWindow(XC_SETWIN_INFO * pstXC_SetWin_Info,MS_U32 u32InitDataLen,SCALER_DIP_WIN eWindow)674 E_APIXC_ReturnValue MApi_XC_DIP_SetWindow(XC_SETWIN_INFO *pstXC_SetWin_Info, MS_U32 u32InitDataLen, SCALER_DIP_WIN eWindow)
675 {
676 #ifndef DISABLE_DIP_FUNCTION
677
678 #ifdef UTOPIA_V2
679 DIP_SET_WINDOW* pSetWindow = NULL;
680
681 #ifdef GOPD_DIP
682 if(eWindow == Gopd_dip){
683 GopD_property.u16x = pstXC_SetWin_Info->stCapWin.x;
684 GopD_property.u16y = pstXC_SetWin_Info->stCapWin.y;
685 if( pstXC_SetWin_Info->u16PreHCusScalingSrc != pstXC_SetWin_Info->u16PreHCusScalingDst ){
686 XC_ERR("eWindow[%d] doesnt support Hscaling src[%d] dst[%d]\n",eWindow,pstXC_SetWin_Info->u16PreHCusScalingSrc,pstXC_SetWin_Info->u16PreHCusScalingDst);
687 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
688 }
689 if( pstXC_SetWin_Info->u16PreVCusScalingSrc != pstXC_SetWin_Info->u16PreVCusScalingDst ){
690 XC_ERR("eWindow[%d] doesnt support Vscaling src[%d] dst[%d]\n",eWindow,pstXC_SetWin_Info->u16PreVCusScalingSrc,pstXC_SetWin_Info->u16PreVCusScalingDst);
691 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
692 }
693 return E_APIXC_RET_OK;
694 }
695 #endif
696 if(pInstantDip[eWindow] == NULL)
697 {
698 XC_ERR("DIP not Opened\n");
699 return E_APIXC_RET_FAIL;
700 }
701 pSetWindow = (DIP_SET_WINDOW*)utopia_malloc(sizeof(DIP_SET_WINDOW));
702 if (pSetWindow == NULL)
703 {
704 XC_ERR("%s alloc fail\n",__FUNCTION__);
705 return E_APIXC_RET_FAIL;
706 }
707 pSetWindow->u32DataLen = u32InitDataLen;
708 memcpy(&(pSetWindow->WinInfo),pstXC_SetWin_Info, sizeof(XC_SETWIN_INFO));
709 pSetWindow->eWindow = eWindow;
710 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_WINDOW,(void*)pSetWindow) != UTOPIA_STATUS_SUCCESS)
711 {
712 XC_ERR("Ioctl MDrv_CMD_DIP_SET_WINDOW fail\n");
713 utopia_free(pSetWindow);
714 return E_APIXC_RET_FAIL;
715 }
716 pstXC_SetWin_Info->u16PreHCusScalingDst=pSetWindow->WinInfo.u16PreHCusScalingDst;
717 utopia_free(pSetWindow);
718
719 return E_APIXC_RET_OK;
720 #else
721 MDrv_XC_DIP_SetWindow(NULL,pstXC_SetWin_Info,u32InitDataLen,eWindow);
722 #endif
723 return E_APIXC_RET_OK;
724 #else
725 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
726 #endif
727
728 }
729
730 //******************************************************************************
731 /// API to get DE window for DIP path
732 /// @param psWin \b OUT: the DE window info to get
733 /// @param eWindow \b IN: for which window(DIP_WINDOW)
734 /// @return E_APIXC_RET_OK - Success
735 //******************************************************************************
MApi_XC_DIP_GetDEWindow(MS_WINDOW_TYPE * psWin,SCALER_DIP_WIN eWindow)736 E_APIXC_ReturnValue MApi_XC_DIP_GetDEWindow(MS_WINDOW_TYPE *psWin, SCALER_DIP_WIN eWindow)
737 {
738 #ifndef DISABLE_DIP_FUNCTION
739
740 #ifdef UTOPIA_V2
741
742 #else
743 MDrv_XC_DWIN_get_DE_Window(NULL,psWin, eWindow);
744 #endif
745 return E_APIXC_RET_OK;
746 #else
747 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
748 #endif
749
750 }
751
752 //---------------------------------
753
754 //---- Aileen
755 //-------------------------------------------------------------------------------------------------
756 /// Set the Vertical start of capture window for specific window
757 /// @param u16Vstart \b IN: the window info to get
758 /// @param eWindow \b IN: for which window(DIP_WINDOW) to set
759 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetCaptureWindowVstart(MS_U16 u16Vstart,SCALER_DIP_WIN eWindow)760 E_APIXC_ReturnValue MApi_XC_DIP_SetCaptureWindowVstart(MS_U16 u16Vstart , SCALER_DIP_WIN eWindow)
761 {
762 #ifndef DISABLE_DIP_FUNCTION
763
764 #ifdef UTOPIA_V2
765
766 #else
767 MDrv_XC_DWIN_set_capture_v_start(NULL,u16Vstart, eWindow);
768 #endif
769 return E_APIXC_RET_OK;
770 #else
771 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
772 #endif
773
774 }
775
776 //-------------------------------------------------------------------------------------------------
777 /// Set the horizontal start of capture window for specific window
778 /// @param u16Hstart \b IN: the window info to get
779 /// @param eWindow \b IN: which window(DIP_WINDOW) to set
780 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetCaptureWindowHstart(MS_U16 u16Hstart,SCALER_DIP_WIN eWindow)781 E_APIXC_ReturnValue MApi_XC_DIP_SetCaptureWindowHstart(MS_U16 u16Hstart , SCALER_DIP_WIN eWindow)
782 {
783 #ifndef DISABLE_DIP_FUNCTION
784
785 #ifdef UTOPIA_V2
786
787 #else
788 MDrv_XC_DWIN_set_capture_h_start(NULL,u16Hstart, eWindow);
789 #endif
790 return E_APIXC_RET_OK;
791 #else
792 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
793 #endif
794
795 }
796
797 //-------------------------------------------------------------------------------------------------
798 /// Set the Vertical size of capture window for specific window
799 /// @param u16Vsize \b IN: the window info to get
800 /// @param eWindow \b IN: which window(DIP_WINDOW) to set
801 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetCaptureWindowVsize(MS_U16 u16Vsize,SCALER_DIP_WIN eWindow)802 E_APIXC_ReturnValue MApi_XC_DIP_SetCaptureWindowVsize(MS_U16 u16Vsize , SCALER_DIP_WIN eWindow)
803 {
804 #ifndef DISABLE_DIP_FUNCTION
805
806 #ifdef UTOPIA_V2
807
808 #else
809 MDrv_XC_DWIN_set_capture_v_size(NULL,u16Vsize, eWindow);
810 #endif
811 return E_APIXC_RET_OK;
812 #else
813 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
814 #endif
815
816 }
817
818 //-------------------------------------------------------------------------------------------------
819 /// Set the Horizontal size of capture window for specific window
820 /// @param u16Hsize \b IN: the window info to get
821 /// @param eWindow \b IN: which window(DIP_WINDOW) to set
822 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetCaptureWindowHsize(MS_U16 u16Hsize,SCALER_DIP_WIN eWindow)823 E_APIXC_ReturnValue MApi_XC_DIP_SetCaptureWindowHsize(MS_U16 u16Hsize , SCALER_DIP_WIN eWindow)
824 {
825 #ifndef DISABLE_DIP_FUNCTION
826
827 #ifdef UTOPIA_V2
828
829 #else
830 MDrv_XC_DWIN_set_capture_h_size(NULL,u16Hsize, eWindow);
831 #endif
832 return E_APIXC_RET_OK;
833 #else
834 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
835 #endif
836
837 }
838
839 //-------------------------------------------------------------------------------------------------
840 /// Get the capture window for specific window
841 /// @param capture_win \b OUT: the window info to get
842 /// @param eWindow \b IN: which window(DIP_WINDOW) to get
843 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_GetCaptureWindow(MS_WINDOW_TYPE * capture_win,SCALER_DIP_WIN eWindow)844 E_APIXC_ReturnValue MApi_XC_DIP_GetCaptureWindow(MS_WINDOW_TYPE* capture_win, SCALER_DIP_WIN eWindow)
845 {
846 #ifndef DISABLE_DIP_FUNCTION
847
848 #ifdef UTOPIA_V2
849
850 #else
851 MDrv_XC_DWIN_get_capture_window(NULL,capture_win, eWindow);
852 #endif
853 return E_APIXC_RET_OK;
854 #else
855 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
856 #endif
857
858 }
859
860 //******************************************************************************
861 /// API for enable or disable RGB to YUV color space convertion
862 /// @param bEnable \b IN: enable or disable
863 /// @param eWindow \b IN: which window(DIP_WINDOW) to set
864 /// @return E_APIXC_RET_OK - Success
865 //******************************************************************************
MApi_XC_DIP_EnableR2Y(MS_BOOL benable,SCALER_DIP_WIN eWindow)866 E_APIXC_ReturnValue MApi_XC_DIP_EnableR2Y(MS_BOOL benable, SCALER_DIP_WIN eWindow)
867 {
868 #ifndef DISABLE_DIP_FUNCTION
869
870 #ifdef UTOPIA_V2
871 DIP_SET_PROPERTY* pSetProperty = NULL;
872
873 #ifdef GOPD_DIP
874 if(eWindow == Gopd_dip){
875 MApi_GOP_DWIN_EnableR2YCSC(benable);
876 return E_APIXC_RET_OK;
877 }
878 #endif
879
880 if(pInstantDip[eWindow] == NULL)
881 {
882 XC_ERR("DIP not Opened\n");
883 return E_APIXC_RET_FAIL;
884 }
885 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
886 if (pSetProperty == NULL)
887 {
888 XC_ERR("%s alloc fail\n",__FUNCTION__);
889 return E_APIXC_RET_FAIL;
890 }
891 pSetProperty->Property.bR2Y = benable;
892 pSetProperty->eFlag = DIP_PRO_R2Y;
893 pSetProperty->eWindow = eWindow;
894 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
895 {
896 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_R2Y fail\n");
897 utopia_free(pSetProperty);
898 return E_APIXC_RET_FAIL;
899 }
900 utopia_free(pSetProperty);
901 #else
902 MDrv_XC_DWIN_EnableR2YCSC(NULL,benable, eWindow);
903 #endif
904 return E_APIXC_RET_OK;
905 #else
906 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
907 #endif
908
909 }
910
911 //=============== DIP =====================//
912 //-------------------------------------------------------------------------------------------------
913 /// Set FrameRateCtrl
914 /// @param bEnable \b IN: FrameRateCtrl enable or not
915 /// @param u16Src \b IN: Src Frame
916 /// @param u16Dst \b IN: Dst Frame
917 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_FrameRateCtrl(MS_BOOL bEnable,MS_U16 u16In,MS_U16 u16Out,SCALER_DIP_WIN eWindow)918 E_APIXC_ReturnValue MApi_XC_DIP_FrameRateCtrl(MS_BOOL bEnable,MS_U16 u16In,MS_U16 u16Out, SCALER_DIP_WIN eWindow)
919 {
920 #ifndef DISABLE_DIP_FUNCTION
921
922 #ifdef UTOPIA_V2
923 DIP_SET_PROPERTY* pSetProperty = NULL;
924
925 #ifdef GOPD_DIP
926 if(eWindow == Gopd_dip){
927 XC_ERR("eWindow[%d] doesnt support frame rate cnt\n",eWindow);
928 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
929 }
930 #endif
931
932 if(pInstantDip[eWindow] == NULL)
933 {
934 XC_ERR("DIP not Opened\n");
935 return E_APIXC_RET_FAIL;
936 }
937 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
938 if (pSetProperty == NULL)
939 {
940 XC_ERR("%s alloc fail\n",__FUNCTION__);
941 return E_APIXC_RET_FAIL;
942 }
943 pSetProperty->Property.stFrameRateControl.bFrameRateCtrl = bEnable;
944 pSetProperty->Property.stFrameRateControl.u16In = u16In;
945 pSetProperty->Property.stFrameRateControl.u16Out = u16Out;
946 pSetProperty->eFlag = DIP_PRO_FRC;
947 pSetProperty->eWindow = eWindow;
948 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
949 {
950 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_FRC fail\n");
951 utopia_free(pSetProperty);
952 return E_APIXC_RET_FAIL;
953 }
954 utopia_free(pSetProperty);
955 #else
956 MDrv_XC_DIP_SetFRC(NULL,bEnable,u16In,u16Out,eWindow);
957 #endif
958 return E_APIXC_RET_OK;
959 #else
960 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
961 #endif
962
963 }
964
965 //-------------------------------------------------------------------------------------------------
966 /// Set DIP win property
967 /// @param pstDIPWinProperty \b IN: @ref ST_DIP_WINPROPERTY
968 /// @param eWindow \b IN: the window
969 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetDIPWinProperty(ST_XC_DIP_WINPROPERTY * pstDIPWinProperty,SCALER_DIP_WIN eWindow)970 E_APIXC_ReturnValue MApi_XC_DIP_SetDIPWinProperty(ST_XC_DIP_WINPROPERTY *pstDIPWinProperty, SCALER_DIP_WIN eWindow)
971 {
972 #ifndef DISABLE_DIP_FUNCTION
973
974 #ifdef UTOPIA_V2
975 DIP_SET_WIN_PROPERTY* pSetWinProperty = NULL;
976
977 #ifdef GOPD_DIP
978 if(eWindow == Gopd_dip){
979 GopD_property.u16w = pstDIPWinProperty->u16Width;
980 GopD_property.u16h = pstDIPWinProperty->u16Height;
981 if( (DataFmt == DIP_DATA_FMT_YUV422) || (DataFmt == DIP_DATA_FMT_RGB565))
982 GopD_property.u16fbw = pstDIPWinProperty->u16Pitch/2;
983 else if(DataFmt == DIP_DATA_FMT_ARGB8888)
984 GopD_property.u16fbw = pstDIPWinProperty->u16Pitch/4;
985 GopD_property.u32fbaddr0 = pstDIPWinProperty->u32BufStart;
986 GopD_property.u32fbaddr1 = pstDIPWinProperty->u32BufEnd;
987
988 if(pstDIPWinProperty->enSource == SCALER_DIP_SOURCE_TYPE_MAIN)
989 MApi_GOP_DWIN_SetSourceSel(DWIN_SRC_IP);
990 else if(pstDIPWinProperty->enSource == SCALER_DIP_SOURCE_TYPE_OP_CAPTURE)
991 MApi_GOP_DWIN_SetSourceSel(DWIN_SRC_OP);
992 else{
993 XC_ERR("eWindow[%d] doesnt support capture source[%d]\n",eWindow,pstDIPWinProperty->enSource);
994 return E_APIXC_RET_FAIL_ENUM_NOT_SUPPORT;
995 }
996 MApi_GOP_DWIN_SetWinProperty(&GopD_property);
997 return E_APIXC_RET_OK;
998 }
999 #endif
1000
1001 if(pInstantDip[eWindow] == NULL)
1002 {
1003 XC_ERR("DIP not Opened\n");
1004 return E_APIXC_RET_FAIL;
1005 }
1006 pSetWinProperty = (DIP_SET_WIN_PROPERTY*)utopia_malloc(sizeof(DIP_SET_WIN_PROPERTY));
1007 if (pSetWinProperty == NULL)
1008 {
1009 XC_ERR("%s alloc fail\n",__FUNCTION__);
1010 return E_APIXC_RET_FAIL;
1011 }
1012 memcpy(&(pSetWinProperty->WinProperty),pstDIPWinProperty, sizeof(ST_XC_DIP_WINPROPERTY));
1013 pSetWinProperty->eWindow = eWindow;
1014 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_WINPROPERTY,(void*)pSetWinProperty) != UTOPIA_STATUS_SUCCESS)
1015 {
1016 XC_ERR("Ioctl MDrv_CMD_DIP_SET_WINPROPERTY fail\n");
1017 utopia_free(pSetWinProperty);
1018 return E_APIXC_RET_FAIL;
1019 }
1020 utopia_free(pSetWinProperty);
1021 #else
1022 MDrv_XC_DIP_SetWinProperty(NULL,pstDIPWinProperty, eWindow);
1023 #endif
1024 return E_APIXC_RET_OK;
1025 #else
1026 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1027 #endif
1028
1029 }
1030
1031 //-------------------------------------------------------------------------------------------------
1032 /// Get DWIN GetBufferInfo
1033 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_GetBufInfo(SCALER_DIP_WIN eWindow)1034 BUFFER_INFO MApi_XC_DIP_GetBufInfo(SCALER_DIP_WIN eWindow)
1035 {
1036 #ifndef DISABLE_DIP_FUNCTION
1037
1038 #ifdef UTOPIA_V2
1039 BUFFER_INFO BufInfo;
1040 DIP_BUF_INFO* pBufInfo = NULL;
1041 DIP_RESOURCE* pResource = NULL;
1042
1043 #ifdef GOPD_DIP
1044 if(eWindow == Gopd_dip){
1045 BufInfo.u8BufCnt = 1;
1046 BufInfo.u32YBuf[0] = GopD_property.u32fbaddr0;
1047 return BufInfo;
1048 }
1049 #endif
1050
1051 memset(&BufInfo, 0, sizeof(BUFFER_INFO));
1052 if(pInstantDip[eWindow] == NULL)
1053 {
1054 pResource = (DIP_RESOURCE*)utopia_malloc(sizeof(DIP_RESOURCE));
1055 if(UtopiaOpen(MODULE_DIP|DIPDRIVER_BASE,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
1056 {
1057 XC_ERR("Open DIP fail\n");
1058 utopia_free(pResource);
1059 return BufInfo;
1060 }
1061 utopia_free(pResource);
1062 }
1063
1064 pBufInfo = (DIP_BUF_INFO*)utopia_malloc(sizeof(DIP_BUF_INFO));
1065 if (pBufInfo == NULL)
1066 {
1067 XC_ERR("%s alloc fail\n",__FUNCTION__);
1068 return BufInfo;
1069 }
1070 memset(&(pBufInfo->BufInfo), 0, sizeof(BUFFER_INFO));
1071 pBufInfo->eWindow = eWindow;
1072 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_GET_BUFINFO,(void*)pBufInfo) != UTOPIA_STATUS_SUCCESS)
1073 {
1074 XC_ERR("Ioctl MDrv_CMD_DIP_GET_BUFINFO fail\n");
1075 utopia_free(pBufInfo);
1076 return BufInfo;
1077 }
1078 memcpy(&BufInfo,&(pBufInfo->BufInfo), sizeof(BUFFER_INFO));
1079 utopia_free(pBufInfo);
1080 return BufInfo;
1081 #else
1082 return MDrv_XC_DIP_GetBufferInfo(NULL,eWindow);
1083 #endif
1084 #else
1085 BUFFER_INFO BufInfo;
1086 memset(&BufInfo, 0, sizeof(BUFFER_INFO));
1087 return BufInfo;
1088 #endif
1089
1090 }
1091
1092 /********************************************************************************/
1093 /// Set gop dwin capture one frame
1094 /// @return E_APIXC_RET_OK - Success
1095 /********************************************************************************/
MApi_XC_DIP_CapOneFrame(SCALER_DIP_WIN eWindow)1096 E_APIXC_ReturnValue MApi_XC_DIP_CapOneFrame(SCALER_DIP_WIN eWindow)
1097 {
1098 #ifndef DISABLE_DIP_FUNCTION
1099
1100 #ifdef UTOPIA_V2
1101 DIP_TRIGGER_MODE* pTrigMode = NULL;
1102
1103 #ifdef GOPD_DIP
1104 if(eWindow == Gopd_dip){
1105 MApi_GOP_DWIN_CaptureOneFrame();
1106 return E_APIXC_RET_OK;
1107 }
1108 #endif
1109
1110 if(pInstantDip[eWindow] == NULL)
1111 {
1112 XC_ERR("DIP not Opened\n");
1113 return E_APIXC_RET_FAIL;
1114 }
1115
1116 pTrigMode = (DIP_TRIGGER_MODE*)utopia_malloc(sizeof(DIP_TRIGGER_MODE));
1117 if (pTrigMode == NULL)
1118 {
1119 XC_ERR("%s alloc fail\n",__FUNCTION__);
1120 return E_APIXC_RET_FAIL;
1121 }
1122 pTrigMode->eTrigMode = DIP_TRIG_ONESHOT;
1123 pTrigMode->eWindow = eWindow;
1124 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_TRIGGER,(void*)pTrigMode) != UTOPIA_STATUS_SUCCESS)
1125 {
1126 XC_ERR("Ioctl MDrv_CMD_DIP_TRIGGER DIP_TRIG_ONESHOT fail\n");
1127 utopia_free(pTrigMode);
1128 return E_APIXC_RET_FAIL;
1129 }
1130 utopia_free(pTrigMode);
1131 #else
1132 MDrv_XC_DIP_CaptureOneFrame(NULL,eWindow);
1133 #endif
1134 return E_APIXC_RET_OK;
1135 #else
1136 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1137 #endif
1138
1139 }
1140
1141 /********************************************************************************/
1142 /// Set XC dwin capture one frame
1143 /// @return E_APIXC_RET_OK - Success
1144 /********************************************************************************/
MApi_XC_DIP_CapOneFrameFast(SCALER_DIP_WIN eWindow)1145 E_APIXC_ReturnValue MApi_XC_DIP_CapOneFrameFast(SCALER_DIP_WIN eWindow)
1146 {
1147 #ifndef DISABLE_DIP_FUNCTION
1148
1149 #ifdef UTOPIA_V2
1150 DIP_TRIGGER_MODE* pTrigMode = NULL;
1151
1152 #ifdef GOPD_DIP
1153 if(eWindow == Gopd_dip){
1154 MApi_GOP_DWIN_CaptureOneFrame2();
1155 return E_APIXC_RET_OK;
1156 }
1157 #endif
1158
1159 if(pInstantDip[eWindow] == NULL)
1160 {
1161 XC_ERR("DIP not Opened\n");
1162 return E_APIXC_RET_FAIL;
1163 }
1164
1165 pTrigMode = (DIP_TRIGGER_MODE*)utopia_malloc(sizeof(DIP_TRIGGER_MODE));
1166 if (pTrigMode == NULL)
1167 {
1168 XC_ERR("%s alloc fail\n",__FUNCTION__);
1169 return E_APIXC_RET_FAIL;
1170 }
1171 pTrigMode->eTrigMode = DIP_TRIG_ONESHOTFAST;
1172 pTrigMode->eWindow = eWindow;
1173 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_TRIGGER,(void*)pTrigMode) != UTOPIA_STATUS_SUCCESS)
1174 {
1175 XC_ERR("Ioctl MDrv_CMD_DIP_TRIGGER DIP_TRIG_ONESHOTFAST fail\n");
1176 utopia_free(pTrigMode);
1177 return E_APIXC_RET_FAIL;
1178 }
1179 utopia_free(pTrigMode);
1180 #else
1181 MDrv_XC_DIP_CaptureOneFrame2(NULL,eWindow);
1182 #endif
1183 return E_APIXC_RET_OK;
1184 #else
1185 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1186 #endif
1187
1188 }
1189
1190 //******************************************************************************
1191 /// clear DWIN interrupt
1192 /// @param u8mask \b IN: interrup mask
1193 /// @return E_APIXC_RET_OK - Success
1194 //******************************************************************************
MApi_XC_DIP_ClearInt(MS_U16 u8mask,SCALER_DIP_WIN eWindow)1195 E_APIXC_ReturnValue MApi_XC_DIP_ClearInt(MS_U16 u8mask, SCALER_DIP_WIN eWindow)
1196 {
1197 #ifndef DISABLE_DIP_FUNCTION
1198
1199 #ifdef UTOPIA_V2
1200 DIP_INTER_STUS* pIntrStus = NULL;
1201
1202 #ifdef GOPD_DIP
1203 if(eWindow == Gopd_dip){
1204 MApi_GOP_DWIN_ClearIntr(u8mask);
1205 return E_APIXC_RET_OK;
1206 }
1207 #endif
1208
1209 if(pInstantDip[eWindow] == NULL)
1210 {
1211 XC_ERR("DIP not Opened\n");
1212 return E_APIXC_RET_OK;
1213 }
1214
1215 pIntrStus = (DIP_INTER_STUS*)utopia_malloc(sizeof(DIP_INTER_STUS));
1216 if (pIntrStus == NULL)
1217 {
1218 XC_ERR("%s alloc fail\n",__FUNCTION__);
1219 return E_APIXC_RET_FAIL;
1220 }
1221 pIntrStus->IntrStautus = u8mask;
1222 pIntrStus->eFlag = DIP_INTR_CLEAR;
1223 pIntrStus->eWindow = eWindow;
1224 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_INTERRUPT,(void*)pIntrStus) != UTOPIA_STATUS_SUCCESS)
1225 {
1226 XC_ERR("Ioctl MDrv_CMD_DIP_INTERRUPT DIP_INTR_CLEAR fail\n");
1227 utopia_free(pIntrStus);
1228 return E_APIXC_RET_OK;
1229 }
1230 utopia_free(pIntrStus);
1231 #else
1232 MDrv_XC_DIP_ClearIntr(NULL,u8mask,eWindow);
1233 #endif
1234 return E_APIXC_RET_OK;
1235 #else
1236 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1237 #endif
1238
1239 }
1240
1241 //******************************************************************************
1242 /// API for enable or disable DWIN
1243 /// @param bEnable \b IN DWIN enable or not
1244 /// @return E_APIXC_RET_OK - Success
1245 //******************************************************************************
MApi_XC_DIP_Ena(MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1246 E_APIXC_ReturnValue MApi_XC_DIP_Ena(MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1247 {
1248 #ifndef DISABLE_DIP_FUNCTION
1249
1250 #ifdef UTOPIA_V2
1251 DIP_TRIGGER_MODE* pTrigMode = NULL;
1252
1253 #ifdef GOPD_DIP
1254 if(eWindow == Gopd_dip){
1255 MApi_GOP_DWIN_Enable(bEnable);
1256 return E_APIXC_RET_OK;
1257 }
1258 #endif
1259
1260 if(pInstantDip[eWindow] == NULL)
1261 {
1262 XC_ERR("DIP not Opened\n");
1263 return E_APIXC_RET_FAIL;
1264 }
1265
1266 pTrigMode = (DIP_TRIGGER_MODE*)utopia_malloc(sizeof(DIP_TRIGGER_MODE));
1267 if (pTrigMode == NULL)
1268 {
1269 XC_ERR("%s alloc fail\n",__FUNCTION__);
1270 return E_APIXC_RET_FAIL;
1271 }
1272 if(bEnable)
1273 pTrigMode->eTrigMode = DIP_TRIG_ON;
1274 else
1275 pTrigMode->eTrigMode = DIP_TRIG_OFF;
1276 pTrigMode->eWindow = eWindow;
1277 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_TRIGGER,(void*)pTrigMode) != UTOPIA_STATUS_SUCCESS)
1278 {
1279 if(bEnable)
1280 {
1281 XC_ERR("Ioctl MDrv_CMD_DIP_TRIGGER DIP_TRIG_ON fail\n");
1282 }
1283 else
1284 {
1285 XC_ERR("Ioctl MDrv_CMD_DIP_TRIGGER DIP_TRIG_OFF fail\n");
1286 }
1287 utopia_free(pTrigMode);
1288 return E_APIXC_RET_FAIL;
1289 }
1290 utopia_free(pTrigMode);
1291 #else
1292 MDrv_XC_DIP_EnableCaptureStream(NULL,bEnable,eWindow);
1293 #endif
1294 return E_APIXC_RET_OK;
1295 #else
1296 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1297 #endif
1298
1299 }
1300
1301 /******************************************************************************/
1302 /// Set interrupt mask of XC DWIN.
1303 /// @param u8mask \b IN bitmask of interrupt type
1304 /// - bit7 DWIN VSYNC interrupt mask
1305 /// - bit6 Dump Window interlace Bottom Field ACK Interrupt Mask
1306 /// - bit5 Dump Window interlace Top Field ACK Interrupt Mask
1307 /// - bit4 Dump Window Progressive ACK Interrupt Mask
1308 /// - bit3:1 Reserved
1309 /// - bit0 GWIN VSYNC Interrupt Mask
1310 /// @param bEnable \b IN
1311 /// - # TRUE enable interrupts specified by u8mask
1312 /// - # FALSE disable interrupts specified by u8mask
1313 /// @return E_APIXC_RET_OK - Success
1314 /******************************************************************************/
MApi_XC_DIP_EnaInt(MS_U16 u8mask,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1315 E_APIXC_ReturnValue MApi_XC_DIP_EnaInt(MS_U16 u8mask, MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1316 {
1317 #ifndef DISABLE_DIP_FUNCTION
1318
1319 #ifdef UTOPIA_V2
1320 DIP_INTER_STUS* pIntrStus = NULL;
1321
1322 #ifdef GOPD_DIP
1323 if(eWindow == Gopd_dip){
1324 MApi_GOP_DWIN_EnableIntr(u8mask,bEnable);
1325 return E_APIXC_RET_OK;
1326 }
1327 #endif
1328
1329 if(pInstantDip[eWindow] == NULL)
1330 {
1331 XC_ERR("DIP not Opened\n");
1332 return E_APIXC_RET_OK;
1333 }
1334
1335 pIntrStus = (DIP_INTER_STUS*)utopia_malloc(sizeof(DIP_INTER_STUS));
1336 if (pIntrStus == NULL)
1337 {
1338 XC_ERR("%s alloc fail\n",__FUNCTION__);
1339 return E_APIXC_RET_FAIL;
1340 }
1341 pIntrStus->IntrStautus = u8mask;
1342 if(bEnable)
1343 pIntrStus->eFlag = DIP_INTR_ENABLE;
1344 else
1345 pIntrStus->eFlag = DIP_INTR_DISABLE;
1346 pIntrStus->eWindow = eWindow;
1347 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_INTERRUPT,(void*)pIntrStus) != UTOPIA_STATUS_SUCCESS)
1348 {
1349 if(bEnable)
1350 {
1351 XC_ERR("Ioctl MDrv_CMD_DIP_INTERRUPT DIP_INTR_ENABLE fail\n");
1352 }
1353 else
1354 {
1355 XC_ERR("Ioctl MDrv_CMD_DIP_INTERRUPT DIP_INTR_DISABLE fail\n");
1356 }
1357 utopia_free(pIntrStus);
1358 return E_APIXC_RET_OK;
1359 }
1360 utopia_free(pIntrStus);
1361 #else
1362 MDrv_XC_DIP_EnableIntr(NULL,u8mask, bEnable,eWindow);
1363 #endif
1364 return E_APIXC_RET_OK;
1365 #else
1366 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1367 #endif
1368
1369 }
1370
1371 /********************************************************************************/
1372 /// Get XC Dwin interrupt status
1373 /// @return XC Dwin interrupt status
1374 /********************************************************************************/
MApi_XC_DIP_GetIntStatus(SCALER_DIP_WIN eWindow)1375 MS_U16 MApi_XC_DIP_GetIntStatus(SCALER_DIP_WIN eWindow)
1376 {
1377 #ifndef DISABLE_DIP_FUNCTION
1378
1379 #ifdef UTOPIA_V2
1380 MS_U16 u16IntrStus = 0;
1381 DIP_INTER_STUS* pIntrStus = NULL;
1382 DIP_RESOURCE* pResource = NULL;
1383
1384 #ifdef GOPD_DIP
1385 if(eWindow == Gopd_dip){
1386 u16IntrStus = MApi_GOP_DWIN_GetIntrStatus();
1387 return u16IntrStus;
1388 }
1389 #endif
1390 if(pInstantDip[eWindow] == NULL)
1391 {
1392 pResource = (DIP_RESOURCE*)utopia_malloc(sizeof(DIP_RESOURCE));
1393 if(UtopiaOpen(MODULE_DIP|DIPDRIVER_BASE,(void**)&pInstantDip[eWindow], 0, NULL) != UTOPIA_STATUS_SUCCESS)
1394 {
1395 XC_ERR("Open DIP fail\n");
1396 utopia_free(pResource);
1397 return u16IntrStus;
1398 }
1399
1400 utopia_free(pResource);
1401 }
1402 pIntrStus = (DIP_INTER_STUS*)utopia_malloc(sizeof(DIP_INTER_STUS));
1403 if (pIntrStus == NULL)
1404 {
1405 XC_ERR("%s alloc fail\n",__FUNCTION__);
1406 return u16IntrStus;
1407 }
1408 pIntrStus->eFlag = DIP_INTR_GET;
1409 pIntrStus->IntrStautus=0;
1410 pIntrStus->eWindow = eWindow;
1411 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_INTERRUPT,(void*)pIntrStus) != UTOPIA_STATUS_SUCCESS)
1412 {
1413 XC_ERR("Ioctl MDrv_CMD_DIP_INTERRUPT DIP_INTR_GET fail\n");
1414 utopia_free(pIntrStus);
1415 return u16IntrStus;
1416 }
1417 u16IntrStus = pIntrStus->IntrStautus;
1418 utopia_free(pIntrStus);
1419
1420 return u16IntrStus;
1421 #else
1422 return MDrv_XC_DIP_GetIntrStatus(NULL,eWindow);
1423 #endif
1424 #else
1425 MS_U16 u16IntrStus = 0;
1426 return u16IntrStus;
1427 #endif
1428
1429 }
1430
1431 //******************************************************************************
1432 /// Set DWIN data source scan type
1433 /// @param enScanMode \b IN: EN_GOP_DWIN_SCAN_MODE
1434 /// @return E_APIXC_RET_OK - Success
1435 //******************************************************************************
MApi_XC_DIP_SetSourceScanType(EN_XC_DIP_SCAN_MODE enScanMode,SCALER_DIP_WIN eWindow)1436 E_APIXC_ReturnValue MApi_XC_DIP_SetSourceScanType(EN_XC_DIP_SCAN_MODE enScanMode, SCALER_DIP_WIN eWindow)
1437 {
1438 #ifndef DISABLE_DIP_FUNCTION
1439
1440 #ifdef UTOPIA_V2
1441 DIP_SET_PROPERTY* pSetProperty = NULL;
1442
1443 #ifdef GOPD_DIP
1444 if(eWindow == Gopd_dip){
1445 MApi_GOP_DWIN_SelectSourceScanType((EN_GOP_DWIN_SCAN_MODE)enScanMode);
1446 return E_APIXC_RET_OK;
1447 }
1448 #endif
1449
1450 if(pInstantDip[eWindow] == NULL)
1451 {
1452 XC_ERR("DIP not Opened\n");
1453 return E_APIXC_RET_FAIL;
1454 }
1455 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1456 if (pSetProperty == NULL)
1457 {
1458 XC_ERR("%s alloc fail\n",__FUNCTION__);
1459 return E_APIXC_RET_FAIL;
1460 }
1461 pSetProperty->Property.eScanMode = enScanMode;
1462 pSetProperty->eFlag = DIP_PRO_SCANMODE;
1463 pSetProperty->eWindow = eWindow;
1464 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1465 {
1466 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_SCANMODE fail\n");
1467 utopia_free(pSetProperty);
1468 return E_APIXC_RET_FAIL;
1469 }
1470 utopia_free(pSetProperty);
1471 #else
1472 MDrv_XC_DIP_SelectSourceScanType(NULL,(EN_XC_DWIN_SCAN_TYPE)enScanMode,eWindow);
1473 #endif
1474 return E_APIXC_RET_OK;
1475 #else
1476 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1477 #endif
1478
1479 }
1480
1481 //******************************************************************************
1482 /// API for enable or disable DWIN Interlace write
1483 /// @param bEnable \b IN DWIN enable or not
1484 /// @return E_APIXC_RET_OK - Success
1485 //******************************************************************************
MApi_XC_DIP_EnaInterlaceWrite(MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1486 E_APIXC_ReturnValue MApi_XC_DIP_EnaInterlaceWrite(MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1487 {
1488 #ifndef DISABLE_DIP_FUNCTION
1489
1490 #ifdef UTOPIA_V2
1491 DIP_SET_PROPERTY* pSetProperty = NULL;
1492
1493 #ifdef GOPD_DIP
1494 if(eWindow == Gopd_dip){
1495 XC_ERR("eWindow[%d] doesnt support interlace write\n",eWindow);
1496 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1497 }
1498 #endif
1499
1500 if(pInstantDip[eWindow] == NULL)
1501 {
1502 XC_ERR("DIP not Opened\n");
1503 return E_APIXC_RET_FAIL;
1504 }
1505 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1506 if (pSetProperty == NULL)
1507 {
1508 XC_ERR("%s alloc fail\n",__FUNCTION__);
1509 return E_APIXC_RET_FAIL;
1510 }
1511 pSetProperty->Property.bInterlaceW = bEnable;
1512 pSetProperty->eFlag = DIP_PRO_INTERLACE_W;
1513 pSetProperty->eWindow = eWindow;
1514 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1515 {
1516 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_INTERLACE_W fail\n");
1517 utopia_free(pSetProperty);
1518 return E_APIXC_RET_FAIL;
1519 }
1520 utopia_free(pSetProperty);
1521 #else
1522 MDrv_XC_DIP_SetInterlaceWrite(NULL,bEnable,eWindow);
1523 #endif
1524 return E_APIXC_RET_OK;
1525 #else
1526 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1527 #endif
1528
1529 }
1530 //******************************************************************************
1531 /// API for enable or disable DWIN Y2R
1532 /// @param bEnable \b IN DWIN enable or not
1533 /// @return E_APIXC_RET_OK - Success
1534 //******************************************************************************
MApi_XC_DIP_EnableY2R(MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1535 E_APIXC_ReturnValue MApi_XC_DIP_EnableY2R(MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1536 {
1537 #ifndef DISABLE_DIP_FUNCTION
1538
1539 #ifdef UTOPIA_V2
1540 DIP_SET_PROPERTY* pSetProperty = NULL;
1541
1542 #ifdef GOPD_DIP
1543 if(eWindow == Gopd_dip){
1544 XC_ERR("eWindow[%d] doesnt support Y2R\n",eWindow);
1545 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1546 }
1547 #endif
1548
1549 if(pInstantDip[eWindow] == NULL)
1550 {
1551 XC_ERR("DIP not Opened\n");
1552 return E_APIXC_RET_FAIL;
1553 }
1554 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1555 if (pSetProperty == NULL)
1556 {
1557 XC_ERR("%s alloc fail\n",__FUNCTION__);
1558 return E_APIXC_RET_FAIL;
1559 }
1560 pSetProperty->Property.bY2R = bEnable;
1561 pSetProperty->eFlag = DIP_PRO_Y2R;
1562 pSetProperty->eWindow = eWindow;
1563 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1564 {
1565 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_Y2R fail\n");
1566 utopia_free(pSetProperty);
1567 return E_APIXC_RET_FAIL;
1568 }
1569 utopia_free(pSetProperty);
1570 #else
1571 MDrv_XC_DIP_SetY2R(NULL,bEnable,eWindow);
1572 #endif
1573 return E_APIXC_RET_OK;
1574 #else
1575 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1576 #endif
1577
1578 }
1579 //******************************************************************************
1580 /// Set DWIN Capture format
1581 /// @param fmt \b IN: buffer format to store DWIN content
1582 /// @return E_APIXC_RET_OK - Success
1583 //******************************************************************************
MApi_XC_DIP_SetOutputDataFmt(EN_XC_DIP_DATA_FMT fmt,SCALER_DIP_WIN eWindow)1584 E_APIXC_ReturnValue MApi_XC_DIP_SetOutputDataFmt(EN_XC_DIP_DATA_FMT fmt, SCALER_DIP_WIN eWindow)
1585 {
1586 #ifndef DISABLE_DIP_FUNCTION
1587
1588 #ifdef UTOPIA_V2
1589 DIP_SET_PROPERTY* pSetProperty = NULL;
1590
1591 #ifdef GOPD_DIP
1592 if(eWindow == Gopd_dip){
1593 DataFmt = fmt;
1594 if(fmt == DIP_DATA_FMT_YUV422)
1595 MApi_GOP_DWIN_SetDataFmt(DWIN_DATA_FMT_UV8Y8);
1596 else if(fmt == DIP_DATA_FMT_RGB565)
1597 MApi_GOP_DWIN_SetDataFmt(DWIN_DATA_FMT_RGB565);
1598 else if(fmt == DIP_DATA_FMT_ARGB8888)
1599 MApi_GOP_DWIN_SetDataFmt(DWIN_DATA_FMT_ARGB8888);
1600 else{
1601 XC_ERR("eWindow[%d] doesnt support fmt[%d]\n",eWindow,fmt);
1602 return E_APIXC_RET_FAIL_ENUM_NOT_SUPPORT;
1603 }
1604 return E_APIXC_RET_OK;
1605 }
1606 #endif
1607
1608 if(pInstantDip[eWindow] == NULL)
1609 {
1610 XC_ERR("DIP not Opened\n");
1611 return E_APIXC_RET_FAIL;
1612 }
1613 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1614 if (pSetProperty == NULL)
1615 {
1616 XC_ERR("%s alloc fail\n",__FUNCTION__);
1617 return E_APIXC_RET_FAIL;
1618 }
1619 pSetProperty->Property.eDataFmt = fmt;
1620 pSetProperty->eFlag = DIP_PRO_DATAFMT;
1621 pSetProperty->eWindow = eWindow;
1622 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1623 {
1624 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_DATAFMT fail\n");
1625 utopia_free(pSetProperty);
1626 return E_APIXC_RET_FAIL;
1627 }
1628 utopia_free(pSetProperty);
1629 #else
1630 MDrv_XC_DIP_SetDataFmt(NULL,(EN_DRV_XC_DWIN_DATA_FMT)fmt,eWindow);
1631 #endif
1632 return E_APIXC_RET_OK;
1633 #else
1634 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1635 #endif
1636
1637 }
1638 /*****************************************************************************/
1639 /// Set DWIN Capture constant alpha value for format ARGB8888
1640 /// @param u8AlphaVal \b IN: constant alpha value
1641 /// @return E_APIXC_RET_OK - Success
1642 /*****************************************************************************/
MApi_XC_DIP_SetAlpha(MS_U8 u8AlphaVal,SCALER_DIP_WIN eWindow)1643 E_APIXC_ReturnValue MApi_XC_DIP_SetAlpha(MS_U8 u8AlphaVal, SCALER_DIP_WIN eWindow)
1644 {
1645 #ifndef DISABLE_DIP_FUNCTION
1646
1647 #ifdef UTOPIA_V2
1648 DIP_SET_PROPERTY* pSetProperty = NULL;
1649
1650 #ifdef GOPD_DIP
1651 if(eWindow == Gopd_dip){
1652 MApi_GOP_DWIN_SetAlphaValue(u8AlphaVal);
1653 return E_APIXC_RET_OK;
1654 }
1655 #endif
1656
1657 if(pInstantDip[eWindow] == NULL)
1658 {
1659 XC_ERR("DIP not Opened\n");
1660 return E_APIXC_RET_FAIL;
1661 }
1662 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1663 if (pSetProperty == NULL)
1664 {
1665 XC_ERR("%s alloc fail\n",__FUNCTION__);
1666 return E_APIXC_RET_FAIL;
1667 }
1668 pSetProperty->Property.u8Alpha = u8AlphaVal;
1669 pSetProperty->eFlag = DIP_PRO_ALPHA;
1670 pSetProperty->eWindow = eWindow;
1671 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1672 {
1673 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_ALPHA fail\n");
1674 utopia_free(pSetProperty);
1675 return E_APIXC_RET_FAIL;
1676 }
1677 utopia_free(pSetProperty);
1678 #else
1679 MDrv_XC_DIP_SetAlphaValue(NULL,u8AlphaVal,eWindow);
1680 #endif
1681 return E_APIXC_RET_OK;
1682 #else
1683 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1684 #endif
1685
1686 }
1687 //******************************************************************************
1688 /// API for enable or disable DWIN UV SWAP
1689 /// @param bEnable \b IN DWIN enable or not
1690 /// @return E_APIXC_RET_OK - Success
1691 //******************************************************************************
MApi_XC_DIP_SwapUV(MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1692 E_APIXC_ReturnValue MApi_XC_DIP_SwapUV(MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1693 {
1694 #ifndef DISABLE_DIP_FUNCTION
1695
1696 #ifdef UTOPIA_V2
1697 DIP_SET_PROPERTY* pSetProperty = NULL;
1698
1699 #ifdef GOPD_DIP
1700 if(eWindow == Gopd_dip){
1701 MApi_GOP_DWIN_SetUVSwap(bEnable);
1702 return E_APIXC_RET_OK;
1703 }
1704 #endif
1705
1706 if(pInstantDip[eWindow] == NULL)
1707 {
1708 XC_ERR("DIP not Opened\n");
1709 return E_APIXC_RET_FAIL;
1710 }
1711 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1712 if (pSetProperty == NULL)
1713 {
1714 XC_ERR("%s alloc fail\n",__FUNCTION__);
1715 return E_APIXC_RET_FAIL;
1716 }
1717 pSetProperty->Property.bSwapUV = bEnable;
1718 pSetProperty->eFlag = DIP_PRO_SWAPUV;
1719 pSetProperty->eWindow = eWindow;
1720 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1721 {
1722 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_SWAPUV fail\n");
1723 utopia_free(pSetProperty);
1724 return E_APIXC_RET_FAIL;
1725 }
1726 utopia_free(pSetProperty);
1727 #else
1728 MDrv_XC_DIP_SetUVSwap(NULL,bEnable,eWindow);
1729 #endif
1730 return E_APIXC_RET_OK;
1731 #else
1732 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1733 #endif
1734
1735 }
1736 //******************************************************************************
1737 /// API for enable or disable DWIN YC SWAP
1738 /// @param bEnable \b IN DWIN enable or not
1739 /// @return E_APIXC_RET_OK - Success
1740 //******************************************************************************
MApi_XC_DIP_SwapYC(MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1741 E_APIXC_ReturnValue MApi_XC_DIP_SwapYC(MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1742 {
1743 #ifndef DISABLE_DIP_FUNCTION
1744
1745 #ifdef UTOPIA_V2
1746 DIP_SET_PROPERTY* pSetProperty = NULL;
1747
1748 #ifdef GOPD_DIP
1749 if(eWindow == Gopd_dip){
1750 XC_ERR("eWindow[%d] doesnt support YC swap\n",eWindow);
1751 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1752 }
1753 #endif
1754
1755 if(pInstantDip[eWindow] == NULL)
1756 {
1757 XC_ERR("DIP not Opened\n");
1758 return E_APIXC_RET_FAIL;
1759 }
1760 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1761 if (pSetProperty == NULL)
1762 {
1763 XC_ERR("%s alloc fail\n",__FUNCTION__);
1764 return E_APIXC_RET_FAIL;
1765 }
1766 pSetProperty->Property.bSwapYC = bEnable;
1767 pSetProperty->eFlag = DIP_PRO_SWAPYC;
1768 pSetProperty->eWindow = eWindow;
1769 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1770 {
1771 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_SWAPYC fail\n");
1772 utopia_free(pSetProperty);
1773 return E_APIXC_RET_FAIL;
1774 }
1775 utopia_free(pSetProperty);
1776 #else
1777 MDrv_XC_DIP_SetYCSwap(NULL,bEnable,eWindow);
1778 #endif
1779 return E_APIXC_RET_OK;
1780 #else
1781 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1782 #endif
1783
1784 }
1785 //******************************************************************************
1786 /// API for enable or disable DWIN RGB SWAP
1787 /// @param bEnable \b IN DWIN enable or not
1788 /// @return E_APIXC_RET_OK - Success
1789 //******************************************************************************
MApi_XC_DIP_SwapRGB(MS_BOOL bEnable,EN_XC_DIP_RGB_SWAP_TYPE enSwapType,SCALER_DIP_WIN eWindow)1790 E_APIXC_ReturnValue MApi_XC_DIP_SwapRGB(MS_BOOL bEnable, EN_XC_DIP_RGB_SWAP_TYPE enSwapType, SCALER_DIP_WIN eWindow)
1791 {
1792 #ifndef DISABLE_DIP_FUNCTION
1793
1794 #ifdef UTOPIA_V2
1795 DIP_SET_PROPERTY* pSetProperty = NULL;
1796
1797 #ifdef GOPD_DIP
1798 if(eWindow == Gopd_dip){
1799 XC_ERR("eWindow[%d] doesnt support RGB swap\n",eWindow);
1800 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1801 }
1802 #endif
1803
1804 if(pInstantDip[eWindow] == NULL)
1805 {
1806 XC_ERR("DIP not Opened\n");
1807 return E_APIXC_RET_FAIL;
1808 }
1809 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1810 if (pSetProperty == NULL)
1811 {
1812 XC_ERR("%s alloc fail\n",__FUNCTION__);
1813 return E_APIXC_RET_FAIL;
1814 }
1815 pSetProperty->Property.stSwapRGB.bSwap = bEnable;
1816 pSetProperty->Property.stSwapRGB.eSwapType = enSwapType;
1817 pSetProperty->eFlag = DIP_PRO_SWAPRGB;
1818 pSetProperty->eWindow = eWindow;
1819 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1820 {
1821 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_SWAPRGB fail\n");
1822 utopia_free(pSetProperty);
1823 return E_APIXC_RET_FAIL;
1824 }
1825 utopia_free(pSetProperty);
1826 #else
1827 MDrv_XC_DIP_SetRGBSwap(NULL,bEnable,eWindow);
1828 #endif
1829 return E_APIXC_RET_OK;
1830 #else
1831 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1832 #endif
1833
1834 }
1835 //******************************************************************************
1836 /// API for set output capture mux
1837 /// @return E_APIXC_RET_OK - Success
1838 //******************************************************************************
MApi_XC_DIP_SetOutputCapture(MS_BOOL bEnable,EN_XC_DIP_OP_CAPTURE eOpCapture,SCALER_DIP_WIN eWindow)1839 E_APIXC_ReturnValue MApi_XC_DIP_SetOutputCapture(MS_BOOL bEnable,EN_XC_DIP_OP_CAPTURE eOpCapture,SCALER_DIP_WIN eWindow)
1840 {
1841 #ifndef DISABLE_DIP_FUNCTION
1842
1843 #ifdef UTOPIA_V2
1844 DIP_SET_PROPERTY* pSetProperty = NULL;
1845
1846 #ifdef GOPD_DIP
1847 if(eWindow == Gopd_dip){
1848 if( eOpCapture == E_XC_DIP_OP2 )
1849 MApi_XC_OP2VOPDESel(E_OP2VOPDE_WHOLEFRAME_WITHOSD);
1850 else
1851 MApi_XC_OP2VOPDESel(E_OP2VOPDE_WHOLEFRAME);
1852 return E_APIXC_RET_OK;
1853 }
1854 #endif
1855
1856 if(pInstantDip[eWindow] == NULL)
1857 {
1858 XC_ERR("DIP not Opened\n");
1859 return E_APIXC_RET_FAIL;
1860 }
1861 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1862 if (pSetProperty == NULL)
1863 {
1864 XC_ERR("%s alloc fail\n",__FUNCTION__);
1865 return E_APIXC_RET_FAIL;
1866 }
1867 pSetProperty->Property.stOpCapture.bOpCapture = bEnable;
1868 pSetProperty->Property.stOpCapture.eOpCapture = eOpCapture;
1869 pSetProperty->eFlag = DIP_PRO_OP_CAPTURE;
1870 pSetProperty->eWindow = eWindow;
1871 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1872 {
1873 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_OP_CAPTURE fail\n");
1874 utopia_free(pSetProperty);
1875 return E_APIXC_RET_FAIL;
1876 }
1877 utopia_free(pSetProperty);
1878 #else
1879 MDrv_XC_DIP_SetOutputCapture(NULL,bEnable,eOpCapture,eWindow);
1880 #endif
1881 return E_APIXC_RET_OK;
1882 #else
1883 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1884 #endif
1885
1886 }
1887 //******************************************************************************
1888 /// API for set DIPW H & V Mirror
1889 /// @return E_APIXC_RET_OK - Success
1890 //******************************************************************************
MApi_XC_DIP_SetMirror(MS_BOOL bHMirror,MS_BOOL bVMirror,SCALER_DIP_WIN eWindow)1891 E_APIXC_ReturnValue MApi_XC_DIP_SetMirror(MS_BOOL bHMirror,MS_BOOL bVMirror,SCALER_DIP_WIN eWindow)
1892 {
1893 #ifndef DISABLE_DIP_FUNCTION
1894
1895 #ifdef UTOPIA_V2
1896 DIP_SET_PROPERTY* pSetProperty = NULL;
1897
1898 #ifdef GOPD_DIP
1899 if(eWindow == Gopd_dip){
1900 XC_ERR("eWindow[%d] doesnt support Mirror\n",eWindow);
1901 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1902 }
1903 #endif
1904
1905 if(pInstantDip[eWindow] == NULL)
1906 {
1907 XC_ERR("DIP not Opened\n");
1908 return E_APIXC_RET_FAIL;
1909 }
1910 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
1911 if (pSetProperty == NULL)
1912 {
1913 XC_ERR("%s alloc fail\n",__FUNCTION__);
1914 return E_APIXC_RET_FAIL;
1915 }
1916 pSetProperty->Property.stMirror.bHMirror = bHMirror;
1917 pSetProperty->Property.stMirror.bVMirror = bVMirror;
1918 pSetProperty->eFlag = DIP_PRO_MIRROR;
1919 pSetProperty->eWindow = eWindow;
1920 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
1921 {
1922 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_MIRROR fail\n");
1923 utopia_free(pSetProperty);
1924 return E_APIXC_RET_FAIL;
1925 }
1926 utopia_free(pSetProperty);
1927 #else
1928 MDrv_XC_DIP_SetMirror(NULL,bHMirror,bVMirror,eWindow);
1929 #endif
1930 return E_APIXC_RET_OK;
1931 #else
1932 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1933 #endif
1934
1935 }
1936 //******************************************************************************
1937 /// API for set DIPR Property
1938 /// @return E_APIXC_RET_OK - Success
1939 //******************************************************************************
1940
MApi_XC_DIP_SetDIPRProperty(ST_XC_DIPR_PROPERTY * pstDIPRProperty,SCALER_DIP_WIN eWindow)1941 E_APIXC_ReturnValue MApi_XC_DIP_SetDIPRProperty(ST_XC_DIPR_PROPERTY *pstDIPRProperty,SCALER_DIP_WIN eWindow)
1942 {
1943 #ifndef DISABLE_DIP_FUNCTION
1944
1945 #ifdef UTOPIA_V2
1946 DIP_SET_DIPR_PROPERTY_EX* pSetDIPRProperty_ex = NULL;
1947
1948 #ifdef GOPD_DIP
1949 if(eWindow == Gopd_dip){
1950 XC_ERR("eWindow[%d] doesnt support DIPR\n",eWindow);
1951 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1952 }
1953 #endif
1954
1955 if(pInstantDip[eWindow] == NULL)
1956 {
1957 XC_ERR("DIP not Opened\n");
1958 return E_APIXC_RET_FAIL;
1959 }
1960 pSetDIPRProperty_ex = (DIP_SET_DIPR_PROPERTY_EX*)utopia_malloc(sizeof(DIP_SET_DIPR_PROPERTY_EX));
1961 if (pSetDIPRProperty_ex == NULL)
1962 {
1963 XC_ERR("%s alloc fail\n",__FUNCTION__);
1964 return E_APIXC_RET_FAIL;
1965 }
1966 memcpy(&(pSetDIPRProperty_ex->stDIPRProperty_ex.stDIPRProperty),pstDIPRProperty, sizeof(ST_XC_DIPR_PROPERTY));
1967 pSetDIPRProperty_ex->enDIPRFlag = E_DIP_SET_DIPR_NORMAL;
1968 pSetDIPRProperty_ex->eWindow = eWindow;
1969 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_DIPR_PROPERTY,(void*)pSetDIPRProperty_ex) != UTOPIA_STATUS_SUCCESS)
1970 {
1971 XC_ERR("Ioctl MDrv_CMD_DIP_SET_DIPR_PROPERTY fail\n");
1972 utopia_free(pSetDIPRProperty_ex);
1973 return E_APIXC_RET_FAIL;
1974 }
1975 utopia_free(pSetDIPRProperty_ex);
1976 #else
1977 MDrv_XC_DIP_SetDIPRProperty(NULL,pstDIPRProperty, eWindow);
1978 #endif
1979 return E_APIXC_RET_OK;
1980 #else
1981 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1982 #endif
1983
1984 }
1985
MApi_XC_DIP_SetDIPRProperty_EX(ST_XC_DIPR_PROPERTY_EX * pstDIPRProperty_ex,SCALER_DIP_WIN eWindow)1986 E_APIXC_ReturnValue MApi_XC_DIP_SetDIPRProperty_EX(ST_XC_DIPR_PROPERTY_EX *pstDIPRProperty_ex, SCALER_DIP_WIN eWindow)
1987 {
1988 #ifndef DISABLE_DIP_FUNCTION
1989
1990 #ifdef UTOPIA_V2
1991 DIP_SET_DIPR_PROPERTY_EX* pSetDIPRProperty_ex = NULL;
1992
1993 #ifdef GOPD_DIP
1994 if(eWindow == Gopd_dip){
1995 XC_ERR("eWindow[%d] doesnt support DIPR\n",eWindow);
1996 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
1997 }
1998 #endif
1999
2000 if(pInstantDip[eWindow] == NULL)
2001 {
2002 XC_ERR("DIP not Opened\n");
2003 return E_APIXC_RET_FAIL;
2004 }
2005 pSetDIPRProperty_ex = (DIP_SET_DIPR_PROPERTY_EX*)utopia_malloc(sizeof(DIP_SET_DIPR_PROPERTY_EX));
2006 if (pSetDIPRProperty_ex == NULL)
2007 {
2008 XC_ERR("%s alloc fail\n",__FUNCTION__);
2009 return E_APIXC_RET_FAIL;
2010 }
2011 memcpy(&(pSetDIPRProperty_ex->stDIPRProperty_ex),pstDIPRProperty_ex, sizeof(ST_XC_DIPR_PROPERTY_EX));
2012 pSetDIPRProperty_ex->enDIPRFlag = E_DIP_SET_DIPR_EX;
2013 pSetDIPRProperty_ex->eWindow = eWindow;
2014 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_DIPR_PROPERTY,(void*)pSetDIPRProperty_ex) != UTOPIA_STATUS_SUCCESS)
2015 {
2016 XC_ERR("Ioctl MDrv_CMD_DIP_SET_DIPR_PROPERTY_EX fail\n");
2017 utopia_free(pSetDIPRProperty_ex);
2018 return E_APIXC_RET_FAIL;
2019 }
2020 utopia_free(pSetDIPRProperty_ex);
2021 #else
2022 MDrv_XC_DIP_SetDIPRProperty_EX(NULL,pstDIPRProperty_ex, eWindow);
2023 #endif
2024 return E_APIXC_RET_OK;
2025 #else
2026 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2027 #endif
2028
2029 }
2030
2031
2032 //******************************************************************************
2033 /// API for MApi_XC_DIP_Rotation
2034 /// @return E_APIXC_RET_OK - Success
2035 //******************************************************************************
MApi_XC_DIP_Rotation(MS_BOOL bRotation,EN_XC_DIP_ROTATION eRoDirection,SCALER_DIP_WIN eTmpWindow)2036 E_APIXC_ReturnValue MApi_XC_DIP_Rotation(MS_BOOL bRotation,EN_XC_DIP_ROTATION eRoDirection,SCALER_DIP_WIN eTmpWindow)
2037 {
2038 #ifndef DISABLE_DIP_FUNCTION
2039
2040 #ifdef UTOPIA_V2
2041 DIP_SET_PROPERTY* pSetProperty = NULL;
2042
2043 #ifdef GOPD_DIP
2044 if(eTmpWindow == Gopd_dip){
2045 XC_ERR("eWindow[%d] doesnt support Rotate\n",eTmpWindow);
2046 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2047 }
2048 #endif
2049
2050 if(pInstantDip[eTmpWindow] == NULL)
2051 {
2052 XC_ERR("DIP not Opened\n");
2053 return E_APIXC_RET_FAIL;
2054 }
2055 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
2056 if (pSetProperty == NULL)
2057 {
2058 XC_ERR("%s alloc fail\n",__FUNCTION__);
2059 return E_APIXC_RET_FAIL;
2060 }
2061 pSetProperty->Property.stRotation.bRotation = bRotation;
2062 pSetProperty->Property.stRotation.eRoDirection = eRoDirection;
2063 pSetProperty->eFlag = DIP_PRO_ROTATION;
2064 pSetProperty->eWindow = eTmpWindow;
2065 if(UtopiaIoctl(pInstantDip[eTmpWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
2066 {
2067 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_ROTATION fail\n");
2068 utopia_free(pSetProperty);
2069 return E_APIXC_RET_FAIL;
2070 }
2071 utopia_free(pSetProperty);
2072 #else
2073 MDrv_XC_DIP_SetRotation(NULL,bRotation,eRoDirection,eTmpWindow);
2074 #endif
2075 return E_APIXC_RET_OK;
2076 #else
2077 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2078 #endif
2079
2080 }
2081 //******************************************************************************
2082 /// API for MApi_XC_DIP_SetPinpon
2083 /// @return E_APIXC_RET_OK - Success
2084 //******************************************************************************
MApi_XC_DIP_SetPinpon(MS_BOOL bPinpon,MS_PHY u32PinponAddr,SCALER_DIP_WIN eWindow)2085 E_APIXC_ReturnValue MApi_XC_DIP_SetPinpon(MS_BOOL bPinpon,MS_PHY u32PinponAddr,SCALER_DIP_WIN eWindow)
2086 {
2087 #ifndef DISABLE_DIP_FUNCTION
2088
2089 #ifdef UTOPIA_V2
2090 DIP_SET_PROPERTY* pSetProperty = NULL;
2091
2092 #ifdef GOPD_DIP
2093 if(eWindow == Gopd_dip){
2094 XC_ERR("eWindow[%d] doesnt support Pinpon\n",eWindow);
2095 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2096 }
2097 #endif
2098
2099 if(pInstantDip[eWindow] == NULL)
2100 {
2101 XC_ERR("DIP not Opened\n");
2102 return E_APIXC_RET_FAIL;
2103 }
2104 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
2105 if (pSetProperty == NULL)
2106 {
2107 XC_ERR("%s alloc fail\n",__FUNCTION__);
2108 return E_APIXC_RET_FAIL;
2109 }
2110 pSetProperty->Property.stPinpon.bPinpon = bPinpon;
2111 pSetProperty->Property.stPinpon.u32PinponAddr = u32PinponAddr;
2112 pSetProperty->eFlag = DIP_PRO_PINPON;
2113 pSetProperty->eWindow = eWindow;
2114 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
2115 {
2116 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_PINPON fail\n");
2117 utopia_free(pSetProperty);
2118 return E_APIXC_RET_FAIL;
2119 }
2120 utopia_free(pSetProperty);
2121 #else
2122 MDrv_XC_DIP_SetPinpon(NULL,bPinpon,u32PinponAddr,eWindow);
2123 #endif
2124 return E_APIXC_RET_OK;
2125 #else
2126 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2127 #endif
2128
2129 }
2130
2131 #ifdef DIP_UTOPIA2K
2132 static InterruptCb pAPI_DipIntCb;
2133 static InterruptCb pAPI_Dwin0IntCb;
2134 static InterruptCb pAPI_Dwin1IntCb;
2135 static MS_BOOL bAPI_DipIsr = FALSE,bAPI_Dwin0Isr = FALSE,bAPI_Dwin1Isr = FALSE,bAPI_Attached = FALSE;
2136
_MApi_XC_DIP_CallBack(InterruptNum eIntNum)2137 static void _MApi_XC_DIP_CallBack(InterruptNum eIntNum)
2138 {
2139 if( (MApi_XC_DIP_GetIntStatus(DIP_WINDOW) > 0) && (pAPI_DipIntCb != NULL) )
2140 (void)(pAPI_DipIntCb)(eIntNum);
2141 if( (MApi_XC_DIP_GetIntStatus(DWIN0_WINDOW) > 0) && (pAPI_Dwin0IntCb != NULL) )
2142 (void)(pAPI_Dwin0IntCb)(eIntNum);
2143 if( (MApi_XC_DIP_GetIntStatus(DWIN1_WINDOW) > 0) && (pAPI_Dwin1IntCb != NULL) )
2144 (void)(pAPI_Dwin1IntCb)(eIntNum);
2145
2146 MsOS_EnableInterrupt(E_INT_IRQ_DIPW);
2147 }
2148 #endif
2149 //******************************************************************************
2150 /// API for MApi_XC_InterruptAttach
2151 /// @return E_APIXC_RET_OK - Success
2152 //******************************************************************************
2153 #ifdef GOPD_DIP
2154 #ifdef MSOS_TYPE_LINUX
dip_thread(void)2155 void dip_thread(void)
2156 {
2157 while(1)
2158 {
2159 if( MApi_GOP_DWIN_GetIntrStatus() )
2160 (void)(pGopd_CB)(E_INT_IRQ_DIPW);
2161 MsOS_DelayTask(FRAME_DELAY);
2162 if(bDeAttached)
2163 break;
2164 }
2165 }
2166 #endif
2167 #endif
2168
MApi_XC_DIP_InterruptAttach(InterruptCb pIntCb,SCALER_DIP_WIN eWindow)2169 E_APIXC_ReturnValue MApi_XC_DIP_InterruptAttach(InterruptCb pIntCb,SCALER_DIP_WIN eWindow)
2170 {
2171 #ifndef DISABLE_DIP_FUNCTION
2172
2173 #ifdef UTOPIA_V2
2174 #ifdef GOPD_DIP
2175 if(eWindow == Gopd_dip){
2176 #ifdef MSOS_TYPE_LINUX
2177 pGopd_CB = pIntCb;
2178 if(bDeAttached == TRUE)
2179 {
2180 pthread_create(&id,NULL,(void *) dip_thread,NULL);
2181 bDeAttached = FALSE;
2182 }
2183 return E_APIXC_RET_OK;
2184 #else
2185 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2186 #endif
2187 }
2188 #endif
2189
2190 #ifndef DIP_UTOPIA2K
2191 DIP_INTER_CB* pIntrCb = NULL;
2192 if(pInstantDip[eWindow] == NULL)
2193 {
2194 XC_ERR("DIP not Opened\n");
2195 return E_APIXC_RET_OK;
2196 }
2197
2198 pIntrCb = (DIP_INTER_CB*)utopia_malloc(sizeof(DIP_INTER_CB));
2199 if (pIntrCb == NULL)
2200 {
2201 XC_ERR("%s alloc fail\n",__FUNCTION__);
2202 return E_APIXC_RET_FAIL;
2203 }
2204 pIntrCb->pIntCb = pIntCb;
2205 pIntrCb->eFlag = DIP_INTR_ATTACH;
2206 pIntrCb->eWindow = eWindow;
2207 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_INTERRUPT_CB,(void*)pIntrCb) != UTOPIA_STATUS_SUCCESS)
2208 {
2209 XC_ERR("Ioctl MDrv_CMD_DIP_INTERRUPT DIP_INTR_ATTACH fail\n");
2210 utopia_free(pIntrCb);
2211 return E_APIXC_RET_OK;
2212 }
2213 utopia_free(pIntrCb);
2214 #else
2215 if(bAPI_Attached == FALSE)
2216 {
2217 MsOS_AttachInterrupt(E_INT_IRQ_DIPW,_MApi_XC_DIP_CallBack);
2218 }
2219 bAPI_Attached = TRUE;
2220
2221 if( (bAPI_DipIsr == FALSE) && (bAPI_Dwin0Isr == FALSE) && (bAPI_Dwin1Isr == FALSE))
2222 {
2223 MsOS_EnableInterrupt(E_INT_IRQ_DIPW);
2224 }
2225
2226 if( eWindow == DIP_WINDOW )
2227 {
2228 pAPI_DipIntCb = pIntCb;
2229 bAPI_DipIsr = TRUE;
2230 }
2231 else if( eWindow == DWIN0_WINDOW )
2232 {
2233 pAPI_Dwin0IntCb = pIntCb;
2234 bAPI_Dwin0Isr = TRUE;
2235 }
2236 else if( eWindow == DWIN1_WINDOW )
2237 {
2238 pAPI_Dwin1IntCb = pIntCb;
2239 bAPI_Dwin1Isr = TRUE;
2240 }
2241 else
2242 {
2243 return E_APIXC_RET_FAIL;
2244 }
2245 #endif
2246 #else
2247 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR)
2248 MDrv_XC_DIP_InterruptAttach(NULL,pIntCb,eWindow);
2249 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2250 #endif
2251 return E_APIXC_RET_OK;
2252 #else
2253 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2254 #endif
2255
2256 }
2257 //******************************************************************************
2258 /// API for MApi_XC_InterruptDetach
2259 /// @return E_APIXC_RET_OK - Success
2260 //******************************************************************************
MApi_XC_DIP_InterruptDetach(SCALER_DIP_WIN eWindow)2261 E_APIXC_ReturnValue MApi_XC_DIP_InterruptDetach(SCALER_DIP_WIN eWindow)
2262 {
2263 #ifndef DISABLE_DIP_FUNCTION
2264
2265 #ifdef UTOPIA_V2
2266 #ifdef GOPD_DIP
2267 if(eWindow == Gopd_dip){
2268 #ifdef MSOS_TYPE_LINUX
2269 bDeAttached = TRUE;
2270 if( pthread_join(id, NULL) != 0 )
2271 {
2272 XC_DBUG("[DIP] InterruptDetach fail \n");
2273 }
2274 return E_APIXC_RET_OK;
2275 #else
2276 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2277 #endif
2278 }
2279 #endif
2280
2281 #ifndef DIP_UTOPIA2K
2282 DIP_INTER_CB* pIntrCb = NULL;
2283 if(pInstantDip[eWindow] == NULL)
2284 {
2285 XC_ERR("DIP not Opened\n");
2286 return E_APIXC_RET_OK;
2287 }
2288
2289 pIntrCb = (DIP_INTER_CB*)utopia_malloc(sizeof(DIP_INTER_CB));
2290 if (pIntrCb == NULL)
2291 {
2292 XC_ERR("%s alloc fail\n",__FUNCTION__);
2293 return E_APIXC_RET_FAIL;
2294 }
2295 pIntrCb->eFlag = DIP_INTR_DETACH;
2296 pIntrCb->eWindow = eWindow;
2297 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_INTERRUPT_CB,(void*)pIntrCb) != UTOPIA_STATUS_SUCCESS)
2298 {
2299 XC_ERR("Ioctl MDrv_CMD_DIP_INTERRUPT DIP_INTR_DETACH fail\n");
2300 utopia_free(pIntrCb);
2301 return E_APIXC_RET_OK;
2302 }
2303 utopia_free(pIntrCb);
2304 #else
2305 if( eWindow == DIP_WINDOW )
2306 {
2307 bAPI_DipIsr = FALSE;
2308 }
2309 else if( eWindow == DWIN0_WINDOW )
2310 {
2311 bAPI_Dwin0Isr = FALSE;
2312 }
2313 else if( eWindow == DWIN1_WINDOW )
2314 {
2315 bAPI_Dwin1Isr = FALSE;
2316 }
2317 else
2318 {
2319 return E_APIXC_RET_FAIL;
2320 }
2321
2322 if( (bAPI_DipIsr == FALSE) && (bAPI_Dwin0Isr == FALSE) && (bAPI_Dwin1Isr == FALSE))
2323 {
2324 MsOS_DisableInterrupt(E_INT_IRQ_DIPW);
2325 //MsOS_DetachInterrupt(E_INT_IRQ_DIPW); // do not deattach, because deattach will take 100 ms to wait pthread join
2326 }
2327 #endif
2328 #else
2329 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR)
2330 MDrv_XC_DIP_InterruptDetach(NULL,eWindow);
2331 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2332 #endif
2333 return E_APIXC_RET_OK;
2334 #else
2335 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2336 #endif
2337
2338 }
2339
2340 //******************************************************************************
2341 /// API for MApi_XC_DIP_SetHVSP
2342 /// @return E_APIXC_RET_OK - Success
2343 //******************************************************************************
MApi_XC_DIP_SetHVSP(MS_BOOL bSelect,SCALER_DIP_WIN eWindow)2344 E_APIXC_ReturnValue MApi_XC_DIP_SetHVSP(MS_BOOL bSelect,SCALER_DIP_WIN eWindow)
2345 {
2346 #ifndef DISABLE_DIP_FUNCTION
2347 DIP_SET_PROPERTY* pSetProperty = NULL;
2348
2349 #ifdef GOPD_DIP
2350 if(eWindow == Gopd_dip){
2351 XC_ERR("eWindow[%d] doesnt support HVSP swap\n",eWindow);
2352 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2353 }
2354 #endif
2355
2356 if(pInstantDip[eWindow] == NULL)
2357 {
2358 XC_ERR("DIP not Opened\n");
2359 return E_APIXC_RET_FAIL;
2360 }
2361 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
2362 if (pSetProperty == NULL)
2363 {
2364 XC_ERR("%s alloc fail\n",__FUNCTION__);
2365 return E_APIXC_RET_FAIL;
2366 }
2367 pSetProperty->Property.bHVSP = bSelect;
2368 pSetProperty->eFlag = DIP_PRO_HVSP;
2369 pSetProperty->eWindow = eWindow;
2370 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
2371 {
2372 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_PINPON fail\n");
2373 utopia_free(pSetProperty);
2374 return E_APIXC_RET_FAIL;
2375 }
2376 utopia_free(pSetProperty);
2377
2378 return E_APIXC_RET_OK;
2379 #else
2380 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2381 #endif
2382 }
2383
2384 //******************************************************************************
2385 /// API for MApi_XC_DIP_Set420TileBlock
2386 /// @return E_APIXC_RET_OK - Success
2387 //******************************************************************************
MApi_XC_DIP_Set420TileBlock(EN_XC_DIP_TILE_BLOCK eTileBlock,SCALER_DIP_WIN eWindow)2388 E_APIXC_ReturnValue MApi_XC_DIP_Set420TileBlock(EN_XC_DIP_TILE_BLOCK eTileBlock,SCALER_DIP_WIN eWindow)
2389 {
2390 #ifndef DISABLE_DIP_FUNCTION
2391 DIP_SET_PROPERTY* pSetProperty = NULL;
2392
2393 #ifdef GOPD_DIP
2394 if(eWindow == Gopd_dip){
2395 XC_ERR("eWindow[%d] doesnt support 420 tile block\n",eWindow);
2396 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2397 }
2398 #endif
2399
2400 if(pInstantDip[eWindow] == NULL)
2401 {
2402 XC_ERR("DIP not Opened\n");
2403 return E_APIXC_RET_FAIL;
2404 }
2405 pSetProperty = (DIP_SET_PROPERTY*)utopia_malloc(sizeof(DIP_SET_PROPERTY));
2406 if (pSetProperty == NULL)
2407 {
2408 XC_ERR("%s alloc fail\n",__FUNCTION__);
2409 return E_APIXC_RET_FAIL;
2410 }
2411 pSetProperty->Property.eTileBlock = eTileBlock;
2412 pSetProperty->eFlag = DIP_PRO_TILEBLOCK;
2413 pSetProperty->eWindow = eWindow;
2414 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_PROPERTY,(void*)pSetProperty) != UTOPIA_STATUS_SUCCESS)
2415 {
2416 XC_ERR("Ioctl MDrv_CMD_DIP_SET_PROPERTY DIP_PRO_PINPON fail\n");
2417 utopia_free(pSetProperty);
2418 return E_APIXC_RET_FAIL;
2419 }
2420 utopia_free(pSetProperty);
2421
2422 return E_APIXC_RET_OK;
2423 #else
2424 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2425 #endif
2426 }
2427
2428 //******************************************************************************
2429 /// API for MApi_XC_DIP_SetPowerState
2430 /// @return E_APIXC_RET_OK - Success
2431 //******************************************************************************
MApi_XC_DIP_SetPowerState(EN_POWER_MODE u16PowerState)2432 MS_U32 MApi_XC_DIP_SetPowerState(EN_POWER_MODE u16PowerState)
2433 {
2434 #ifndef DISABLE_DIP_FUNCTION
2435 #ifdef UTOPIA_V2
2436
2437 #else
2438
2439 #endif
2440 #endif
2441 return UTOPIA_STATUS_SUCCESS;
2442 }
2443
2444 //******************************************************************************
2445 /// API for MApi_XC_DIP_SetDbgLevel
2446 /// @return E_APIXC_RET_OK - Success
2447 //******************************************************************************
MApi_XC_DIP_SetDbgLevel(EN_XC_DIP_DEBUG_LEVEL u8DbgLevel)2448 MS_U32 MApi_XC_DIP_SetDbgLevel(EN_XC_DIP_DEBUG_LEVEL u8DbgLevel)
2449 {
2450 #ifndef DISABLE_DIP_FUNCTION
2451 if(pInstantDip[DIP_WINDOW] == NULL)
2452 {
2453 XC_ERR("DIP not Opened\n");
2454 return E_APIXC_RET_FAIL;
2455 }
2456
2457 if(UtopiaIoctl(pInstantDip[DIP_WINDOW], MDrv_CMD_DIP_SET_DBG_LEVEL, (void*)(&u8DbgLevel)) != UTOPIA_STATUS_SUCCESS)
2458 {
2459 XC_ERR("Ioctl MDrv_CMD_DIP_SET_DBG_LEVEL fail\n");
2460 return E_APIXC_RET_FAIL;
2461 }
2462 return E_APIXC_RET_OK;
2463 #else
2464 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2465 #endif
2466 }
2467 //================================ Obsolete Function Start =======================================
2468 //-------------------------------------------------------------------------------------------------
2469 /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Alert !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2470 /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Alert !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2471 /// !!! below function will be "REMOVED" or "REFACTORING" later, please do not use it !!!!!!!!!
2472 //-------------------------------------------------------------------------------------------------
2473
2474 //-------------------------------------------------------------------------------------------------
2475 /// Set DWIN base0 base 1 address
2476 /// @param u32FBAddress0,u32FBAddress1 \b IN: the framebuffer address
2477 /// @param eWindow \b IN: the window
2478 //-------------------------------------------------------------------------------------------------
MApi_XC_DIP_SetWinProperty_Ex(MS_U8 u8BufCnt,MS_U16 u16Width,MS_U16 u16Height,MS_PHY u32BufStart,MS_PHY u32BufEnd,SCALER_DIP_SOURCE_TYPE eSource,SCALER_DIP_WIN eWindow)2479 E_APIXC_ReturnValue MApi_XC_DIP_SetWinProperty_Ex(MS_U8 u8BufCnt ,MS_U16 u16Width, MS_U16 u16Height, MS_PHY u32BufStart ,MS_PHY u32BufEnd, SCALER_DIP_SOURCE_TYPE eSource, SCALER_DIP_WIN eWindow)
2480 {
2481 #ifndef DISABLE_DIP_FUNCTION
2482
2483 ST_XC_DIP_WINPROPERTY stDIPWinProperty;
2484 stDIPWinProperty.u8BufCnt = u8BufCnt;
2485 stDIPWinProperty.u16Width = u16Width;
2486 stDIPWinProperty.u16Pitch = 0x0;
2487 stDIPWinProperty.u16Height = u16Height;
2488 stDIPWinProperty.u32BufStart = u32BufStart;
2489 stDIPWinProperty.u32BufEnd = u32BufEnd;
2490 stDIPWinProperty.enSource = eSource;
2491 #ifdef UTOPIA_V2
2492 DIP_SET_WIN_PROPERTY* pSetWinProperty = NULL;
2493
2494 #ifdef GOPD_DIP
2495 if(eWindow == Gopd_dip){
2496 GopD_property.u16w = u16Width;
2497 GopD_property.u16h = u16Height;
2498 GopD_property.u16fbw = u16Width;
2499 GopD_property.u32fbaddr0 = u32BufStart;
2500 GopD_property.u32fbaddr1 = u32BufEnd;
2501 if(eSource == SCALER_DIP_SOURCE_TYPE_MAIN)
2502 MApi_GOP_DWIN_SetSourceSel(DWIN_SRC_IP);
2503 else if(eSource == SCALER_DIP_SOURCE_TYPE_OP_CAPTURE)
2504 MApi_GOP_DWIN_SetSourceSel(DWIN_SRC_OP);
2505 else{
2506 XC_ERR("eWindow[%d] doesnt support capture source[%d]\n",eWindow,eSource);
2507 return E_APIXC_RET_FAIL_ENUM_NOT_SUPPORT;
2508 }
2509 MApi_GOP_DWIN_SetWinProperty(&GopD_property);
2510 return E_APIXC_RET_OK;
2511 }
2512 #endif
2513
2514 if(pInstantDip[eWindow] == NULL)
2515 {
2516 XC_ERR("DIP not Opened\n");
2517 return E_APIXC_RET_FAIL;
2518 }
2519 pSetWinProperty = (DIP_SET_WIN_PROPERTY*)utopia_malloc(sizeof(DIP_SET_WIN_PROPERTY));
2520 if (pSetWinProperty == NULL)
2521 {
2522 XC_ERR("%s alloc fail\n",__FUNCTION__);
2523 return E_APIXC_RET_FAIL;
2524 }
2525 memcpy(&(pSetWinProperty->WinProperty),&stDIPWinProperty, sizeof(ST_XC_DIP_WINPROPERTY));
2526 pSetWinProperty->eWindow = eWindow;
2527 if(UtopiaIoctl(pInstantDip[eWindow],MDrv_CMD_DIP_SET_WINPROPERTY,(void*)pSetWinProperty) != UTOPIA_STATUS_SUCCESS)
2528 {
2529 XC_ERR("Ioctl MDrv_CMD_DIP_SET_WINPROPERTY fail\n");
2530 utopia_free(pSetWinProperty);
2531 return E_APIXC_RET_FAIL;
2532 }
2533 utopia_free(pSetWinProperty);
2534 #else
2535 MDrv_XC_DIP_SetWinProperty(NULL,&stDIPWinProperty, eWindow);
2536 #endif
2537 return E_APIXC_RET_OK;
2538 #else
2539 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2540 #endif
2541
2542 }
MDrv_XC_DIP_GetResourceByPipeID(MS_U32 u32PipeID,MS_U32 * U32RetResNum,DIPRESOURCE * pResource)2543 MS_U32 MDrv_XC_DIP_GetResourceByPipeID(MS_U32 u32PipeID, MS_U32* U32RetResNum, DIPRESOURCE* pResource)
2544 {
2545 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2546 }
2547
MDrv_XC_DIP_ConfigPipe(MS_U32 u32PipeID,MS_U32 u32SecureDMA,MS_U32 u32OperationMode)2548 MS_U32 MDrv_XC_DIP_ConfigPipe(MS_U32 u32PipeID, MS_U32 u32SecureDMA, MS_U32 u32OperationMode)
2549 {
2550 SCALER_DIP_WIN eWindow=DIP_WINDOW;
2551 DIP_CONFIG_PIPE DIP_Config_Pipe;
2552 MS_U32 i=0;
2553
2554 DIP_Config_Pipe.u32PipeID = u32PipeID;
2555 DIP_Config_Pipe.u32SecureDMA = u32SecureDMA;
2556 DIP_Config_Pipe.u32OperationMode = u32OperationMode;
2557 DIP_Config_Pipe.u32ReturnValue = UTOPIA_STATUS_FAIL;
2558
2559 for(i=0;i<MAX_DIP_WINDOW;i++)
2560 {
2561 if (pInstantDip[(SCALER_DIP_WIN)i] == NULL)
2562 {
2563 continue;
2564 }
2565 else
2566 {
2567 eWindow = (SCALER_DIP_WIN)i;
2568 break;
2569 }
2570 if( i == (MAX_DIP_WINDOW-1))
2571 {
2572 XC_ERR("DIP not Opened\n");
2573 return UTOPIA_STATUS_FAIL;
2574 }
2575 }
2576
2577 if(UtopiaIoctl(pInstantDip[eWindow], MDrv_CMD_DIP_CONFIG_PIPE, (void*)&DIP_Config_Pipe) != UTOPIA_STATUS_SUCCESS)
2578 {
2579 printf("Obtain XC engine fail\n");
2580 return UTOPIA_STATUS_FAIL;
2581 }
2582 else
2583 {
2584 return DIP_Config_Pipe.u32ReturnValue;
2585 }
2586 }
2587
MDrv_XC_DIP_CheckPipe(MS_U32 u32PipeID,MS_U32 u32SecureDMA,MS_U32 u32OperationMode)2588 MS_U32 MDrv_XC_DIP_CheckPipe(MS_U32 u32PipeID, MS_U32 u32SecureDMA, MS_U32 u32OperationMode)
2589 {
2590 return E_APIXC_RET_FAIL_FUN_NOT_SUPPORT;
2591 }
2592
2593 //================================ Obsolete Function End =======================================
2594
2595 //=============== DIP =====================//
2596