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 apiDAC.c
98 /// @author MStar Semiconductor,Inc.
99 /// @brief DAC Api
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 //-------------------------------------------------------------------------------------------------
103 // Include Files
104 //-------------------------------------------------------------------------------------------------
105
106 #include "MsCommon.h"
107 #include "MsVersion.h"
108 #include "MsIRQ.h"
109 #include "MsOS.h"
110
111 #include "mdrv_dac_tbl.h"
112 #include "drvDAC.h"
113 #include "drvMMIO.h"
114 #include "apiDAC.h"
115
116 #ifdef MSOS_TYPE_LINUX_KERNEL
117 #include <linux/string.h>
118 #else
119 #include <string.h>
120 #endif
121
122 #include "utopia.h"
123 #include "utopia_dapi.h"
124 #include "apiDAC_private.h"
125 #include "apiDAC_v2.h"
126 #include "UFO.h"
127
128 static MSIF_Version _api_dac_version = {
129 .DDI = { DAC_API_VERSION },
130 };
131
132 // for Utopia 2.0 to Utopia 1.0 compatibility.
133 void* g_pDACInst;
134 void* g_pDACRes;
135
MDrv_DAC_Get_Semaphore(void * pInstance)136 MS_U32 MDrv_DAC_Get_Semaphore(void* pInstance)
137 {
138 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
139
140 if (pInstance == NULL)
141 {
142 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
143 return u32Return;
144 }
145
146 void* pModule = NULL;
147 UtopiaInstanceGetModule(pInstance, &pModule);
148 if(UtopiaResourceObtain(pModule, E_DAC_POOL_ID_INTERNAL_VARIABLE, &g_pDACRes) != UTOPIA_STATUS_SUCCESS)
149 {
150 printf("UtopiaResourceObtain fail\n");
151 return UTOPIA_STATUS_ERR_RESOURCE;
152 }
153 u32Return = UTOPIA_STATUS_SUCCESS;
154 return u32Return;
155 }
156
MDrv_DAC_Release_Semaphore(void)157 MS_U32 MDrv_DAC_Release_Semaphore(void)
158 {
159 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
160 u32Return = UtopiaResourceRelease(g_pDACRes);
161 return u32Return;
162 }
163
_MApi_DAC_VideoTiming_ReMapping(E_OUTPUT_VIDEO_TIMING_TYPE eApiTiming,EN_OUTPUT_VIDEO_TIMING_TYPE * eDrvTiming)164 MS_BOOL _MApi_DAC_VideoTiming_ReMapping(E_OUTPUT_VIDEO_TIMING_TYPE eApiTiming, EN_OUTPUT_VIDEO_TIMING_TYPE* eDrvTiming)
165 {
166 if (eApiTiming == E_RES_720x480I_60Hz)
167 {
168 *eDrvTiming = RES_720x480I_60Hz;
169 }
170 else if (eApiTiming == E_RES_720x480P_60Hz)
171 {
172 *eDrvTiming = RES_720x480P_60Hz;
173 }
174 else if (eApiTiming == E_RES_720x576I_50Hz)
175 {
176 *eDrvTiming = RES_720x576I_50Hz;
177 }
178 else if (eApiTiming == E_RES_720x576P_50Hz)
179 {
180 *eDrvTiming = RES_720x576P_50Hz;
181 }
182 else if (eApiTiming == E_RES_1280x720P_50Hz)
183 {
184 *eDrvTiming = RES_1280x720P_50Hz;
185 }
186 else if (eApiTiming == E_RES_1280x720P_60Hz)
187 {
188 *eDrvTiming = RES_1280x720P_60Hz;
189 }
190 else if (eApiTiming == E_RES_1920x1080I_50Hz)
191 {
192 *eDrvTiming = RES_1920x1080I_50Hz;
193 }
194 else if (eApiTiming == E_RES_1920x1080I_60Hz)
195 {
196 *eDrvTiming = RES_1920x1080I_60Hz;
197 }
198 else if (eApiTiming == E_RES_1920x1080P_24Hz)
199 {
200 *eDrvTiming = RES_1920x1080P_24Hz;
201 }
202 else if (eApiTiming == E_RES_1920x1080P_25Hz)
203 {
204 *eDrvTiming = RES_1920x1080P_25Hz;
205 }
206 else if (eApiTiming == E_RES_1920x1080P_30Hz)
207 {
208 *eDrvTiming = RES_1920x1080P_30Hz;
209 }
210 else if (eApiTiming == E_RES_1920x1080P_50Hz)
211 {
212 *eDrvTiming = RES_1920x1080P_50Hz;
213 }
214 else if (eApiTiming == E_RES_1920x1080P_60Hz)
215 {
216 *eDrvTiming = RES_1920x1080P_60Hz;
217 }
218 else if (eApiTiming == E_RES_VGA640x480P_60Hz)
219 {
220 *eDrvTiming = RES_VGA640x480P_60Hz;
221 }
222 else if (eApiTiming == E_RES_640x480P_60Hz)
223 {
224 *eDrvTiming = RES_640x480P_60Hz;
225 }
226 else if (eApiTiming == E_RES_TTL480X272P_60Hz)
227 {
228 *eDrvTiming = RES_TTL480X272P_60Hz;
229 }
230 else if (eApiTiming == E_RES_3840x2160P_24Hz)
231 {
232 *eDrvTiming = RES_3840x2160P_24Hz;
233 }
234 else if (eApiTiming == E_RES_3840x2160P_25Hz)
235 {
236 *eDrvTiming = RES_3840x2160P_25Hz;
237 }
238 else if (eApiTiming == E_RES_3840x2160P_30Hz)
239 {
240 *eDrvTiming = RES_3840x2160P_30Hz;
241 }
242 else if (eApiTiming == E_RES_3840x2160P_50Hz)
243 {
244 *eDrvTiming = RES_3840x2160P_50Hz;
245 }
246 else if (eApiTiming == E_RES_3840x2160P_60Hz)
247 {
248 *eDrvTiming = RES_3840x2160P_60Hz;
249 }
250 else if (eApiTiming == E_RES_4096x2160P_24Hz)
251 {
252 *eDrvTiming = RES_4096x2160P_24Hz;
253 }
254 else if (eApiTiming == E_RES_4096x2160P_25Hz)
255 {
256 *eDrvTiming = RES_4096x2160P_25Hz;
257 }
258 else if (eApiTiming == E_RES_4096x2160P_30Hz)
259 {
260 *eDrvTiming = RES_4096x2160P_30Hz;
261 }
262 else if (eApiTiming == E_RES_4096x2160P_50Hz)
263 {
264 *eDrvTiming = RES_4096x2160P_50Hz;
265 }
266 else if (eApiTiming == E_RES_4096x2160P_60Hz)
267 {
268 *eDrvTiming = RES_4096x2160P_60Hz;
269 }
270 else if (eApiTiming == E_RES_3840x2160P420_30Hz)
271 {
272 *eDrvTiming = RES_3840x2160P420_30Hz;
273 }
274 else if (eApiTiming == E_RES_3840x2160P420_50Hz)
275 {
276 *eDrvTiming = RES_3840x2160P420_50Hz;
277 }
278 else if (eApiTiming == E_RES_3840x2160P420_60Hz)
279 {
280 *eDrvTiming = RES_3840x2160P420_60Hz;
281 }
282 else if (eApiTiming == E_RES_4096x2160P420_30Hz)
283 {
284 *eDrvTiming = RES_4096x2160P420_30Hz;
285 }
286 else if (eApiTiming == E_RES_4096x2160P420_50Hz)
287 {
288 *eDrvTiming = RES_4096x2160P420_50Hz;
289 }
290 else if (eApiTiming == E_RES_4096x2160P420_60Hz)
291 {
292 *eDrvTiming = RES_4096x2160P420_60Hz;
293 }
294 else if (eApiTiming == E_RES_1600x1200P_60Hz)
295 {
296 *eDrvTiming = RES_1600x1200P_60Hz;
297 }
298 else if (eApiTiming == E_RES_1440x900P_60Hz)
299 {
300 *eDrvTiming = RES_1440x900P_60Hz;
301 }
302 else if (eApiTiming == E_RES_1280x1024P_60Hz)
303 {
304 *eDrvTiming = RES_1280x1024P_60Hz;
305 }
306 else if (eApiTiming == E_RES_1024x768P_60Hz)
307 {
308 *eDrvTiming = RES_1024x768P_60Hz;
309 }
310 else if (eApiTiming == E_RES_1920x2205P_24Hz)
311 {
312 *eDrvTiming = RES_1920x2205P_24Hz;
313 }
314 else if (eApiTiming == E_RES_1280x1470P_50Hz)
315 {
316 *eDrvTiming = RES_1280x1470P_50Hz;
317 }
318 else if (eApiTiming == E_RES_1280x1470P_60Hz)
319 {
320 *eDrvTiming = RES_1280x1470P_60Hz;
321 }
322 else
323 {
324 return FALSE;
325 }
326
327 return TRUE;
328 }
329
MApi_DAC_GetLibVer_U2(void * pInstance,const MSIF_Version ** ppVersion)330 APIDAC_Result MApi_DAC_GetLibVer_U2(void* pInstance, const MSIF_Version **ppVersion)
331 {
332 if (!ppVersion)
333 {
334 return E_APIDAC_FAIL;
335 }
336
337 *ppVersion = &_api_dac_version;
338 return E_APIDAC_OK;
339 }
340
MApi_DAC_GetLibVer(const MSIF_Version ** ppVersion)341 APIDAC_Result MApi_DAC_GetLibVer(const MSIF_Version **ppVersion)
342 {
343 if (g_pDACInst == NULL)
344 {
345 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
346 return E_APIDAC_FAIL;
347 }
348
349 stDAC_GET_LIBVER DACArgs;
350 DACArgs.ppVersion = ppVersion;
351 DACArgs.eReturnValue = E_APIDAC_FAIL;
352
353 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_LIBVER, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
354 {
355 printf("Obtain DAC engine fail\n");
356 }
357 return DACArgs.eReturnValue;
358 }
359
MApi_DAC_GetInfo_U2(void * pInstance)360 const DAC_ApiInfo * MApi_DAC_GetInfo_U2(void* pInstance) ///< Get info from driver
361 {
362 MDrv_DAC_Get_Semaphore(pInstance);
363 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
364 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
365 MDrv_DAC_Release_Semaphore();
366 return &pDACResourcePrivate->stapiDAC._cstDac_ApiInfo;
367 }
368
MApi_DAC_GetInfo(void)369 const DAC_ApiInfo * MApi_DAC_GetInfo(void) ///< Get info from driver
370 {
371 if (g_pDACInst == NULL)
372 {
373 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
374 return NULL;
375 }
376
377 stDAC_GET_INFO DACArgs;
378 DACArgs.stReturnValue = NULL;
379
380 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_INFO, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
381 {
382 printf("Obtain DAC engine fail\n");
383 }
384 return DACArgs.stReturnValue;
385 }
386
387 #ifdef UFO_XC_GETOUTPUTINTELACETIMING
MApi_DAC_GetOutputInterlaceTiming_U2(void * pInstance)388 MS_BOOL MApi_DAC_GetOutputInterlaceTiming_U2(void* pInstance)
389 {
390 MS_BOOL bRet = FALSE;
391 MDrv_DAC_Get_Semaphore(pInstance);
392 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
393 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
394 bRet = MDrv_DAC_GetOutputInterlaceTiming();
395 MDrv_DAC_Release_Semaphore();
396 return bRet;
397 }
398
MApi_DAC_GetOutputInterlaceTiming(void)399 MS_BOOL MApi_DAC_GetOutputInterlaceTiming(void) ///< Get interlace or not from driver
400 {
401 if (g_pDACInst == NULL)
402 {
403 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
404 return FALSE;
405 }
406
407 stDAC_GET_OUTPUTINTERLACETIMING DACArgs;
408 DACArgs.bReturnValue = FALSE;
409 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_GETOUTPUTINTERLACETIMING, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
410 {
411 printf("Obtain DAC engine fail\n");
412 }
413 return DACArgs.bReturnValue;
414 }
415 #endif
416
MApi_DAC_GetStatus_U2(void * pInstance,DAC_ApiStatus * pDacStatus)417 MS_BOOL MApi_DAC_GetStatus_U2(void* pInstance, DAC_ApiStatus *pDacStatus)
418 {
419 MDrv_DAC_Get_Semaphore(pInstance);
420 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
421 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
422 pDacStatus->bDac_Initialized = pDACResourcePrivate->stapiDAC._stDac_ApiStatus.bDac_Initialized;
423 pDacStatus->bDac_VE_enabled = pDACResourcePrivate->stapiDAC._stDac_ApiStatus.bDac_VE_enabled;
424 pDacStatus->bDac_YPbPr_enabled = pDACResourcePrivate->stapiDAC._stDac_ApiStatus.bDac_YPbPr_enabled;
425 MDrv_DAC_Release_Semaphore();
426 return TRUE;
427 }
428
MApi_DAC_GetStatus(DAC_ApiStatus * pDacStatus)429 MS_BOOL MApi_DAC_GetStatus(DAC_ApiStatus *pDacStatus)
430 {
431 if (g_pDACInst == NULL)
432 {
433 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
434 return FALSE;
435 }
436
437 stDAC_GET_STATUS DACArgs;
438 DACArgs.pDacStatus = pDacStatus;
439 DACArgs.bReturnValue = FALSE;
440
441 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_STATUS, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
442 {
443 printf("Obtain DAC engine fail\n");
444 }
445 return DACArgs.bReturnValue;
446 }
447
MApi_DAC_SetDbgLevel_U2(void * pInstance,MS_U16 u16DbgSwitch)448 MS_BOOL MApi_DAC_SetDbgLevel_U2(void* pInstance, MS_U16 u16DbgSwitch)
449 {
450 MDrv_DAC_Get_Semaphore(pInstance);
451 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
452 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
453 pDACResourcePrivate->stapiDAC._u16DbgSwitch = u16DbgSwitch;
454 MDrv_DAC_Release_Semaphore();
455 return TRUE;
456 }
457
MApi_DAC_SetDbgLevel(MS_U16 u16DbgSwitch)458 MS_BOOL MApi_DAC_SetDbgLevel(MS_U16 u16DbgSwitch)
459 {
460 if (g_pDACInst == NULL)
461 {
462 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
463 return FALSE;
464 }
465
466 stDAC_SET_DBG_LEVEL DACArgs;
467 DACArgs.u16DbgSwitch = u16DbgSwitch;
468 DACArgs.bReturnValue = FALSE;
469
470 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_DBG_LEVEL, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
471 {
472 printf("Obtain DAC engine fail\n");
473 }
474 return DACArgs.bReturnValue;
475 }
476
477
MApi_DAC_Init_U2(void * pInstance)478 MS_BOOL MApi_DAC_Init_U2(void* pInstance)
479 {
480 MS_VIRT virtPMBaseAddr = 0;
481 MS_PHY phyPMBaseSize = 0;
482
483 if(!MDrv_MMIO_GetBASE(&virtPMBaseAddr, &phyPMBaseSize, MS_MODULE_PM))
484 {
485 printf("[MAPI_DAC]MApi_DAC_Init Get PM BASE failure!\n");
486 return FALSE;
487 }
488
489 MDrv_DAC_Get_Semaphore(pInstance);
490 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
491 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
492 MDrv_DAC_SetIOMapBase(virtPMBaseAddr, virtPMBaseAddr);
493 MDrv_DAC_Init();
494
495 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u32NPMBase = virtPMBaseAddr;
496 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u32PMBase = virtPMBaseAddr;
497 pDACResourcePrivate->stapiDAC._stDac_ApiStatus.bDac_Initialized = TRUE;
498
499 // Check DAC table type number
500 if(DAC_TABLE_TYPE_NUM != DAC_TABTYPE_NUMS)
501 {
502 printf("Please check DAC table type number setting!\n");
503 }
504
505 MDrv_DAC_Release_Semaphore();
506 return TRUE;
507 }
508
MApi_DAC_Init(void)509 MS_BOOL MApi_DAC_Init(void)
510 {
511 if (g_pDACInst == NULL)
512 {
513 if(UtopiaOpen(MODULE_DAC, &g_pDACInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
514 {
515 printf("UtopiaOpen DAC failed\n");
516 return FALSE;
517 }
518 }
519
520 stDAC_INIT DACArgs;
521 DACArgs.bReturnValue = FALSE;
522 if(UtopiaIoctl(g_pDACInst, E_DAC_INIT, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
523 {
524 printf("Obtain DAC engine fail\n");
525 }
526 return DACArgs.bReturnValue;
527 }
528
529
MApi_DAC_Enable_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bIsYPbPr)530 void MApi_DAC_Enable_U2(void* pInstance, MS_BOOL bEnable, MS_BOOL bIsYPbPr)
531 {
532 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
533 MDrv_DAC_Get_Semaphore(pInstance);
534 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
535 MDrv_DAC_Enable(bEnable, bIsYPbPr);
536
537 if(bIsYPbPr)
538 {
539 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.bHDDACEnable = bEnable;
540 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.bDACIsYPbPr = bIsYPbPr;
541 }
542 else
543 {
544 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.bSDDACEnable = bEnable;
545 }
546
547 /*
548 * DAC enable/disable should not do MDrv_DAC_SetOutputSource or
549 * MDrv_DAC_SetOutputLevel. In order to make this API downward compatible,
550 * MDrv_DAC_SetOutputSource and MDrv_DAC_SetOutputLevel are called
551 * only when the first time that MApi_DAC_Enable is called. (HD and SD)
552 */
553 if (bIsYPbPr && !MDrv_DAC_GetDACState(TRUE)) {
554 MDrv_DAC_SetOutputSource(DAC_TO_HDGEN, bIsYPbPr);
555 MDrv_DAC_SetOutputLevel(DAC_OUTPUT_LEVEL_LOW, bIsYPbPr);
556 //Can not call MApi because of mutex
557 //MApi_DAC_SetOutputSwapSel(E_DAC_R_B_G, bIsYPbPr);
558 MDrv_DAC_SetDACState(TRUE, TRUE);
559 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDOutputType = DAC_TO_HDGEN;
560 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDMaxOutputLevel = DAC_OUTPUT_LEVEL_LOW;
561 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDSwapSEL = E_DAC_R_B_G;
562 }
563 if (!bIsYPbPr && !MDrv_DAC_GetDACState(FALSE)) {
564 MDrv_DAC_SetOutputSource(DAC_TO_VE, bIsYPbPr);
565 MDrv_DAC_SetOutputLevel(DAC_OUTPUT_LEVEL_HIGH, bIsYPbPr);
566 //Can not call MApi because of mutex
567 //MApi_DAC_SetOutputSwapSel(E_DAC_R_G_B, bIsYPbPr);
568 MDrv_DAC_SetDACState(TRUE, FALSE);
569 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDOutputType = DAC_TO_VE;
570 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDMaxOutputLevel = DAC_OUTPUT_LEVEL_HIGH;
571 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDSwapSEL = E_DAC_R_G_B;
572 }
573
574 if (bIsYPbPr)
575 {
576 pDACResourcePrivate->stapiDAC._stDac_ApiStatus.bDac_YPbPr_enabled = bEnable;
577 }
578 else
579 {
580 pDACResourcePrivate->stapiDAC._stDac_ApiStatus.bDac_VE_enabled = bEnable;
581 }
582 MDrv_DAC_Release_Semaphore();
583 }
584
MApi_DAC_Enable(MS_BOOL bEnable,MS_BOOL bIsYPbPr)585 void MApi_DAC_Enable(MS_BOOL bEnable, MS_BOOL bIsYPbPr)
586 {
587 if (g_pDACInst == NULL)
588 {
589 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
590 return;
591 }
592
593 stDAC_ENABLE DACArgs;
594 DACArgs.bEnable = bEnable;
595 DACArgs.bIsYPbPr = bIsYPbPr;
596
597 if(UtopiaIoctl(g_pDACInst, E_DAC_ENABLE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
598 {
599 printf("Obtain DAC engine fail\n");
600 }
601 return;
602 }
603
MApi_DAC_SetOutputSource_U2(void * pInstance,E_DAC_OUTPUT_TYPE enOutputType,MS_BOOL bIsYPbPr)604 void MApi_DAC_SetOutputSource_U2(void* pInstance, E_DAC_OUTPUT_TYPE enOutputType, MS_BOOL bIsYPbPr)
605 {
606 MDrv_DAC_SetOutputSource((EN_DAC_OUTPUT_TYPE)enOutputType,bIsYPbPr);
607 return;
608 }
609
MApi_DAC_SetOutputSource(E_DAC_OUTPUT_TYPE enOutputType,MS_BOOL bIsYPbPr)610 void MApi_DAC_SetOutputSource(E_DAC_OUTPUT_TYPE enOutputType, MS_BOOL bIsYPbPr)
611 {
612 if (g_pDACInst == NULL)
613 {
614 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
615 return;
616 }
617
618 stDAC_SET_OUTPUT_SOURCE DACArgs;
619 DACArgs.enOutputType = enOutputType;
620 DACArgs.bIsYPbPr = bIsYPbPr;
621
622 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_OUTPUT_SOURCE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
623 {
624 printf("Obtain DAC engine fail\n");
625 }
626 return;
627 }
628
MApi_DAC_SetOutputLevel_U2(void * pInstance,E_DAC_MAX_OUTPUT_LEVEL enLevel,MS_BOOL bIsYPbPr)629 void MApi_DAC_SetOutputLevel_U2(void* pInstance, E_DAC_MAX_OUTPUT_LEVEL enLevel, MS_BOOL bIsYPbPr)
630 {
631 MDrv_DAC_SetOutputLevel((EN_DAC_MAX_OUTPUT_LEVEL)enLevel,bIsYPbPr);
632 }
633
MApi_DAC_SetOutputLevel(E_DAC_MAX_OUTPUT_LEVEL enLevel,MS_BOOL bIsYPbPr)634 void MApi_DAC_SetOutputLevel(E_DAC_MAX_OUTPUT_LEVEL enLevel, MS_BOOL bIsYPbPr)
635 {
636 if (g_pDACInst == NULL)
637 {
638 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
639 return;
640 }
641
642 stDAC_SET_OUTPUT_LEVEL DACArgs;
643 DACArgs.enLevel = enLevel;
644 DACArgs.bIsYPbPr = bIsYPbPr;
645
646 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_OUTPUT_LEVEL, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
647 {
648 printf("Obtain DAC engine fail\n");
649 }
650 return;
651 }
652
MApi_DAC_SetOutputSwapSel_U2(void * pInstance,E_DAC_SWAP_SEL enSwap,MS_BOOL bIsYPbPr)653 void MApi_DAC_SetOutputSwapSel_U2(void* pInstance, E_DAC_SWAP_SEL enSwap,MS_BOOL bIsYPbPr)
654 {
655 MDrv_DAC_Get_Semaphore(pInstance);
656 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
657 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
658 MDrv_DAC_SetOutputSwapSel((EN_DAC_SWAP_SEL)enSwap, bIsYPbPr);
659
660 if(bIsYPbPr)
661 {
662 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDSwapSEL = enSwap;
663 }
664 else
665 {
666 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDSwapSEL = enSwap;
667 }
668
669 MDrv_DAC_Release_Semaphore();
670 }
671
MApi_DAC_SetOutputSwapSel(E_DAC_SWAP_SEL enSwap,MS_BOOL bIsYPbPr)672 void MApi_DAC_SetOutputSwapSel(E_DAC_SWAP_SEL enSwap,MS_BOOL bIsYPbPr)
673 {
674 if (g_pDACInst == NULL)
675 {
676 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
677 return;
678 }
679
680 stDAC_SET_OUTPUT_SWAPSEL DACArgs;
681 DACArgs.enSwap = enSwap;
682 DACArgs.bIsYPbPr = bIsYPbPr;
683
684 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_OUTPUT_SWAPSEL, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
685 {
686 printf("Obtain DAC engine fail\n");
687 }
688 return;
689 }
690
MApi_DAC_SetClkInv_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bIsYPbPr)691 void MApi_DAC_SetClkInv_U2(void* pInstance, MS_BOOL bEnable, MS_BOOL bIsYPbPr)
692 {
693 MDrv_DAC_SetClkInv(bEnable, bIsYPbPr);
694 }
695
MApi_DAC_SetClkInv(MS_BOOL bEnable,MS_BOOL bIsYPbPr)696 void MApi_DAC_SetClkInv(MS_BOOL bEnable, MS_BOOL bIsYPbPr)
697 {
698 if (g_pDACInst == NULL)
699 {
700 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
701 return;
702 }
703
704 stDAC_SET_CLKINV DACArgs;
705 DACArgs.bEnable = bEnable;
706 DACArgs.bIsYPbPr = bIsYPbPr;
707
708 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_CLKINV, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
709 {
710 printf("Obtain DAC engine fail\n");
711 }
712 return;
713 }
714
MApi_DAC_OnOffSD_U2(void * pInstance,E_DAC_SD_ENABLE_CTRL enBit)715 void MApi_DAC_OnOffSD_U2(void* pInstance, E_DAC_SD_ENABLE_CTRL enBit)
716 {
717 MDrv_DAC_OnOffSD((EN_DAC_SD_ENABLE_CTRL)enBit);
718 }
719
MApi_DAC_OnOffSD(E_DAC_SD_ENABLE_CTRL enBit)720 void MApi_DAC_OnOffSD(E_DAC_SD_ENABLE_CTRL enBit)
721 {
722 if (g_pDACInst == NULL)
723 {
724 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
725 return;
726 }
727
728 stDAC_ONOFF_SD DACArgs;
729 DACArgs.enBit = enBit;
730
731 if(UtopiaIoctl(g_pDACInst, E_DAC_ONOFF_SD, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
732 {
733 printf("Obtain DAC engine fail\n");
734 }
735 return;
736 }
737
MApi_DAC_GetSDStatus_U2(void * pInstance)738 E_DAC_SD_ENABLE_CTRL MApi_DAC_GetSDStatus_U2(void* pInstance)
739 {
740 E_DAC_SD_ENABLE_CTRL enBit = 0;
741 MDrv_DAC_Get_Semaphore(pInstance);
742 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
743 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
744 enBit = MDrv_DAC_GetSDStatus();
745 MDrv_DAC_Release_Semaphore();
746 return enBit;
747 }
748
MApi_DAC_GetSDStatus(void)749 E_DAC_SD_ENABLE_CTRL MApi_DAC_GetSDStatus(void)
750 {
751 if (g_pDACInst == NULL)
752 {
753 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
754 return FALSE;
755 }
756
757 stDAC_GET_SD_STATUS DACArgs;
758 DACArgs.enBit = E_DAC_SD_OFF;
759 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_SD_STATUS, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
760 {
761 printf("Obtain DAC engine fail\n");
762 }
763 return DACArgs.enBit;
764 }
765
MApi_DAC_OnOffHD_U2(void * pInstance,E_DAC_HD_ENABLE_CTRL enBit)766 void MApi_DAC_OnOffHD_U2(void* pInstance, E_DAC_HD_ENABLE_CTRL enBit)
767 {
768 MDrv_DAC_OnOffHD((EN_DAC_HD_ENABLE_CTRL)enBit);
769 }
770
MApi_DAC_OnOffHD(E_DAC_HD_ENABLE_CTRL enBit)771 void MApi_DAC_OnOffHD(E_DAC_HD_ENABLE_CTRL enBit)
772 {
773 if (g_pDACInst == NULL)
774 {
775 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
776 return;
777 }
778
779 stDAC_ONOFF_HD DACArgs;
780 DACArgs.enBit = enBit;
781
782 if(UtopiaIoctl(g_pDACInst, E_DAC_ONOFF_HD, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
783 {
784 printf("Obtain DAC engine fail\n");
785 }
786 return;
787 }
788
MApi_DAC_GetHDStatus_U2(void * pInstance)789 E_DAC_HD_ENABLE_CTRL MApi_DAC_GetHDStatus_U2(void* pInstance)
790 {
791 MS_BOOL bRet = FALSE;
792 MDrv_DAC_Get_Semaphore(pInstance);
793 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
794 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
795 bRet = MDrv_DAC_GetHDStatus();
796 MDrv_DAC_Release_Semaphore();
797 return bRet;
798 }
799
MApi_DAC_GetHDStatus(void)800 E_DAC_HD_ENABLE_CTRL MApi_DAC_GetHDStatus(void)
801 {
802 if (g_pDACInst == NULL)
803 {
804 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
805 return FALSE;
806 }
807
808 stDAC_GET_HD_STATUS DACArgs;
809 DACArgs.enBit = E_DAC_HD_OFF;
810
811 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_HD_STATUS, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
812 {
813 printf("Obtain DAC engine fail\n");
814 }
815 return DACArgs.enBit;
816 }
817
818 //set output timing for YPbPr (hdgen)
MApi_DAC_SetYPbPrOutputTiming_U2(void * pInstance,E_OUTPUT_VIDEO_TIMING_TYPE eTiming)819 void MApi_DAC_SetYPbPrOutputTiming_U2(void* pInstance, E_OUTPUT_VIDEO_TIMING_TYPE eTiming)
820 {
821 EN_OUTPUT_VIDEO_TIMING_TYPE enTimingType;
822 MS_BOOL bRet = FALSE;
823
824 bRet = _MApi_DAC_VideoTiming_ReMapping(eTiming, &enTimingType);
825 if(!bRet)
826 {
827 printf("[MAPI_DAC]Error timing type %d!\n", eTiming);
828 return;
829 }
830
831 MDrv_DAC_SetOutputTiming(enTimingType);
832
833 MDrv_DAC_Get_Semaphore(pInstance);
834 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
835 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
836 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_now = enTimingType;
837 MDrv_DAC_Release_Semaphore();
838 }
839
MApi_DAC_SetYPbPrOutputTiming(E_OUTPUT_VIDEO_TIMING_TYPE eTiming)840 void MApi_DAC_SetYPbPrOutputTiming(E_OUTPUT_VIDEO_TIMING_TYPE eTiming)
841 {
842 if (g_pDACInst == NULL)
843 {
844 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
845 return;
846 }
847
848 stDAC_SET_YPBPR_OUTPUTTIMING DACArgs;
849 DACArgs.eTiming = eTiming;
850
851 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_YPBPR_OUTPUTTIMING, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
852 {
853 printf("Obtain DAC engine fail\n");
854 }
855 return;
856 }
857
858
MApi_DAC_ClkSel_U2(void * pInstance,E_OUTPUT_VIDEO_TIMING_TYPE eTiming,E_OUTPUT_BIT_TYPE ebits)859 void MApi_DAC_ClkSel_U2(void* pInstance, E_OUTPUT_VIDEO_TIMING_TYPE eTiming, E_OUTPUT_BIT_TYPE ebits)
860 {
861 EN_OUTPUT_VIDEO_TIMING_TYPE enTimingType;
862 EN_OUTPUT_BIT_TYPE enBits;
863 MS_BOOL bRet = FALSE;
864
865 bRet = _MApi_DAC_VideoTiming_ReMapping(eTiming, &enTimingType);
866 if(!bRet)
867 {
868 printf("[MAPI_DAC]Error timing type %d!\n", eTiming);
869 return;
870 }
871
872 switch(ebits)
873 {
874 case E_COLOR_8_BIT:
875 enBits = COLOR_8_BIT;
876 break;
877 case E_COLOR_10_BIT:
878 enBits = COLOR_10_BIT;
879 break;
880 case E_COLOR_12_BIT:
881 enBits = COLOR_12_BIT;
882 break;
883 default:
884 printf("[MAPI_CLKSEL]Error bit type %d!\n", ebits);
885 return;
886 }
887 MDrv_ClkSel_Set(enTimingType, enBits);
888 }
889
MApi_DAC_ClkSel(E_OUTPUT_VIDEO_TIMING_TYPE eTiming,E_OUTPUT_BIT_TYPE ebits)890 void MApi_DAC_ClkSel(E_OUTPUT_VIDEO_TIMING_TYPE eTiming, E_OUTPUT_BIT_TYPE ebits)
891 {
892 if (g_pDACInst == NULL)
893 {
894 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
895 return;
896 }
897
898 stDAC_CLKSEL DACArgs;
899 DACArgs.eTiming = eTiming;
900 DACArgs.ebits = ebits;
901
902 if(UtopiaIoctl(g_pDACInst, E_DAC_CLKSEL, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
903 {
904 printf("Obtain DAC engine fail\n");
905 }
906 return;
907
908 }
909
MApi_DAC_Exit_U2(void * pInstance)910 void MApi_DAC_Exit_U2(void* pInstance)
911 {
912 MDrv_DAC_Exit();
913 if(UtopiaClose(g_pDACInst))
914 {
915 g_pDACRes = NULL;
916 g_pDACInst = NULL;
917 }
918 else
919 {
920 printf("Close DAC engine fail\n");
921 }
922 }
923
MApi_DAC_Exit(void)924 void MApi_DAC_Exit(void)
925 {
926 if (g_pDACInst == NULL)
927 {
928 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
929 return;
930 }
931
932 if(UtopiaIoctl(g_pDACInst, E_DAC_EXIT, NULL) != UTOPIA_STATUS_SUCCESS)
933 {
934 printf("Obtain DAC engine fail\n");
935 }
936 return;
937 }
938
MApi_DAC_DumpTable_U2(void * pInstance,MS_U8 * pDACTable,MS_U8 u8DACtype)939 void MApi_DAC_DumpTable_U2(void* pInstance, MS_U8 *pDACTable, MS_U8 u8DACtype)
940 {
941 MDrv_DAC_Get_Semaphore(pInstance);
942 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
943 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
944 MDrv_DAC_DumpTable(pDACTable, u8DACtype);
945
946 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.DACTable[u8DACtype] = (MS_VIRT)pDACTable;
947 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u8DACtype[u8DACtype] = 1;
948
949 if((u8DACtype == DAC_TABTYPE_SC1_INIT) || (u8DACtype == DAC_TABTYPE_SC1_INIT_SC))
950 {
951 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_SC1 = pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_now;
952 }
953 else
954 {
955 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_SC0 = pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_now;
956 }
957
958 MDrv_DAC_Release_Semaphore();
959 }
960
MApi_DAC_DumpTable(MS_U8 * pDACTable,MS_U8 u8DACtype)961 void MApi_DAC_DumpTable(MS_U8 *pDACTable, MS_U8 u8DACtype)
962 {
963 if (g_pDACInst == NULL)
964 {
965 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
966 return;
967 }
968
969 stDAC_DUMP_TABLE DACArgs;
970 DACArgs.pDACTable = pDACTable;
971 DACArgs.u8DACtype = u8DACtype;
972
973 if(UtopiaIoctl(g_pDACInst, E_DAC_DUMP_TABLE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
974 {
975 printf("Obtain DAC engine fail\n");
976 }
977 return;
978 }
979
980 //----------------------------------------------------------------
981 // DAC - set half output current
982 // @return none
983 //----------------------------------------------------------------
MApi_DAC_SetIHalfOutput_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bIsYPbPr)984 void MApi_DAC_SetIHalfOutput_U2(void* pInstance, MS_BOOL bEnable, MS_BOOL bIsYPbPr)
985 {
986 MDrv_DAC_SetIHalfOutput(bEnable, bIsYPbPr);
987 }
988
MApi_DAC_SetIHalfOutput(MS_BOOL bEnable,MS_BOOL bIsYPbPr)989 void MApi_DAC_SetIHalfOutput(MS_BOOL bEnable, MS_BOOL bIsYPbPr)
990 {
991 if (g_pDACInst == NULL)
992 {
993 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
994 return;
995 }
996
997 stDAC_SET_IHALF_OUTPUT DACArgs;
998 DACArgs.bEnable = bEnable;
999 DACArgs.bIsYPbPr = bIsYPbPr;
1000
1001 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_IHALF_OUTPUT, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1002 {
1003 printf("Obtain DAC engine fail\n");
1004 }
1005 return;
1006 }
1007
1008 //----------------------------------------------------------------
1009 // DAC - set quart output current
1010 // @return none
1011 //----------------------------------------------------------------
MApi_DAC_SetQuartOutput_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bIsYPbPr)1012 void MApi_DAC_SetQuartOutput_U2(void* pInstance, MS_BOOL bEnable,MS_BOOL bIsYPbPr)
1013 {
1014 MDrv_DAC_SetQuartOutput(bEnable, bIsYPbPr);
1015 }
1016
MApi_DAC_SetQuartOutput(MS_BOOL bEnable,MS_BOOL bIsYPbPr)1017 void MApi_DAC_SetQuartOutput(MS_BOOL bEnable,MS_BOOL bIsYPbPr)
1018 {
1019 if (g_pDACInst == NULL)
1020 {
1021 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1022 return;
1023 }
1024
1025 stDAC_SET_QUART_OUTPUT DACArgs;
1026 DACArgs.bEnable = bEnable;
1027 DACArgs.bIsYPbPr = bIsYPbPr;
1028
1029 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_QUART_OUTPUT, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1030 {
1031 printf("Obtain DAC engine fail\n");
1032 }
1033 return;
1034 }
1035
1036 //----------------------------------------------------------------
1037 // DAC - SetDacState
1038 // When DAC is already enabled in the MBoot, we can use this function to
1039 // mark the DAC init state as "enabled".
1040 // @bInited: TRUE: enabled, FALSE: not enabled
1041 // @bIsYPbPr: TRUE: HD, FALSE: SD
1042 // @return none
1043 //----------------------------------------------------------------
MApi_DAC_SetDacState_U2(void * pInstance,MS_BOOL bEnabled,MS_BOOL bIsYPbPr)1044 void MApi_DAC_SetDacState_U2(void* pInstance, MS_BOOL bEnabled, MS_BOOL bIsYPbPr)
1045 {
1046 MDrv_DAC_SetDACState(bEnabled, bIsYPbPr);
1047 }
1048
MApi_DAC_SetDacState(MS_BOOL bEnabled,MS_BOOL bIsYPbPr)1049 void MApi_DAC_SetDacState(MS_BOOL bEnabled, MS_BOOL bIsYPbPr)
1050 {
1051 if (g_pDACInst == NULL)
1052 {
1053 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1054 return;
1055 }
1056
1057 stDAC_SET_DAC_STATE DACArgs;
1058 DACArgs.bEnabled = bEnabled;
1059 DACArgs.bIsYPbPr = bIsYPbPr;
1060
1061 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_DAC_STATE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1062 {
1063 printf("Obtain DAC engine fail\n");
1064 }
1065 return;
1066 }
1067
1068 //----------------------------------------------------------------
1069 // MApi_DAC_HotPlugDetect - Get DAC HotPlug state
1070 // @param: SelDAC: DAC_DETECT_HD, DAC_DETECT_SD
1071 // @param: DetectType: DAC_DETECT_PLUGIN, DAC_DETECT_PLUGOUT
1072 // @param: bIsSignIn: Report signal is in/out
1073 // @return: TRUE is working successful
1074 //----------------------------------------------------------------
MApi_DAC_HotPlugDetect_U2(void * pInstance,E_DAC_DETECT SelDAC,E_DAC_DETECT_TYPE DetectType,MS_BOOL * State)1075 MS_BOOL MApi_DAC_HotPlugDetect_U2(void* pInstance, E_DAC_DETECT SelDAC,E_DAC_DETECT_TYPE DetectType, MS_BOOL *State)
1076 {
1077 return MDrv_DAC_HotPlugDetect((EN_DAC_DETECT) SelDAC, (EN_DAC_DETECT_TYPE)DetectType, State);
1078 }
1079
MApi_DAC_HotPlugDetect(E_DAC_DETECT SelDAC,E_DAC_DETECT_TYPE DetectType,MS_BOOL * State)1080 MS_BOOL MApi_DAC_HotPlugDetect(E_DAC_DETECT SelDAC,E_DAC_DETECT_TYPE DetectType, MS_BOOL *State)
1081 {
1082 if (g_pDACInst == NULL)
1083 {
1084 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1085 return FALSE;
1086 }
1087
1088 stDAC_HOTPLUG_DETECT DACArgs;
1089 DACArgs.SelDAC = SelDAC;
1090 DACArgs.DetectType = DetectType;
1091 DACArgs.State = State;
1092 DACArgs.bReturnValue = FALSE;
1093
1094 if(UtopiaIoctl(g_pDACInst, E_DAC_HOTPLUG_DETECT, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1095 {
1096 printf("Obtain DAC engine fail\n");
1097 }
1098 return DACArgs.bReturnValue;
1099 }
1100
1101 #ifdef CONFIG_MSTAR_CLKM
1102 #include "drvCLKM.h"
1103 #endif
Mapi_DAC_SetPowerState_U2(void * pInstance,E_DAC_POWER_MODE ePowerState)1104 MS_U32 Mapi_DAC_SetPowerState_U2(void* pInstance, E_DAC_POWER_MODE ePowerState)
1105 {
1106 static EN_POWER_MODE prev_PowerState = E_DAC_POWER_MECHANICAL;
1107 MS_U32 u32Ret = FALSE;
1108
1109 MDrv_DAC_Get_Semaphore(pInstance);
1110 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
1111 UtopiaResourceGetPrivate(g_pDACRes,(void**)(&pDACResourcePrivate));
1112
1113 if(ePowerState == E_DAC_POWER_SUSPEND)
1114 {
1115 prev_PowerState = ePowerState;
1116 u32Ret = TRUE; //SUSPEND_OK;
1117 #ifdef CONFIG_MSTAR_CLKM
1118 MS_U32 u32DacHandle = Drv_Clkm_Get_Handle("g_clk_hdgen");
1119 Drv_Clkm_Clk_Gate_Disable(u32DacHandle);
1120 u32DacHandle = Drv_Clkm_Get_Handle("g_clk_hdgen_fir");
1121 Drv_Clkm_Clk_Gate_Disable(u32DacHandle);
1122 u32DacHandle = Drv_Clkm_Get_Handle("g_clk_hdgen_in");
1123 Drv_Clkm_Clk_Gate_Disable(u32DacHandle);
1124 #endif
1125 }
1126 else if(ePowerState == E_DAC_POWER_RESUME)
1127 {
1128 if(prev_PowerState == E_POWER_SUSPEND)
1129 {
1130 MDrv_DAC_SetIOMapBase(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u32NPMBase, pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u32PMBase);
1131 MDrv_DAC_Init();
1132 MDrv_DAC_SetClkInv(TRUE, TRUE);
1133
1134 // Setting HD DAC
1135 MDrv_DAC_Enable(TRUE, TRUE);
1136 MDrv_DAC_SetOutputSource(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDOutputType, TRUE);
1137 MDrv_DAC_SetOutputSwapSel(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDSwapSEL, TRUE);
1138 MDrv_DAC_SetOutputLevel(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.HDMaxOutputLevel, TRUE);
1139
1140 // Setting SD DAC
1141 MDrv_DAC_Enable(TRUE, FALSE);
1142 MDrv_DAC_SetOutputSource(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDOutputType, FALSE);
1143 MDrv_DAC_SetOutputSwapSel(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDSwapSEL, FALSE);
1144 MDrv_DAC_SetOutputLevel(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.SDMaxOutputLevel, FALSE);
1145
1146 int i = 0;
1147 MS_U8 *DacTbl = NULL;
1148 MS_U8 DacType = 0;
1149 for(i = 0; i < DAC_TABLE_TYPE_NUM; i++)
1150 {
1151 if(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u8DACtype[i] == 1)
1152 {
1153 if((i == DAC_TABTYPE_SC1_INIT) || (i == DAC_TABTYPE_SC1_INIT_SC))
1154 {
1155 MDrv_DAC_SetOutputTiming(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_SC1);
1156 }
1157 else
1158 {
1159 MDrv_DAC_SetOutputTiming(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_SC0);
1160 }
1161 DacTbl = (MS_U8*)pDACResourcePrivate->stapiDAC._stDac_DacPowerState.DACTable[i];
1162 DacType = i;
1163 MDrv_DAC_DumpTable(DacTbl, DacType);
1164 }
1165 }
1166
1167 prev_PowerState = ePowerState;
1168 u32Ret = TRUE;
1169 }
1170 else
1171 {
1172 printf("[%s,%5d] It is not suspended yet. We shouldn't resume\n", __FUNCTION__, __LINE__);
1173 u32Ret = FALSE;
1174 }
1175 }
1176 else
1177 {
1178 printf("[%s,%5d] Do Nothing: %u\n", __FUNCTION__, __LINE__, ePowerState);
1179 u32Ret = FALSE;
1180 }
1181
1182 MDrv_DAC_Release_Semaphore();
1183 return u32Ret;
1184 }
1185
Mapi_DAC_SetPowerState(E_DAC_POWER_MODE ePowerState)1186 MS_U32 Mapi_DAC_SetPowerState(E_DAC_POWER_MODE ePowerState)
1187 {
1188 if (g_pDACInst == NULL)
1189 {
1190 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1191 return FALSE;
1192 }
1193
1194 stDAC_POWER_MODE DACArgs;
1195 DACArgs.ePowerState = ePowerState;
1196 DACArgs.stReturnValue = 0;
1197
1198 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_POWER_STATE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1199 {
1200 printf("Obtain DAC engine fail\n");
1201 }
1202 return DACArgs.stReturnValue;
1203 }
1204
1205 //----------------------------------------------------------------
1206 // MApi_DAC_SetWSSOnOFF
1207 // @bEnabled: TRUE: enabled, FALSE: not enabled
1208 // @bIsYPbPr: TRUE: component, FALSE: CVBS
1209 // @return: TRUE is working successful
1210 //----------------------------------------------------------------
MApi_DAC_SetWSSOnOff_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bIsYPbPr)1211 MS_BOOL MApi_DAC_SetWSSOnOff_U2(void* pInstance, MS_BOOL bEnable, MS_BOOL bIsYPbPr)
1212 {
1213 if (!bIsYPbPr)
1214 {
1215 // CVBS VBI
1216 printf("CVBS VBI is not implement at here! \n");
1217 return FALSE;
1218 }
1219 else
1220 {
1221 MDrv_DAC_SetWSSOnOff(bEnable);
1222 }
1223
1224 return TRUE;
1225 }
1226
MApi_DAC_SetWSSOnOff(MS_BOOL bEnable,MS_BOOL bIsYPbPr)1227 MS_BOOL MApi_DAC_SetWSSOnOff(MS_BOOL bEnable, MS_BOOL bIsYPbPr)
1228 {
1229 if (g_pDACInst == NULL)
1230 {
1231 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1232 return FALSE;
1233 }
1234
1235 stDAC_SET_WSSONOFF DACArgs;
1236 DACArgs.bEnable = bEnable;
1237 DACArgs.bIsYPbPr = bIsYPbPr;
1238 DACArgs.bReturnValue = FALSE;
1239
1240 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_WSSONOFF, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1241 {
1242 printf("Obtain DAC engine fail\n");
1243 }
1244 return DACArgs.bReturnValue;
1245 }
1246
1247 //----------------------------------------------------------------
1248 // MApi_DAC_GetWSSStatus
1249 // @bIsYPbPr: TRUE: component, FALSE: CVBS
1250 // @pEnabled: \b OUT: the pointer to WSS OnOff. TRUE: enabled, FALSE: not enabled
1251 ///@pSetWSS_Data: \b OUT: the pointer to DAC_SETWSS_INFO structure
1252 // @return: TRUE is working successful
1253 //----------------------------------------------------------------
MApi_DAC_GetWSSStatus_U2(void * pInstance,MS_BOOL bIsYPbPr,MS_BOOL * pEnable,DAC_SETWSS_INFO * pSetWSS_Data)1254 MS_BOOL MApi_DAC_GetWSSStatus_U2(void* pInstance, MS_BOOL bIsYPbPr, MS_BOOL *pEnable, DAC_SETWSS_INFO *pSetWSS_Data)
1255 {
1256 if (!bIsYPbPr)
1257 {
1258 // CVBS VBI
1259 printf("CVBS VBI is not implement at here! \n");
1260 return FALSE;
1261 }
1262 else
1263 {
1264 *pEnable = MDrv_DAC_GetWSSStatus();
1265
1266 //TBD, set defalut value first.
1267 if(pSetWSS_Data != NULL)
1268 {
1269 pSetWSS_Data->u32DAC_SetWSS_version = 0;
1270 pSetWSS_Data->u32DAC_SetWSS_Length = sizeof(DAC_SETWSS_INFO);
1271 pSetWSS_Data->eOutput_Timing = E_RES_720x480I_60Hz;
1272 pSetWSS_Data->eVBI_WSS_Type = E_DAC_VIDEO_VBI_WSS_START;
1273 }
1274 }
1275
1276 return TRUE;
1277 }
1278
MApi_DAC_GetWSSStatus(MS_BOOL bIsYPbPr,MS_BOOL * pEnable,DAC_SETWSS_INFO * pSetWSS_Data)1279 MS_BOOL MApi_DAC_GetWSSStatus(MS_BOOL bIsYPbPr, MS_BOOL *pEnable, DAC_SETWSS_INFO *pSetWSS_Data)
1280 {
1281 if (g_pDACInst == NULL)
1282 {
1283 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1284 return FALSE;
1285 }
1286
1287 stDAC_GET_WSSSTATUS DACArgs;
1288 DACArgs.bIsYPbPr = bIsYPbPr;
1289 DACArgs.pEnable = pEnable;
1290 DACArgs.pSetWSS_Data = pSetWSS_Data;
1291 DACArgs.bReturnValue = FALSE;
1292
1293 if(UtopiaIoctl(g_pDACInst, E_DAC_GET_WSSSTATUS, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1294 {
1295 printf("Obtain DAC engine fail\n");
1296 }
1297 return DACArgs.bReturnValue;
1298 }
1299
1300 //----------------------------------------------------------------
1301 // MApi_DAC_ResetWSSData
1302 // @bIsYPbPr: TRUE: component, FALSE: CVBS
1303 // @return: TRUE is working successful
1304 //----------------------------------------------------------------
MApi_DAC_ResetWSSData_U2(void * pInstance,MS_BOOL bIsYPbPr)1305 MS_BOOL MApi_DAC_ResetWSSData_U2(void* pInstance, MS_BOOL bIsYPbPr)
1306 {
1307 if (!bIsYPbPr)
1308 {
1309 // CVBS VBI
1310 printf("CVBS VBI is not implement at here! \n");
1311 return FALSE;
1312 }
1313 else
1314 {
1315 MDrv_DAC_ResetWSSData();
1316 }
1317
1318 return TRUE;
1319 }
1320
MApi_DAC_ResetWSSData(MS_BOOL bIsYPbPr)1321 MS_BOOL MApi_DAC_ResetWSSData(MS_BOOL bIsYPbPr)
1322 {
1323 if (g_pDACInst == NULL)
1324 {
1325 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1326 return FALSE;
1327 }
1328
1329 stDAC_RESET_WSSDATA DACArgs;
1330 DACArgs.bIsYPbPr = bIsYPbPr;
1331 DACArgs.bReturnValue = FALSE;
1332
1333 if(UtopiaIoctl(g_pDACInst, E_DAC_RESET_WSSDATA, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1334 {
1335 printf("Obtain DAC engine fail\n");
1336 }
1337 return DACArgs.bReturnValue;
1338 }
1339
1340 //----------------------------------------------------------------
1341 // MApi_DAC_SetWSSOutput
1342 // @bEnabled: TRUE: enabled, FALSE: not enabled
1343 // @bIsYPbPr: TRUE: component, FALSE: CVBS
1344 // @DAC_SETWSS_INFO: video vbi data struct
1345 // @return: TRUE is working successful
1346 //----------------------------------------------------------------
MApi_DAC_SetWSSOutput_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bIsYPbPr,DAC_SETWSS_INFO SetWSS_Data)1347 MS_BOOL MApi_DAC_SetWSSOutput_U2(void* pInstance, MS_BOOL bEnable, MS_BOOL bIsYPbPr, DAC_SETWSS_INFO SetWSS_Data)
1348 {
1349 MS_U16 u16WSS_Type = 0x00;
1350 EN_OUTPUT_VIDEO_TIMING_TYPE eVideo_Timing = RES_720x480I_60Hz;
1351 MS_BOOL bRet = FALSE;
1352
1353 if (!bIsYPbPr)
1354 {
1355 // CVBS VBI
1356 printf("CVBS VBI is not implement at here! \n");
1357 return FALSE;
1358 }
1359 else
1360 {
1361 bRet = _MApi_DAC_VideoTiming_ReMapping(SetWSS_Data.eOutput_Timing, &eVideo_Timing);
1362 if(!bRet)
1363 {
1364 printf("[MAPI_DAC]Error timing type %d!\n", SetWSS_Data.eOutput_Timing);
1365 return FALSE;
1366 }
1367
1368 if(((SetWSS_Data.eVBI_WSS_Type >= E_DAC_VIDEO_VBI_WSS_AS_4x3_FULL) && (SetWSS_Data.eVBI_WSS_Type <= E_DAC_VIDEO_VBI_WSS_AS_16x9_ANAMORPHIC))
1369 ||((SetWSS_Data.eVBI_WSS_Type >= E_DAC_VIDEO_VBI_WSS525_A_AS_4x3_NORMAL) && (SetWSS_Data.eVBI_WSS_Type <= E_DAC_VIDEO_VBI_WSS525_A_AS_RESERVED)))
1370 {
1371 switch(SetWSS_Data.eVBI_WSS_Type)
1372 {
1373 default:
1374 case E_DAC_VIDEO_VBI_WSS_AS_4x3_FULL:
1375 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_4x3_FULL;
1376 break;
1377 case E_DAC_VIDEO_VBI_WSS_AS_14x9_LETTERBOX_CENTER:
1378 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_14x9_LETTERBOX_CENTER;
1379 break;
1380 case E_DAC_VIDEO_VBI_WSS_AS_14x9_LETTERBOX_TOP:
1381 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_14x9_LETTERBOX_TOP;
1382 break;
1383 case E_DAC_VIDEO_VBI_WSS_AS_16x9_LETTERBOX_CENTER:
1384 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_16x9_LETTERBOX_CENTER;
1385 break;
1386 case E_DAC_VIDEO_VBI_WSS_AS_16x9_LETTERBOX_TOP:
1387 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_16x9_LETTERBOX_TOP;
1388 break;
1389 case E_DAC_VIDEO_VBI_WSS_AS_ABOVE16x9_LETTERBOX_CENTER:
1390 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_ABOVE16x9_LETTERBOX_CENTER;
1391 break;
1392 case E_DAC_VIDEO_VBI_WSS_AS_14x9_FULL_CENTER:
1393 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_14x9_FULL_CENTER;
1394 break;
1395 case E_DAC_VIDEO_VBI_WSS_AS_16x9_ANAMORPHIC:
1396 u16WSS_Type = DAC_VIDEO_VBI_WSS_AS_16x9_ANAMORPHIC;
1397 break;
1398 case E_DAC_VIDEO_VBI_WSS525_A_AS_4x3_NORMAL:
1399 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_AS_4x3_NORMAL;
1400 break;
1401 case E_DAC_VIDEO_VBI_WSS525_A_AS_4x3_LETTERBOX:
1402 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_AS_4x3_LETTERBOX;
1403 break;
1404 //case E_DAC_VIDEO_VBI_WSS525_A_AS_16x9_ANAMORPHIC:
1405 case E_DAC_VIDEO_VBI_WSS525_A_AS_16x9_NORMAL:
1406 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_AS_16x9_NORMAL;
1407 break;
1408 case E_DAC_VIDEO_VBI_WSS525_A_AS_RESERVED:
1409 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_AS_RESERVED;
1410 break;
1411 }
1412
1413 bRet = MDrv_DAC_WSS_SetAS(bEnable, eVideo_Timing, u16WSS_Type);
1414 }
1415 else if(((SetWSS_Data.eVBI_WSS_Type >= E_DAC_VIDEO_VBI_WSS_CGMS_COPYRIGHT) && (SetWSS_Data.eVBI_WSS_Type <= E_DAC_VIDEO_VBI_WSS_CGMS_COPY_PROTECTION))
1416 ||((SetWSS_Data.eVBI_WSS_Type >= E_DAC_VIDEO_VBI_WSS_CGMS_COPY_FREELY) && (SetWSS_Data.eVBI_WSS_Type <= E_DAC_VIDEO_VBI_WSS_CGMS_COPY_NEVER))
1417 ||((SetWSS_Data.eVBI_WSS_Type >= E_DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_FREELY) && (SetWSS_Data.eVBI_WSS_Type <= E_DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_NEVER)))
1418 {
1419 switch(SetWSS_Data.eVBI_WSS_Type)
1420 {
1421 default:
1422 case E_DAC_VIDEO_VBI_WSS_CGMS_COPYRIGHT:
1423 u16WSS_Type = DAC_VIDEO_VBI_WSS_CGMS_COPYRIGHT;
1424 break;
1425 case E_DAC_VIDEO_VBI_WSS_CGMS_COPY_PROTECTION:
1426 u16WSS_Type = DAC_VIDEO_VBI_WSS_CGMS_COPY_PROTECTION;
1427 break;
1428 case E_DAC_VIDEO_VBI_WSS_CGMS_COPY_FREELY:
1429 u16WSS_Type = DAC_VIDEO_VBI_WSS_CGMS_COPY_FREELY;
1430 break;
1431 case E_DAC_VIDEO_VBI_WSS_CGMS_COPY_ONCE:
1432 u16WSS_Type = DAC_VIDEO_VBI_WSS_CGMS_COPY_ONCE;
1433 break;
1434 case E_DAC_VIDEO_VBI_WSS_CGMS_COPY_NO_MORE:
1435 u16WSS_Type = DAC_VIDEO_VBI_WSS_CGMS_COPY_NO_MORE;
1436 break;
1437 case E_DAC_VIDEO_VBI_WSS_CGMS_COPY_NEVER:
1438 u16WSS_Type = DAC_VIDEO_VBI_WSS_CGMS_COPY_NEVER;
1439 break;
1440 case E_DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_FREELY:
1441 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_FREELY;
1442 break;
1443 case E_DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_ONCE:
1444 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_ONCE;
1445 break;
1446 case E_DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_NO_MORE:
1447 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_NO_MORE;
1448 break;
1449 case E_DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_NEVER:
1450 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_CGMS_COPY_NEVER;
1451 break;
1452 }
1453
1454 bRet = MDrv_DAC_WSS_SetCGMS(bEnable, eVideo_Timing, u16WSS_Type);
1455 }
1456 else if((SetWSS_Data.eVBI_WSS_Type >= E_DAC_VIDEO_VBI_WSS525_A_APS_NO_APS) && (SetWSS_Data.eVBI_WSS_Type <= E_DAC_VIDEO_VBI_WSS525_A_APS_PSP_4_LINE_CS))
1457 {
1458 switch(SetWSS_Data.eVBI_WSS_Type)
1459 {
1460 default:
1461 case E_DAC_VIDEO_VBI_WSS525_A_APS_NO_APS:
1462 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_APS_NO_APS;
1463 break;
1464 case E_DAC_VIDEO_VBI_WSS525_A_APS_PSP_CS_OFF:
1465 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_APS_PSP_CS_OFF;
1466 break;
1467 case E_DAC_VIDEO_VBI_WSS525_A_APS_PSP_2_LINE_CS:
1468 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_APS_PSP_2_LINE_CS;
1469 break;
1470 case E_DAC_VIDEO_VBI_WSS525_A_APS_PSP_4_LINE_CS:
1471 u16WSS_Type = DAC_VIDEO_VBI_WSS525_A_APS_PSP_4_LINE_CS;
1472 break;
1473 }
1474
1475 bRet = MDrv_DAC_WSS_SetAPS(bEnable, eVideo_Timing, u16WSS_Type);
1476 }
1477
1478 if(!bRet)
1479 {
1480 printf("[MAPI_DAC]The DAC WSS Timing %d Set Type %d Error!\n", SetWSS_Data.eOutput_Timing, SetWSS_Data.eVBI_WSS_Type);
1481 return FALSE;
1482 }
1483 }
1484
1485 return TRUE;
1486 }
1487
MApi_DAC_SetWSSOutput(MS_BOOL bEnable,MS_BOOL bIsYPbPr,DAC_SETWSS_INFO SetWSS_Data)1488 MS_BOOL MApi_DAC_SetWSSOutput(MS_BOOL bEnable, MS_BOOL bIsYPbPr, DAC_SETWSS_INFO SetWSS_Data)
1489 {
1490 if (g_pDACInst == NULL)
1491 {
1492 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1493 return FALSE;
1494 }
1495
1496 stDAC_SET_WSSOUTPUT DACArgs;
1497 DACArgs.bEnable = bEnable;
1498 DACArgs.bIsYPbPr = bIsYPbPr;
1499 memcpy(&DACArgs.SetWSS_Data, &SetWSS_Data, sizeof(DAC_SETWSS_INFO));
1500 DACArgs.bReturnValue = 0;
1501
1502 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_WSSOUTPUT, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1503 {
1504 printf("Obtain DAC engine fail\n");
1505 }
1506 return DACArgs.bReturnValue;
1507 }
1508
1509 //----------------------------------------------------------------
1510 // MApi_DAC_EnableICT
1511 // Enable hdgen ICT (Image Constriant Token) function
1512 // @bEnable: TRUE: enable, FALSE: disable
1513 // @return: TRUE is working successful
1514 //----------------------------------------------------------------
1515
MApi_DAC_EnableICT_U2(void * pInstance,MS_BOOL bEnable)1516 MS_BOOL MApi_DAC_EnableICT_U2(void* pInstance, MS_BOOL bEnable)
1517 {
1518 MDrv_DAC_EnableICT(bEnable);
1519 return TRUE;
1520 }
1521
MApi_DAC_EnableICT(MS_BOOL bEnable)1522 MS_BOOL MApi_DAC_EnableICT(MS_BOOL bEnable)
1523 {
1524 if (g_pDACInst == NULL)
1525 {
1526 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1527 return FALSE;
1528 }
1529
1530 stDAC_ENABLE_ICT DACArgs;
1531 DACArgs.bEnable = bEnable;
1532 DACArgs.bReturnValue = 0;
1533
1534 if(UtopiaIoctl(g_pDACInst, E_DAC_ENABLE_ICT, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1535 {
1536 printf("Obtain DAC engine fail\n");
1537 }
1538 return DACArgs.bReturnValue;
1539 }
1540
1541 //----------------------------------------------------------------
1542 // DAC - set VGA Hsync Vsync
1543 // @return none
1544 //----------------------------------------------------------------
MApi_DAC_SetVGAHsyncVsync_U2(void * pInstance,MS_BOOL bEnable)1545 void MApi_DAC_SetVGAHsyncVsync_U2(void* pInstance, MS_BOOL bEnable)
1546 {
1547 MDrv_DAC_SetVGAHsyncVsync(bEnable);
1548 }
1549
MApi_DAC_SetVGAHsyncVsync(MS_BOOL bEnable)1550 void MApi_DAC_SetVGAHsyncVsync(MS_BOOL bEnable)
1551 {
1552 if (g_pDACInst == NULL)
1553 {
1554 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_DAC_Init() first\n",__FUNCTION__,__LINE__);
1555 return;
1556 }
1557
1558 stDAC_SET_VGA_HsyncVsync DACArgs;
1559 DACArgs.bEnable = bEnable;
1560
1561 if(UtopiaIoctl(g_pDACInst, E_DAC_SET_VGA_HSYNCVSYNC, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
1562 {
1563 printf("Obtain DAC engine fail\n");
1564 }
1565 return;
1566 }
1567
1568 EXPORT_SYMBOL(MApi_DAC_DumpTable);
1569 EXPORT_SYMBOL(MApi_DAC_SetYPbPrOutputTiming);
1570