1 #define _DAC_C_
2
3 #include "MsTypes.h"
4 #ifndef MSOS_TYPE_LINUX_KERNEL
5 #include <stdio.h>
6 #include <string.h>
7 #endif
8 #include "MsCommon.h"
9 #include "utopia.h"
10 #include "utopia_dapi.h"
11 #include "apiDAC.h"
12 #include "apiDAC_private.h"
13 #include "apiDAC_v2.h"
14 #include "UFO.h"
15 #include "utopia_api_database.h"
16 //-------------------------------------------------------------------------------------------------
17 // Local Compiler Options
18 //-------------------------------------------------------------------------------------------------
19 // for semaphore POOL
20
21
22 //Below is dbg msg for some important dbg function, like:setmux, set gop dst, atexit,etc...
23
24
25 //-------------------------------------------------------------------------------------------------
26 // Local Defines
27 //-------------------------------------------------------------------------------------------------
28 // ========== Global definition ==========
29 void* pModuleDAC = NULL;
30 #ifdef MSOS_TYPE_LINUX_KERNEL
31 void *pInstanceDACStr = NULL;
DACStr(MS_U32 u32PowerState,void * pModule)32 MS_U32 DACStr(MS_U32 u32PowerState, void* pModule)
33 {
34 MS_U32 u32Return=UTOPIA_STATUS_FAIL;
35 stDAC_POWER_MODE DACArgs;
36
37 switch(u32PowerState)
38 {
39 case E_POWER_SUSPEND:
40 if (pInstanceDACStr == NULL)
41 {
42 if(UtopiaOpen(MODULE_DAC, &pInstanceDACStr, 0, NULL) != UTOPIA_STATUS_SUCCESS)
43 {
44 printf("UtopiaOpen DAC failed\n");
45 return UTOPIA_STATUS_FAIL;
46 }
47 }
48 DACArgs.ePowerState = u32PowerState;
49 DACArgs.stReturnValue = UTOPIA_STATUS_FAIL;
50 if(UtopiaIoctl(pInstanceDACStr, E_DAC_SET_POWER_STATE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
51 {
52 printf("Obtain DAC engine fail\n");
53 return UTOPIA_STATUS_FAIL;
54 }
55 u32Return=DACArgs.stReturnValue;
56 break;
57 case E_POWER_RESUME:
58 if (pInstanceDACStr == NULL)
59 {
60 if(UtopiaOpen(MODULE_DAC, &pInstanceDACStr, 0, NULL) != UTOPIA_STATUS_SUCCESS)
61 {
62 printf("UtopiaOpen DAC failed\n");
63 return UTOPIA_STATUS_FAIL;
64 }
65 }
66 DACArgs.ePowerState = u32PowerState;
67 DACArgs.stReturnValue = UTOPIA_STATUS_FAIL;
68 if(UtopiaIoctl(pInstanceDACStr, E_DAC_SET_POWER_STATE, (void*)&DACArgs) != UTOPIA_STATUS_SUCCESS)
69 {
70 printf("Obtain DAC engine fail\n");
71 return UTOPIA_STATUS_FAIL;
72 }
73 u32Return=DACArgs.stReturnValue;
74 break;
75 default:
76 printf("[%s][%d] PowerState:%lx not Implement now!!!\n",__FUNCTION__,__LINE__,u32PowerState);
77 break;
78 }
79 return u32Return;
80 }
81 #endif
82
83 // this func will be call to init by utopia20 framework
DACRegisterToUtopia(void)84 void DACRegisterToUtopia(void)
85 {
86 MS_U32 u32ResourceStatusCheck[E_DAC_POOL_ID_MAX] = {UTOPIA_STATUS_FAIL};
87 // 1. deal with module
88 UtopiaModuleCreate(MODULE_DAC, 8, &pModuleDAC);
89 UtopiaModuleRegister(pModuleDAC);
90 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
91 UtopiaModuleSetupFunctionPtr(pModuleDAC, (FUtopiaOpen)DACOpen, (FUtopiaClose)DACClose, (FUtopiaIOctl)DACIoctl);
92
93 #if defined(MSOS_TYPE_LINUX_KERNEL)
94 UtopiaModuleSetupSTRFunctionPtr(pModuleDAC, (FUtopiaSTR)DACStr);
95 UtopiaModuleSetSTRPrivate(pModuleDAC, sizeof(DAC_REGS_SAVE_AREA));
96 #endif
97
98 // 2. deal with resource
99 void* psResource = NULL;
100 // start func to add res, call once will create 2 access in resource. Also can declare BDMA_POOL_ID_BDMA1 for another channel depend on driver owner.
101 UtopiaModuleAddResourceStart(pModuleDAC, E_DAC_POOL_ID_INTERNAL_VARIABLE);
102 // resource can alloc private for internal use, ex, BDMA_RESOURCE_PRIVATE
103 u32ResourceStatusCheck[E_DAC_POOL_ID_INTERNAL_VARIABLE] = UtopiaResourceCreate("dac", sizeof(DAC_RESOURCE_PRIVATE), &psResource);
104 // func to reg res
105 UtopiaResourceRegister(pModuleDAC, psResource, E_DAC_POOL_ID_INTERNAL_VARIABLE);
106
107 UtopiaModuleAddResourceEnd(pModuleDAC, E_DAC_POOL_ID_INTERNAL_VARIABLE);
108
109 //4. init resource private members here (aka, global variable)
110 DAC_RESOURCE_PRIVATE* pDACResourcePrivate = NULL;
111 UtopiaResourceGetPrivate(psResource,(void**)(&pDACResourcePrivate));
112
113 //pXCResourcePrivate->bResourceRegistered will automatically cleared by UtopiaResourceRegister
114 if (u32ResourceStatusCheck[E_DAC_POOL_ID_INTERNAL_VARIABLE] == UTOPIA_STATUS_SHM_EXIST)
115 {
116 // do nothing, since it is already inited
117 }
118 else
119 {
120 // Init flow control related variables here. Other global variable should be
121 // inited in each of its init function relatively.
122 pDACResourcePrivate->bResourceRegistered = TRUE;
123 memset(&(pDACResourcePrivate->stapiDAC),0,sizeof(pDACResourcePrivate->stapiDAC));
124 memset(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.DACTable, 0, sizeof(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.DACTable));
125 memset(&pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u8DACtype, 0, sizeof(pDACResourcePrivate->stapiDAC._stDac_DacPowerState.u8DACtype));
126 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_now = E_RES_720x480I_60Hz;
127 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_SC0 = E_RES_720x480I_60Hz;
128 pDACResourcePrivate->stapiDAC._stDac_DacPowerState.OutputVideoTimingType_SC1 = E_RES_720x480I_60Hz;
129 }
130 }
131
DACOpen(void ** ppInstance,const void * const pAttribute)132 MS_U32 DACOpen(void** ppInstance, const void* const pAttribute)
133 {
134 DAC_INSTANT_PRIVATE *pDACPri = NULL;
135
136 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__));
137 // instance is allocated here, also can allocate private for internal use, ex, BDMA_INSTANT_PRIVATE
138 UtopiaInstanceCreate(sizeof(DAC_INSTANT_PRIVATE), ppInstance);
139 // setup func in private and assign the calling func in func ptr in instance private
140 UtopiaInstanceGetPrivate(*ppInstance, (void**)&pDACPri);
141
142 #ifdef CONFIG_UTOPIA_SIZE_CUSTOMER
143 #define URELATION(a,b,c) pDACPri->_URELATION_ASSIGN(a,b,c)
144 _MODULE_DAC_U1_U2_RELATION
145 #undef URELEATION
146 #else
147 pDACPri->fpDACGetLibVer = MApi_DAC_GetLibVer_U2;
148 pDACPri->fpDACGetInfo = MApi_DAC_GetInfo_U2;
149 pDACPri->fpDACGetStatus = MApi_DAC_GetStatus_U2;
150 pDACPri->fpDACSetDbgLevel = MApi_DAC_SetDbgLevel_U2;
151 pDACPri->fpDACInit = MApi_DAC_Init_U2;
152 pDACPri->fpDACEnable = MApi_DAC_Enable_U2;
153 pDACPri->fpDACSetClkInv = MApi_DAC_SetClkInv_U2;
154 pDACPri->fpDACSetYPbPrOutputTiming = MApi_DAC_SetYPbPrOutputTiming_U2;
155 pDACPri->fpDACSetOutputSource = MApi_DAC_SetOutputSource_U2;
156 pDACPri->fpDACSetOutputLevel = MApi_DAC_SetOutputLevel_U2;
157 pDACPri->fpDACSetOutputSwapSel = MApi_DAC_SetOutputSwapSel_U2;
158 pDACPri->fpDACOnOffSD = MApi_DAC_OnOffSD_U2;
159 pDACPri->fpDACGetSDStatus = MApi_DAC_GetSDStatus_U2;
160 pDACPri->fpDACOnOffHD = MApi_DAC_OnOffHD_U2;
161 pDACPri->fpDACGetHDStatus = MApi_DAC_GetHDStatus_U2;
162 pDACPri->fpDACClkSel = MApi_DAC_ClkSel_U2;
163 pDACPri->fpDACDumpTable = MApi_DAC_DumpTable_U2;
164 pDACPri->fpDACExit = MApi_DAC_Exit_U2;
165 pDACPri->fpDACSetIHalfOutput = MApi_DAC_SetIHalfOutput_U2;
166 pDACPri->fpDACSetQuartOutput = MApi_DAC_SetQuartOutput_U2;
167 pDACPri->fpDACSetDacState = MApi_DAC_SetDacState_U2;
168 pDACPri->fpDACHotPlugDetect = MApi_DAC_HotPlugDetect_U2;
169 pDACPri->fpDACSetPowerState = Mapi_DAC_SetPowerState_U2;
170 #ifdef UFO_XC_GETOUTPUTINTELACETIMING
171 pDACPri->fpDACGetOutputInterlaceTiming = MApi_DAC_GetOutputInterlaceTiming_U2;
172 #endif
173 pDACPri->fpDACSetWSSOnOff = MApi_DAC_SetWSSOnOff_U2;
174 pDACPri->fpDACGetWSSStatus = MApi_DAC_GetWSSStatus_U2;
175 pDACPri->fpDACResetWSSData = MApi_DAC_ResetWSSData_U2;
176 pDACPri->fpDACSetWSSOutput = MApi_DAC_SetWSSOutput_U2;
177 pDACPri->fpDACEnableICT = MApi_DAC_EnableICT_U2;
178 pDACPri->fpDACSetVGAHsyncVsync = MApi_DAC_SetVGAHsyncVsync_U2;
179 #endif
180 return UTOPIA_STATUS_SUCCESS;
181 }
182
DACIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)183 MS_U32 DACIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
184 {
185 if(pInstance == NULL)
186 {
187 printf("[%s] pInstance is NULL\n",__FUNCTION__);
188 return UTOPIA_STATUS_FAIL;
189 }
190 void* pModule = NULL;
191 UtopiaInstanceGetModule(pInstance, &pModule);
192 DAC_INSTANT_PRIVATE* psDACInstPri = NULL;
193 UtopiaInstanceGetPrivate(pInstance, (void**)&psDACInstPri);
194 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
195
196 //printf("[%s] cmd:%lx\n",__FUNCTION__,u32Cmd);
197 switch(u32Cmd)
198 {
199 case E_DAC_GET_LIBVER:
200 {
201 pstDAC_GET_LIBVER ptr = (pstDAC_GET_LIBVER)pArgs;
202 ptr->eReturnValue = psDACInstPri->fpDACGetLibVer(pInstance, ptr->ppVersion);
203 u32Return = UTOPIA_STATUS_SUCCESS;
204 break;
205 }
206 case E_DAC_GET_INFO:
207 {
208 pstDAC_GET_INFO ptr = (pstDAC_GET_INFO)pArgs;
209 ptr->stReturnValue = psDACInstPri->fpDACGetInfo(pInstance);
210 u32Return = UTOPIA_STATUS_SUCCESS;
211 break;
212 }
213 #ifdef UFO_XC_GETOUTPUTINTELACETIMING
214 case E_DAC_GET_GETOUTPUTINTERLACETIMING:
215 {
216 pstDAC_GET_OUTPUTINTERLACETIMING ptr = (pstDAC_GET_OUTPUTINTERLACETIMING)pArgs;
217 ptr->bReturnValue = psDACInstPri->fpDACGetOutputInterlaceTiming(pInstance);
218 u32Return = UTOPIA_STATUS_SUCCESS;
219 break;
220 }
221 #endif
222 case E_DAC_GET_STATUS:
223 {
224 pstDAC_GET_STATUS ptr = (pstDAC_GET_STATUS)pArgs;
225 ptr->bReturnValue = psDACInstPri->fpDACGetStatus(pInstance, ptr->pDacStatus);
226 u32Return = UTOPIA_STATUS_SUCCESS;
227 break;
228 }
229 case E_DAC_SET_DBG_LEVEL:
230 {
231 pstDAC_SET_DBG_LEVEL ptr = (pstDAC_SET_DBG_LEVEL)pArgs;
232 ptr->bReturnValue = psDACInstPri->fpDACSetDbgLevel(pInstance, ptr->u16DbgSwitch);
233 u32Return = UTOPIA_STATUS_SUCCESS;
234 break;
235 }
236 case E_DAC_INIT:
237 {
238 pstDAC_INIT ptr = (pstDAC_INIT)pArgs;
239 ptr->bReturnValue = psDACInstPri->fpDACInit(pInstance);
240 u32Return = UTOPIA_STATUS_SUCCESS;
241 break;
242 }
243 case E_DAC_ENABLE:
244 {
245 pstDAC_ENABLE ptr = (pstDAC_ENABLE)pArgs;
246 psDACInstPri->fpDACEnable(pInstance, ptr->bEnable,ptr->bIsYPbPr);
247 u32Return = UTOPIA_STATUS_SUCCESS;
248 break;
249 }
250 case E_DAC_SET_CLKINV:
251 {
252 pstDAC_SET_CLKINV ptr = (pstDAC_SET_CLKINV)pArgs;
253 psDACInstPri->fpDACSetClkInv(pInstance, ptr->bEnable,ptr->bIsYPbPr);
254 u32Return = UTOPIA_STATUS_SUCCESS;
255 break;
256
257 }
258 case E_DAC_SET_YPBPR_OUTPUTTIMING:
259 {
260 pstDAC_SET_YPBPR_OUTPUTTIMING ptr = (pstDAC_SET_YPBPR_OUTPUTTIMING)pArgs;
261 psDACInstPri->fpDACSetYPbPrOutputTiming(pInstance, ptr->eTiming);
262 u32Return = UTOPIA_STATUS_SUCCESS;
263 break;
264 }
265 case E_DAC_SET_OUTPUT_SOURCE:
266 {
267 pstDAC_SET_OUTPUT_SOURCE ptr = (pstDAC_SET_OUTPUT_SOURCE)pArgs;
268 psDACInstPri->fpDACSetOutputSource(pInstance, ptr->enOutputType,ptr->bIsYPbPr);
269 u32Return = UTOPIA_STATUS_SUCCESS;
270 break;
271 }
272 case E_DAC_SET_OUTPUT_LEVEL:
273 {
274 pstDAC_SET_OUTPUT_LEVEL ptr = (pstDAC_SET_OUTPUT_LEVEL)pArgs;
275 psDACInstPri->fpDACSetOutputLevel(pInstance, ptr->enLevel,ptr->bIsYPbPr);
276 u32Return = UTOPIA_STATUS_SUCCESS;
277 break;
278 }
279 case E_DAC_SET_OUTPUT_SWAPSEL:
280 {
281 pstDAC_SET_OUTPUT_SWAPSEL ptr = (pstDAC_SET_OUTPUT_SWAPSEL)pArgs;
282 psDACInstPri->fpDACSetOutputSwapSel(pInstance, ptr->enSwap,ptr->bIsYPbPr);
283 u32Return = UTOPIA_STATUS_SUCCESS;
284 break;
285 }
286 case E_DAC_ONOFF_SD:
287 {
288 pstDAC_ONOFF_SD ptr = (pstDAC_ONOFF_SD)pArgs;
289 psDACInstPri->fpDACOnOffSD(pInstance, ptr->enBit);
290 u32Return = UTOPIA_STATUS_SUCCESS;
291 break;
292 }
293 case E_DAC_GET_SD_STATUS:
294 {
295 pstDAC_GET_SD_STATUS ptr = (pstDAC_GET_SD_STATUS)pArgs;
296 ptr->enBit = psDACInstPri->fpDACGetSDStatus(pInstance);
297 u32Return = UTOPIA_STATUS_SUCCESS;
298 break;
299 }
300 case E_DAC_ONOFF_HD:
301 {
302 pstDAC_ONOFF_HD ptr = (pstDAC_ONOFF_HD)pArgs;
303 psDACInstPri->fpDACOnOffHD(pInstance, ptr->enBit);
304 u32Return = UTOPIA_STATUS_SUCCESS;
305 break;
306 }
307 case E_DAC_GET_HD_STATUS:
308 {
309 pstDAC_GET_HD_STATUS ptr = (pstDAC_GET_HD_STATUS)pArgs;
310 ptr->enBit = psDACInstPri->fpDACGetHDStatus(pInstance);
311 u32Return = UTOPIA_STATUS_SUCCESS;
312 break;
313 }
314 case E_DAC_CLKSEL:
315 {
316 pstDAC_CLKSEL ptr = (pstDAC_CLKSEL)pArgs;
317 psDACInstPri->fpDACClkSel(pInstance, ptr->eTiming,ptr->ebits);
318 u32Return = UTOPIA_STATUS_SUCCESS;
319 break;
320 }
321 case E_DAC_DUMP_TABLE:
322 {
323 pstDAC_DUMP_TABLE ptr = (pstDAC_DUMP_TABLE)pArgs;
324 psDACInstPri->fpDACDumpTable(pInstance, ptr->pDACTable,ptr->u8DACtype);
325 u32Return = UTOPIA_STATUS_SUCCESS;
326 break;
327 }
328 case E_DAC_EXIT:
329 {
330 psDACInstPri->fpDACExit(pInstance);
331 u32Return = UTOPIA_STATUS_SUCCESS;
332 break;
333 }
334 case E_DAC_SET_IHALF_OUTPUT:
335 {
336 pstDAC_SET_IHALF_OUTPUT ptr = (pstDAC_SET_IHALF_OUTPUT)pArgs;
337 psDACInstPri->fpDACSetIHalfOutput(pInstance, ptr->bEnable,ptr->bIsYPbPr);
338 u32Return = UTOPIA_STATUS_SUCCESS;
339 break;
340 }
341 case E_DAC_SET_QUART_OUTPUT:
342 {
343 pstDAC_SET_QUART_OUTPUT ptr = (pstDAC_SET_QUART_OUTPUT)pArgs;
344 psDACInstPri->fpDACSetQuartOutput(pInstance, ptr->bEnable,ptr->bIsYPbPr);
345 u32Return = UTOPIA_STATUS_SUCCESS;
346 break;
347 }
348 case E_DAC_SET_DAC_STATE:
349 {
350 pstDAC_SET_DAC_STATE ptr = (pstDAC_SET_DAC_STATE)pArgs;
351 psDACInstPri->fpDACSetDacState(pInstance, ptr->bEnabled,ptr->bIsYPbPr);
352 u32Return = UTOPIA_STATUS_SUCCESS;
353 break;
354 }
355 case E_DAC_HOTPLUG_DETECT:
356 {
357 pstDAC_HOTPLUG_DETECT ptr = (pstDAC_HOTPLUG_DETECT)pArgs;
358 ptr->bReturnValue = psDACInstPri->fpDACHotPlugDetect(pInstance, ptr->SelDAC,ptr->DetectType,ptr->State);
359 u32Return = UTOPIA_STATUS_SUCCESS;
360 break;
361 }
362 case E_DAC_SET_POWER_STATE:
363 {
364 pstDAC_POWER_MODE ptr = (pstDAC_POWER_MODE) pArgs;
365 ptr->stReturnValue = psDACInstPri->fpDACSetPowerState(pInstance, ptr->ePowerState);
366 u32Return = UTOPIA_STATUS_SUCCESS;
367 break;
368 }
369 case E_DAC_SET_WSSONOFF:
370 {
371 pstDAC_SET_WSSONOFF ptr = (pstDAC_SET_WSSONOFF) pArgs;
372 ptr->bReturnValue = psDACInstPri->fpDACSetWSSOnOff(pInstance, ptr->bEnable, ptr->bIsYPbPr);
373 u32Return = UTOPIA_STATUS_SUCCESS;
374 break;
375 }
376 case E_DAC_GET_WSSSTATUS:
377 {
378 pstDAC_GET_WSSSTATUS ptr = (pstDAC_GET_WSSSTATUS) pArgs;
379 ptr->bReturnValue = psDACInstPri->fpDACGetWSSStatus(pInstance, ptr->bIsYPbPr, ptr->pEnable, ptr->pSetWSS_Data);
380 u32Return = UTOPIA_STATUS_SUCCESS;
381 break;
382 }
383 case E_DAC_RESET_WSSDATA:
384 {
385 pstDAC_RESET_WSSDATA ptr = (pstDAC_RESET_WSSDATA) pArgs;
386 ptr->bReturnValue = psDACInstPri->fpDACResetWSSData(pInstance, ptr->bIsYPbPr);
387 u32Return = UTOPIA_STATUS_SUCCESS;
388 break;
389 }
390 case E_DAC_SET_WSSOUTPUT:
391 {
392 pstDAC_SET_WSSOUTPUT ptr = (pstDAC_SET_WSSOUTPUT) pArgs;
393 ptr->bReturnValue = psDACInstPri->fpDACSetWSSOutput(pInstance, ptr->bEnable, ptr->bIsYPbPr, ptr->SetWSS_Data);
394 u32Return = UTOPIA_STATUS_SUCCESS;
395 break;
396 }
397 case E_DAC_ENABLE_ICT:
398 {
399 pstDAC_ENABLE_ICT ptr = (pstDAC_ENABLE_ICT) pArgs;
400 ptr->bReturnValue = psDACInstPri->fpDACEnableICT(pInstance, ptr->bEnable);
401 u32Return = UTOPIA_STATUS_SUCCESS;
402 break;
403 }
404 case E_DAC_SET_VGA_HSYNCVSYNC:
405 {
406 pstDAC_SET_VGA_HSYNCVSYNC ptr = (pstDAC_SET_VGA_HSYNCVSYNC)pArgs;
407 psDACInstPri->fpDACSetVGAHsyncVsync(pInstance, ptr->bEnable);
408 u32Return = UTOPIA_STATUS_SUCCESS;
409 break;
410 }
411 default:
412 printf("[%s] out of DAC cmd:%td\n",__FUNCTION__,(ptrdiff_t)u32Cmd);
413 break;
414 };
415
416 //printf("(%s) Done\n\n",__FUNCTION__);
417
418 return UTOPIA_STATUS_SUCCESS;
419 }
420
DACClose(void * pInstance)421 MS_U32 DACClose(void* pInstance)
422 {
423 UtopiaInstanceDelete(pInstance);
424
425 return TRUE;
426 }
427
428
429