1 #include "MsTypes.h"
2 #if defined(MSOS_TYPE_LINUX_KERNEL)
3 #include <linux/slab.h>
4 #include <linux/string.h>
5 #else
6 #include <stdio.h>
7 #include <string.h>
8 #endif
9 #include "drvVBI_v2.h"
10 #include "drvVBI_private.h"
11 #include "utopia_dapi.h"
12 #include "drvVBI.h"
13 #include "drvDMX_TTX.h"
14 #include "MsOS.h"
15 #include "utopia.h"
16 #include "ULog.h"
17 #define VBI_DEBUG 0
18
19 #if (VBI_DEBUG == 1)
20 #define VBI_DEBUG_MSG(x) x
21 #else
22 #define VBI_DEBUG_MSG(x)
23 #endif
24
25
VBIRegisterToUtopia(FUtopiaOpen ModuleType)26 void VBIRegisterToUtopia(FUtopiaOpen ModuleType)
27 {
28 void* pUtopiaModule = NULL;
29
30 VBI_DEBUG_MSG(ULOGD("VBI", "\n[VBI INFO] vbi register start\n"));
31
32 // 1. deal with module
33 UtopiaModuleCreate(MODULE_VBI, 8, &pUtopiaModule);
34 UtopiaModuleRegister(pUtopiaModule);
35 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)VBIOpen, (FUtopiaClose)VBIClose, (FUtopiaIOctl)VBIIoctl);
36 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
37 UtopiaModuleRegisterMdbNode("vbi", (FUtopiaMdbIoctl)VBIMdbIoctl);
38 #endif
39 #if defined(MSOS_TYPE_LINUX_KERNEL)
40 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule,(FUtopiaSTR)VBIStr);
41 UtopiaModuleSetSTRPrivate(pUtopiaModule, sizeof(VBI_INSTANT_PRIVATE));
42 #endif
43
44 // 2. deal with resource (2 resources for DTV & ATV)
45 void* psResource = NULL;
46 UtopiaModuleAddResourceStart(pUtopiaModule, VBI_POOL_ID_VBI0);
47 UtopiaResourceCreate("VBI0", sizeof(VBI_RESOURCE_PRIVATE), &psResource);
48 UtopiaResourceRegister(pUtopiaModule, psResource, VBI_POOL_ID_VBI0);
49 UtopiaModuleAddResourceEnd(pUtopiaModule, VBI_POOL_ID_VBI0);
50
51 psResource = NULL;
52 UtopiaModuleAddResourceStart(pUtopiaModule, VBI_POOL_ID_VBI1);
53 UtopiaResourceCreate("VBI1", sizeof(VBI_RESOURCE_PRIVATE), &psResource);
54 UtopiaResourceRegister(pUtopiaModule, psResource, VBI_POOL_ID_VBI1);
55 UtopiaModuleAddResourceEnd(pUtopiaModule, VBI_POOL_ID_VBI1);
56
57 }
58
59 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
VBIMdbIoctl(MS_U32 cmd,const void * const pArgs)60 MS_U32 VBIMdbIoctl(MS_U32 cmd, const void* const pArgs)
61 {
62 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
63 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
64 VBI_DrvStatus _vbiStatus;
65 switch(cmd)
66 {
67 case MDBCMD_CMDLINE:
68 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
69 paraCmdLine->result = MDBRESULT_SUCCESS_FIN;
70 break;
71 case MDBCMD_GETINFO:
72 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
73 MdbPrint(paraGetInfo->u64ReqHdl,"---------MStar vbi state---------\n");
74 if(FALSE == MDrv_VBI_GetStatus(&_vbiStatus))
75 {
76 MdbPrint(paraGetInfo->u64ReqHdl,"Not Initialized\n", _vbiStatus.eInitType);
77 }
78 else
79 {
80 switch(_vbiStatus.eInitType)
81 {
82 case E_VBI_TELETEXT:
83 MdbPrint(paraGetInfo->u64ReqHdl,"state : TTX\n");
84 MdbPrint(paraGetInfo->u64ReqHdl,"pktcnt : %d\n", MDrv_VBI_TTX_GetPacketCount());
85 break;
86 case E_VBI_CC:
87 MdbPrint(paraGetInfo->u64ReqHdl,"state : CC\n");
88 MdbPrint(paraGetInfo->u64ReqHdl,"pktcnt : %d\n", MDrv_VBI_CC_GetInfo(VBI_CC_PACKET_COUNT));
89 break;
90 case E_VBI_WSS:
91 MdbPrint(paraGetInfo->u64ReqHdl,"state : WSS\n");
92 break;
93 default:
94 break;
95 }
96 }
97 paraGetInfo->result = MDBRESULT_SUCCESS_FIN;
98 break;
99 default:
100 break;
101 }
102 return 0;
103 }
104 #endif
105
106 #if defined(MSOS_TYPE_LINUX_KERNEL)
VBIStr(MS_U32 u32PowerState,void * pModule)107 MS_U32 VBIStr(MS_U32 u32PowerState, void* pModule)
108 {
109 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
110
111 if ((u32PowerState == E_POWER_SUSPEND) || (u32PowerState == E_POWER_RESUME))
112 {
113 u32Return = _MDrv_VBI_SetPowerState(u32PowerState);
114 }
115 else
116 {
117 u32Return = UTOPIA_STATUS_FAIL;
118 }
119 return u32Return;// for success
120 }
121 #endif
122
VBIOpen(void ** ppInstance,const void * const pAttribute)123 MS_U32 VBIOpen(void** ppInstance, const void* const pAttribute)
124 {
125 VBI_DEBUG_MSG(ULOGD("VBI", "\n[VBI INFO] vbi open start\n"));
126
127 VBI_INSTANT_PRIVATE *pVbiPri = NULL;
128 void *pVbiPriVoid = NULL;
129 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,ULOGD("VBI", "enter %s %d\n",__FUNCTION__,__LINE__));
130
131 UtopiaInstanceCreate(sizeof(VBI_INSTANT_PRIVATE), ppInstance);
132 UtopiaInstanceGetPrivate(*ppInstance, &pVbiPriVoid);
133
134 pVbiPri = (VBI_INSTANT_PRIVATE*)pVbiPriVoid;
135 // For ATV
136 pVbiPri->fpVBIGetLibVer = (IOCTL_VBI_GETLIBVER )MDrv_VBI_GetLibVer;
137 pVbiPri->fpVBIGetInfo = (IOCTL_VBI_GETINFO )MDrv_VBI_GetInfo;
138 pVbiPri->fpVBIGetStatus = (IOCTL_VBI_GETSTATUS )_MDrv_VBI_GetStatus;
139 pVbiPri->fpVBISetDbgLevel = (IOCTL_VBI_SET_DBGLEVEL )MDrv_VBI_SetDbgLevel;
140 pVbiPri->fpVBIInit = (IOCTL_VBI_INIT )_MDrv_VBI_Init;
141 pVbiPri->fpVBIExit = (IOCTL_VBI_EXIT )_MDrv_VBI_Exit;
142 pVbiPri->fpVBIRegisterCB = (IOCTL_VBI_REGISTERCB )_MDrv_VBI_RegisterCB;
143 pVbiPri->fpVBIRingBufferReset = (IOCTL_VBI_RINGBUFFER_RESET )_MDrv_VBI_RingBuffer_Reset;
144 pVbiPri->fpVBIInitializeTTXSlicer = (IOCTL_VBI_INITIALIZETTXSLICER )_MDrv_VBI_InitializeTTXSlicer;
145 pVbiPri->fpVBIEnableTTXSlicer = (IOCTL_VBI_ENABLETTXSLICER )_MDrv_VBI_EnableTTXSlicer;
146 pVbiPri->fpVBIIsVPSReady = (IOCTL_VBI_ISVPS_READY )_MDrv_VBI_IsVPS_Ready;
147 pVbiPri->fpVBIIsTTXReady = (IOCTL_VBI_ISTTX_READY )_MDrv_VBI_IsTTX_Ready;
148 pVbiPri->fpVBIIsWSSReady = (IOCTL_VBI_ISWSS_READY )_MDrv_VBI_IsWSS_Ready;
149 pVbiPri->fpVBIGetWSSData = (IOCTL_VBI_GETWSS_DATA )_MDrv_VBI_GetWSS_Data;
150 pVbiPri->fpVBIGetVPSData = (IOCTL_VBI_GETVPS_DATA )_MDrv_VBI_GetVPS_Data;
151 pVbiPri->fpVBISetVideoStandard = (IOCTL_VBI_SETVIDEOSTANDARD )_MDrv_VBI_SetVideoStandard;
152 pVbiPri->fpVBITTXPacketBufferIsEmpty = (IOCTL_VBI_TTX_PACKETBUFFERISEMPTY )_MDrv_VBI_TTX_PacketBufferIsEmpty;
153 pVbiPri->fpVBITTXCheckCircuitReady = (IOCTL_VBI_TTX_CHECKCIRCUITREADY )_MDrv_VBI_TTX_CheckCircuitReady;
154 pVbiPri->fpVBITTXGetPacketCount = (IOCTL_VBI_TTX_GETPACKETCOUNT )_MDrv_VBI_TTX_GetPacketCount;
155 pVbiPri->fpVBITTXGetPackets = (IOCTL_VBI_TTX_GETPACKETS )_MDrv_VBI_TTX_GetPackets;
156 pVbiPri->fpVBITTXGetPacket = (IOCTL_VBI_TTX_GETPACKET )_MDrv_VBI_TTX_GetPacket;
157 pVbiPri->fpVBITTXPacktetBufferIsOverflow = (IOCTL_VBI_TTX_PACKETBUFFERISOVERFLOW )_MDrv_VBI_TTX_PacketBufferIsOverflow;
158 pVbiPri->fpVBITTXPacketBufferGetNoOfOverflows = (IOCTL_VBI_TTX_PACKETBUFFERGETNOOFOVERFLOWS)_MDrv_VBI_TTX_PacketBufferGetNoOfOverflows;
159 pVbiPri->fpVBITTXEnableLine = (IOCTL_VBI_TTX_ENABLELINE )_MDrv_VBI_TTX_EnableLine;
160 pVbiPri->fpVBISyncMemory = (IOCTL_VBI_SYNCMEMORY )_MDrv_VBI_SyncMemory;
161 pVbiPri->fpVBICCInitSlicer = (IOCTL_VBI_CC_INITSLICER )_MDrv_VBI_CC_InitSlicer;
162 pVbiPri->fpVBICCInitYPbYr = (IOCTL_VBI_CC_INITYPBYR )_MDrv_VBI_CC_InitYPbYr;
163 pVbiPri->fpVBICCSetDataRate = (IOCTL_VBI_CC_SETDATARATE )_MDrv_VBI_CC_SetDataRate;
164 pVbiPri->fpVBICCGetInfo = (IOCTL_VBI_CC_GETINFO )_MDrv_VBI_CC_GetInfo;
165 pVbiPri->fpVBICCSetFrameCnt = (IOCTL_VBI_CC_SETFRAMECNT )_MDrv_VBI_CC_SetFrameCnt;
166 pVbiPri->fpVBICCEnableSlicer = (IOCTL_VBI_CC_ENABLESLICER )_MDrv_VBI_CC_EnableSlicer;
167 pVbiPri->fpVBICCEnableLine = (IOCTL_VBI_CC_ENABLELINE )_MDrv_VBI_CC_EnableLine;
168 pVbiPri->fpVBICCSetSCWindowLen = (IOCTL_VBI_CC_SETSCWINDOWLEN )_MDrv_VBI_CC_SetSCWindowLen;
169 pVbiPri->fpVBICCSetVideoStandard = (IOCTL_VBI_CC_SETVIDEOSTANDARD )_MDrv_VBI_CC_SetStandard;
170 pVbiPri->fpVBIWSSSetVpsByteNum = (IOCTL_VBI_WSS_SETVPSBYTENUM )_MDrv_VBI_WSS_SetVpsByteNum;
171 pVbiPri->fpVBISuspend = (IOCTL_VBI_SUSPEND )_MDrv_VBI_Suspend;
172 pVbiPri->fpVBIResume = (IOCTL_VBI_RESUME )_MDrv_VBI_Resume;
173 pVbiPri->fpVBISetPowerState = (IOCTL_VBI_SETPOWERSTATE )_MDrv_VBI_SetPowerState;
174
175 // For DTV
176 pVbiPri->fpDMXTTXRingBufferReset = (IOCTL_DMX_TTX_RINGBUFFER_RESET )_MDrv_DMX_TTX_RingBuffer_Reset;
177 pVbiPri->fpDMXTTXInit = (IOCTL_DMX_TTX_INIT )_MDrv_DMX_TTX_Init;
178 pVbiPri->fpDMXTTXExit = (IOCTL_DMX_TTX_EXIT )_MDrv_DMX_TTX_Exit;
179 pVbiPri->fpDMXTTXSetFilterID = (IOCTL_DMX_TTX_SETFILTERID )_MDrv_DMX_TTX_SetFilterID;
180 pVbiPri->fpDMXTTXSetCB = (IOCTL_DMX_TTX_SETCB )_MDrv_DMX_TTX_SetCB;
181 pVbiPri->fpDMXTTXPacketBufferIsEmpty = (IOCTL_DMX_TTX_PACKETBUFFERISEMPTY )_MDrv_DMX_TTX_PacketBufferIsEmpty;
182 pVbiPri->fpDMXTTXGetPackets = (IOCTL_DMX_TTX_GETPACKETS )_MDrv_DMX_TTX_GetPackets;
183 pVbiPri->fpDMXTTXGetPacket = (IOCTL_DMX_TTX_GETPACKET )_MDrv_DMX_TTX_GetPacket;
184 pVbiPri->fpDMXTTXPacketBufferIsOverflow = (IOCTL_DMX_TTX_PACKETBUFFERISOVERFLOW )_MDrv_DMX_TTX_PacketBufferIsOverflow;
185 pVbiPri->fpDMXTTXPacketBufferGetNoOfOverflows = (IOCTL_DMX_TTX_PACKETBUFFERGETNOOFOVERFLOWS)_MDrv_DMX_TTX_PacketBufferGetNoOfOverflows;
186 pVbiPri->fpDMXTTXSuspend = (IOCTL_DMX_TTX_SUSPEND )_MDrv_DMX_TTX_Suspend;
187 pVbiPri->fpDMXTTXResume = (IOCTL_DMX_TTX_RESUME )_MDrv_DMX_TTX_Resume;
188 pVbiPri->fpDMXTTXSetPowerState = (IOCTL_DMX_TTX_SETPOWERSTATE )_MDrv_DMX_TTX_SetPowerState;
189
190 return UTOPIA_STATUS_SUCCESS;
191 }
192
VBIIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)193 MS_U32 VBIIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
194 {
195 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,ULOGD("VBI", "enter %s %d\n",__FUNCTION__,__LINE__));
196 VBI_DEBUG_MSG(ULOGD("VBI", "\n[VBI INFO] vbi ioctl cmd = %ld\n",u32Cmd));
197 MS_U32 u32Ret = UTOPIA_STATUS_FAIL;
198 VBI_INSTANT_PRIVATE* psVbiInstPri = NULL;
199 void* pModule = NULL;
200 void* pResource_atv = NULL;
201 void* pResource_dtv = NULL;
202
203 UtopiaInstanceGetModule(pInstance, &pModule);
204 UtopiaInstanceGetPrivate(pInstance, (void**)&psVbiInstPri); // Get instance
205
206 PVBI_GETLIBVER pGetLibVer = NULL;
207 PVBI_GETINFO_PARAM pGetInfoParam = NULL;
208 PVBI_GETSTATUS pGetStatus = NULL;
209 PVBI_SETDBGLEVEL pSetDbgLevel = NULL;
210 PVBI_INIT_TYPE pInitType = NULL;
211 PVBI_REGISTER_CB pRegisterCB = NULL;
212 PVBI_INITIALIZER_TTX_SLICER pInitializerTTXSlicer = NULL;
213 PVBI_ENABLE_TTX_SLICER pEnableTTXSlicer = NULL;
214 PVBI_GET_VPS_DATA pGetVPSData = NULL;
215 PVBI_SET_VIDEO_STANDARD pSetVideoStandard = NULL;
216 PVBI_TTX_GET_PACKETS pGetPackets = NULL;
217 PVBI_TTX_GET_PACKET pGetPacket = NULL;
218 PVBI_TTX_ENABLE_LINE pEnableLine = NULL;
219 PVBI_SYNC_MEMORY pSyncMemory = NULL;
220 PVBI_CC_INIT_SLICER pCCInitSlicer = NULL;
221 PVBI_CC_INIT_YPBYR pCCInitYPbYr = NULL;
222 PVBI_CC_SETDATARATE pCCSetDataRate = NULL;
223 PVBI_CC_GETINFO pGetInfo = NULL;
224 PVBI_CC_SET_FRAMECNT pCCSetFrameCnt = NULL;
225 PVBI_CC_ENABLE_SLICER pCCEnableSlicer = NULL;
226 PVBI_CC_ENABLE_LINE pCCEnableLine = NULL;
227 PVBI_CC_SET_SC_WND_LEN pCCSetWndLen = NULL;
228 PVBI_VBI_WSS_VPSBYTENUM pWSSSetVpsByteCnt = NULL;
229 PVBI_GET_RAW_VPS_DATA pGetRawVPSData = NULL;
230 PDMX_TTX_SET_FILTERID pDMXSetFilterID = NULL;
231 PDMX_TTX_SET_CB pDMXSetCB = NULL;
232
233 PVBI_CMD pVbiCmd = NULL;
234 PDMX_TTX_CMD pDmxTtxCmd = NULL;
235
236 PVBI_GET_DATA pGetData = NULL;
237 PVBI_BOOL pCheckTureFalse = NULL;
238 PVBI_GET_RESULT pGetResult = NULL;
239 PVBI_PROTECT_MEMORY pProtectMemory = NULL;
240
241 VBI_DrvInfo *pVBIInfo;
242
243 if(u32Cmd <= MDrv_CMD_VBI_WSS_SetVpsByteNum || u32Cmd == MDrv_CMD_VBI_Exit)
244 {
245 if(UtopiaResourceObtain(pModule, VBI_POOL_ID_VBI0, &pResource_atv) == UTOPIA_STATUS_FAIL)
246 {
247 return UTOPIA_STATUS_ERR_RESOURCE;
248 }
249 }
250 else
251 {
252 if(UtopiaResourceObtain(pModule, VBI_POOL_ID_VBI1, &pResource_dtv) == UTOPIA_STATUS_FAIL)
253 {
254 return UTOPIA_STATUS_ERR_RESOURCE;
255 }
256 }
257
258 switch(u32Cmd)
259 {
260 //=============================================
261 // ATV - TTX, CC
262 //=============================================
263 case MDrv_CMD_VBI_GetLibVer:
264 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_GetLibVer\n");
265 pGetLibVer = (PVBI_GETLIBVER)pArgs;
266 if(psVbiInstPri->fpVBIGetLibVer(pGetLibVer->ppVersion) == TRUE)
267 u32Ret = UTOPIA_STATUS_SUCCESS;
268 break;
269 case MDrv_CMD_VBI_GetInfo:
270 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_GetInfo\n");
271 pGetInfoParam = (PVBI_GETINFO_PARAM)pArgs;
272 pVBIInfo = psVbiInstPri->fpVBIGetInfo();
273 memcpy (pGetInfoParam,pVBIInfo,sizeof(VBI_DrvInfo));
274 u32Ret = UTOPIA_STATUS_SUCCESS;
275 break;
276 case MDrv_CMD_VBI_GetStatus:
277 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_GetStatus\n");
278 pGetStatus = (PVBI_GETSTATUS)pArgs;
279 if(psVbiInstPri->fpVBIGetStatus(pGetStatus->pDrvStatus) == TRUE)
280 u32Ret = UTOPIA_STATUS_SUCCESS;
281 break;
282 case MDrv_CMD_VBI_SetDbgLevel:
283 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_SetDbgLevel\n");
284 pSetDbgLevel = (PVBI_SETDBGLEVEL)pArgs;
285 if(psVbiInstPri->fpVBISetDbgLevel(pSetDbgLevel->u16DbgSwitch) == TRUE)
286 u32Ret = UTOPIA_STATUS_SUCCESS;
287 break;
288 case MDrv_CMD_VBI_Init:
289 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_Init\n");
290 pInitType = (PVBI_INIT_TYPE)pArgs;
291 if(psVbiInstPri->fpVBIInit(pInitType->cmd, pInitType->type) == TRUE)
292 u32Ret = UTOPIA_STATUS_SUCCESS;
293 break;
294 case MDrv_CMD_VBI_RegisterCB:
295 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_RegisterCB\n");
296 pRegisterCB = (PVBI_REGISTER_CB)pArgs;
297 psVbiInstPri->fpVBIRegisterCB(pRegisterCB->pFN,
298 pRegisterCB->bufferAddr,
299 pRegisterCB->length);
300 u32Ret = UTOPIA_STATUS_SUCCESS;
301 break;
302 case MDrv_CMD_VBI_RingBuffer_Reset:
303 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_RingBuffer_Reset\n");
304 psVbiInstPri->fpVBIRingBufferReset();
305 u32Ret = UTOPIA_STATUS_SUCCESS;
306 break;
307 case MDrv_CMD_VBI_InitializeTTXSlicer:
308 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_InitializeTTXSlicer\n");
309 pInitializerTTXSlicer = (PVBI_INITIALIZER_TTX_SLICER)pArgs;
310 psVbiInstPri->fpVBIInitializeTTXSlicer(pInitializerTTXSlicer->bufferAddr,
311 pInitializerTTXSlicer->packetCount);
312 u32Ret = UTOPIA_STATUS_SUCCESS;
313 break;
314 case MDrv_CMD_VBI_EnableTTXSlicer:
315 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_EnableTTXSlicer\n");
316 pEnableTTXSlicer = (PVBI_ENABLE_TTX_SLICER)pArgs;
317 psVbiInstPri->fpVBIEnableTTXSlicer(pEnableTTXSlicer->bEnable);
318 u32Ret = UTOPIA_STATUS_SUCCESS;
319 break;
320 case MDrv_CMD_VBI_IsVPS_Ready:
321 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_IsVPS_Ready\n");
322 pCheckTureFalse = (PVBI_BOOL)pArgs;
323 pCheckTureFalse->bCheck = psVbiInstPri->fpVBIIsVPSReady();
324 u32Ret = UTOPIA_STATUS_SUCCESS;
325 break;
326 case MDrv_CMD_VBI_IsTTX_Ready:
327 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_IsTTX_Ready\n");
328 pCheckTureFalse = (PVBI_BOOL)pArgs;
329 pCheckTureFalse->bCheck = psVbiInstPri->fpVBIIsTTXReady();
330 u32Ret = UTOPIA_STATUS_SUCCESS;
331 break;
332 case MDrv_CMD_VBI_IsWSS_Ready:
333 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_IsWSS_Ready\n");
334 pCheckTureFalse = (PVBI_BOOL)pArgs;
335 pCheckTureFalse->bCheck = psVbiInstPri->fpVBIIsWSSReady();
336 u32Ret = UTOPIA_STATUS_SUCCESS;
337 break;
338 case MDrv_CMD_VBI_GetWSS_Data:
339 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_GetWSS_Data\n");
340 pGetData = (PVBI_GET_DATA)pArgs;
341 pGetData->u16data = psVbiInstPri->fpVBIGetWSSData();
342 u32Ret = UTOPIA_STATUS_SUCCESS;
343 break;
344 case MDrv_CMD_VBI_GetVPS_Data:
345 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_GetVPS_Data\n");
346 pGetVPSData = (PVBI_GET_VPS_DATA)pArgs;
347 psVbiInstPri->fpVBIGetVPSData(pGetVPSData->lowerWord, pGetVPSData->higherWord);
348 u32Ret = UTOPIA_STATUS_SUCCESS;
349 break;
350 case MDrv_CMD_VBI_GetRawVPS_Data:
351 //printf("VBIIoctl - MDrv_CMD_VBI_GetVPS_Data\n");
352 pGetRawVPSData = (PVBI_GET_RAW_VPS_DATA)pArgs;
353 psVbiInstPri->fpVBIGetRawVPSData(&pGetRawVPSData->byte0, &pGetRawVPSData->byte1, &pGetRawVPSData->byte2, &pGetRawVPSData->byte3);
354 u32Ret = UTOPIA_STATUS_SUCCESS;
355 break;
356 case MDrv_CMD_VBI_SetVideoStandard:
357 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_SetVideoStandard\n");
358 pSetVideoStandard = (PVBI_SET_VIDEO_STANDARD)pArgs;
359 psVbiInstPri->fpVBISetVideoStandard(pSetVideoStandard->eStandard);
360 u32Ret = UTOPIA_STATUS_SUCCESS;
361 break;
362 case MDrv_CMD_VBI_TTX_PacketBufferIsEmpty:
363 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_PacketBufferIsEmpty\n");
364 pCheckTureFalse = (PVBI_BOOL)pArgs;
365 pCheckTureFalse->bCheck= psVbiInstPri->fpVBITTXPacketBufferIsEmpty();
366 u32Ret = UTOPIA_STATUS_SUCCESS;
367 break;
368 case MDrv_CMD_VBI_TTX_CheckCircuitReady:
369 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_CheckCircuitReady\n");
370 pCheckTureFalse = (PVBI_BOOL)pArgs;
371 pCheckTureFalse->bCheck = psVbiInstPri->fpVBITTXCheckCircuitReady();
372 u32Ret = UTOPIA_STATUS_SUCCESS;
373 break;
374 case MDrv_CMD_VBI_TTX_GetPacketCount:
375 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_GetPacketCount\n");
376 pGetData = (PVBI_GET_DATA)pArgs;
377 pGetData->u16data = psVbiInstPri->fpVBITTXGetPacketCount();
378 u32Ret = UTOPIA_STATUS_SUCCESS;
379 break;
380 case MDrv_CMD_VBI_TTX_GetPackets:
381 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_GetPackets\n");
382 pGetPackets = (PVBI_TTX_GET_PACKETS)pArgs;
383 if(psVbiInstPri->fpVBITTXGetPackets(pGetPackets->dataAddr, pGetPackets->length) == TRUE)
384 u32Ret = UTOPIA_STATUS_SUCCESS;
385 break;
386 case MDrv_CMD_VBI_TTX_GetPacket:
387 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_GetPacket\n");
388 pGetPacket = (PVBI_TTX_GET_PACKET)pArgs;
389 if(psVbiInstPri->fpVBITTXGetPacket(pGetPacket->packetAddress) == TRUE)
390 u32Ret = UTOPIA_STATUS_SUCCESS;
391 break;
392 case MDrv_CMD_VBI_TTX_PacketBufferIsOverflow:
393 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_PacketBufferIsOverflow\n");
394 pCheckTureFalse = (PVBI_BOOL)pArgs;
395 pCheckTureFalse->bCheck = psVbiInstPri->fpVBITTXPacktetBufferIsOverflow();
396 u32Ret = UTOPIA_STATUS_SUCCESS;
397 break;
398 case MDrv_CMD_VBI_TTX_PacketBufferGetNoOfOverflows:
399 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_PacketBufferGetNoOfOverflows\n");
400 pGetData = (PVBI_GET_DATA)pArgs;
401 pGetData->u16data = psVbiInstPri->fpVBITTXPacketBufferGetNoOfOverflows();
402 u32Ret = UTOPIA_STATUS_SUCCESS;
403 break;
404 case MDrv_CMD_VBI_TTX_EnableLine:
405 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_TTX_EnableLine\n");
406 pEnableLine = (PVBI_TTX_ENABLE_LINE)pArgs;
407 psVbiInstPri->fpVBITTXEnableLine(pEnableLine->StartLine,
408 pEnableLine->EndLine);
409 u32Ret = UTOPIA_STATUS_SUCCESS;
410 break;
411 case MDrv_CMD_VBI_SyncMemory:
412 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_SyncMemory\n");
413 pSyncMemory = (PVBI_SYNC_MEMORY)pArgs;
414 if(psVbiInstPri->fpVBISyncMemory(pSyncMemory->u32Start, pSyncMemory->u32Size) == TRUE)
415 u32Ret = UTOPIA_STATUS_SUCCESS;
416 break;
417 case MDrv_CMD_VBI_CC_InitSlicer:
418 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_InitSlicer\n");
419 pCCInitSlicer = (PVBI_CC_INIT_SLICER)pArgs;
420 psVbiInstPri->fpVBICCInitSlicer(pCCInitSlicer->u32RiuAddr,
421 pCCInitSlicer->bufferAddr,
422 pCCInitSlicer->packetCount);
423 u32Ret = UTOPIA_STATUS_SUCCESS;
424 break;
425 case MDrv_CMD_VBI_CC_InitYPbYr:
426 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_InitYPbYr\n");
427 pCCInitYPbYr = (PVBI_CC_INIT_YPBYR)pArgs;
428 psVbiInstPri->fpVBICCInitYPbYr(pCCInitYPbYr->cvbs_no);
429 u32Ret = UTOPIA_STATUS_SUCCESS;
430 break;
431 case MDrv_CMD_VBI_CC_SetDataRate:
432 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_SetDataRate\n");
433 pCCSetDataRate = (PVBI_CC_SETDATARATE)pArgs;
434 if(psVbiInstPri->fpVBICCSetDataRate(pCCSetDataRate->ptable) == TRUE)
435 u32Ret = UTOPIA_STATUS_SUCCESS;
436 break;
437 case MDrv_CMD_VBI_CC_GetInfo:
438 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_GetInfo\n");
439 pGetInfo = (PVBI_CC_GETINFO)pArgs;
440 pGetInfo->info = psVbiInstPri->fpVBICCGetInfo(pGetInfo->selector);
441 u32Ret = UTOPIA_STATUS_SUCCESS;
442 break;
443 case MDrv_CMD_VBI_CC_SetFrameCnt:
444 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_SetFrameCnt\n");
445 pCCSetFrameCnt = (PVBI_CC_SET_FRAMECNT)pArgs;
446 psVbiInstPri->fpVBICCSetFrameCnt(pCCSetFrameCnt->cnt);
447 u32Ret = UTOPIA_STATUS_SUCCESS;
448 break;
449 case MDrv_CMD_VBI_CC_EnableSlicer:
450 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_EnableSlicer\n");
451 pCCEnableSlicer = (PVBI_CC_ENABLE_SLICER)pArgs;
452 psVbiInstPri->fpVBICCEnableSlicer(pCCEnableSlicer->bEnable);
453 u32Ret = UTOPIA_STATUS_SUCCESS;
454 break;
455 case MDrv_CMD_VBI_CC_EnableLine:
456 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_EnableLine\n");
457 pCCEnableLine = (PVBI_CC_ENABLE_LINE)pArgs;
458 psVbiInstPri->fpVBICCEnableLine(pCCEnableLine->StartLine,
459 pCCEnableLine->EndLine,
460 pCCEnableLine->mode);
461 u32Ret = UTOPIA_STATUS_SUCCESS;
462 break;
463
464 case MDrv_CMD_VBI_CC_SetSCWindowLen:
465 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_SetSCWindowLen\n");
466 pCCSetWndLen = (PVBI_CC_SET_SC_WND_LEN)pArgs;
467 pCCSetWndLen->bRet = psVbiInstPri->fpVBICCSetSCWindowLen(pCCSetWndLen->u8Len);
468 u32Ret = UTOPIA_STATUS_SUCCESS;
469 break;
470
471 case MDrv_CMD_VBI_CC_SetVideoStandard:
472 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_CC_SetVideoStandard\n");
473 pSetVideoStandard = (PVBI_SET_VIDEO_STANDARD)pArgs;
474 pSetVideoStandard->bRet = psVbiInstPri->fpVBICCSetVideoStandard(pSetVideoStandard->eStandard);
475 u32Ret = UTOPIA_STATUS_SUCCESS;
476 break;
477 case MDrv_CMD_VBI_WSS_SetVpsByteNum:
478 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_WSS_SetVpsByteNum\n");
479 pWSSSetVpsByteCnt = (PVBI_VBI_WSS_VPSBYTENUM)pArgs;
480 psVbiInstPri->fpVBIWSSSetVpsByteNum(pWSSSetVpsByteCnt->cnt);
481 u32Ret = UTOPIA_STATUS_SUCCESS;
482 break;
483
484 case MDrv_CMD_VBI_Suspend:
485 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_Suspend\n");
486 pCheckTureFalse = (PVBI_BOOL)pArgs;
487 pCheckTureFalse->bCheck = psVbiInstPri->fpVBISuspend();
488 u32Ret = UTOPIA_STATUS_SUCCESS;
489 break;
490 case MDrv_CMD_VBI_Resume:
491 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_Resume\n");
492 pCheckTureFalse = (PVBI_BOOL)pArgs;
493 pCheckTureFalse->bCheck = psVbiInstPri->fpVBIResume();
494 u32Ret = UTOPIA_STATUS_SUCCESS;
495 break;
496 case MDrv_CMD_VBI_SetPowerState:
497 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_SetPowerState\n");
498 pGetResult = (PVBI_GET_RESULT)pArgs;
499 pGetResult->u32result= psVbiInstPri->fpVBISetPowerState(pGetResult->u16PowerState);
500 u32Ret = UTOPIA_STATUS_SUCCESS;
501 break;
502
503 case MDrv_CMD_VBI_ProtectMemory:
504 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_ProtectMemory\n");
505 pProtectMemory = (PVBI_PROTECT_MEMORY)pArgs;
506 pProtectMemory->bRet = psVbiInstPri->fpVBIProtectMemory(pProtectMemory->bEnable,
507 pProtectMemory->phyAddr,
508 pProtectMemory->u32Size);
509 u32Ret = UTOPIA_STATUS_SUCCESS;
510 break;
511 //=============================================
512 // DTV - TTX
513 //=============================================
514 case MDrv_CMD_DMX_TTX_RingBuffer_Reset:
515 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_RingBuffer_Reset\n");
516 psVbiInstPri->fpDMXTTXRingBufferReset();
517 u32Ret = UTOPIA_STATUS_SUCCESS;
518 break;
519 case MDrv_CMD_DMX_TTX_Init:
520 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_Init\n");
521 pInitializerTTXSlicer = (PVBI_INITIALIZER_TTX_SLICER)pArgs;
522 if(psVbiInstPri->fpDMXTTXInit(pInitializerTTXSlicer->cmd, pInitializerTTXSlicer->bufferAddr, pInitializerTTXSlicer->packetCount) == TRUE)
523 u32Ret = UTOPIA_STATUS_SUCCESS;
524 break;
525 case MDrv_CMD_DMX_TTX_SetFilterID:
526 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_SetFilterID\n");
527 pDMXSetFilterID = (PDMX_TTX_SET_FILTERID)pArgs;
528 psVbiInstPri->fpDMXTTXSetFilterID(pDMXSetFilterID->fid);
529 u32Ret = UTOPIA_STATUS_SUCCESS;
530 break;
531 case MDrv_CMD_DMX_TTX_SetCB:
532 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_SetCB\n");
533 pDMXSetCB = (PDMX_TTX_SET_CB)pArgs;
534 psVbiInstPri->fpDMXTTXSetCB(pDMXSetCB->fn);
535 u32Ret = UTOPIA_STATUS_SUCCESS;
536 break;
537 case MDrv_CMD_DMX_TTX_PacketBufferIsEmpty:
538 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_PacketBufferIsEmpty\n");
539 pCheckTureFalse = (PVBI_BOOL)pArgs;
540 pCheckTureFalse->bCheck = psVbiInstPri->fpDMXTTXPacketBufferIsEmpty();
541 u32Ret = UTOPIA_STATUS_SUCCESS;
542 break;
543 case MDrv_CMD_DMX_TTX_GetPackets:
544 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_GetPackets\n");
545 pGetPackets = (PVBI_TTX_GET_PACKETS)pArgs;
546 if(psVbiInstPri->fpDMXTTXGetPackets(pGetPackets->dataAddr, pGetPackets->length) == TRUE)
547 u32Ret = UTOPIA_STATUS_SUCCESS;
548 break;
549 case MDrv_CMD_DMX_TTX_GetPacket:
550 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_GetPacket\n");
551 pGetPacket = (PVBI_TTX_GET_PACKET)pArgs;
552 if(psVbiInstPri->fpDMXTTXGetPacket(pGetPacket->packetAddress) == TRUE)
553 u32Ret = UTOPIA_STATUS_SUCCESS;
554 break;
555 case MDrv_CMD_DMX_TTX_PacketBufferIsOverflow:
556 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_PacketBufferIsOverflow\n");
557 pCheckTureFalse = (PVBI_BOOL)pArgs;
558 pCheckTureFalse->bCheck = psVbiInstPri->fpDMXTTXPacketBufferIsOverflow();
559 u32Ret = UTOPIA_STATUS_SUCCESS;
560 break;
561 case MDrv_CMD_DMX_TTX_PacketBufferGetNoOfOverflows:
562 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_PacketBufferGetNoOfOverflows\n");
563 pGetData = (PVBI_GET_DATA)pArgs;
564 pGetData->u16data = psVbiInstPri->fpDMXTTXPacketBufferGetNoOfOverflows();
565 u32Ret = UTOPIA_STATUS_SUCCESS;
566 break;
567 case MDrv_CMD_VBI_Exit:
568 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_VBI_Exit\n");
569 pVbiCmd = (PVBI_CMD)pArgs;
570 if(psVbiInstPri->fpVBIExit(pVbiCmd->cmd) == TRUE)
571 u32Ret = UTOPIA_STATUS_SUCCESS;
572 break;
573 case MDrv_CMD_DMX_TTX_Exit:
574 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_Exit\n");
575 pDmxTtxCmd = (PDMX_TTX_CMD)pArgs;
576 if(psVbiInstPri->fpDMXTTXExit(pDmxTtxCmd->cmd) == TRUE)
577 u32Ret = UTOPIA_STATUS_SUCCESS;
578 break;
579
580 case MDrv_CMD_DMX_TTX_Suspend:
581 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_Suspend\n");
582 pCheckTureFalse = (PVBI_BOOL)pArgs;
583 pCheckTureFalse->bCheck = psVbiInstPri->fpDMXTTXSuspend();
584 u32Ret = UTOPIA_STATUS_SUCCESS;
585 break;
586 case MDrv_CMD_DMX_TTX_Resume:
587 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_Resume\n");
588 pCheckTureFalse = (PVBI_BOOL)pArgs;
589 pCheckTureFalse->bCheck = psVbiInstPri->fpDMXTTXResume();
590 u32Ret = UTOPIA_STATUS_SUCCESS;
591 break;
592 case MDrv_CMD_DMX_TTX_SetPowerState:
593 //ULOGD("VBI", "VBIIoctl - MDrv_CMD_DMX_TTX_SetPowerState\n");
594 pGetResult = (PVBI_GET_RESULT)pArgs;
595 pGetResult->u32result= psVbiInstPri->fpDMXTTXSetPowerState(pGetResult->u16PowerState);
596 u32Ret = UTOPIA_STATUS_SUCCESS;
597 break;
598 default:
599 break;
600 };
601
602 if(u32Cmd <= MDrv_CMD_VBI_WSS_SetVpsByteNum || u32Cmd == MDrv_CMD_VBI_Exit )
603 {
604 UtopiaResourceRelease(pResource_atv);
605 }
606 else
607 {
608 UtopiaResourceRelease(pResource_dtv);
609 }
610
611 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,ULOGD("VBI", "leave %s %d\n",__FUNCTION__,__LINE__));
612 return u32Ret; // FIXME: error code
613 }
614
VBIClose(void * pInstance)615 MS_U32 VBIClose(void* pInstance)
616 {
617 UtopiaInstanceDelete(pInstance);
618 return UTOPIA_STATUS_SUCCESS;
619 }
620
621