1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ///////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2010 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 dmx.c
98 /// @brief Demux (DMX) API Interface
99 /// @author MStar Semiconductor,Inc.
100 /// @attention
101 ///////////////////////////////////////////////////////////////////////////////////////////////////
102
103
104 //-------------------------------------------------------------------------------------------------
105 // Include Files
106 //-------------------------------------------------------------------------------------------------
107 #ifdef MSOS_TYPE_LINUX_KERNEL
108 #include <linux/string.h>
109 #include <linux/errno.h>
110 #else
111 #include <stdio.h>
112 #include <string.h>
113 #endif
114
115 #include "MsTypes.h"
116 #include "apiDMX.h"
117 #include "apiDMX_tsio.h"
118 #include "apiDMX_private.h"
119 #include "utopia.h"
120 #include "utopia_dapi.h"
121 #include "MsOS.h"
122 #include "ULog.h"
123
124 //-------------------------------------------------------------------------------------------------
125 // Driver Compiler Options
126 //-------------------------------------------------------------------------------------------------
127
128 //-------------------------------------------------------------------------------------------------
129 // Global Variables
130 //-------------------------------------------------------------------------------------------------
131
132 //-------------------------------------------------------------------------------------------------
133 // Local Defines
134 //-------------------------------------------------------------------------------------------------
135
136 #define DMX_MSG(x) // x
137
138
139 //-------------------------------------------------------------------------------------------------
140 // Local Structures
141 //-------------------------------------------------------------------------------------------------
142
143 enum
144 {
145 DMX_POOL_ID_DMX0,
146 } eDmxPoolID;
147
148
149 //-------------------------------------------------------------------------------------------------
150 // Local Variables
151 //-------------------------------------------------------------------------------------------------
152
153
154 //-------------------------------------------------------------------------------------------------
155 // Local Functions
156 //-------------------------------------------------------------------------------------------------
_DMX_PhyAddr_To_U32Param(MS_PHY phyaddr,MS_U32 * pu32param)157 static void _DMX_PhyAddr_To_U32Param(MS_PHY phyaddr, MS_U32* pu32param)
158 {
159 pu32param[0] = (MS_U32)phyaddr;
160 pu32param[1] = ((sizeof(MS_PHY) > sizeof(MS_U32)) ? *(((MS_U32*)&phyaddr) + 1) : 0);
161 }
162
_DMXProbeResourceToUtopia(DMX_INSTANT_PRIVATE * pDmxInstant)163 static MS_BOOL _DMXProbeResourceToUtopia(DMX_INSTANT_PRIVATE *pDmxInstant)
164 {
165 pDmxInstant->fpDMXInitLibRes = MApi_DMX_InitLibResource;
166 pDmxInstant->fpDMXSetFWBuf = _MApi_DMX_SetFW;
167 pDmxInstant->fpDMXSetFWMiuDataAddr = _MApi_DMX_SetFwDataAddr;
168 pDmxInstant->fpDMXSetHK = _MApi_DMX_SetHK;
169 pDmxInstant->fpDMXInit = _MApi_DMX_Init;
170 pDmxInstant->fpDMXTSPInit = _MApi_DMX_TSPInit;
171 pDmxInstant->fpDMXTSPInit_GetConfig = _MApi_DMX_TSPInit_GetConfig;
172 pDmxInstant->fpDMXExit = _MApi_DMX_Exit;
173 pDmxInstant->fpDMXForceExit = _MApi_DMX_ForceExit;
174 pDmxInstant->fpDMXSuspend = _MApi_DMX_Suspend;
175 pDmxInstant->fpDMXResume = _MApi_DMX_Resume;
176 pDmxInstant->fpDMXChkFwAlive = _MApi_DMX_ChkAlive;
177 pDmxInstant->fpDMXReset = _MApi_DMX_Reset;
178 pDmxInstant->fpDMXReleaseHwSemp = _MApi_DMX_ReleaseSemaphone;
179 pDmxInstant->fpDMXWProtectEnable = _MApi_DMX_WriteProtect_Enable;
180 pDmxInstant->fpDMXOrzWProtectEnable = _MApi_DMX_OrzWriteProtect_Enable;
181 pDmxInstant->fpDMXReadDropCount = _MApi_DMX_Read_DropPktCnt;
182 pDmxInstant->fpDMXSetPowerState = _MApi_DMX_SetPowerState;
183
184 pDmxInstant->fpDMXSetOwner = _MApi_DMX_SetOwner;
185 pDmxInstant->fpDMXGetCap = _MApi_DMX_GetCap;
186 pDmxInstant->fpDMXGetCapEx = _MApi_DMX_GetCap_Ex;
187 pDmxInstant->fpDMXParlInvert = _MApi_DMX_Parl_Invert;
188 pDmxInstant->fpDMXSetBurstLen = _MApi_DMX_SetBurstLen;
189
190 pDmxInstant->fpDMXFlowSet = _MApi_DMX_FlowSet;
191 pDmxInstant->fpDMXPvrFlowSet = _MApi_DMX_PVR_FlowSet;
192 pDmxInstant->fpDMXGetFlowInputSts = _MApi_DMX_Get_FlowInput_Status;
193 pDmxInstant->fpDMXFlowEnable = _MApi_DMX_FlowEnable;
194 pDmxInstant->fpDMXTsOutpadCfg = _MApi_DMX_TsOutputPadCfg;
195 pDmxInstant->fpDMXTsS2POutPhase = _MApi_DMX_TsS2POutputClkPhase;
196 pDmxInstant->fpDMXFlowDscmbEng = _MApi_DMX_Flow_DscmbEng;
197 pDmxInstant->fpDMXDropScmbPkt = _MApi_DMX_DropScmbPkt;
198
199 pDmxInstant->fpDMX64bitModeEn = _MApi_DMX_STC64_Mode_Enable;
200 pDmxInstant->fpDMXGetPcrEng = _MApi_DMX_Pcr_Eng_Get;
201 pDmxInstant->fpDMXGetStcEng = _MApi_DMX_Stc_Eng_Get;
202 pDmxInstant->fpDMXSetStcEng = _MApi_DMX_Stc_Eng_Set;
203 pDmxInstant->fpDMXStcUpdateCtrl = _MApi_DMX_STC_UpdateCtrl;
204 pDmxInstant->fpDMXSetStcOffset = _MApi_DMX_Stc_Eng_SetOffset;
205 pDmxInstant->fpDMXStcClkAdjust = _MApi_DMX_Stc_Clk_Adjust;
206 pDmxInstant->fpDMXStcSel = _MApi_DMX_Stc_Select;
207
208 pDmxInstant->fpDMXOpen = _MApi_DMX_Open;
209 pDmxInstant->fpDMXOpenEx = _MApi_DMX_Open_Ex;
210 pDmxInstant->fpDMXClose = _MApi_DMX_Close;
211 pDmxInstant->fpDMXStart = _MApi_DMX_Start;
212 pDmxInstant->fpDMXStop = _MApi_DMX_Stop;
213 pDmxInstant->fpDMXInfo = _MApi_DMX_Info;
214 pDmxInstant->fpDMXInfoEx = _MApi_DMX_Info_Ex;
215 pDmxInstant->fpDMXPid = _MApi_DMX_Pid;
216 pDmxInstant->fpDMXIsStart = _MApi_DMX_IsStart;
217 pDmxInstant->fpDMXCopyData = _MApi_DMX_CopyData;
218 pDmxInstant->fpDMXProc = _MApi_DMX_Proc;
219 pDmxInstant->fpDMXChangeFltSrc = _MApi_DMX_Change_FilterSource;
220 pDmxInstant->fpDMXSwitchLiveFltSrc = _MApi_DMX_LiveSrcSwitch;
221 pDmxInstant->fpDMXGetOnwer = _MApi_DMX_GetOwner;
222
223 pDmxInstant->fpDMXGetFltScmbSts = _MApi_DMX_Get_FltScmbSts;
224 pDmxInstant->fpDMXGetPesScmbSts = _MApi_DMX_Get_PesScmbSts;
225 pDmxInstant->fpDMXGetTsScmbSts = _MApi_DMX_Get_TsScmbSts;
226
227 pDmxInstant->fpDMXSecReset = _MApi_DMX_SectReset;
228 pDmxInstant->fpDMXSecSetReadAddr = _MApi_DMX_SectReadSet;
229 pDmxInstant->fpDMXSecGetReadAddr = _MApi_DMX_SectReadGet;
230 pDmxInstant->fpDMXSecGetWriteAddr = _MApi_DMX_SectWriteGet;
231 pDmxInstant->fpDMXSecGetStartAddr = _MApi_DMX_SectStartGet;
232 pDmxInstant->fpDMXSecGetEndAddr = _MApi_DMX_SectEndGet;
233 pDmxInstant->fpDMXSecSetPattern = _MApi_DMX_SectPatternSet;
234
235 pDmxInstant->fpDMXGetTTXWrite = _MApi_DMX_TTX_WriteGet;
236 pDmxInstant->fpDMXGetAccess = _MApi_DMX_GetAccess;
237 pDmxInstant->fpDMXReleaseAccess = _MApi_DMX_ReleaseAccess;
238
239 pDmxInstant->fpDMXAVFifoReset = _MApi_DMX_AVFifo_Reset;
240 pDmxInstant->fpDMXAVFifoStatus = _MApi_DMX_AVFifo_Status;
241 pDmxInstant->fpDMXRemoveDupAVPkt = _MApi_DMX_RemoveDupAVPkt;
242 pDmxInstant->fpDMXRemoveDupAVFifoPkt = _MApi_DMX_RemoveDupAVFifoPkt;
243 pDmxInstant->fpDMXAUBDModeEn = _MApi_DMX_AU_BD_Mode_Enable;
244 pDmxInstant->fpDMXSetPktMode = _MApi_DMX_SetPacketMode;
245 pDmxInstant->fpDMXSetMerStrSyc = _MApi_DMX_SetMergeStrSyncByte;
246
247 pDmxInstant->fpDMXFileSetPlayStamp = _MApi_DMX_Filein_Eng_SetPlaybackStamp;
248 pDmxInstant->fpDMXFileGetPlayStamp = _MApi_DMX_Filein_Eng_GetPlaybackStamp;
249 pDmxInstant->fpDMXFileTimestampEnable = _MApi_DMX_Filein_Eng_PlaybackTimeStampEnable;
250 pDmxInstant->fpDMXFileTimestampDisable = _MApi_DMX_Filein_Eng_PlaybackTimeStampDisable;
251
252 pDmxInstant->fpDMXPvrEngOpen = _MApi_DMX_Pvr_Eng_Open;
253 pDmxInstant->fpDMXPvrEngClose = _MApi_DMX_Pvr_Eng_Close;
254 pDmxInstant->fpDMXPvrEngPidOpen = _MApi_DMX_Pvr_Eng_Pid_Open;
255 pDmxInstant->fpDMXPvrEngPidClose = _MApi_DMX_Pvr_Eng_Pid_Close;
256 pDmxInstant->fpDMXPvrEngStart = _MApi_DMX_Pvr_Eng_Start;
257 pDmxInstant->fpDMXPvrEngStop = _MApi_DMX_Pvr_Eng_Stop;
258 pDmxInstant->fpDMXPvrEngGetWriteAddr = _MApi_DMX_Pvr_Eng_WriteGet;
259 pDmxInstant->fpDMXPvrEngSetPktMode = _MApi_DMX_Pvr_Eng_SetPacketMode;
260 pDmxInstant->fpDMXPvrEngSetRecordStamp = _MApi_DMX_Pvr_Eng_SetRecordStamp;
261 pDmxInstant->fpDMXPvrEngGetRecordStamp = _MApi_DMX_Pvr_Eng_GetRecordStamp;
262 pDmxInstant->fpDMXPvrEngMobfEn = _MApi_DMX_Pvr_Eng_MOBF_Enable;
263 pDmxInstant->fpDMXPvrEngSetRecordStampClk = _MApi_DMX_Pvr_Eng_SetRecordStampClk;
264 pDmxInstant->fpDMXPvrEngCBSize = _MApi_DMX_Pvr_Eng_CallbackSize;
265 pDmxInstant->fpDMXPvrEngSetCaMode = _MApi_DMX_Pvr_Eng_SetCaMode;
266 pDmxInstant->fpDMXPvrIsStart = _MApi_DMX_Pvr_Eng_IsStart;
267
268 pDmxInstant->fpDMXFileEngSetPlayStampClk = _MApi_DMX_Pvr_Eng_SetPlaybackStampClk;
269
270 pDmxInstant->fpDMXPvrcaEngPidOpen = _MApi_DMX_PvrCA_Eng_Pid_Open;
271 pDmxInstant->fpDMXPvrcaEngPidClose = _MApi_DMX_PvrCA_Eng_Pid_Close;
272 pDmxInstant->fpDMXPvrcaEngStart = _MApi_DMX_PvrCA_Eng_Start;
273 pDmxInstant->fpDMXPvrcaEngStop = _MApi_DMX_PvrCA_Eng_Stop;
274
275 pDmxInstant->fpDMXFileStart = _MApi_DMX_Filein_Eng_Start;
276 pDmxInstant->fpDMXFileStop = _MApi_DMX_Filein_Eng_Stop;
277 pDmxInstant->fpDMXFileInfo = _MApi_DMX_Filein_Info;
278 pDmxInstant->fpDMXFileEngInfo = _MApi_DMX_Filein_Eng_Info;
279 pDmxInstant->fpDMXFilePause = _MApi_DMX_Filein_Eng_Pause;
280 pDmxInstant->fpDMXFileResume = _MApi_DMX_Filein_Eng_Resume;
281 pDmxInstant->fpDMXFileIsIdle = _MApi_DMX_Filein_Eng_IsIdle;
282 pDmxInstant->fpDMXFileIsBusy = _MApi_DMX_Filein_Eng_IsBusy;
283 pDmxInstant->fpDMXFileIsPause = _MApi_DMX_Filein_Eng_IsPause;
284 pDmxInstant->fpDMXFileCmdQReset = _MApi_DMX_Filein_Eng_CMDQ_Reset;
285 pDmxInstant->fpDMXFileCmdQGetEmptyNum = _MApi_DMX_Filein_Eng_CMDQ_GetEmptyNum;
286 pDmxInstant->fpDMXFileBypassFileTimeStamp = _MApi_DMX_Filein_Eng_BypassFileInTimeStamp;
287 pDmxInstant->fpDMXFileCmdQGetFifoWLevel = _MApi_DMX_Filein_Eng_CMDQ_FIFOWriteLevel;
288 pDmxInstant->fpDMXFileGetFileTimestamp = _MApi_DMX_Filein_Eng_GetFileInTimeStamp;
289 pDmxInstant->fpDMXFileGetReadAddr = _MApi_DMX_Filein_Eng_GetReadAddr;
290 pDmxInstant->fpDMXFileMobfEn = _MApi_DMX_Filein_Eng_MOBF_Enable;
291
292 pDmxInstant->fpDMXMMFIIsIdle = _MApi_DMX_MMFI_Filein_IsIdle;
293 pDmxInstant->fpDMXMMFIIsBusy = _MApi_DMX_MMFI_Filein_IsBusy;
294 pDmxInstant->fpDMXMMFICmdQReset = _MApi_DMX_MMFI_Filein_CMDQ_Reset;
295 pDmxInstant->fpDMXMMFIGetEmptyNum = _MApi_DMX_MMFI_Filein_CMDQ_GetEmptyNum;
296 pDmxInstant->fpDMXMMFIStart = _MApi_DMX_MMFI_Filein_Start;
297 pDmxInstant->fpDMXMMFIGetFileTimestamp = _MApi_DMX_MMFI_GetFileInTimeStamp;
298
299 pDmxInstant->fpDMXMMFIPidOpen = _MApi_DMX_MMFI_Pid_Open;
300 pDmxInstant->fpDMXMMFIPidClose = _MApi_DMX_MMFI_Pid_Close;
301 pDmxInstant->fpDMXMMFIGetFifoLevel = _MApi_DMX_MMFI_Filein_CMDQ_FIFOWriteLevel;
302 pDmxInstant->fpDMXMMFISetPlayTimestamp = _MApi_DMX_MMFI_SetPlaybackTimeStamp;
303 pDmxInstant->fpDMXMMFIGetPlayTimestamp = _MApi_DMX_MMFI_GetPlaybackTimeStamp;
304 pDmxInstant->fpDMXMMFISetTimestampClk = _MApi_DMX_MMFI_TimeStampClk;
305 pDmxInstant->fpDMXMMFIInfo = _MApi_DMX_MMFI_Filein_Info;
306 pDmxInstant->fpDMXMMFIBypassStamp = _MApi_DMX_MMFI_Filein_BypassTimeStamp;
307 pDmxInstant->fpDMXMMFIRemoveDupAVPkt = _MApi_DMX_MMFI_RemoveDupAVPkt;
308 pDmxInstant->fpDMXMMFIMobfEn = _MApi_DMX_MMFI_MOBF_Enable;
309 pDmxInstant->fpDMXMMFITimestampEn = _MApi_DMX_MMFI_TimeStampEnable;
310 pDmxInstant->fpDMXMMFITimestampDisable = _MApi_DMX_MMFI_TimeStampDisable;
311
312 pDmxInstant->fpDMXTsoFileInfo = _MApi_DMX_TSO_Filein_Info;
313 pDmxInstant->fpDMXTsoFileIsIdle = _MApi_DMX_TSO_Filein_IsIdle;
314 pDmxInstant->fpDMXTsoFileGetCmdQEmptyNum = _MApi_DMX_TSO_Filein_CMDQ_GetEmptyNum;
315 pDmxInstant->fpDMXTsoFileGetCmdQReset = _MApi_DMX_TSO_Filein_CMDQ_Reset;
316 pDmxInstant->fpDMXTsoFileStart = _MApi_DMX_TSO_Filein_Start;
317 pDmxInstant->fpDMXTsoFileStop = _MApi_DMX_TSO_Filein_Stop;
318 pDmxInstant->fpDMXTsoFileSetPlayStamp = _MApi_DMX_TSO_SetPlaybackTimeStamp;
319 pDmxInstant->fpDMXTsoFileGetPlayStamp = _MApi_DMX_TSO_GetPlaybackStamp;
320 pDmxInstant->fpDMXTsoFileGetTimeStamp = _MApi_DMX_TSO_GetFileInTimeStamp;
321 pDmxInstant->fpDMXTsoFileBypassStamp = _MApi_DMX_TSO_BypassFileInTimeStamp;
322 pDmxInstant->fpDMXTsoFileTimeStampEnable = _MApi_DMX_TSO_TimeStampEnable;
323 pDmxInstant->fpDMXTsoFileTimeStampDisable = _MApi_DMX_TSO_TimeStampDisable;
324 pDmxInstant->fpDMXTsoSetOutClk = _MApi_DMX_TSO_SetOutClk;
325 pDmxInstant->fpDMXTsoOutputEn = _MApi_DMX_TSO_OutputEnable;
326 pDmxInstant->fpDMXTsoLocStrId = _MApi_DMX_TSO_LocalStreamId;
327 pDmxInstant->fpDMXTsoSvqBufSet = _MApi_DMX_TSO_SVQBuf_Set;
328 pDmxInstant->fpDMXTsoFlowInputCfg = _MApi_DMX_TSO_Flow_InputCfg;
329 pDmxInstant->fpDMXTsoFlowOutputCfg = _MApi_DMX_TSO_Flow_OutputCfg;
330 pDmxInstant->fpDMXTsoPidOpen = _MApi_DMX_TSO_Pid_Open;
331 pDmxInstant->fpDMXTsoPidClose = _MApi_DMX_TSO_Pid_Close;
332 pDmxInstant->fpDMXTsoGetFileinAddr = _MApi_DMX_TSO_Filein_GetReadAddr;
333
334 pDmxInstant->fpDMXSetDbgLevel = _MApi_DMX_SetDbgLevel;
335 pDmxInstant->fpDMXGetFwVer = _MApi_TSP_Get_FW_VER;
336 pDmxInstant->fpDMXGetLibVer = _MApi_DMX_GetLibVer;
337 pDmxInstant->fpDMXGetDisConCnt = _MApi_DMX_Get_DisContiCnt;
338 pDmxInstant->fpDMXGetDropPktCnt = _MApi_DMX_Get_DropPktCnt;
339 pDmxInstant->fpDMXGetLockPktCnt = _MApi_DMX_Get_LockPktCnt;
340 pDmxInstant->fpDMXGetAVPktCnt = _MApi_DMX_Get_AVPktCnt;
341 pDmxInstant->fpDMXGetSecTeiPktCnt = _MApi_DMX_Get_SecTEI_PktCount;
342 pDmxInstant->fpDMXResetSecTeiPktCnt = _MApi_DMX_Reset_SecTEI_PktCount;
343 pDmxInstant->fpDMXGetSecDisConPktCnt = _MApi_DMX_Get_SecDisCont_PktCount;
344 pDmxInstant->fpDMXResetSecDisContPktCnt = _MApi_DMX_Reset_SecDisCont_PktCount;
345
346 pDmxInstant->fpDMXCmdRun = _MApi_DMX_CMD_Run;
347
348 pDmxInstant->fpDMXFQSetFltRushPass = _MApi_DMX_FQ_SetFltRushPass;
349 pDmxInstant->fpDMXFQInit = _MApi_DMX_FQ_Init;
350 pDmxInstant->fpDMXFQExit = _MApi_DMX_FQ_Exit;
351 pDmxInstant->fpDMXFQRushEn = _MApi_DMX_FQ_RushEnable;
352 pDmxInstant->fpDMXFQSkipRushData = _MApi_DMX_FQ_SkipRushData;
353 pDmxInstant->fpDMXFQConfigure = _MApi_DMX_FQ_Configure;
354 pDmxInstant->fpDMXFQSetRushAddr = _MApi_DMX_FQ_SetRushAddr;
355 pDmxInstant->fpDMXFQReadGet = _MApi_DMX_FQ_ReadGet;
356 pDmxInstant->fpDMXFQWriteGet = _MApi_DMX_FQ_WriteGet;
357
358 pDmxInstant->fpDMXMStrSyncBy = _MApi_DMX_MStr_SyncByte;
359 pDmxInstant->fpDMXWaitTspSig = _MApi_DMX_Wait_TspIoSignal;
360
361 pDmxInstant->fpDMXGetIntCnt = _MApi_DMX_Get_Intr_Count;
362 pDmxInstant->fpDMXDropEn = _MApi_DMX_Drop_Enable;
363 pDmxInstant->fpDMXTeiRmErrPkt = _MApi_DMX_TEI_RemoveErrorPkt;
364 pDmxInstant->fpDMXSetFwDbgParam = _MApi_DMX_SetFwDbgParam;
365 pDmxInstant->fpDMXPvrMobfEn = _MApi_DMX_Pvr_MOBF_Enable;
366 pDmxInstant->fpDMXGetDbgportInfo = _MApi_DMX_GetDbgPortInfo;
367 pDmxInstant->fpDMXOpenMultiFlt = _MApi_DMX_Open_MultiFlt;
368
369 pDmxInstant->fpDMXFilePvrPidOpen = _MApi_DMX_Filein_Pvr_Eng_Pid_Open;
370 pDmxInstant->fpDMXFilePvrPidClose = _MApi_DMX_Filein_Pvr_Eng_Pid_Close;
371 pDmxInstant->fpDMXFilePvrStart = _MApi_DMX_Filein_Pvr_Eng_Start;
372 pDmxInstant->fpDMXFilePvrStop = _MApi_DMX_Filein_Pvr_Eng_Stop;
373
374 pDmxInstant->fpDMXPvrPause = _MApi_DMX_Pvr_Eng_Pause;
375 pDmxInstant->fpDMXPvrPid = _MApi_DMX_Pvr_Eng_Pid;
376
377 pDmxInstant->fpDMXResAllocate = _MApi_DMX_ResAllocate;
378 pDmxInstant->fpDMXResFree = _MApi_DMX_ResFree;
379 pDmxInstant->fpDMXPcrGetMapStc = _MApi_DMX_Pcr_Get_MapSTC;
380
381 pDmxInstant->fpDMXTSIOServiceSetDMAoutVC = _MApi_DMX_TSIO_Service_SetDMAoutVC;
382 pDmxInstant->fpDMXTSIOServiceDMAoutWriteGet = _MApi_DMX_TSIO_Service_DMAout_WriteGet;
383 pDmxInstant->fpDMXTSIOServiceSetDestination = _MApi_DMX_TSIO_Service_SetDestination;
384 pDmxInstant->fpDMXTSIOServiceSetDMAinVC = _MApi_DMX_TSIO_Service_SetDMAinVC;
385 pDmxInstant->fpDMXTSIOServiceDMAinVCStart = _MApi_DMX_TSIO_Service_DMAinVC_Start;
386 pDmxInstant->fpDMXTSIOServiceSetLocdecKey = _MApi_DMX_TSIO_Service_SetLocdecKey;
387 pDmxInstant->fpDMXTSIOServiceLocdecKeyEnable = _MApi_DMX_TSIO_Service_LocdecKeyEnable;
388 pDmxInstant->fpDMXTSIOServicePidOpen = _MApi_DMX_TSIO_Service_PidOpen;
389 pDmxInstant->fpDMXTSIOServicePidClose = _MApi_DMX_TSIO_Service_PidClose;
390 pDmxInstant->fpDMXTSIOServiceAlloc = _MApi_DMX_TSIO_Service_Alloc;
391 pDmxInstant->fpDMXTSIOServiceFree = _MApi_DMX_TSIO_Service_Free;
392 pDmxInstant->fpDMXTSIORegisterIntCb = _MApi_DMX_TSIO_RegisterIntCb;
393 pDmxInstant->fpDMXTSIOInit = _MApi_DMX_TSIO_Init;
394 pDmxInstant->fpDMXTSIOOpen = _MApi_DMX_TSIO_Open;
395 pDmxInstant->fpDMXTSIOCmd = _MApi_DMX_TSIO_Cmd;
396 pDmxInstant->fpDMXTSIOExit = _MApi_DMX_TSIO_Exit;
397 pDmxInstant->fpDMXTSIOClose = _MApi_DMX_TSIO_Close;
398 pDmxInstant->fpDMXTSIOCC = _MApi_DMX_TSIO_CC;
399 pDmxInstant->fpDMXTSIOGetInfo = _MApi_DMX_TSIO_GetInfo;
400
401 pDmxInstant->fpDMXGetPipeId = _MApi_DMX_Get_PipeId;
402
403 return TRUE;
404
405 }
406
407 //-------------------------------------------------------------------------------------------------
408 // Global Functions
409 //-------------------------------------------------------------------------------------------------
410 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
DMXMdbIoctl(MS_U32 cmd,const void * const pArgs)411 MS_U32 DMXMdbIoctl(MS_U32 cmd, const void* const pArgs)
412 {
413 MDBCMD_CMDLINE_PARAMETER *paraCmdLine;
414 MDBCMD_GETINFO_PARAMETER *paraGetInfo;
415
416 switch(cmd)
417 {
418 case MDBCMD_CMDLINE:
419 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs;
420 //MdbPrint(paraCmdLine->u64ReqHdl,"LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
421 //MdbPrint(paraCmdLine->u64ReqHdl,"u32CmdSize: %d\n", paraCmdLine->u32CmdSize);
422 //MdbPrint(paraCmdLine->u64ReqHdl,"pcCmdLine: %s\n", paraCmdLine->pcCmdLine);
423 _MApi_DMX_DBG_EchoCmd(paraCmdLine->u64ReqHdl, paraCmdLine->u32CmdSize, paraCmdLine->pcCmdLine);
424 paraCmdLine->result = MDBRESULT_SUCCESS_FIN;
425 break;
426 case MDBCMD_GETINFO:
427 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs;
428 //MdbPrint(paraGetInfo->u64ReqHdl,"LINE:%d, MDBCMD_GETINFO\n", __LINE__);
429 _MApi_DMX_DBG_GetModuleInfo(paraGetInfo->u64ReqHdl);
430 paraGetInfo->result = MDBRESULT_SUCCESS_FIN;
431 break;
432 default:
433 break;
434 }
435 return 0;
436 }
437 #endif
438
DMXRegisterToUtopia(FUtopiaOpen ModuleType)439 void DMXRegisterToUtopia(FUtopiaOpen ModuleType)
440 {
441 void* pUtopiaModule = NULL;
442 void* psResource = NULL;
443 MS_U32 u32ResSize = 0;
444
445 // 1. deal with module
446 UtopiaModuleCreate(MODULE_DMX, 8, &pUtopiaModule);
447 UtopiaModuleRegister(pUtopiaModule);
448 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)DMXOpen, (FUtopiaClose)DMXClose, (FUtopiaIOctl)DMXIoctl);
449
450 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
451 UtopiaModuleRegisterMdbNode("dmx", (FUtopiaMdbIoctl)DMXMdbIoctl);
452 #endif
453
454 #ifdef MSOS_TYPE_LINUX_KERNEL
455 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule, (FUtopiaSTR)DMXStr);
456 #endif
457
458 // 2. deal with resource
459 UtopiaModuleAddResourceStart(pUtopiaModule, DMX_POOL_ID_DMX0);
460 _MApi_DMX_GetCap(DMX_CAP_RESOURCE_SIZE, (void*)(&u32ResSize));
461 UtopiaResourceCreate("DMX", u32ResSize, &psResource);
462 UtopiaResourceRegister(pUtopiaModule, psResource, DMX_POOL_ID_DMX0);
463 UtopiaModuleAddResourceEnd(pUtopiaModule, DMX_POOL_ID_DMX0);
464 }
465
DMXOpen(void ** ppInstance,void * pAttribute)466 MS_U32 DMXOpen(void** ppInstance, void* pAttribute)
467 {
468 DMX_INSTANT_PRIVATE* psDmxInstPri = NULL;
469
470 DMX_MSG(ULOGD("DMX", "DMX open \n"));
471
472 if(ppInstance == 0)
473 {
474 return UTOPIA_STATUS_PARAMETER_ERROR;
475 }
476
477 UtopiaInstanceCreate(sizeof(DMX_INSTANT_PRIVATE), ppInstance);
478 UtopiaInstanceGetPrivate(*ppInstance, (void**)&psDmxInstPri);
479
480 if(_DMXProbeResourceToUtopia(psDmxInstPri) == FALSE)
481 {
482 DMX_MSG(ULOGE("DMX", "DMX module version is not supported \n"));
483 return UTOPIA_STATUS_NOT_SUPPORTED;
484 }
485
486 return UTOPIA_STATUS_SUCCESS;
487
488 }
489
DMXIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)490 MS_U32 DMXIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
491 {
492 DMX_INSTANT_PRIVATE* psDmxInstPri = NULL;
493 void* pModule = NULL;
494 void* pResource = NULL;
495 void* pResPrivate = NULL;
496 MS_U32 u32Res = UTOPIA_STATUS_SUCCESS;
497 MS_PHY phyaddr = 0UL, phyaddr1 = 0UL;
498 void* ptrTmp = NULL;
499
500 MS_U32* pu32Param = NULL;
501 DMX_TSPParam* pTSPParam = NULL;
502 PDMX_CAP_PARAM pCapParam = NULL;
503 PDMX_CAP_EX_PARAM pCapExParam = NULL;
504 PDMX_FLOW_PARAM pFlowParam = NULL;
505 PDMX_PVRFLOW_PARAM pPvrFlowParam = NULL;
506 PDMX_FLT_TYPE_PARAM pFltTypeParam = NULL;
507 PDMX_FLT_INFO_PARAM pFltInfoParam = NULL;
508 PDMX_FLT_INFO_PARAM_Ex pFltInfoParam_Ex = NULL;
509 PDMX_FLT_COPY_PARAM pFltCopyParam = NULL;
510 PDMX_FLT_EVENT_PARAM pFltEventParam = NULL;
511 PDMX_FLT_SEC_PAT_PARAM pFltSecPatParam = NULL;
512 PDMX_AVFIFO_PARAM pAVFifoParam = NULL;
513 PDMX_AVFIFO_DROP_PARAM pAVFifoDropParam = NULL;
514 PDMX_TIMESTAMP_CLK_PARAM pStampClkParam = NULL;
515 PDMX_PVR_INFO_PARAM pPvrInfoParam = NULL;
516 PDMX_PVR_FLTTYPE_PARAM pPvrFltTypeParam = NULL;
517 PDMX_FILE_START_PARAM pFileStartParam = NULL;
518 PDMX_FILE_INFO_PARAM pFileInfoParam = NULL;
519 PDMX_MMFI_FLT_PARAM pMMFIFltParam = NULL;
520 PDMX_CMDRUN_PARAM pCmdRunParam = NULL;
521 PDMX_POWSTATE_PARAM pCmdPowerState = NULL;
522 PDMX_MMFI_START_PARAM pMMFIStartParam = NULL;
523 PDMX_PKT_MODE_PARAM pPktModeParam = NULL;
524 PDMX_PKT_DISCONCNT_PARAM pPktDisConCntParam = NULL;
525 PDMX_PKT_DROPCNT_PARAM pPktDropCntParam = NULL;
526 PDMX_PKT_LOCKCNT_PARAM pPktLockCntParam = NULL;
527 PDMX_PKT_AVCNT_PARAM pPktAVCNTParam = NULL;
528 PDMX_WP_PARAM pWPParam = NULL;
529 PDMX_PKT_SECTEI_PARAM pPktSecTeiParam = NULL;
530 PDMX_TSO_OUTCLK_PARAM pTsoOutClkParam = NULL;
531 PDMX_TSO_LOCSTRID_PARAM pTsoLocStrId = NULL;
532 PDMX_FQ_INIT_PARAM pFQInitParam = NULL;
533 PDMX_FQ_SKIP_RUSH_DATA_PARAM pFQSkipRushData = NULL;
534 DMX_FQ_Cfg* pFQConfigure = NULL;
535 PDMX_MSTR_SYNCBY_PARAM pMStrSync = NULL;
536 DMX_OutputPad_Cfg* pstOutPadCfg = NULL;
537 PDMX_FLOW_DSCMBENG_PARAM pstFlowDscmbEng = NULL;
538 PDMX_DROP_SCMB_PKT_PARAM pstDropScmbPkt = NULL;
539 PDMX_TSIO_Service_SetDMAoutVC_PARAM pstSerDMAoutVC = NULL;
540 PDMX_TSIO_Service_DMAout_WriteGet_PARAM pstSerDMAoutWrite = NULL;
541 PDMX_TSIO_Service_SetDestination_PARAM pstSerDestination = NULL;
542 PDMX_TSIO_Service_SetDMAinVC_PARAM pstSerDMAinVC = NULL;
543 PDMX_TSIO_Service_DMAinVC_Start_PARAM pstSerDMAinVCStart = NULL;
544 PDMX_TSIO_Service_SetLocdecKey_PARAM pstSerLocdecKey = NULL;
545 PDMX_TSIO_Service_LocdecKeyEnable_PARAM pstSerLocdecEnable = NULL;
546 PDMX_TSIO_Service_PidOpen_PARAM pstSerPidOpen = NULL;
547 PDMX_TSIO_Service_PidClose_PARAM pstSerPidClose = NULL;
548 PDMX_TSIO_Service_Alloc_PARAM pstSerAlloc = NULL;
549 PDMX_TSIO_Service_Free_PARAM pstSerFree = NULL;
550 PDMX_TSIO_RegisterIntCb_PARAM pstRegisterIntCb = NULL;
551 PDMX_TSIO_Init_PARAM pstTSIOInit = NULL;
552 PDMX_TSIO_Open_PARAM pstTSIOOpen = NULL;
553 PDMX_TSIO_Cmd_PARAM pstTSIOCmd = NULL;
554 PDMX_TSIO_CC_PARAM pstTSIOCc = NULL;
555 PDMX_TSIO_GetInfo_PARAM pstTSIOGetInfo = NULL;
556 #ifdef MSOS_TYPE_LINUX_KERNEL
557 DMX_TSP_IOSIGNAL* pstTspSig = NULL;
558 DMX_TSIO_IOSIGNAL* pstTSIOSig = NULL;
559 #endif
560
561 if(pInstance == NULL)
562 {
563 ULOGE("DMX", "DMXIoctl - pInstance is NULL!!! \n");
564 return UTOPIA_STATUS_FAIL;
565 }
566
567 //wait forever events, don't block mutex...
568 #ifdef MSOS_TYPE_LINUX_KERNEL
569
570 if(u32Cmd == MApi_CMD_DMX_WaitTspCbEvt)
571 {
572 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_WaitTspCbEvt\n"));
573 pstTspSig = (DMX_TSP_IOSIGNAL*)pArgs;
574
575 if(_MApi_DMX_Wait_TspIoSignal(pstTspSig) == DMX_FILTER_STATUS_OK)
576 {
577 return UTOPIA_STATUS_SUCCESS;
578 }
579 else
580 {
581 return UTOPIA_STATUS_FAIL;
582 }
583 }
584 else if (u32Cmd == MApi_CMD_DMX_TSIO_WaitCbEvt)
585 {
586 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_WaitCbEvt\n"));
587 pstTSIOSig = (DMX_TSIO_IOSIGNAL *)pArgs;
588 if(_MApi_DMX_TSIO_WaitIoSignal(pstTSIOSig) == DMX_FILTER_STATUS_OK)
589 {
590 return UTOPIA_STATUS_SUCCESS;
591 }
592 else
593 {
594 return UTOPIA_STATUS_FAIL;
595 }
596 }
597 #endif //MSOS_TYPE_LINUX_KERNEL
598
599 if(UtopiaInstanceGetPrivate(pInstance, (void*)&psDmxInstPri) != 0)
600 {
601 ULOGE("DMX", "DMXIoctl - UtopiaInstanceGetPrivate fail\n");
602 return UTOPIA_STATUS_FAIL;
603 }
604 if(UtopiaInstanceGetModule(pInstance, &pModule) != 0)
605 {
606 ULOGE("DMX", "DMXIoctl - UtopiaInstanceGetModule fail\n");
607 return UTOPIA_STATUS_FAIL;
608 }
609 if(UtopiaResourceObtain(pModule, DMX_POOL_ID_DMX0, &pResource) != 0)
610 {
611 ULOGE("DMX", "DMXIoctl - UtopiaResourceObtain fail\n");
612 return UTOPIA_STATUS_FAIL;
613 }
614 if(UtopiaResourceGetPrivate(pResource, &pResPrivate) != 0)
615 {
616 ULOGE("DMX", "DMXIoctl - UtopiaResourceGetPrivatefail\n");
617 goto IOCTRL_END;
618 }
619
620 // init share resource of driver and assign share mem pointer to process
621 if(psDmxInstPri->fpDMXInitLibRes(pResPrivate) != DMX_FILTER_STATUS_OK)
622 {
623 ULOGE("DMX", "DMXIoctl - DMX init share memory failed \n");
624 u32Res = UTOPIA_STATUS_ERR_USER;
625 goto IOCTRL_END;
626 }
627
628 switch(u32Cmd)
629 {
630 // General API
631 case MApi_CMD_DMX_Init:
632 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Init\n"));
633
634 pTSPParam = (DMX_TSPParam*)pArgs;
635 if(psDmxInstPri->fpDMXSetFWBuf(pTSPParam->phyFWAddr, pTSPParam->u32FWSize) != DMX_FILTER_STATUS_OK)
636 {
637 DMX_MSG(ULOGE("DMX", "DMX Set FW failed \n"));
638 pTSPParam->u32Res = (MS_U32)DMX_FILTER_STATUS_ERROR;
639 break;
640 }
641 if(psDmxInstPri->fpDMXSetHK((MS_BOOL)pTSPParam->u32IsHK) != DMX_FILTER_STATUS_OK)
642 {
643 DMX_MSG(ULOGE("DMX", "DMX Set HK failed \n"));
644 pTSPParam->u32Res = (MS_U32)DMX_FILTER_STATUS_ERROR;
645 break;
646 }
647 if(psDmxInstPri->fpDMXInit() != DMX_FILTER_STATUS_OK)
648 {
649 DMX_MSG(ULOGE("DMX", "DMX Set init failed \n)"));
650 pTSPParam->u32Res = (MS_U32)DMX_FILTER_STATUS_ERROR;
651 break;
652 }
653 pTSPParam->u32Res = (MS_U32)psDmxInstPri->fpDMXTSPInit(pTSPParam);
654 break;
655
656 case MApi_CMD_DMX_Exit:
657 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Exit\n)"));
658 pu32Param = (MS_U32*)pArgs;
659 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXExit();
660 break;
661
662 case MApi_CMD_DMX_ForceExit:
663 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_ForceExit\n"));
664 pu32Param = (MS_U32*)pArgs;
665 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXForceExit();
666 break;
667
668 case MApi_CMD_DMX_Suspend:
669 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Suspend\n"));
670 pu32Param = (MS_U32*)pArgs;
671 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXSuspend();
672 break;
673
674 case MApi_CMD_DMX_Resume:
675 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Resume\n"));
676 pTSPParam = (DMX_TSPParam*)pArgs;
677 pTSPParam->u32Res = (MS_U32)psDmxInstPri->fpDMXResume(pTSPParam->phyFWAddr, pTSPParam->u32FWSize);
678 break;
679
680 case MApi_CMD_DMX_ChkFwAlive:
681 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_ChkFwAlive\n"));
682 pu32Param = (MS_U32*)pArgs;
683 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXChkFwAlive();
684 break;
685
686 case MApi_CMD_DMX_Reset:
687 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Reset\n"));
688 pu32Param = (MS_U32*)pArgs;
689 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXReset();
690 break;
691
692 case MApi_CMD_DMX_SetFwMiuDataAddr:
693 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetFwMiuDataAddr\n"));
694 pu32Param = (MS_U32*)pArgs;
695 phyaddr = *((MS_PHY*)pArgs);
696 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSetFWMiuDataAddr(phyaddr, pu32Param[2]);
697 break;
698
699 case MApi_CMD_DMX_WProtectEnable:
700 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_WProtectEnable\n"));
701 pWPParam = (PDMX_WP_PARAM)pArgs;
702 psDmxInstPri->fpDMXWProtectEnable(pWPParam->bEnable, pWPParam->pu32StartAddr, pWPParam->pu32EndAddr);
703 break;
704
705 case MApi_CMD_DMX_OrzWProtectEnable:
706 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_OrzWProtectEnable\n"));
707 pu32Param = (MS_U32*)pArgs;
708 ptrTmp = (void*)(pu32Param + 1);
709 phyaddr = *((MS_PHY*)ptrTmp);
710 ptrTmp = (void*)(pu32Param + 3);
711 phyaddr1 = *((MS_PHY*)ptrTmp);
712 psDmxInstPri->fpDMXOrzWProtectEnable((MS_BOOL)pu32Param[0], phyaddr, phyaddr1);
713 break;
714
715 case MApi_CMD_DMX_ReadDropCount:
716 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_ReadDropCount\n"));
717 pu32Param = (MS_U32*)pArgs;
718 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXReadDropCount((MS_U16*)&(pu32Param[0]), (MS_U16*)&(pu32Param[1]));
719 break;
720
721 case MApi_CMD_DMX_SetPowerState:
722 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetPowerState\n"));
723 pCmdPowerState = (PDMX_POWSTATE_PARAM)pArgs;
724 pCmdPowerState->u32Res = (MS_U32)psDmxInstPri->fpDMXSetPowerState(pCmdPowerState->u16PowerState, pCmdPowerState->u32FWAddr, pCmdPowerState->u32FWSize);
725 break;
726
727 case MApi_CMD_DMX_SetOwner:
728 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetOwner\n"));
729 pu32Param = (MS_U32*)pArgs;
730 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSetOwner(pu32Param[0], pu32Param[1], (MS_BOOL)(pu32Param[2]));
731 break;
732
733 case MApi_CMD_DMX_GetCap:
734 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetCap\n"));
735 pCapParam = (PDMX_CAP_PARAM)pArgs;
736 pCapParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetCap(pCapParam->Quetype, pCapParam->pdata);
737 break;
738
739 case MApi_CMD_DMX_GetCapEx:
740 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetCapEx\n"));
741 pCapExParam = (PDMX_CAP_EX_PARAM)pArgs;
742 pCapExParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetCapEx(pCapExParam->StrQuetype, pCapExParam->InputStrLen, pCapExParam->pdata, &(pCapExParam->OutputSize));
743 break;
744
745 case MApi_CMD_DMX_SetBurstLen:
746 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetBurstLen\n"));
747 psDmxInstPri->fpDMXSetBurstLen(*((DMX_BURSTTYPE*)pArgs));
748 break;
749
750 //Flow Control
751 case MApi_CMD_DMX_Flow:
752 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Flow\n"));
753 pFlowParam = (PDMX_FLOW_PARAM)pArgs;
754 if(pFlowParam->bSet == 1)
755 {
756 pFlowParam->u32Res = (MS_U32)psDmxInstPri->fpDMXFlowSet(pFlowParam->DmxFlow, pFlowParam->DmxFlowInput, pFlowParam->bClkInv,
757 pFlowParam->bExtSync, pFlowParam->bParallel);
758 }
759 else
760 {
761 pFlowParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetFlowInputSts(pFlowParam->DmxFlow, &(pFlowParam->DmxFlowInput),
762 &(pFlowParam->bClkInv), &(pFlowParam->bExtSync), &(pFlowParam->bParallel));
763 }
764 break;
765
766 case MApi_CMD_DMX_PVR_Flow:
767 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_PVR_Flow\n"));
768 pPvrFlowParam = (PDMX_PVRFLOW_PARAM)pArgs;
769 if(pPvrFlowParam->bSet)
770 {
771 pPvrFlowParam->u32Res = (MS_U32)psDmxInstPri->fpDMXPvrFlowSet(pPvrFlowParam->eEng, pPvrFlowParam->eSrcTSIf, pPvrFlowParam->bDscmbRec);
772 }
773 else
774 {
775 pPvrFlowParam->u32Res = 1;
776 u32Res = UTOPIA_STATUS_NOT_SUPPORTED;
777 ULOGE("DMX", "Commend does not support yet! \n");
778 }
779 break;
780
781 case MApi_CMD_DMX_Flow_ParlInvert:
782 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Flow_ParlInvert\n"));
783 pu32Param = (MS_U32*)pArgs;
784 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXParlInvert((DMX_FLOW)pu32Param[0], (MS_BOOL)pu32Param[1]);
785 break;
786
787 case MApi_CMD_DMX_OutPadCfg:
788 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_OutPadCfg\n"));
789 pstOutPadCfg = (PDMX_OutputPad_Cfg)pArgs;
790 pstOutPadCfg->u32Res = (MS_U32)psDmxInstPri->fpDMXTsOutpadCfg(pstOutPadCfg->eOutPad, pstOutPadCfg->eInSrcPad,
791 pstOutPadCfg->bInParallel, pstOutPadCfg->u32ResvNum, pstOutPadCfg->pu32Resv);
792 break;
793
794 case MApi_CMD_DMX_TsOutPhase:
795 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TsOutPhase\n"));
796 pu32Param = (MS_U32*)pArgs;
797 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXTsS2POutPhase((MS_U16)pu32Param[0], (MS_BOOL)pu32Param[1], pu32Param[2]);
798 break;
799
800 case MApi_CMD_DMX_FlowDscmbEng:
801 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FlowDscmbEng\n"));
802 pstFlowDscmbEng = (PDMX_FLOW_DSCMBENG_PARAM)pArgs;
803 pstFlowDscmbEng->u32Res = psDmxInstPri->fpDMXFlowDscmbEng(pstFlowDscmbEng->eTsif, &pstFlowDscmbEng->u32DscmbEng, pstFlowDscmbEng->bSet);
804 break;
805 case MApi_CMD_DMX_DropScmbPkt:
806 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_DMX_DropScmbPkt\n"));
807 pstDropScmbPkt = (PDMX_DROP_SCMB_PKT_PARAM)pArgs;
808 pstDropScmbPkt->u32Res = (MS_U32)psDmxInstPri->fpDMXDropScmbPkt(pstDropScmbPkt->eType, pstDropScmbPkt->bEnable);
809 break;
810 case MApi_CMD_DMX_Flow_ENABLE:
811 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Flow_ENABLE\n"));
812 pu32Param = (MS_U32*)pArgs;
813 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFlowEnable((DMX_FLOW)pu32Param[0], (MS_BOOL)pu32Param[1]);
814 break;
815
816 //STC API
817 case MApi_CMD_DMX_GetPcr:
818 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetPcr\n"));
819 pu32Param = (MS_U32*)pArgs;
820 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXGetPcrEng((MS_U8)(pu32Param[0]),&(pu32Param[1]), &(pu32Param[2]));
821 break;
822
823 case MApi_CMD_DMX_Stc_Get:
824 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Stc_Get\n"));
825 pu32Param = (MS_U32*)pArgs;
826 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXGetStcEng((MS_U8)(pu32Param[0]), &(pu32Param[1]), &(pu32Param[2]));
827 break;
828
829 case MApi_CMD_DMX_Stc_Set:
830 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Stc_Set\n"));
831 pu32Param = (MS_U32*)pArgs;
832 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSetStcEng((MS_U8)(pu32Param[0]), pu32Param[1], pu32Param[2]);
833 break;
834
835 case MApi_CMD_DMX_Stc_UpdateCtrl:
836 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Stc_UpdateCtrl\n"));
837 pu32Param = (MS_U32*)pArgs;
838 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXStcUpdateCtrl((MS_U8)(pu32Param[0]), (eStcUpdateCtrlMode)pu32Param[1]);
839 break;
840
841 case MApi_CMD_DMX_Stc_SetOffset:
842 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Stc_SetOffset\n"));
843 pu32Param = (MS_U32*)pArgs;
844 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSetStcOffset((MS_U32)(pu32Param[0]), (MS_U32)(pu32Param[1]), (MS_BOOL)pu32Param[2]);
845 break;
846
847 case MApi_CMD_DMX_Stc_ClkAdjust:
848 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Stc_ClkAdjust\n"));
849 pu32Param = (MS_U32*)pArgs;
850 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXStcClkAdjust(pu32Param[0], (MS_BOOL)pu32Param[1], pu32Param[2]);
851 break;
852
853 //Filter API
854 case MApi_CMD_DMX_Open:
855 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Open\n"));
856 pFltTypeParam = (PDMX_FLT_TYPE_PARAM)pArgs;
857 pFltTypeParam->u32Res = (MS_U32)psDmxInstPri->fpDMXOpen(pFltTypeParam->DmxFltType, &(pFltTypeParam->u32DmxId));
858 break;
859 //new API
860 case MApi_CMD_DMX_Open_Ex:
861 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Open_Ex\n"));
862 pFltTypeParam = (PDMX_FLT_TYPE_PARAM)pArgs;
863 pFltTypeParam->u32Res = (MS_U32)psDmxInstPri->fpDMXOpenEx(pFltTypeParam->DmxFltType, &(pFltTypeParam->u32DmxId));
864 break;
865
866 case MApi_CMD_DMX_Close:
867 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Close\n"));
868 pu32Param = (MS_U32*)pArgs;
869 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXClose(pu32Param[0]);
870 break;
871
872 case MApi_CMD_DMX_Start:
873 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Start\n"));
874 pu32Param = (MS_U32*)pArgs;
875 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXStart(pu32Param[0]);
876 break;
877
878 case MApi_CMD_DMX_Stop:
879 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Stop\n"));
880 pu32Param = (MS_U32*)pArgs;
881 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXStop(pu32Param[0]);
882 break;
883
884 case MApi_CMD_DMX_Info:
885 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Info\n"));
886 pFltInfoParam = (PDMX_FLT_INFO_PARAM)pArgs;
887 pFltInfoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXInfo(pFltInfoParam->u32DmxId,
888 pFltInfoParam->pDmxFltInfo, pFltInfoParam->pDmxFltType, pFltInfoParam->bSet);
889 break;
890
891 case MApi_CMD_DMX_Info_Ex:
892 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Info_Ex\n"));
893 pFltInfoParam_Ex = (PDMX_FLT_INFO_PARAM_Ex)pArgs;
894 pFltInfoParam_Ex->u32Res = (MS_U32)psDmxInstPri->fpDMXInfoEx(pFltInfoParam_Ex->u32DmxId, pFltInfoParam_Ex->pDmxFltInfo);
895 break;
896
897 case MApi_CMD_DMX_Pid:
898 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pid\n"));
899 pu32Param = (MS_U32*)pArgs;
900 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPid(pu32Param[0], (MS_U16*)(&(pu32Param[1])), (MS_BOOL)(pu32Param[2]));
901 break;
902
903 case MApi_CMD_DMX_IsStart:
904 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_IsStart\n"));
905 pu32Param = (MS_U32*)pArgs;
906 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXIsStart(pu32Param[0], (MS_BOOL*)(&(pu32Param[1])));
907 break;
908
909 case MApi_CMD_DMX_CopyData:
910 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_CopyData\n"));
911 pFltCopyParam = (PDMX_FLT_COPY_PARAM)pArgs;
912 pFltCopyParam->u32Res = (MS_U32)psDmxInstPri->fpDMXCopyData((MS_U8)(pFltCopyParam->u32DmxId), pFltCopyParam->pu8Buf,
913 pFltCopyParam->u32BufSize, &(pFltCopyParam->u32ActualSize), &(pFltCopyParam->u32RmnSize),
914 pFltCopyParam->pfCheckCB);
915 break;
916
917 case MApi_CMD_DMX_Proc:
918 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Proc\n"));
919 pFltEventParam = (PDMX_FLT_EVENT_PARAM)pArgs;
920 pFltEventParam->u32Res = (MS_U32)psDmxInstPri->fpDMXProc(pFltEventParam->u32DmxId, pFltEventParam->pEvent);
921 break;
922
923 case MApi_CMD_DMX_ChangeFltSrc:
924 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_ChangeFltSrc\n"));
925 pFltTypeParam = (PDMX_FLT_TYPE_PARAM)pArgs;
926 pFltTypeParam->u32Res = (MS_U32)psDmxInstPri->fpDMXChangeFltSrc(pFltTypeParam->u32DmxId, pFltTypeParam->DmxFltType);
927 break;
928
929 case MApi_CMD_DMX_GetOwner:
930 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetOwner\n"));
931 pu32Param = (MS_U32*)pArgs;
932 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXGetOnwer(pu32Param[0], (MS_BOOL*)(&(pu32Param[1])));
933 break;
934
935 case MApi_CMD_DMX_GetFltScmbSts:
936 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetFltScmbSts\n"));
937 pu32Param = (MS_U32*)pArgs;
938 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXGetFltScmbSts(pu32Param[0], pu32Param[1], pu32Param[2], &(pu32Param[3]));
939 break;
940
941 case MApi_CMD_DMX_GetPESScmbSts:
942 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetPESScmbSts\n"));
943 pu32Param = (MS_U32*)pArgs;
944 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXGetPesScmbSts(pu32Param[0], (MS_U8*)(&(pu32Param[1])));
945 break;
946
947 case MApi_CMD_DMX_GetTsScmbSts:
948 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetTsScmbSts\n"));
949 pu32Param = (MS_U32*)pArgs;
950 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXGetTsScmbSts(pu32Param[0], (MS_U8*)(&(pu32Param[1])));
951 break;
952
953 // Section API
954 case MApi_CMD_DMX_Sec_Reset:
955 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Sec_Reset\n"));
956 pu32Param = (MS_U32*)pArgs;
957 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXSecReset(pu32Param[0]);
958 break;
959
960 case MApi_CMD_DMX_Sec_ReadAddr:
961 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Sec_ReadAddr\n"));
962 pu32Param = (MS_U32*)pArgs;
963 if(pu32Param[3] == 1UL)
964 {
965 ptrTmp = (void*)(pu32Param + 1);
966 phyaddr = *((MS_PHY*)ptrTmp);
967 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXSecSetReadAddr(pu32Param[0], phyaddr);
968 }
969 else
970 {
971 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXSecGetReadAddr(pu32Param[0], &phyaddr);
972 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
973 }
974 break;
975
976 case MApi_CMD_DMX_Sec_GetWriteAddr:
977 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Sec_GetWriteAddr\n"));
978 pu32Param = (MS_U32*)pArgs;
979 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSecGetWriteAddr(pu32Param[0], &phyaddr);
980 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
981 break;
982
983 case MApi_CMD_DMX_Sec_GetStartAddr:
984 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Sec_GetStartAddr\n"));
985 pu32Param = (MS_U32*)pArgs;
986 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSecGetStartAddr(pu32Param[0], &phyaddr);
987 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
988 break;
989
990 case MApi_CMD_DMX_Sec_GetEndAddr:
991 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Sec_GetEndAddr\n"));
992 pu32Param = (MS_U32*)pArgs;
993 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSecGetEndAddr(pu32Param[0], &phyaddr);
994 pu32Param[1] = (MS_U32)phyaddr;
995 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
996 break;
997
998 case MApi_CMD_DMX_Sec_SetPattern:
999 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Sec_SetPattern\n"));
1000 pFltSecPatParam = (PDMX_FLT_SEC_PAT_PARAM)pArgs;
1001 pFltSecPatParam->u32Res = (MS_U32)psDmxInstPri->fpDMXSecSetPattern(pFltSecPatParam->u32DmxId, pFltSecPatParam->pu8Pattern,
1002 pFltSecPatParam->pu8Mask, pFltSecPatParam->pu8NotMask, pFltSecPatParam->u32MatchSize);
1003 break;
1004
1005 //TTX API
1006 case MApi_CMD_DMX_GetTTXWrite:
1007 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetTTXWrite\n"));
1008 pu32Param = (MS_U32*)pArgs;
1009 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXGetTTXWrite(pu32Param[0], &phyaddr);
1010 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
1011 break;
1012
1013 case MApi_CMD_DMX_GetAccess:
1014 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetAccess\n"));
1015 pu32Param = (MS_U32*)pArgs;
1016 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXGetAccess(pu32Param[0]);
1017 break;
1018
1019 case MApi_CMD_DMX_ReleaseAccess:
1020 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_ReleaseAccess\n"));
1021 pu32Param = (MS_U32*)pArgs;
1022 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXReleaseAccess();
1023 break;
1024
1025 // AVFIFO control
1026 case MApi_CMD_DMX_AVFIFO_Reset:
1027 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_AVFIFO_Reset\n"));
1028 pAVFifoParam = (PDMX_AVFIFO_PARAM)pArgs;
1029 pAVFifoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXAVFifoReset(pAVFifoParam->DmxFltType, (MS_BOOL)(pAVFifoParam->u32Data));
1030 break;
1031
1032 case MApi_CMD_DMX_AVFIFO_Status:
1033 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_AVFIFO_Status\n"));
1034 pAVFifoParam = (PDMX_AVFIFO_PARAM)pArgs;
1035 pAVFifoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXAVFifoStatus(pAVFifoParam->DmxFltType, (DMX_FIFO_STATUS*)(&(pAVFifoParam->u32Data)));
1036 break;
1037
1038 case MApi_CMD_DMX_RemoveDupAVFifoPkt:
1039 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_RemoveDupAVFifoPkt\n"));
1040 pAVFifoDropParam = (PDMX_AVFIFO_DROP_PARAM)pArgs;
1041 if(pAVFifoDropParam->bAllFifo)
1042 {
1043 pAVFifoDropParam->u32Res = (MS_U32)psDmxInstPri->fpDMXRemoveDupAVPkt(pAVFifoDropParam->bEnable);
1044 }
1045 else
1046 {
1047 pAVFifoDropParam->u32Res = (MS_U32)psDmxInstPri->fpDMXRemoveDupAVFifoPkt(pAVFifoDropParam->DmxFltType, pAVFifoDropParam->bEnable);
1048 }
1049 break;
1050
1051 case MApi_CMD_DMX_AUBD_Enable:
1052 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_AUBD_Enable\n"));
1053 pu32Param = (MS_U32*)pArgs;
1054 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXAUBDModeEn((MS_BOOL)pu32Param[0]);
1055 break;
1056
1057 //PVR Playback API
1058 case MApi_CMD_DMX_FI_PlayStamp:
1059 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_PlayStamp\n"));
1060 pu32Param = (MS_U32*)pArgs;
1061 if(pu32Param[2] == 0)
1062 {
1063 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFileGetPlayStamp((DMX_FILEIN_PATH)pu32Param[0], &(pu32Param[1]));
1064 }
1065 else
1066 {
1067 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFileSetPlayStamp((DMX_FILEIN_PATH)pu32Param[0], pu32Param[1]);
1068 }
1069 break;
1070
1071 case MApi_CMD_DMX_FI_TimestampMode:
1072 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_TimestampMode\n"));
1073 pu32Param = (MS_U32*)pArgs;
1074 if(pu32Param[1] == 0)
1075 {
1076 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFileTimestampDisable((DMX_FILEIN_PATH)pu32Param[0]);
1077 }
1078 else
1079 {
1080 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFileTimestampEnable((DMX_FILEIN_PATH)pu32Param[0]);
1081 }
1082 break;
1083
1084 case MApi_CMD_DMX_FI_SetPlaybackStampClk:
1085 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_SetPlaybackStampClk\n"));
1086 pStampClkParam = (PDMX_TIMESTAMP_CLK_PARAM)pArgs;
1087 pStampClkParam->u32Res = (MS_U32)psDmxInstPri->fpDMXFileEngSetPlayStampClk((MS_U8)(pStampClkParam->u32EngId), pStampClkParam->eClk);
1088 break;
1089
1090 // PVR Engine API
1091 case MApi_CMD_DMX_Pvr_Open:
1092 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_Open\n"));
1093 pPvrInfoParam = (PDMX_PVR_INFO_PARAM)pArgs;
1094 pPvrInfoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXPvrEngOpen((DMX_PVR_ENG)(pPvrInfoParam->u32EngId), pPvrInfoParam->pPvrInfo);
1095 break;
1096
1097 case MApi_CMD_DMX_Pvr_Close:
1098 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_Close\n"));
1099 pu32Param = (MS_U32*)pArgs;
1100 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXPvrEngClose((DMX_PVR_ENG)(pu32Param[0]));
1101 break;
1102
1103 case MApi_CMD_DMX_Pvr_PidOpen:
1104 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_PidOpen\n"));
1105 pPvrFltTypeParam = (PDMX_PVR_FLTTYPE_PARAM)pArgs;
1106 if(pPvrFltTypeParam->u32CAEngSel == 0xFFFFFFFF)
1107 {
1108 pPvrFltTypeParam->u32Res = (MS_U32)psDmxInstPri->fpDMXPvrEngPidOpen((DMX_PVR_ENG)(pPvrFltTypeParam->u32EngId), pPvrFltTypeParam->u32Pid,
1109 &(pPvrFltTypeParam->u32DmxId));
1110 }
1111 else
1112 {
1113 pPvrFltTypeParam->u32Res = (MS_U32)psDmxInstPri->fpDMXPvrcaEngPidOpen((DMX_PVR_ENG)(pPvrFltTypeParam->u32EngId), pPvrFltTypeParam->u32Pid,
1114 &(pPvrFltTypeParam->u32DmxId), (MS_U8)(pPvrFltTypeParam->u32SelShareFlt));
1115 }
1116 break;
1117
1118 case MApi_CMD_DMX_Pvr_PidClose:
1119 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_PidClose\n"));
1120 pu32Param = (MS_U32*)pArgs;
1121 if(pu32Param[2] == 0)
1122 {
1123 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrEngPidClose((DMX_PVR_ENG)(pu32Param[0]), pu32Param[1]);
1124 }
1125 else
1126 {
1127 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrcaEngPidClose((DMX_PVR_ENG)(pu32Param[0]), pu32Param[1]);
1128 }
1129 break;
1130
1131 case MApi_CMD_DMX_Pvr_Start:
1132 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_Start\n"));
1133 pu32Param = (MS_U32*)pArgs;
1134 if(pu32Param[2] == 0)
1135 {
1136 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrEngStart((DMX_PVR_ENG)(pu32Param[0]), (MS_BOOL)(pu32Param[1]));
1137 }
1138 else
1139 {
1140 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrcaEngStart((DMX_PVR_ENG)(pu32Param[0]), (MS_BOOL)(pu32Param[1]));
1141 }
1142 break;
1143
1144 case MApi_CMD_DMX_Pvr_Stop:
1145 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_Stop\n"));
1146 pu32Param = (MS_U32*)pArgs;
1147 if(pu32Param[1] == 0)
1148 {
1149 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrEngStop((DMX_PVR_ENG)(pu32Param[0]));
1150 }
1151 else
1152 {
1153 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrcaEngStop((DMX_PVR_ENG)(pu32Param[0]));
1154 }
1155 break;
1156
1157 case MApi_CMD_DMX_Pvr_GetWriteAddr:
1158 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_GetWriteAddr\n"));
1159 pu32Param = (MS_U32*)pArgs;
1160 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrEngGetWriteAddr((DMX_PVR_ENG)(pu32Param[0]), &phyaddr);
1161 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
1162 break;
1163
1164 case MApi_CMD_DMX_Pvr_SetPktMode:
1165 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_SetPktMode\n"));
1166 pu32Param = (MS_U32*)pArgs;
1167 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrEngSetPktMode((DMX_PVR_ENG)(pu32Param[0]), (MS_U32)(pu32Param[1]));
1168 break;
1169
1170 case MApi_CMD_DMX_Pvr_SetRecordStamp:
1171 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_SetRecordStamp\n"));
1172 pu32Param = (MS_U32*)pArgs;
1173 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrEngSetRecordStamp((DMX_PVR_ENG)(pu32Param[0]), pu32Param[1]);
1174 break;
1175
1176 case MApi_CMD_DMX_Pvr_GetRecordStamp:
1177 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_GetRecordStamp\n"));
1178 pu32Param = (MS_U32*)pArgs;
1179 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrEngGetRecordStamp((DMX_PVR_ENG)(pu32Param[0]), &(pu32Param[1]));
1180 break;
1181
1182 case MApi_CMD_DMX_Pvr_SetMobfKey:
1183 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_SetMobfKey\n"));
1184 pu32Param = (MS_U32*)pArgs;
1185 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXPvrEngMobfEn((DMX_PVR_ENG)(pu32Param[0]), ((pu32Param[1] || pu32Param[2]) != 0),
1186 pu32Param[1], pu32Param[2]);
1187 break;
1188
1189 case MApi_CMD_DMX_Pvr_SetRecordStampClk:
1190 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_SetRecordStampClk\n"));
1191 pStampClkParam = (PDMX_TIMESTAMP_CLK_PARAM)pArgs;
1192 pStampClkParam->u32Res = (MS_U32)psDmxInstPri->fpDMXPvrEngSetRecordStampClk((DMX_PVR_ENG)(pStampClkParam->u32EngId), pStampClkParam->eClk);
1193 break;
1194
1195 // File-in Engine API
1196 case MApi_CMD_DMX_FI_Start:
1197 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_Start\n"));
1198 pFileStartParam = (PDMX_FILE_START_PARAM)pArgs;
1199 pFileStartParam->u32Res = (MS_U32)psDmxInstPri->fpDMXFileStart((DMX_FILEIN_PATH)pFileStartParam->u32EngId, pFileStartParam->Dst, pFileStartParam->pBuf, pFileStartParam->u32BufSize);
1200 break;
1201
1202 case MApi_CMD_DMX_FI_Stop:
1203 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_Stop\n"));
1204 pu32Param = (MS_U32*)pArgs;
1205 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXFileStop((DMX_FILEIN_PATH)pu32Param[0]);
1206 break;
1207
1208 case MApi_CMD_DMX_FI_Info:
1209 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_Info\n"));
1210 pFileInfoParam = (PDMX_FILE_INFO_PARAM)pArgs;
1211 pFileInfoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXFileInfo(pFileInfoParam->pFileinInfo);
1212 break;
1213
1214 case MApi_CMD_DMX_FI_Eng_Info:
1215 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_Eng_Info\n"));
1216 pFileInfoParam = (PDMX_FILE_INFO_PARAM)pArgs;
1217 pFileInfoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXFileEngInfo((DMX_FILEIN_PATH)pFileInfoParam->u32EngId, pFileInfoParam->pFileinInfo);
1218 break;
1219
1220 case MApi_CMD_DMX_FI_Pause:
1221 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_Pause\n"));
1222 pu32Param = (MS_U32*)pArgs;
1223 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXFilePause((DMX_FILEIN_PATH)pu32Param[0]);
1224 break;
1225
1226 case MApi_CMD_DMX_FI_Resume:
1227 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_Resume\n"));
1228 pu32Param = (MS_U32*)pArgs;
1229 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXFileResume((DMX_FILEIN_PATH)pu32Param[0]);
1230 break;
1231
1232 case MApi_CMD_DMX_FI_IsIdle:
1233 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_IsIdle\n"));
1234 pu32Param = (MS_U32*)pArgs;
1235 *((MS_U8*)&(pu32Param[1])) = psDmxInstPri->fpDMXFileIsIdle((DMX_FILEIN_PATH)pu32Param[0]);
1236 break;
1237
1238 case MApi_CMD_DMX_FI_IsBusy:
1239 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_IsBusy\n"));
1240 pu32Param = (MS_U32*)pArgs;
1241 *((MS_U8*)&(pu32Param[1])) = psDmxInstPri->fpDMXFileIsBusy((DMX_FILEIN_PATH)pu32Param[0]);
1242 break;
1243
1244 case MApi_CMD_DMX_FI_IsPause:
1245 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_IsPause\n"));
1246 pu32Param = (MS_U32*)pArgs;
1247 *((MS_U8*)&(pu32Param[1])) = psDmxInstPri->fpDMXFileIsPause((DMX_FILEIN_PATH)pu32Param[0]);
1248 break;
1249
1250 case MApi_CMD_DMX_FI_CmdQReset:
1251 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_CmdQReset\n"));
1252 pu32Param = (MS_U32*)pArgs;
1253 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXFileCmdQReset((DMX_FILEIN_PATH)pu32Param[0]);
1254 break;
1255
1256 case MApi_CMD_DMX_FI_CmdQGetEmptyNum:
1257 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_CmdQGetEmptyNum\n"));
1258 pu32Param = (MS_U32*)pArgs;
1259 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFileCmdQGetEmptyNum((DMX_FILEIN_PATH)pu32Param[0], &(pu32Param[1]));
1260 break;
1261
1262 case MApi_CMD_DMX_FI_BypassFileTimestamp:
1263 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_BypassFileTimestamp\n"));
1264 pu32Param = (MS_U32*)pArgs;
1265 psDmxInstPri->fpDMXFileBypassFileTimeStamp((DMX_FILEIN_PATH)pu32Param[0], (MS_BOOL)(pu32Param[1]));
1266 break;
1267
1268 case MApi_CMD_DMX_FI_CmdQGetFifoLevel:
1269 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_CmdQGetFifoLevel\n"));
1270 pu32Param = (MS_U32*)pArgs;
1271 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFileCmdQGetFifoWLevel((DMX_FILEIN_PATH)pu32Param[0], (MS_U8*)(&(pu32Param[1])));
1272 break;
1273
1274 case MApi_CMD_DMX_FI_GetFileTimeStamp:
1275 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_GetFileTimeStamp\n"));
1276 pu32Param = (MS_U32*)pArgs;
1277 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFileGetFileTimestamp((DMX_FILEIN_PATH)pu32Param[0], &(pu32Param[1]));
1278 break;
1279
1280 case MApi_CMD_DMX_FI_GetReadAddr:
1281 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_GetReadAddr\n"));
1282 pu32Param = (MS_U32*)pArgs;
1283 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFileGetReadAddr((DMX_FILEIN_PATH)pu32Param[0], &phyaddr);
1284 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
1285 break;
1286
1287 case MApi_CMD_DMX_FI_SetMobfKey:
1288 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FI_SetMobfKey\n"));
1289 pu32Param = (MS_U32*)pArgs;
1290 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFileMobfEn((DMX_FILEIN_PATH)pu32Param[0], (pu32Param[1] != 0), pu32Param[2]);
1291 break;
1292
1293 //MMFI API
1294 case MApi_CMD_DMX_MMFI_IsIdle:
1295 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_IsIdle\n"));
1296 pu32Param = (MS_U32*)pArgs;
1297 *((MS_U8*)&(pu32Param[1])) = psDmxInstPri->fpDMXMMFIIsIdle((DMX_MMFI_PATH)(pu32Param[0]));
1298 break;
1299
1300 case MApi_CMD_DMX_MMFI_IsBusy:
1301 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_IsBusy\n"));
1302 pu32Param = (MS_U32*)pArgs;
1303 *((MS_U8*)&(pu32Param[1])) = psDmxInstPri->fpDMXMMFIIsBusy((DMX_MMFI_PATH)(pu32Param[0]));
1304 break;
1305
1306 case MApi_CMD_DMX_MMFI_CmdQReset:
1307 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_CmdQReset\n"));
1308 pu32Param = (MS_U32*)pArgs;
1309 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXMMFICmdQReset((DMX_MMFI_PATH)(pu32Param[0]));
1310 break;
1311
1312 case MApi_CMD_DMX_MMFI_GetEmptyNum:
1313 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_GetEmptyNum\n"));
1314 pu32Param = (MS_U32*)pArgs;
1315 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFIGetEmptyNum((DMX_MMFI_PATH)(pu32Param[0]), &(pu32Param[1]));
1316 break;
1317
1318 case MApi_CMD_DMX_MMFI_Start:
1319 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_Start\n"));
1320 pMMFIStartParam = (PDMX_MMFI_START_PARAM)pArgs;
1321 pMMFIStartParam->u32Res = (MS_U32)psDmxInstPri->fpDMXMMFIStart(pMMFIStartParam->Dst, pMMFIStartParam->pBuf, pMMFIStartParam->u32BufSize);
1322 break;
1323
1324 case MApi_CMD_DMX_MMFI_GetFileTimeStamp:
1325 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_GetFileTimeStamp\n"));
1326 pu32Param = (MS_U32*)pArgs;
1327 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFIGetFileTimestamp((DMX_MMFI_PATH)(pu32Param[0]), &(pu32Param[1]));
1328 break;
1329
1330 case MApi_CMD_DMX_MMFI_PidOpen:
1331 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_PidOpen\n"));
1332 pMMFIFltParam = (PDMX_MMFI_FLT_PARAM)pArgs;
1333 pMMFIFltParam->u32Res = (MS_U32)psDmxInstPri->fpDMXMMFIPidOpen(pMMFIFltParam->flttype, (MS_U16)(pMMFIFltParam->u32Pid),
1334 (MS_U8*)(&(pMMFIFltParam->u32DmxId)));
1335 break;
1336
1337 case MApi_CMD_DMX_MMFI_PidClose:
1338 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_PidClose\n"));
1339 pu32Param = (MS_U32*)pArgs;
1340 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFIPidClose((MS_U8)(pu32Param[1]));
1341 break;
1342
1343 case MApi_CMD_DMX_MMFI_GetFifoLevel:
1344 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_GetFifoLevel\n"));
1345 pu32Param = (MS_U32*)pArgs;
1346 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFIGetFifoLevel((DMX_MMFI_PATH)(pu32Param[0]), (MS_U8*)(&(pu32Param[1])));
1347 break;
1348
1349 case MApi_CMD_DMX_MMFI_PlayStamp_Set:
1350 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_PlayStamp_Set\n"));
1351 pu32Param = (MS_U32*)pArgs;
1352 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFISetPlayTimestamp((DMX_MMFI_PATH)(pu32Param[0]), pu32Param[1]);
1353 break;
1354
1355 case MApi_CMD_DMX_MMFI_PlayStamp_Get:
1356 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_PlayStamp_Get\n"));
1357 pu32Param = (MS_U32*)pArgs;
1358 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFIGetPlayTimestamp((DMX_MMFI_PATH)(pu32Param[0]), &(pu32Param[1]));
1359 break;
1360
1361 case MApi_CMD_DMX_MMFI_SetTimeStampClk:
1362 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_SetTimeStampClk\n"));
1363 pu32Param = (MS_U32*)pArgs;
1364 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFISetTimestampClk((DMX_MMFI_PATH)(pu32Param[0]), (DMX_TimeStamp_Clk)(pu32Param[1]));
1365 break;
1366
1367
1368 case MApi_CMD_DMX_MMFI_RemoveDupAVPkt:
1369 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_RemoveDupAVPkt\n"));
1370 pAVFifoParam = (PDMX_AVFIFO_PARAM)pArgs;
1371 pAVFifoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXMMFIRemoveDupAVPkt((MS_BOOL)(pAVFifoParam->u32Data));
1372 break;
1373
1374 case MApi_CMD_DMX_MMFI_SetMOBFKey:
1375 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_SetMOBFKey\n"));
1376 pu32Param = (MS_U32*)pArgs;
1377 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFIMobfEn((DMX_MMFI_PATH)(pu32Param[0]), (pu32Param[1] != 0), pu32Param[1]);
1378 break;
1379
1380 case MApi_CMD_DMX_MMFI_Timestamp_En:
1381 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_TIMESTAMP_EN\n"));
1382 pu32Param = (MS_U32*)pArgs;
1383 if(pu32Param[1] == 1)
1384 {
1385 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFITimestampEn((DMX_MMFI_PATH)(pu32Param[0]));
1386 }
1387 else
1388 {
1389 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXMMFITimestampDisable((DMX_MMFI_PATH)(pu32Param[0]));
1390 }
1391 break;
1392
1393 //Debug API
1394 case MApi_CMD_DMX_SetDbgLevel:
1395 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetDbgLevel\n"));
1396 pu32Param = (MS_U32*)pArgs;
1397 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXSetDbgLevel((DMX_DBGMSG_LEVEL)pu32Param[0]);
1398 break;
1399
1400 case MApi_CMD_DMX_GetFwVer:
1401 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetFwVer\n"));
1402 pu32Param = (MS_U32*)pArgs;
1403 psDmxInstPri->fpDMXGetFwVer(pu32Param);
1404 break;
1405
1406 case MApi_CMD_DMX_Get_PipeId:
1407 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Get_PipeIdByFlow\n"));
1408 pu32Param = (MS_U32*)pArgs;
1409 pu32Param[3] = psDmxInstPri->fpDMXGetPipeId((DMX_PIPEID_GROUP)pu32Param[0], (DMX_GENERAL_ENGID)pu32Param[1], &(pu32Param[2]));
1410 break;
1411
1412 case MApi_CMD_DMX_CmdRun:
1413 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_CmdRun\n"));
1414 pCmdRunParam = (PDMX_CMDRUN_PARAM)pArgs;
1415 pCmdRunParam->u32Res = (MS_U32)psDmxInstPri->fpDMXCmdRun(pCmdRunParam->u32Cmd,
1416 pCmdRunParam->u32Config, pCmdRunParam->u32DataNum, pCmdRunParam->pData);
1417 break;
1418
1419 //Utopia 1.0 compatible API
1420 case MApi_CMD_DMX_SetFw:
1421 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetFw\n"));
1422 pu32Param = (MS_U32*)pArgs;
1423 phyaddr = *((MS_PHY*)pArgs);
1424 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXSetFWBuf(phyaddr, pu32Param[2]);
1425 break;
1426
1427 case MApi_CMD_DMX_SetHK:
1428 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetHK\n"));
1429 pu32Param = (MS_U32*)pArgs;
1430 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXSetHK((MS_BOOL)pu32Param[0]);
1431 break;
1432
1433 case MApi_CMD_DMX_Init_1_0:
1434 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Init_1_0\n"));
1435 pu32Param = (MS_U32*)pArgs;
1436 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXInit();
1437 break;
1438
1439 case MApi_CMD_DMX_TSPInit_1_0:
1440 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSPInit_1_0\n"));
1441 pTSPParam = (DMX_TSPParam*)pArgs;
1442 pTSPParam->u32Res = (MS_U32)psDmxInstPri->fpDMXTSPInit(pTSPParam);
1443 break;
1444
1445 case MApi_CMD_DMX_TSPInit_GetConfig:
1446 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSPInit_GetConfig\n"));
1447 pTSPParam = (DMX_TSPParam*)pArgs;
1448 pTSPParam->u32Res = psDmxInstPri->fpDMXTSPInit_GetConfig(pTSPParam);
1449 break;
1450
1451 case MApi_CMD_DMX_ReleseHWSemp:
1452 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_ReleseHWSemp\n"));
1453 pu32Param = (MS_U32*)pArgs;
1454 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXReleaseHwSemp();
1455 break;
1456
1457 case MApi_CMD_DMX_GetLibVer:
1458 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetLibVer\n"));
1459 psDmxInstPri->fpDMXGetLibVer((const MSIF_Version **)pArgs);
1460 break;
1461
1462 case MApi_CMD_DMX_STC64ModeEnable:
1463 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_STC64ModeEnable\n"));
1464 pu32Param = (MS_U32*)pArgs;
1465 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMX64bitModeEn((MS_BOOL)pu32Param[0]);
1466 break;
1467
1468 //Merge stream API
1469 case MApi_CMD_DMX_SetPktMode:
1470 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetPktMode\n"));
1471 pPktModeParam = (PDMX_PKT_MODE_PARAM)pArgs;
1472 pPktModeParam->u32Res = (MS_U32)psDmxInstPri->fpDMXSetPktMode(pPktModeParam->eFlow, pPktModeParam->ePktMode);
1473 break;
1474
1475 case MApi_CMD_DMX_SetMergeStrSync:
1476 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetMergeStrSync\n"));
1477 pu32Param = (MS_U32*)pArgs;
1478 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXSetMerStrSyc(pu32Param[0], (MS_U8)pu32Param[1]);
1479 break;
1480
1481 //TSO API
1482 case MApi_CMD_DMX_TSO_FileInfo:
1483 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileInfo\n"));
1484 pFileInfoParam = (PDMX_FILE_INFO_PARAM)pArgs;
1485 pFileInfoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXTsoFileInfo((MS_U8)(pFileInfoParam->u32EngId), pFileInfoParam->pFileinInfo);
1486 break;
1487 case MApi_CMD_DMX_TSO_FileIsIdle:
1488 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileIsIdle\n"));
1489 pu32Param = (MS_U32*)pArgs;
1490 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXTsoFileIsIdle((MS_U8)pu32Param[0]);
1491 break;
1492 case MApi_CMD_DMX_TSO_FileGetCmdQEmptyNum:
1493 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileGetCmdQEmptyNum\n"));
1494 pu32Param = (MS_U32*)pArgs;
1495 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoFileGetCmdQEmptyNum((MS_U8)pu32Param[0], &(pu32Param[1]));
1496 break;
1497
1498 case MApi_CMD_DMX_TSO_FileStart:
1499 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileStart\n"));
1500 pu32Param = (MS_U32*)pArgs;
1501 ptrTmp = (void*)(pu32Param + 1);
1502 phyaddr = *((MS_PHY*)ptrTmp);
1503 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXTsoFileStart((MS_U8)pu32Param[0], phyaddr, pu32Param[3]);
1504 break;
1505
1506 case MApi_CMD_DMX_TSO_FileStop:
1507 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileStop\n"));
1508 pu32Param = (MS_U32*)pArgs;
1509 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXTsoFileStop((MS_U8)pu32Param[0]);
1510 break;
1511 case MApi_CMD_DMX_TSO_FilePlayStamp:
1512 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FilePlayStamp\n"));
1513 pu32Param = (MS_U32*)pArgs;
1514 if(pu32Param[2] == 1)
1515 {
1516 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXTsoFileSetPlayStamp((MS_U8)pu32Param[0], pu32Param[1]);
1517 }
1518 else
1519 {
1520 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXTsoFileGetPlayStamp((MS_U8)pu32Param[0], &(pu32Param[1]));
1521 }
1522 break;
1523 case MApi_CMD_DMX_TSO_FileGetTimeStamp:
1524 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileGetTimeStamp\n"));
1525 pu32Param = (MS_U32*)pArgs;
1526 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoFileGetTimeStamp((MS_U8)pu32Param[0], &(pu32Param[1]));
1527 break;
1528 case MApi_CMD_DMX_TSO_FileBypassStamp:
1529 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileBypassStamp\n"));
1530 pu32Param = (MS_U32*)pArgs;
1531 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoFileBypassStamp((MS_U8)pu32Param[0], (MS_BOOL)(pu32Param[1]));
1532 break;
1533 case MApi_CMD_DMX_TSO_FileTimeStampEnable:
1534 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FileTimeStampEnable\n"));
1535 pu32Param = (MS_U32*)pArgs;
1536 if(pu32Param[1] == 1)
1537 {
1538 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoFileTimeStampEnable((MS_U8)pu32Param[0]);
1539 }
1540 else
1541 {
1542 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoFileTimeStampDisable((MS_U8)pu32Param[0]);
1543 }
1544 break;
1545
1546 // DBG INFO API
1547 case MApi_CMD_DMX_DBG_GET_DISCONCNT:
1548 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_DBG_GET_DISCONCNT\n"));
1549 pPktDisConCntParam = (PDMX_PKT_DISCONCNT_PARAM)pArgs;
1550 pPktDisConCntParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetDisConCnt(pPktDisConCntParam->pInfo, &(pPktDisConCntParam->u32Cnt));
1551 break;
1552 case MApi_CMD_DMX_DBG_GET_DROPPKTCNT:
1553 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_DBG_GET_DROPPKTCNT\n"));
1554 pPktDropCntParam = (PDMX_PKT_DROPCNT_PARAM)pArgs;
1555 pPktDropCntParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetDropPktCnt(pPktDropCntParam->pInfo, &(pPktDropCntParam->u32Cnt));
1556 break;
1557 case MApi_CMD_DMX_DBG_GET_LOCKPKTCNT:
1558 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_DBG_GET_LOCKPKTCNT\n"));
1559 pPktLockCntParam = (PDMX_PKT_LOCKCNT_PARAM)pArgs;
1560 pPktLockCntParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetLockPktCnt(pPktLockCntParam->pInfo, &(pPktLockCntParam->u32Cnt));
1561 break;
1562 case MApi_CMD_DMX_DBG_GET_AVPKTCNT:
1563 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_DBG_GET_AVPKTCNT\n"));
1564 pPktAVCNTParam = (PDMX_PKT_AVCNT_PARAM)pArgs;
1565 pPktAVCNTParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetAVPktCnt(pPktAVCNTParam->pInfo, &(pPktAVCNTParam->u32Cnt));
1566 break;
1567 case MApi_CMD_DMX_GET_SECTEI_PKTCNT:
1568 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GET_SECTEI_PKTCNT\n"));
1569 pPktSecTeiParam = (PDMX_PKT_SECTEI_PARAM)pArgs;
1570 pPktSecTeiParam->u32Res = (MS_U32)psDmxInstPri->fpDMXGetSecTeiPktCnt(pPktSecTeiParam->eType, &(pPktSecTeiParam->u32Cnt));
1571 break;
1572 case MApi_CMD_DMX_RESET_SECTEI_PKTCNT:
1573 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_RESET_SECTEI_PKTCNT\n"));
1574 pu32Param = (MS_U32*)pArgs;
1575 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXResetSecTeiPktCnt((DMX_FILTER_TYPE)pu32Param[0]);
1576 break;
1577 case MApi_CMD_DMX_GET_SECDISCON_PKTCNT:
1578 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GET_SECDISCON_PKTCNT\n"));
1579 pu32Param = (MS_U32*)pArgs;
1580 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXGetSecDisConPktCnt(pu32Param[0], &(pu32Param[1]));
1581 break;
1582 case MApi_CMD_DMX_RESET_SECDISCON_PKTCNT:
1583 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_RESET_SECDISCON_PKTCNT\n"));
1584 pu32Param = (MS_U32*)pArgs;
1585 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXResetSecDisContPktCnt(pu32Param[0]);
1586 break;
1587
1588 // BOX Series Only
1589 case MApi_CMD_DMX_Pvr_CBSize:
1590 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_CBSize\n"));
1591 pu32Param = (MS_U32*)pArgs;
1592 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrEngCBSize((DMX_PVR_ENG)pu32Param[0], &(pu32Param[1]), (MS_BOOL)pu32Param[2]);
1593 break;
1594 case MApi_CMD_DMX_Pvr_SetCaMode:
1595 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_SetCaMode\n"));
1596 pu32Param = (MS_U32*)pArgs;
1597 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrEngSetCaMode((DMX_PVR_ENG)pu32Param[0], (DMX_CA_PVRMODE)pu32Param[1], (MS_BOOL)pu32Param[2]);
1598 break;
1599
1600 case MApi_CMD_DMX_Pvr_IsStart:
1601 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_IsStart\n"));
1602 pu32Param = (MS_U32*)pArgs;
1603 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrIsStart((DMX_PVR_ENG)pu32Param[0], (MS_BOOL*)(&(pu32Param[1])));
1604 break;
1605
1606 case MApi_CMD_DMX_TSO_OutClk:
1607 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_OutClk\n"));
1608 pTsoOutClkParam = (PDMX_TSO_OUTCLK_PARAM)pArgs;
1609 if(pTsoOutClkParam->bSet == TRUE)
1610 {
1611 pTsoOutClkParam->u32Res = (MS_U32)psDmxInstPri->fpDMXTsoSetOutClk((MS_U8)pTsoOutClkParam->u32Eng, pTsoOutClkParam->eTsoOutClk, pTsoOutClkParam->eTsoOutClkSrc,
1612 pTsoOutClkParam->u16DivNum, pTsoOutClkParam->bClkInv);
1613 }
1614 else
1615 {
1616 u32Res = UTOPIA_STATUS_NOT_SUPPORTED;
1617 DMX_MSG(ULOGE("DMX", "DMXIoctl - Not Support\n"));
1618 }
1619 break;
1620
1621 case MApi_CMD_DMX_STCEng_Sel:
1622 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_STCEng_Sel\n"));
1623 pu32Param = (MS_U32*)pArgs;
1624 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXStcSel(pu32Param[0], pu32Param[1]);
1625 break;
1626
1627 case MApi_CMD_DMX_TSO_LocStrId:
1628 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_LocStrId\n"));
1629 pTsoLocStrId = (PDMX_TSO_LOCSTRID_PARAM)pArgs;
1630 pTsoLocStrId->u32Res = (MS_U32)psDmxInstPri->fpDMXTsoLocStrId(pTsoLocStrId->u8Eng, pTsoLocStrId->eIf, pTsoLocStrId->pu8StrId, pTsoLocStrId->bSet);
1631 break;
1632
1633 case MApi_CMD_DMX_TSO_CmdQReset:
1634 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_CmdQ\n"));
1635 pu32Param = (MS_U32*)pArgs;
1636 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXTsoFileGetCmdQReset(*pu32Param);
1637 break;
1638
1639 case MApi_CMD_DMX_TSO_InputCfg:
1640 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_InputCfg\n"));
1641 ((DMX_TSO_InputCfg*)pArgs)->u32Res = (MS_U32)psDmxInstPri->fpDMXTsoFlowInputCfg((DMX_TSO_InputCfg*)pArgs);
1642 break;
1643
1644 case MApi_CMD_DMX_TSO_OutputCfg:
1645 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_OutputCfg\n"));
1646 ((DMX_TSO_OutputCfg*)pArgs)->u32Res = (MS_U32)psDmxInstPri->fpDMXTsoFlowOutputCfg((DMX_TSO_OutputCfg*)pArgs);
1647 break;
1648
1649 case MApi_CMD_DMX_TSO_Configure:
1650 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_Configure\n"));
1651 ((DMX_TSO_Cfg*)pArgs)->u32Res = (MS_U32)psDmxInstPri->fpDMXTsoConfigure((DMX_TSO_Cfg*)pArgs);
1652 break;
1653
1654 case MApi_CMD_DMX_TSO_OutputEn:
1655 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_OutputEn\n"));
1656 pu32Param = (MS_U32*)pArgs;
1657 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoOutputEn((MS_U8)pu32Param[0], (MS_BOOL)pu32Param[1]);
1658 break;
1659
1660 case MApi_CMD_DMX_TSO_PidOpen:
1661 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_PidOpen\n"));
1662 pu32Param = (MS_U32*)pArgs;
1663 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXTsoPidOpen((MS_U8)pu32Param[0], (DMX_TSIF)pu32Param[1], (MS_U16)pu32Param[2] ,(MS_U16*)(&pu32Param[3]));
1664 break;
1665
1666 case MApi_CMD_DMX_TSO_PidClose:
1667 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_PidClose\n"));
1668 pu32Param = (MS_U32*)pArgs;
1669 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTsoPidClose((MS_U8)pu32Param[0], (MS_U16)pu32Param[1]);
1670 break;
1671
1672 case MApi_CMD_DMX_TSO_FI_GetReadAddr:
1673 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_FI_GetReadAddr\n"));
1674 pu32Param = (MS_U32*)pArgs;
1675 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXTsoGetFileinAddr((MS_U8)pu32Param[0], &phyaddr);
1676 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
1677 break;
1678
1679 case MApi_CMD_DMX_FQ_SetFltRushPass:
1680 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_SetFltRushPass\n"));
1681 pu32Param = (MS_U32*)pArgs;
1682 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFQSetFltRushPass(pu32Param[0], pu32Param[1]);
1683 break;
1684
1685 case MApi_CMD_DMX_FQ_Init:
1686 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_Init\n"));
1687 pFQInitParam = (PDMX_FQ_INIT_PARAM)pArgs;
1688 pFQInitParam->u32Res = (MS_U32)psDmxInstPri->fpDMXFQInit(pFQInitParam->u32Eng,pFQInitParam->pInfo);
1689 break;
1690
1691 case MApi_CMD_DMX_FQ_Exit:
1692 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_Exit\n"));
1693 pu32Param = (MS_U32*)pArgs;
1694 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFQExit(pu32Param[0]);
1695 break;
1696
1697 case MApi_CMD_DMX_FQ_RushEnable:
1698 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_RushEnable\n"));
1699 pu32Param = (MS_U32*)pArgs;
1700 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFQRushEn(pu32Param[0]);
1701 break;
1702
1703 case MApi_CMD_DMX_FQ_SkipRushData:
1704 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_SkipRushData\n"));
1705 pFQSkipRushData = (PDMX_FQ_SKIP_RUSH_DATA_PARAM)pArgs;
1706 pFQSkipRushData->u32Res = (MS_U32)psDmxInstPri->fpDMXFQSkipRushData(pFQSkipRushData->u32Eng, pFQSkipRushData->eSkipPath);
1707 break;
1708
1709 case MApi_CMD_DMX_FQ_Configure:
1710 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_Configure\n"));
1711 pFQConfigure = (DMX_FQ_Cfg*)pArgs;
1712 pFQConfigure->u32Res = (MS_U32)psDmxInstPri->fpDMXFQConfigure(pFQConfigure);
1713 break;
1714
1715 case MApi_CMD_DMX_FQ_SetRushAddr:
1716 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_SetRushAddr\n"));
1717 pu32Param = (MS_U32*)pArgs;
1718 ptrTmp = (void*)(pu32Param + 1);
1719 phyaddr = *((MS_PHY*)ptrTmp);
1720 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFQSetRushAddr(pu32Param[0], phyaddr);
1721 break;
1722
1723 case MApi_CMD_DMX_FQ_ReadGet:
1724 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_ReadGet\n"));
1725 pu32Param = (MS_U32*)pArgs;
1726 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFQReadGet(pu32Param[0], &phyaddr);
1727 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
1728 break;
1729
1730 case MApi_CMD_DMX_FQ_WriteGet:
1731 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_FQ_WriteGet\n"));
1732 pu32Param = (MS_U32*)pArgs;
1733 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXFQWriteGet(pu32Param[0], &phyaddr);
1734 _DMX_PhyAddr_To_U32Param(phyaddr, pu32Param+1UL);
1735 break;
1736
1737 case MApi_CMD_DMX_TSO_SvqBufSet:
1738 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSO_SvqBufSet\n"));
1739 pu32Param = (MS_U32*)pArgs;
1740 ptrTmp = (void*)(pu32Param + 1);
1741 phyaddr = *((MS_PHY*)ptrTmp);
1742 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXTsoSvqBufSet((MS_U8)pu32Param[0], phyaddr, pu32Param[3]);
1743 break;
1744
1745 case MApi_CMD_DMX_MStr_SyncBy:
1746 DMX_MSG("DMXIoctl - MApi_CMD_DMX_MStr_SyncBy\n");
1747 pMStrSync = (PDMX_MSTR_SYNCBY_PARAM)pArgs;
1748 pMStrSync->u32Res = (MS_U32)psDmxInstPri->fpDMXMStrSyncBy(pMStrSync->eIf, pMStrSync->u8StrId, pMStrSync->pu8SyncByte, pMStrSync->bSet);
1749 break;
1750
1751 case MApi_CMD_DMX_GetIntCnt:
1752 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetIntCnt\n"));
1753 pu32Param = (MS_U32*)pArgs;
1754 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXGetIntCnt((MS_U32*)pArgs);
1755 break;
1756
1757 case MApi_CMD_DMX_DropEn:
1758 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_GetIntCnt\n"));
1759 pu32Param = (MS_U32*)pArgs;
1760 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXDropEn((MS_BOOL)pu32Param[0]);
1761 break;
1762
1763 case MApi_CMD_DMX_TeiRmErrPkt:
1764 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_VqEn\n"));
1765 pu32Param = (MS_U32*)pArgs;
1766 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXTeiRmErrPkt((DMX_TEI_RmPktType)pu32Param[0], (MS_BOOL)pu32Param[1]);
1767 break;
1768 case MApi_CMD_DMX_SetFwDbgParam:
1769 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_SetFwDbgParam\n"));
1770 pu32Param = (MS_U32*)pArgs;
1771 ptrTmp = (void*)(pu32Param);
1772 phyaddr = *((MS_PHY*)ptrTmp);
1773 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXSetFwDbgParam(phyaddr, pu32Param[2], pu32Param[3]);
1774 break;
1775
1776 case MApi_CMD_DMX_PVR_MOBFEn:
1777 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_PVR_MOBFEn\n"));
1778 pu32Param = (MS_U32*)pArgs;
1779 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXPvrMobfEn((MS_BOOL)pu32Param[0], pu32Param[1], pu32Param[2]);
1780 break;
1781
1782 case MApi_CMD_DMX_MMFI_Info:
1783 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_Info\n"));
1784 pFileInfoParam = (PDMX_FILE_INFO_PARAM)pArgs;
1785 pFileInfoParam->u32Res = (MS_U32)psDmxInstPri->fpDMXMMFIInfo((DMX_MMFI_PATH)pFileInfoParam->u32EngId, pFileInfoParam->pFileinInfo);
1786 break;
1787
1788 case MApi_CMD_DMX_MMFI_BypassStamp:
1789 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_MMFI_BypassStamp\n"));
1790 pu32Param = (MS_U32*)pArgs;
1791 psDmxInstPri->fpDMXMMFIBypassStamp((DMX_MMFI_PATH)pu32Param[0], (MS_BOOL)pu32Param[1]);
1792 break;
1793
1794 case MApi_CMD_DMX_Get_DbgPortInfo:
1795 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Get_DbgPortInfo\n"));
1796 pu32Param = (MS_U32*)pArgs;
1797 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXGetDbgportInfo(pu32Param[0], &(pu32Param[1]));
1798 break;
1799
1800 case MApi_CMD_DMX_Open_MultiFlt:
1801 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Open_MultiFlt\n"));
1802 pu32Param = (MS_U32*)pArgs;
1803 pu32Param[3] = (MS_U32)psDmxInstPri->fpDMXOpenMultiFlt((DMX_FILTER_TYPE)pu32Param[0], (MS_U8*)&(pu32Param[1]), (MS_U8)pu32Param[2]);
1804 break;
1805
1806 case MApi_CMD_DMX_File_PVR_PidOpen:
1807 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_File_PVR_PidOpen\n"));
1808 pu32Param = (MS_U32*)pArgs;
1809 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXFilePvrPidOpen((DMX_PVR_ENG)pu32Param[0], pu32Param[1], (MS_U8*)&(pu32Param[2]), (MS_U8)pu32Param[3]);
1810 break;
1811
1812 case MApi_CMD_DMX_File_PVR_PidClose:
1813 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_File_PVR_PidClose\n"));
1814 pu32Param = (MS_U32*)pArgs;
1815 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFilePvrPidClose((DMX_PVR_ENG)pu32Param[0], (MS_U8)pu32Param[1]);
1816 break;
1817
1818 case MApi_CMD_DMX_File_PVR_Start:
1819 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_File_PVR_Start\n"));
1820 pu32Param = (MS_U32*)pArgs;
1821 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXFilePvrStart((DMX_PVR_ENG)pu32Param[0], (MS_BOOL)pu32Param[1]);
1822 break;
1823
1824 case MApi_CMD_DMX_File_PVR_Stop:
1825 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_File_PVR_Stop\n"));
1826 pu32Param = (MS_U32*)pArgs;
1827 pu32Param[1] = (MS_U32)psDmxInstPri->fpDMXFilePvrStop((DMX_PVR_ENG)pu32Param[0]);
1828 break;
1829
1830 case MApi_CMD_DMX_Pvr_Pause:
1831 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_Pause\n"));
1832 pu32Param = (MS_U32*)pArgs;
1833 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPvrPause((DMX_PVR_ENG)pu32Param[0], (MS_BOOL)pu32Param[1]);
1834 break;
1835
1836 case MApi_CMD_DMX_Pvr_Pid:
1837 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_Pvr_Pid\n"));
1838 pu32Param = (MS_U32*)pArgs;
1839 pu32Param[4] = (MS_U32)psDmxInstPri->fpDMXPvrPid((DMX_PVR_ENG)pu32Param[0], pu32Param[1], &(pu32Param[2]), (MS_BOOL)pu32Param[3]);
1840 break;
1841
1842 case MApi_CMD_DMX_RES_ALLOC:
1843 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_RES_ALLOC\n"));
1844 pu32Param = (MS_U32*)pArgs;
1845 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXResAllocate((DMX_RES_TYPE)pu32Param[0], (void*)&(pu32Param[1]));
1846 break;
1847
1848 case MApi_CMD_DMX_RES_FREE:
1849 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_RES_FREE\n"));
1850 pu32Param = (MS_U32*)pArgs;
1851 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXResFree((DMX_RES_TYPE)pu32Param[0], (void*)&(pu32Param[1]));
1852 break;
1853
1854 case MApi_CMD_DMX_PCR_GET_MAP_STC:
1855 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_PCR_GET_MAP_STC\n"));
1856 pu32Param = (MS_U32*)pArgs;
1857 pu32Param[2] = (MS_U32)psDmxInstPri->fpDMXPcrGetMapStc(pu32Param[0], &(pu32Param[1]));
1858 break;
1859
1860 case MApi_CMD_DMX_TSIO_Service_SetDMAoutVC:
1861 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_SetDMAoutVC\n"));
1862 pstSerDMAoutVC = (PDMX_TSIO_Service_SetDMAoutVC_PARAM)pArgs;
1863 pstSerDMAoutVC->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceSetDMAoutVC(pstSerDMAoutVC->u16Handle, pstSerDMAoutVC->eSet);
1864 break;
1865
1866 case MApi_CMD_DMX_TSIO_Service_DMAout_WriteGet:
1867 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_DMAout_WriteGet\n"));
1868 pstSerDMAoutWrite = (PDMX_TSIO_Service_DMAout_WriteGet_PARAM)pArgs;
1869 pstSerDMAoutWrite->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceDMAoutWriteGet(pstSerDMAoutWrite->u16Handle, pstSerDMAoutWrite->pphyWrite);
1870 break;
1871
1872 case MApi_CMD_DMX_TSIO_Service_SetDestination:
1873 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_SetDestination\n"));
1874 pstSerDestination = (PDMX_TSIO_Service_SetDestination_PARAM)pArgs;
1875 pstSerDestination->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceSetDestination(pstSerDestination->u16Handle, pstSerDestination->eDest);
1876 break;
1877
1878 case MApi_CMD_DMX_TSIO_Service_SetDMAinVC:
1879 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_SetDMAinVC\n"));
1880 pstSerDMAinVC = (PDMX_TSIO_Service_SetDMAinVC_PARAM)pArgs;
1881 pstSerDMAinVC->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceSetDMAinVC(pstSerDMAinVC->u16Handle, pstSerDMAinVC->eSet);
1882 break;
1883
1884 case MApi_CMD_DMX_TSIO_Service_DMAinVC_Start:
1885 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_DMAinVC_Start\n"));
1886 pstSerDMAinVCStart = (PDMX_TSIO_Service_DMAinVC_Start_PARAM)pArgs;
1887 pstSerDMAinVCStart->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceDMAinVCStart(pstSerDMAinVCStart->u16Handle, pstSerDMAinVCStart->u32Pacing);
1888 break;
1889
1890 case MApi_CMD_DMX_TSIO_Service_SetLocdecKey:
1891 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_SetLocdecKey\n"));
1892 pstSerLocdecKey = (PDMX_TSIO_Service_SetLocdecKey_PARAM)pArgs;
1893 pstSerLocdecKey->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceSetLocdecKey(pstSerLocdecKey->u16Handle, pstSerLocdecKey->eSet);
1894 break;
1895
1896 case MApi_CMD_DMX_TSIO_Service_LocdecKeyEnable:
1897 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_LocdecKeyEnable\n"));
1898 pstSerLocdecEnable = (PDMX_TSIO_Service_LocdecKeyEnable_PARAM)pArgs;
1899 pstSerLocdecEnable->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceLocdecKeyEnable(pstSerLocdecEnable->u16Handle, pstSerLocdecEnable->bEnable);
1900 break;
1901
1902 case MApi_CMD_DMX_TSIO_Service_PidOpen:
1903 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_PidOpen\n"));
1904 pstSerPidOpen = (PDMX_TSIO_Service_PidOpen_PARAM)pArgs;
1905 pstSerPidOpen->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServicePidOpen(pstSerPidOpen->u16Handle, pstSerPidOpen->eTSOInSrc, pstSerPidOpen->u16Pid, pstSerPidOpen->pu16DmxId);
1906 break;
1907
1908 case MApi_CMD_DMX_TSIO_Service_PidClose:
1909 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_PidClose\n"));
1910 pstSerPidClose = (PDMX_TSIO_Service_PidClose_PARAM)pArgs;
1911 pstSerPidClose->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServicePidClose(pstSerPidClose->u16Handle, pstSerPidClose->u16DmxId);
1912 break;
1913
1914 case MApi_CMD_DMX_TSIO_Service_Alloc:
1915 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_Alloc\n"));
1916 pstSerAlloc = (PDMX_TSIO_Service_Alloc_PARAM)pArgs;
1917 pstSerAlloc->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceAlloc(pstSerAlloc->u8Sid, pstSerAlloc->u16Handle);
1918 break;
1919
1920 case MApi_CMD_DMX_TSIO_Service_Free:
1921 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Service_Free\n"));
1922 pstSerFree = (PDMX_TSIO_Service_Free_PARAM)pArgs;
1923 pstSerFree->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOServiceFree(pstSerFree->u16Handle);
1924 break;
1925
1926 case MApi_CMD_DMX_TSIO_RegisterIntCb:
1927 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_RegisterIntCb\n"));
1928 pstRegisterIntCb = (PDMX_TSIO_RegisterIntCb_PARAM)pArgs;
1929 pstRegisterIntCb->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIORegisterIntCb(pstRegisterIntCb->efn);
1930 break;
1931
1932 case MApi_CMD_DMX_TSIO_Init:
1933 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Init\n"));
1934 pstTSIOInit = (PDMX_TSIO_Init_PARAM)pArgs;
1935 pstTSIOInit->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOInit(pstTSIOInit->eParm);
1936 break;
1937
1938 case MApi_CMD_DMX_TSIO_Open:
1939 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Open\n"));
1940 pstTSIOOpen = (PDMX_TSIO_Open_PARAM)pArgs;
1941 pstTSIOOpen->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOOpen(pstTSIOOpen->eClk);
1942 break;
1943
1944 case MApi_CMD_DMX_TSIO_Cmd:
1945 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Cmd\n"));
1946 pstTSIOCmd = (PDMX_TSIO_Cmd_PARAM)pArgs;
1947 pstTSIOCmd->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOCmd(pstTSIOCmd->eCmd, pstTSIOCmd->u32Value);
1948 break;
1949
1950 case MApi_CMD_DMX_TSIO_Exit:
1951 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Exit\n"));
1952 pu32Param = (MS_U32*)pArgs;
1953 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXTSIOExit();
1954 break;
1955
1956 case MApi_CMD_DMX_TSIO_Close:
1957 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_Close\n"));
1958 pu32Param = (MS_U32*)pArgs;
1959 pu32Param[0] = (MS_U32)psDmxInstPri->fpDMXTSIOClose();
1960 break;
1961
1962 case MApi_CMD_DMX_TSIO_CC:
1963 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_CC\n"));
1964 pstTSIOCc = (PDMX_TSIO_CC_PARAM)pArgs;
1965 pstTSIOCc->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOCC(pstTSIOCc->Parm, pstTSIOCc->pResult);
1966 break;
1967
1968 case MApi_CMD_DMX_TSIO_GetInfo:
1969 DMX_MSG(ULOGD("DMX", "DMXIoctl - MApi_CMD_DMX_TSIO_GetInfo\n"));
1970 pstTSIOGetInfo = (PDMX_TSIO_GetInfo_PARAM)pArgs;
1971 pstTSIOGetInfo->u32Res = (MS_U32)psDmxInstPri->fpDMXTSIOGetInfo(pstTSIOGetInfo->eInfo, pstTSIOGetInfo->u32Arg, pstTSIOGetInfo->u32Retinfo);
1972 break;
1973
1974 default:
1975 DMX_MSG(ULOGD("DMX", "DMXIoctl - Unknown commend!!!\n"));
1976 u32Res = UTOPIA_STATUS_NOT_SUPPORTED;
1977 break;
1978
1979 }
1980
1981 IOCTRL_END:
1982
1983 UtopiaResourceRelease(pResource);
1984
1985 return u32Res;
1986 }
1987
DMXClose(void * pInstance)1988 MS_U32 DMXClose(void* pInstance)
1989 {
1990
1991 UtopiaInstanceDelete(pInstance);
1992
1993 return UTOPIA_STATUS_SUCCESS;
1994 }
1995
1996
1997 #ifdef MSOS_TYPE_LINUX_KERNEL
1998
DMXStr(MS_U32 u32PowerState,void * pModule)1999 MS_U32 DMXStr(MS_U32 u32PowerState, void* pModule)
2000 {
2001 return _MApi_DMX_SetPowerState(u32PowerState, 0, 0);
2002 }
2003 #endif //MSOS_TYPE_LINUX_KERNEL
2004
2005
2006 #if defined(CONFIG_UTOPIA2_CONSTRUCTOR_REGISTER_TO_UTOPIA)
2007 UTOPIA_MODULE_INIT(DMX);
2008 #endif
2009
2010