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) 2011-2013 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 drvTSO.c
98 /// @brief TS I/O Driver Interface
99 /// @author MStar Semiconductor,Inc.
100 /// @attention
101 /// All TSO DDI are not allowed to use in any interrupt context other than TSO ISR and Callback
102 ///////////////////////////////////////////////////////////////////////////////////////////////////
103
104 //-------------------------------------------------------------------------------------------------
105 // Include Files
106 //-------------------------------------------------------------------------------------------------
107
108 // Common Definition
109 #include "MsCommon.h"
110 #include "MsVersion.h"
111 #include "drvMMIO.h"
112
113 // Internal Definition
114 #include "asmCPU.h"
115 #include "regTSO.h"
116 #include "halTSO.h"
117 #include "drvTSO.h"
118
119 #include "ULog.h"
120
121
122 #ifdef MSOS_TYPE_LINUX
123 #include <sys/ioctl.h>
124 #include <unistd.h>
125 #include <fcntl.h> // O_RDWR
126 #endif
127
128 #ifdef MSOS_TYPE_LINUX_KERNEL
129 #include <linux/string.h>
130 #endif
131
132 //-------------------------------------------------------------------------------------------------
133 // Driver Compiler Options
134 //-------------------------------------------------------------------------------------------------
135
136
137 //-------------------------------------------------------------------------------------------------
138 // Local Defines
139 //-------------------------------------------------------------------------------------------------
140 #define TSO_MUTEX_WAIT_TIME 0xFFFFFFFFUL
141
142 #define TSO_DBGERR(x) {if(_tsodbglevel >= E_DRVTSO_DBG_ERR) x; }
143 #define TSO_DBGINFO(x) {if(_tsodbglevel >= E_DRVTSO_DBG_INFO) x; }
144
145 #define TSO_ASSERT(_bool) if(!(_bool)) \
146 { \
147 if(_tsodbglevel >= E_DRVTSO_DBG_INFO) \
148 { ULOGD("TSO", "ASSERT ERR\n"); } \
149 return DRVTSO_FAIL; \
150 }
151
152 #define _TSO_ENTRY() if (!MsOS_ObtainMutex(_ptso_res->_s32TSOMutexId, TSO_MUTEX_WAIT_TIME)) \
153 { \
154 return DRVTSO_FAIL; \
155 }
156
157 #define _TSO_RETURN(_ret) do{ \
158 MsOS_ReleaseMutex(_ptso_res->_s32TSOMutexId); \
159 return _ret; \
160 }while(0);
161
162 //-------------------------------------------------------------------------------------------------
163 // Local Structures
164 //-------------------------------------------------------------------------------------------------
165
166 typedef struct _TSO_RESOURCE_PRIVATE
167 {
168 MS_S32 _s32TSOMutexId;
169 MS_BOOL _bFilterUsed[TSO_ENGINE_NUM][TSO_PIDFLT_NUM];
170
171 MS_BOOL _bSWInit;
172 }TSO_RESOURCE_PRIVATE;
173
174 //-------------------------------------------------------------------------------------------------
175 // Global Variables
176 //-------------------------------------------------------------------------------------------------
177 #ifndef TSO_UTOPIA_20
178 static TSO_RESOURCE_PRIVATE _tso_res = {
179 ._s32TSOMutexId = -1,
180 ._bSWInit = FALSE,
181 };
182
183 static TSO_RESOURCE_PRIVATE* _ptso_res = &_tso_res;
184 #else
185 static TSO_RESOURCE_PRIVATE* _ptso_res = NULL;
186 #endif
187
188 //-------------------------------------------------------------------------------------------------
189 // Local Variables
190 //-------------------------------------------------------------------------------------------------
191 static DrvTSO_DbgLevel _tsodbglevel = E_DRVTSO_DBG_Release;
192 static MS_BOOL _bBankInit = FALSE;
193
194 //-------------------------------------------------------------------------------------------------
195 // Local Functions
196 //-------------------------------------------------------------------------------------------------
_TSO_InitResource(TSO_RESOURCE_PRIVATE * presource)197 static MS_BOOL _TSO_InitResource(TSO_RESOURCE_PRIVATE* presource)
198 {
199 if(presource == NULL)
200 {
201 return FALSE;
202 }
203
204 presource->_s32TSOMutexId = -1;
205 presource->_bSWInit = FALSE;
206
207 return TRUE;
208 }
209
210 //-------------------------------------------------------------------------------------------------
211 // Function and Variable
212 //-------------------------------------------------------------------------------------------------
213 //-------------------------------------------------------------------------------------------------
214 /// Initialize lib resource API
215 /// @param pResMemAddr \b IN: Pointer to store resource memory address
216 /// @return MMFI_Result
217 /// @note
218 //-------------------------------------------------------------------------------------------------
MDrv_TSO_InitLibResource(void * pResMemAddr)219 TSO_Result MDrv_TSO_InitLibResource(void* pResMemAddr)
220 {
221 MS_VIRT virtBank;
222 MS_PHY u32BankSize;
223
224 if(pResMemAddr == 0)
225 return DRVTSO_FAIL;
226
227 _ptso_res = (TSO_RESOURCE_PRIVATE*)pResMemAddr;
228
229 if(_ptso_res->_bSWInit != TRUE)
230 {
231 if(_TSO_InitResource(_ptso_res) == FALSE)
232 return DRVTSO_FAIL;
233 }
234
235 // For multi-process use case. (different process should set the value of bank again)
236 if(_bBankInit == FALSE)
237 {
238 if (FALSE == MDrv_MMIO_GetBASE(&virtBank, &u32BankSize, MS_MODULE_TSO))
239 {
240 TSO_DBGERR(ULOGE("TSO", "MDrv_TSO_GetBASE failed\n"));
241 return DRVTSO_FAIL;
242 }
243 TSO_DBGINFO((ULOGD("TSO", "TSO Base Bank 0x%x\n", (unsigned int)virtBank)));
244 HAL_TSO_SetBank(virtBank);
245 _bBankInit = TRUE;
246 }
247
248 return DRVTSO_OK;
249 }
250
251 //-------------------------------------------------------------------------------------------------
252 /// Initialize TSO driver
253 /// @return TSO_Result
254 /// @note
255 /// It should be called before calling any other TSO DDI functions.
256 /// Driver task is in @ref E_TASK_PRI_SYS level.
257 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Init(void)258 TSO_Result MDrv_TSO_Init(void)
259 {
260 MS_VIRT virtBank;
261 MS_PHY u32BankSize;
262 MS_U8 u8ii, u8jj;
263
264 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
265
266 if (FALSE == MDrv_MMIO_GetBASE(&virtBank, &u32BankSize, MS_MODULE_TSO))
267 {
268 TSO_DBGERR(ULOGE("TSO", "MDrv_TSO_GetBASE failed\n"));
269 return DRVTSO_FAIL;
270 }
271 TSO_DBGINFO((ULOGD("TSO", "TSO Base Bank 0x%08x\n", (unsigned int)virtBank)));
272 HAL_TSO_SetBank(virtBank);
273
274 _ptso_res->_s32TSOMutexId = MsOS_CreateMutex(E_MSOS_FIFO, "Mutex TSO", MSOS_PROCESS_SHARED);
275 if(_ptso_res->_s32TSOMutexId == -1)
276 {
277 TSO_DBGERR(ULOGE("TSO", "MsOS_CreateMutex failed\n"));
278 return DRVTSO_FAIL;
279 }
280
281 _TSO_ENTRY();
282
283 HAL_TSO_Init();
284
285 for(u8jj = 0; u8jj < (MS_U8)TSO_ENGINE_NUM; u8jj++)
286 {
287 HAL_TSO_Reset_All(u8jj);
288
289 for(u8ii = 0; u8ii < (MS_U8)TSO_PIDFLT_NUM; u8ii++)
290 {
291 _ptso_res->_bFilterUsed[u8jj][u8ii] = FALSE;
292 }
293
294 //HAL_TSO_HWInt_Enable(u8jj, TSO_INT_SRC_MASK, TRUE);
295 HAL_TSO_Filein_Rate(u8jj, 0x0A);
296 }
297 _ptso_res->_bSWInit = TRUE;
298
299 _TSO_RETURN(DRVTSO_OK);
300 }
301
302 //-------------------------------------------------------------------------------------------------
303 /// Close TSO driver
304 /// @return TSO_Result
305 /// @note
306 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Exit(void)307 TSO_Result MDrv_TSO_Exit(void)
308 {
309 MS_U8 u8ii, u8jj;
310
311 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
312
313 _TSO_ENTRY();
314
315 for(u8jj = 0; u8jj < TSO_ENGINE_NUM; u8jj++)
316 {
317 HAL_TSO_Cfg1_Enable(u8jj, TSO_CFG1_PKT_NULL_EN, FALSE);
318 HAL_TSO_Cfg4_Enable(u8jj, TSO_CFG4_TS_OUT_EN, FALSE);
319
320 HAL_TSO_Set_InClk(u8jj, 0, FALSE, FALSE);
321 HAL_TSO_Set_OutClk(u8jj, 0, FALSE, FALSE);
322
323 for(u8ii = 0; u8ii < TSO_PIDFLT_NUM; u8ii++)
324 {
325 _ptso_res->_bFilterUsed[u8jj][u8ii] = FALSE;
326 }
327 }
328
329 MsOS_ReleaseMutex(_ptso_res->_s32TSOMutexId);
330 MsOS_DeleteMutex(_ptso_res->_s32TSOMutexId);
331 _ptso_res->_s32TSOMutexId = -1;
332 _ptso_res->_bSWInit = FALSE;
333
334 return DRVTSO_OK;
335 }
336
337 //-------------------------------------------------------------------------------------------------
338 /// Get TSO HW interrupt status
339 /// @param u8Eng \b IN: TSO engine ID
340 /// @param pu16status \b OUT: pointer of storing HW interrupt status value
341 /// @return TSO_Result
342 /// @note
343 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Get_HWIntStatus(MS_U8 u8Eng,MS_U16 * pu16status)344 TSO_Result MDrv_TSO_Get_HWIntStatus(MS_U8 u8Eng, MS_U16* pu16status)
345 {
346 *pu16status = HAL_TSO_HWInt_Status(u8Eng);
347 return DRVTSO_OK;
348 }
349
350 //-------------------------------------------------------------------------------------------------
351 /// Set debug level of TSO
352 /// @param DbgLevel \b IN: Debug Level Value
353 //-------------------------------------------------------------------------------------------------
MDrv_TSO_SetDbgLevel(DrvTSO_DbgLevel DbgLevel)354 TSO_Result MDrv_TSO_SetDbgLevel(DrvTSO_DbgLevel DbgLevel)
355 {
356 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
357
358 _tsodbglevel = DbgLevel;
359 return DRVTSO_OK;
360 }
361
362 //-------------------------------------------------------------------------------------------------
363 /// Set TSO operation mode
364 /// @param u8Eng \b IN: TSO engine ID
365 /// @param TSOCtrlMode \b IN: Ctrol mode
366 /// @param bClkInv \b IN: TSO_IN_Clk Invert
367 /// @param bParallel \b IN: TSO_IN_Interface paralleled
368 /// @return TSO_Result
369 //-------------------------------------------------------------------------------------------------
370 #ifdef TSO_HW_BOX_SERIES
MDrv_TSO_SetOperateMode(MS_U8 u8Eng,DrvTSO_CtrlMode TSOCtrlMode,MS_BOOL bClkInv,MS_BOOL bParallel)371 TSO_Result MDrv_TSO_SetOperateMode(MS_U8 u8Eng, DrvTSO_CtrlMode TSOCtrlMode, MS_BOOL bClkInv, MS_BOOL bParallel)
372 {
373 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
374 TSO_ASSERT((u8Eng < TSO_ENGINE_NUM));
375 _TSO_ENTRY();
376
377 HalTSOOutClk stTsoOutClk = {0xFFFF, 0xFFFF, 0, 0xFFFF, bClkInv, TRUE};
378
379 HAL_TSO_PktChkSize_Set(u8Eng, 0xBB);
380 HAL_TSO_Filein_PktChkSize_Set(u8Eng, 0xBB);
381 HAL_TSO_Output_PktChkSize_Set(u8Eng, 0xBB);
382
383 MS_U16 u16InPad = HAL_TSOIN_MUX_TS0;
384 MS_U16 u16InClk = HAL_TSO_CLKIN_TS0;
385 switch(TSOCtrlMode)
386 {
387 case E_DRVTSO_CTRL_MODE_TS0:
388 u16InPad = HAL_TSOIN_MUX_TS0;
389 u16InClk = HAL_TSO_CLKIN_TS0;
390 break;
391 case E_DRVTSO_CTRL_MODE_TS1:
392 u16InPad = HAL_TSOIN_MUX_TS1;
393 u16InClk = HAL_TSO_CLKIN_TS1;
394 break;
395 case E_DRVTSO_CTRL_MODE_TS2:
396 u16InPad = HAL_TSOIN_MUX_TS2;
397 u16InClk = HAL_TSO_CLKIN_TS2;
398 break;
399 case E_DRVTSO_CTRL_MODE_TS3:
400 u16InPad = HAL_TSOIN_MUX_TS3;
401 u16InClk = HAL_TSO_CLKIN_TS3;
402 break;
403 case E_DRVTSO_CTRL_MODE_TSCB:
404 u16InPad = HAL_TSOIN_MUX_TSCB;
405 u16InClk = HAL_TSO_CLKIN_TSCB;
406 break;
407 case E_DRVTSO_CTRL_MODE_DEMOD0:
408 u16InPad = HAL_TSOIN_MUX_TSDEMOD0;
409 u16InClk = HAL_TSO_CLKIN_TSDEMOD0;
410 break;
411 case E_DRVTSO_CTRL_MODE_DEMOD1:
412 u16InPad = HAL_TSOIN_MUX_TSDEMOD1;
413 u16InClk = HAL_TSO_CLKIN_TSDEMOD1;
414 break;
415 case E_DRVTSO_CTRL_MODE_MEM:
416 u16InPad = HAL_TSOIN_MUX_MEM;
417 u16InClk = 0x0;
418 break;
419
420 default:
421 ULOGE("TSO", "Not supported TSOCtrlMode = %d! \n", TSOCtrlMode);
422 _TSO_RETURN(DRVTSO_INVALID_PARAM);
423 }
424
425 HAL_TSO_OutClk_DefSelect(u8Eng, u16InPad, FALSE, &stTsoOutClk);
426 HAL_TSO_SelPad(u8Eng, u16InPad, bParallel);
427 //HAL_TSO_Set_InClk(u8Eng, u16InClk, FALSE, FALSE);
428 HAL_TSO_ConfigOutputClk(u8Eng, &stTsoOutClk);
429
430 if(TSOCtrlMode == E_DRVTSO_CTRL_MODE_MEM)
431 {
432 HAL_TSO_Set_InClk(u8Eng, u16InClk, FALSE, FALSE);
433 HAL_TSO_Cfg0_Enable(u8Eng, TSO_CFG0_DATA_CHK_2T_EN|TSO_CFG0_SOURCE_FILE|TSO_CFG0_FILEIN_ENABLE, TRUE);
434 HAL_TSO_Cfg0_Enable(u8Eng, TSO_CFG0_TS_SIN_C0_EN, FALSE);
435 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_ALT_TS_SIZE|TSO_CFG1_PID_BYPASS|TSO_CFG1_PKT_NULL_EN, TRUE);
436 }
437 else
438 {
439 MS_U16 u16Cfg = TSO_CFG0_EXTERNAL_SYNC_SEL | TSO_CFG0_SOURCE_LIVE;
440 if(bParallel)
441 u16Cfg |= TSO_CFG0_PARALLEL_SEL;
442
443 HAL_TSO_Set_InClk(u8Eng, u16InClk, FALSE, TRUE);
444 HAL_TSO_Cfg0_Enable(u8Eng, u16Cfg, TRUE);
445 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_FORCE_SYNC_EN|TSO_CFG1_PID_BYPASS|TSO_CFG1_ALT_TS_SIZE, TRUE);
446 }
447
448 HAL_TSO_Cfg4_Enable(u8Eng, TSO_CFG4_TS_OUT_EN, TRUE);
449
450 _TSO_RETURN(DRVTSO_OK);
451 }
452 #else
MDrv_TSO_SetOperateMode(MS_U8 u8Eng,DrvTSO_CtrlMode TSOCtrlMode,MS_BOOL bClkInv,MS_BOOL bParallel)453 TSO_Result MDrv_TSO_SetOperateMode(MS_U8 u8Eng, DrvTSO_CtrlMode TSOCtrlMode, MS_BOOL bClkInv, MS_BOOL bParallel)
454 {
455 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
456 TSO_ASSERT((u8Eng < TSO_ENGINE_NUM));
457 _TSO_ENTRY();
458
459 HAL_TSO_PktChkSize_Set(u8Eng, 0xBB);
460 HAL_TSO_Filein_PktChkSize_Set(u8Eng, 0xBB);
461 HAL_TSO_Output_PktChkSize_Set(u8Eng, 0xBB);
462
463 if(TSOCtrlMode == E_DRVTSO_CTRL_MODE_MEM)
464 {
465 HAL_TSO_Cfg0_Enable(u8Eng, TSO_CFG0_DATA_CHK_2T_EN|TSO_CFG0_SOURCE_FILE|TSO_CFG0_FILEIN_ENABLE, TRUE);
466 HAL_TSO_Cfg0_Enable(u8Eng, TSO_CFG0_TS_SIN_C0_EN, FALSE);
467 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_ALT_TS_SIZE|TSO_CFG1_PID_BYPASS|TSO_CFG1_PKT_NULL_EN, TRUE);
468 }
469 else if(TSOCtrlMode == E_DRVTSO_CTRL_MODE_TS0)
470 {
471 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_FORCE_SYNC_EN|TSO_CFG1_PID_BYPASS|TSO_CFG1_ALT_TS_SIZE, TRUE);
472 }
473 else
474 {
475 _TSO_RETURN(DRVTSO_INVALID_PARAM);
476 }
477
478 HAL_TSO_Cfg4_Enable(u8Eng, TSO_CFG4_TS_OUT_EN, TRUE);
479
480 _TSO_RETURN(DRVTSO_OK);
481 }
482
483 #endif
484
485 //-------------------------------------------------------------------------------------------------
486 /// Set TSO File-in Byte Timer
487 /// @param u8Eng \b IN: TSO engine ID
488 /// @param u16timer \b IN: Timer value
489 /// @param bEnable \b IN: Enable flag
490 /// @return TSO_Result
491 /// @note
492 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_Rate(MS_U8 u8Eng,MS_U16 u16timer)493 TSO_Result MDrv_TSO_Filein_Rate(MS_U8 u8Eng, MS_U16 u16timer)
494 {
495 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
496
497 _TSO_ENTRY();
498
499 HAL_TSO_Filein_Rate(u8Eng, u16timer);
500 if(u16timer == 0)
501 {
502 HAL_TSO_FileinTimer_Enable(u8Eng, FALSE);
503 }
504 else
505 {
506 HAL_TSO_FileinTimer_Enable(u8Eng, TRUE);
507 }
508 _TSO_RETURN(DRVTSO_OK);
509 }
510
511 //-------------------------------------------------------------------------------------------------
512 /// Set TSO Out Clock
513 /// @param u8Eng \b IN: TSO engine ID
514 /// @param eOutClk \b IN: TSO out clock select
515 /// @param eOutClkSrc \b IN: TSO out clock source select
516 /// @param u16DivNum \b IN: If select DMPLLDIV source, setting Divide number
517 /// @param bClkInv \b IN: If Out Clock invert
518 /// @return TSO_Result
519 /// @note
520 /// Out Clk 5.4M,
521 /// eOutClkSrc = E_DRVTSO_OUTCLK_DIV2N
522 /// eOutClkSrc = E_DRVTSO_OUTCLKSRC_172M_2N
523 /// u16DivNum = 15
524 /// Out Clk 6.17M,
525 /// eOutClkSrc = E_DRVTSO_OUTCLK_DIV2N
526 /// eOutClkSrc = E_DRVTSO_OUTCLKSRC_172M_2N
527 /// u16DivNum = 13
528 /// Out Clk 6.64M,
529 /// eOutClkSrc = E_DRVTSO_OUTCLK_DIV2N
530 /// eOutClkSrc = E_DRVTSO_OUTCLKSRC_172M_2N
531 /// u16DivNum = 12
532 //-------------------------------------------------------------------------------------------------
MDrv_TSO_SetOutClk(MS_U8 u8Eng,DrvTSO_OutClk eOutClk,DrvTSO_OutClkSrc eOutClkSrc,MS_U16 u16DivNum,MS_BOOL bClkInv)533 TSO_Result MDrv_TSO_SetOutClk(MS_U8 u8Eng, DrvTSO_OutClk eOutClk, DrvTSO_OutClkSrc eOutClkSrc, MS_U16 u16DivNum, MS_BOOL bClkInv)
534 {
535 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
536
537 _TSO_ENTRY();
538
539 #ifndef TSO_HW_BOX_SERIES
540
541 //ULOGD("TSO", "[%s] eOutClk %x, eOutClkSrc %x, u16DivNum %x \n", __FUNCTION__, eOutClk, eOutClkSrc, u16DivNum);
542
543 MS_U16 u16OutClkSrc = E_DRVTSO_OUTCLK_DIV2N;
544 HalTSOOutClk stTsoOutClk = {0xFFFF, 0xFFFF, u16DivNum, 0xFFFF, bClkInv, TRUE};
545
546 switch(eOutClkSrc)
547 {
548 case E_DRVTSO_OUTCLKSRC_172M_2N:
549 u16OutClkSrc = HAL_TSO_OUT_DIV_SEL_172M_2N;
550 break;
551 case E_DRVTSO_OUTCLKSRC_288M_2N:
552 u16OutClkSrc = HAL_TSO_OUT_DIV_SEL_288M_2N;
553 break;
554 case E_DRVTSO_OUTCLKSRC_216M_N:
555 u16OutClkSrc = HAL_TSO_OUT_DIV_SEL_216M_N;
556 break;
557 case E_DRVTSO_OUTCLKSRC_P_TS0IN:
558 u16OutClkSrc = HAL_PRE_TSO_OUT_SEL_TS0IN;
559 break;
560 case E_DRVTSO_OUTCLKSRC_P_TS1IN:
561 u16OutClkSrc = HAL_PRE_TSO_OUT_SEL_TS1IN;
562 break;
563 case E_DRVTSO_OUTCLKSRC_P_TS2IN:
564 u16OutClkSrc = HAL_PRE_TSO_OUT_SEL_TS2IN;
565 break;
566 default:
567 _TSO_RETURN(DRVTSO_INVALID_PARAM);
568 }
569
570 stTsoOutClk.bClkInvert = bClkInv;
571 switch(eOutClk)
572 {
573 case E_DRVTSO_OUTCLK_DIV2N:
574 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_DIV2N;
575 stTsoOutClk.u16OutDivSrc = u16OutClkSrc;
576 stTsoOutClk.u16OutDivNum = u16DivNum;
577 break;
578 case E_DRVTSO_OUTCLK_DIVN:
579 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_DIV;
580 stTsoOutClk.u16OutDivSrc = u16OutClkSrc;
581 stTsoOutClk.u16OutDivNum = u16DivNum;
582 break;
583 case E_DRVTSO_OUTCLK_62M:
584 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_62MHz;
585 break;
586 case E_DRVTSO_OUTCLK_54M:
587 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_54MHz;
588 break;
589 case E_DRVTSO_OUTCLK_PTSOOUT:
590 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_PTSOOUT;
591 stTsoOutClk.u16OutDivSrc = u16OutClkSrc;
592 break;
593 case E_DRVTSO_OUTCLK_PTSOOUT_DIV8:
594 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_PTSOOUT_DIV8;
595 stTsoOutClk.u16OutDivSrc = u16OutClkSrc;
596 break;
597 case E_DRVTSO_OUTCLK_Dmd:
598 stTsoOutClk.u16OutClk = HAL_TSO_OUT_SEL_TSO_OUT_FROM_DEMOD;
599 break;
600 default:
601 _TSO_RETURN(DRVTSO_INVALID_PARAM);
602 }
603
604 //ULOGD("TSO", "[%s] stTsoOutClk eOutClk %x, eOutClkSrc %x, u16DivNum %x \n", __FUNCTION__, stTsoOutClk.u16OutClk, stTsoOutClk.u16OutDivSrc, stTsoOutClk.u16OutDivNum);
605
606 HAL_TSO_ConfigOutputClk(u8Eng, &stTsoOutClk);
607 #endif
608
609 _TSO_RETURN(DRVTSO_OK);
610 }
611
612 //-------------------------------------------------------------------------------------------------
613 /// Allocate TSO PID filter
614 /// @param u8Eng \b IN: TSO engine ID
615 /// @param pu8PidFltId \b OUT: pointer of PID filter ID for return
616 /// @return TSO_Result
617 /// @note
618 //-------------------------------------------------------------------------------------------------
MDrv_TSO_PidFlt_Alloc(MS_U8 u8Eng,MS_U8 * pu8PidFltId)619 TSO_Result MDrv_TSO_PidFlt_Alloc(MS_U8 u8Eng, MS_U8 *pu8PidFltId)
620 {
621 MS_U8 u8ii;
622 *pu8PidFltId = 0xFF;
623
624 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
625
626 _TSO_ENTRY();
627 for(u8ii = 0; u8ii < TSO_PIDFLT_NUM; u8ii++)
628 {
629 if(_ptso_res->_bFilterUsed[u8Eng][u8ii] == FALSE)
630 {
631 TSO_DBGERR(ULOGE("TSO", "Allocate PID Filter %d\n", (int)u8ii));
632 _ptso_res->_bFilterUsed[u8Eng][u8ii] = TRUE;
633 *pu8PidFltId = u8ii;
634 _TSO_RETURN(DRVTSO_OK);
635 }
636 }
637
638 _TSO_RETURN(DRVTSO_FAIL);
639 }
640
641 //-------------------------------------------------------------------------------------------------
642 /// Free TSO PID filter
643 /// @param u8PidFltId \b IN: PID filter ID
644 /// @return TSO_Result
645 /// @note
646 //-------------------------------------------------------------------------------------------------
MDrv_TSO_PidFlt_Free(MS_U8 u8Eng,MS_U8 u8PidFltId)647 TSO_Result MDrv_TSO_PidFlt_Free(MS_U8 u8Eng, MS_U8 u8PidFltId)
648 {
649 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
650
651 if(_ptso_res->_bFilterUsed[u8Eng][u8PidFltId] == FALSE)
652 return DRVTSO_OK;
653
654 _TSO_ENTRY();
655 HAL_TSO_Flt_SetPid(u8Eng, u8PidFltId, TSO_PID_NULL);
656 _ptso_res->_bFilterUsed[u8Eng][u8PidFltId] = FALSE;
657 _TSO_RETURN(DRVTSO_OK);
658 }
659
660 //-------------------------------------------------------------------------------------------------
661 /// Set PID to PID filter
662 /// @param u8PidFltId \b IN: PID filter ID
663 /// @param u16Pid \b IN: Enable Flag
664 /// @return TSO_Result
665 /// @note
666 //-------------------------------------------------------------------------------------------------
MDrv_TSO_PidFlt_SetPid(MS_U8 u8Eng,MS_U8 u8PidFltId,MS_U16 u16Pid)667 TSO_Result MDrv_TSO_PidFlt_SetPid(MS_U8 u8Eng, MS_U8 u8PidFltId, MS_U16 u16Pid)
668 {
669 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
670
671 _TSO_ENTRY();
672 HAL_TSO_Flt_SetPid(u8Eng, u8PidFltId, u16Pid);
673 _TSO_RETURN(DRVTSO_OK);
674 }
675
676 //-------------------------------------------------------------------------------------------------
677 /// Command Queue Reset
678 /// @param u8Eng \b IN: TSO engine ID
679 /// @return TSO_Result
680 /// @note
681 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_CmdQ_Reset(MS_U8 u8Eng)682 TSO_Result MDrv_TSO_Filein_CmdQ_Reset(MS_U8 u8Eng)
683 {
684 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
685
686 _TSO_ENTRY();
687 HAL_TSO_Reset_SubItem(u8Eng, TSO_SW_RSTZ_CMDQ);
688 _TSO_RETURN(DRVTSO_OK);
689 }
690
691 //-------------------------------------------------------------------------------------------------
692 /// Get Command Queue Write Level value
693 /// @param u8Eng \b IN: TSO engine ID
694 /// @param pu8FifoLevel \b OUT: pointer of Command Queue Write Level value for return
695 /// @return TSO_Result
696 /// @note
697 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_CmdQFifo_Status(MS_U8 u8Eng,MS_U8 * pu8FifoLevel)698 TSO_Result MDrv_TSO_Filein_CmdQFifo_Status(MS_U8 u8Eng, MS_U8 *pu8FifoLevel)
699 {
700 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
701
702 *pu8FifoLevel = HAL_TSO_CmdQ_FIFO_Get_WRLevel(u8Eng);
703 return DRVTSO_OK;
704 }
705
706 //-------------------------------------------------------------------------------------------------
707 /// Get Command Queue Empty Slot value
708 /// @param u8Eng \b IN: TSO engine ID
709 /// @param pu32EmptySlot \b OUT: pointer of Command Queue Empty Slot value for return
710 /// @return TSO_Result
711 /// @note
712 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_CmdQ_GetSlot(MS_U8 u8Eng,MS_U32 * pu32EmptySlot)713 TSO_Result MDrv_TSO_Filein_CmdQ_GetSlot(MS_U8 u8Eng, MS_U32 *pu32EmptySlot)
714 {
715 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
716
717 *pu32EmptySlot = 0;
718 *pu32EmptySlot = (MS_U32)((TSO_CMDQ_SIZE - HAL_TSO_CmdQ_FIFO_Get_WRCnt(u8Eng)) & 0xFFFF);
719 return DRVTSO_OK;
720 }
721
722 //-------------------------------------------------------------------------------------------------
723 /// Set playback timestamp
724 /// @param u8Eng \b IN: TSO engine ID
725 /// @param u32timestamp \b IN: timestamp value
726 /// @return TSO_Result
727 /// @note
728 //-------------------------------------------------------------------------------------------------
MDrv_TSO_SetPlaybackTimeStamp(MS_U8 u8Eng,MS_U32 u32timestamp)729 TSO_Result MDrv_TSO_SetPlaybackTimeStamp(MS_U8 u8Eng, MS_U32 u32timestamp)
730 {
731 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
732
733 _TSO_ENTRY();
734 HAL_TSO_LPcr2_Set(u8Eng, u32timestamp);
735 _TSO_RETURN(DRVTSO_OK);
736 }
737
738 //-------------------------------------------------------------------------------------------------
739 /// Get playback timestamp
740 /// @param u8Eng \b IN: TSO engine ID
741 /// @param pu32timestamp \b OUT: pointer of timestamp value for return
742 /// @return MMFI_Result
743 /// @note
744 //-------------------------------------------------------------------------------------------------
MDrv_TSO_GetPlaybackTimeStamp(MS_U8 u8Eng,MS_U32 * pu32timestamp)745 TSO_Result MDrv_TSO_GetPlaybackTimeStamp(MS_U8 u8Eng, MS_U32 *pu32timestamp)
746 {
747 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
748 TSO_ASSERT((pu32timestamp != 0));
749
750 _TSO_ENTRY();
751 *pu32timestamp = HAL_TSO_LPcr2_Get(u8Eng);
752 _TSO_RETURN(DRVTSO_OK);
753 }
754
755 //-------------------------------------------------------------------------------------------------
756 /// Get File-in timestamp value
757 /// @param u8Eng \b IN: TSO engine ID
758 /// @param pu32Timestamp \b OUT: pointer of Timestamp value for return
759 /// @return TSO_Result
760 /// @note
761 //-------------------------------------------------------------------------------------------------
MDrv_TSO_GetFileInTimeStamp(MS_U8 u8Eng,MS_U32 * pu32Timestamp)762 TSO_Result MDrv_TSO_GetFileInTimeStamp(MS_U8 u8Eng, MS_U32* pu32Timestamp)
763 {
764 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
765 TSO_ASSERT((pu32Timestamp != 0));
766 *pu32Timestamp = HAL_TSO_TimeStamp_Get(u8Eng);
767 return DRVTSO_OK;
768 }
769
770 //-------------------------------------------------------------------------------------------------
771 /// Get TSO File-in read address
772 /// @param u8Eng \b IN: TSO engine ID
773 /// @param pu32ReadAddr \b OUT: Pointer to store file-in current reand pointer
774 /// @return TSP_Result
775 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_GetReadAddr(MS_U8 u8Eng,MS_PHY * pu32ReadAddr)776 TSO_Result MDrv_TSO_Filein_GetReadAddr(MS_U8 u8Eng, MS_PHY *pu32ReadAddr)
777 {
778 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
779 TSO_ASSERT((pu32ReadAddr != 0));
780
781 _TSO_ENTRY();
782 *pu32ReadAddr = HAL_TSO_Get_Filein_ReadAddr(u8Eng);
783 _TSO_RETURN(DRVTSO_OK);
784 }
785
786 //-------------------------------------------------------------------------------------------------
787 /// Set File-in Read Start Address
788 /// @param u8Eng \b IN: TSO engine ID
789 /// @param u32StreamAddr \b IN: MIU Physical Address of File-in Read Start Address.
790 /// @return TSO_Result
791 /// @note
792 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_SetAddr(MS_U8 u8Eng,MS_PHY u32StreamAddr)793 TSO_Result MDrv_TSO_Filein_SetAddr(MS_U8 u8Eng, MS_PHY u32StreamAddr)
794 {
795 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
796
797 _TSO_ENTRY();
798 HAL_TSO_Set_Filein_ReadAddr(u8Eng, u32StreamAddr);
799 _TSO_RETURN(DRVTSO_OK);
800 }
801
802 //-------------------------------------------------------------------------------------------------
803 /// Set File-in Packet Mode
804 /// @param u8Eng \b IN: TSO engine ID
805 /// @param ePktMode \b IN: Select packet mode
806 /// @return TSO_Result
807 /// @note
808 //-------------------------------------------------------------------------------------------------
MDrv_TSO_SetPacketMode(MS_U8 u8Eng,DrvTSO_PacketMode ePktMode)809 TSO_Result MDrv_TSO_SetPacketMode(MS_U8 u8Eng, DrvTSO_PacketMode ePktMode)
810 {
811 MS_U16 u16OutPktSize = 0xBB;
812 MS_U16 u16ValidCount = 0xBB;
813 MS_U16 u16InValidCount = 0x0;
814
815 _TSO_ENTRY();
816
817 switch (ePktMode)
818 {
819 case E_DRVTSO_PKTMODE_188:
820 HAL_TSO_PktChkSize_Set(u8Eng, 0xBB);
821 HAL_TSO_Filein_PktChkSize_Set(u8Eng, 0xBB);
822 break;
823 case E_DRVTSO_PKTMODE_192:
824 HAL_TSO_PktChkSize_Set(u8Eng, 0xBF);
825 HAL_TSO_Filein_PktChkSize_Set(u8Eng, 0xBF);
826 break;
827 case E_DRVTSO_PKTMODE_204:
828 HAL_TSO_PktChkSize_Set(u8Eng, 0xCB);
829 HAL_TSO_Filein_PktChkSize_Set(u8Eng, 0xCB);
830 break;
831 default:
832 break;
833 }
834
835 HAL_TSO_RW_ValidBlock_Count(u8Eng, TRUE, &u16ValidCount);
836 HAL_TSO_RW_InvalidBlock_Count(u8Eng, TRUE, &u16InValidCount);
837 HAL_TSO_RW_OutputPKTSize(u8Eng, TRUE, &u16OutPktSize);
838
839 _TSO_RETURN(DRVTSO_OK);
840
841 }
842
843 //-------------------------------------------------------------------------------------------------
844 /// Set File-in Read Size
845 /// @param u8Eng \b IN: TSO engine ID
846 /// @param u32StreamSize \b IN: File-in Read Size.
847 /// @return TSO_Result
848 // @note u32StreamSize must be larger than 16
849 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_SetSize(MS_U8 u8Eng,MS_U32 u32StreamSize)850 TSO_Result MDrv_TSO_Filein_SetSize(MS_U8 u8Eng, MS_U32 u32StreamSize)
851 {
852 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
853
854 if(u32StreamSize <= 16) //HW limitation
855 return DRVTSO_FAIL;
856
857 _TSO_ENTRY();
858 HAL_TSO_Set_Filein_ReadLen(u8Eng, u32StreamSize);
859 _TSO_RETURN(DRVTSO_OK);
860 }
861
862 //-------------------------------------------------------------------------------------------------
863 /// Set packet size
864 /// @param u8Eng \b IN: TSO engine ID
865 /// @param bFileinMode \b IN: If TRUE, means file-in mode setting, otherwise means live mode setting
866 /// @param u16InPktSize \b IN: Input packet size (192, 204, 188)
867 /// @param u16OutPktSize \b IN: Output packet size (192, 204, 188)
868 /// @return TSO_Result
869 /// @note
870 //-------------------------------------------------------------------------------------------------
MDrv_TSO_SetPacketSize(MS_U8 u8Eng,MS_BOOL bFileinMode,MS_U16 u16InPktSize,MS_U16 u16OutPktSize)871 TSO_Result MDrv_TSO_SetPacketSize(MS_U8 u8Eng, MS_BOOL bFileinMode, MS_U16 u16InPktSize, MS_U16 u16OutPktSize)
872 {
873 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
874
875 _TSO_ENTRY();
876
877 if(bFileinMode)
878 HAL_TSO_Filein_PktChkSize_Set(u8Eng, u16InPktSize-1);
879 else
880 HAL_TSO_PktChkSize_Set(u8Eng, u16InPktSize-1);
881
882 HAL_TSO_Output_PktChkSize_Set(u8Eng, u16OutPktSize-1);
883
884 _TSO_RETURN(DRVTSO_OK);
885 }
886
887 //-------------------------------------------------------------------------------------------------
888 /// Enable/Disable File-in 192 Mode
889 /// @param u8Eng \b IN: TSO engine ID
890 /// @param bEnable \b IN: Enable Flag
891 /// @return TSO_Result
892 /// @note
893 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_192Mode_En(MS_U8 u8Eng,MS_BOOL bEnable)894 TSO_Result MDrv_TSO_Filein_192Mode_En(MS_U8 u8Eng, MS_BOOL bEnable)
895 {
896 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
897
898 _TSO_ENTRY();
899 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_PKT192_ENABLE, bEnable);
900 _TSO_RETURN(DRVTSO_OK);
901 }
902
903 //-------------------------------------------------------------------------------------------------
904 /// Enable/Disable File-in 192 Block Scheme
905 /// @param u8Eng \b IN: TSO engine ID
906 /// @param bEnable \b IN: Enable Flag
907 /// @return TSO_Result
908 /// @note
909 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_192BlockScheme_En(MS_U8 u8Eng,MS_BOOL bEnable)910 TSO_Result MDrv_TSO_Filein_192BlockScheme_En(MS_U8 u8Eng, MS_BOOL bEnable)
911 {
912 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
913
914 _TSO_ENTRY();
915 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_PKT192_BLOCK_DISABLE, (!bEnable));
916 _TSO_RETURN(DRVTSO_OK);
917 }
918
919 //-------------------------------------------------------------------------------------------------
920 /// Enable/Disable Skip TEL packet
921 /// @param u8Eng \b IN: TSO engine ID
922 /// @param bEnable \b IN: Enable Flag
923 /// @return TSO_Result
924 /// @note
925 //-------------------------------------------------------------------------------------------------
MDrv_TSO_TEI_SkipPkt(MS_U8 u8Eng,MS_BOOL bEnable)926 TSO_Result MDrv_TSO_TEI_SkipPkt(MS_U8 u8Eng, MS_BOOL bEnable)
927 {
928 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
929
930 _TSO_ENTRY();
931 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_TEI_SKIP_PKT, bEnable);
932 _TSO_RETURN(DRVTSO_OK);
933 }
934
935 //-------------------------------------------------------------------------------------------------
936 /// Clear PID filter byte counter
937 /// @param u8Eng \b IN: TSO engine ID
938 /// @return TSO_Result
939 /// @note
940 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Clr_Pidflt_ByteCnt(MS_U8 u8Eng)941 TSO_Result MDrv_TSO_Clr_Pidflt_ByteCnt(MS_U8 u8Eng)
942 {
943 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
944
945 _TSO_ENTRY();
946 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_CLEAR_PIDFLT_BYTE_CNT, TRUE);
947 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_CLEAR_PIDFLT_BYTE_CNT, FALSE);
948 _TSO_RETURN(DRVTSO_OK);
949 }
950
951 //-------------------------------------------------------------------------------------------------
952 /// Get TSO Hardware capability
953 /// @param eCap \b IN: Capability item to get
954 /// @param pOutput \b IN: Pointer to store getting result
955 /// @return TSO_Result
956 /// @note
957 //-------------------------------------------------------------------------------------------------
MDrv_TSO_GetCap(DrvTSO_Cap eCap,void * pOutput)958 TSO_Result MDrv_TSO_GetCap(DrvTSO_Cap eCap, void* pOutput)
959 {
960 *((MS_U32*)pOutput) = 0;
961
962 switch (eCap)
963 {
964 case E_DRVTSO_CAP_FILTER_NUM:
965 *((MS_U32*)pOutput) = TSO_PIDFLT_NUM_ALL;
966 break;
967 case E_DRVTSO_CAP_RESOURCE_SIZE:
968 *((MS_U32*)pOutput) = sizeof(TSO_RESOURCE_PRIVATE);
969 break;
970 case E_DRVTSO_CAP_ENGINE_NUM:
971 *((MS_U32*)pOutput) = TSO_ENGINE_NUM;
972 break;
973 case E_DRVTSO_CAP_ENGINE_TSIF_NUM:
974 *((MS_U32*)pOutput) = TSO_TSIF_NUM;
975 break;
976 default:
977 return DRVTSO_INVALID_PARAM;
978 }
979
980 return DRVTSO_OK;
981 }
982
983 //-------------------------------------------------------------------------------------------------
984 /// Get Command queue state
985 /// @param u8Eng \b IN: TSO engine ID
986 /// @param peFileinState \b OUT: Pointer of Filein state to return
987 /// @return MMFI_Result
988 /// @note
989 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_GetState(MS_U8 u8Eng,DrvTSO_FileinState * peFileinState)990 TSO_Result MDrv_TSO_Filein_GetState(MS_U8 u8Eng, DrvTSO_FileinState *peFileinState)
991 {
992 MS_U16 u16state = 0xFF, u16cmdcnt = 0;
993
994 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
995
996 _TSO_ENTRY();
997
998 u16state = HAL_TSO_Get_Filein_Ctrl(u8Eng);
999 u16cmdcnt = HAL_TSO_CmdQ_FIFO_Get_WRCnt(u8Eng);
1000
1001 if((u16state & TSO_FILEIN_RSTART) || u16cmdcnt)
1002 *peFileinState = E_DRVTSO_STATE_BUSY;
1003 else
1004 *peFileinState = E_DRVTSO_STATE_IDLE;
1005 _TSO_RETURN(DRVTSO_OK);
1006 }
1007
1008 //-------------------------------------------------------------------------------------------------
1009 /// Get Command queue interrupt state
1010 /// @param u8Eng \b IN: TSO engine ID
1011 /// @param pStatus \b OUT: Pointer of Filein status to return
1012 /// @return TSO_Result
1013 /// @note
1014 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_ChkStatus(MS_U8 u8Eng,DrvTSO_Status * pStatus)1015 TSO_Result MDrv_TSO_Filein_ChkStatus(MS_U8 u8Eng, DrvTSO_Status* pStatus)
1016 {
1017 MS_U16 u32temp = 0;
1018
1019 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1020
1021 u32temp = HAL_TSO_HWInt_Status(u8Eng);
1022
1023 *pStatus = E_DRVTSO_STATUS_UNKNOWN;
1024 if(u32temp & TSO_INT_SRC_DMA_DOME)
1025 *pStatus |= E_DRVTSO_STATUS_FILEINDONE;
1026 if(u32temp & TSO_INT_SRC_PKT_ERR_FLAG)
1027 *pStatus |= E_DRVTSO_STATUS_PKTERR;
1028 return DRVTSO_OK;
1029 }
1030
1031 //-------------------------------------------------------------------------------------------------
1032 /// Clear Command queue interrupt state
1033 /// @param u8Eng \b IN: TSO engine ID
1034 /// @param u16int \b OUT: Interrupt bit to clear
1035 /// @return MMFI_Result
1036 /// @note
1037 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_ClearHWInt(MS_U8 u8Eng,MS_U16 u16int)1038 TSO_Result MDrv_TSO_Filein_ClearHWInt(MS_U8 u8Eng, MS_U16 u16int)
1039 {
1040 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1041
1042 _TSO_ENTRY();
1043 HAL_TSO_HWInt_Clear(u8Eng, u16int);
1044 _TSO_RETURN(DRVTSO_OK);
1045 }
1046
1047 //-------------------------------------------------------------------------------------------------
1048 /// Control Filein to Start
1049 /// @param u8Eng \b IN: TSO engine ID
1050 /// @return TSO_Result
1051 /// @note
1052 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_Start(MS_U8 u8Eng)1053 TSO_Result MDrv_TSO_Filein_Start(MS_U8 u8Eng)
1054 {
1055 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1056
1057 _TSO_ENTRY();
1058 //HAL_TSO_FileinTimer_Enable(u8Eng, FALSE);
1059 //valid cfg parameters
1060 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_PKT_WAVEFORM_PARAM_LD, TRUE);
1061 HAL_TSO_Cfg1_Enable(u8Eng, TSO_CFG1_PKT_WAVEFORM_PARAM_LD, FALSE);
1062
1063 HAL_TSO_Set_Filein_Ctrl(u8Eng, TSO_FILEIN_RSTART);
1064 _TSO_RETURN(DRVTSO_OK);
1065 }
1066
1067 //-------------------------------------------------------------------------------------------------
1068 /// Control Filein to Stop
1069 /// @param u8Eng \b IN: TSO engine ID
1070 /// @return TSO_Result
1071 /// @note
1072 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_Stop(MS_U8 u8Eng)1073 TSO_Result MDrv_TSO_Filein_Stop(MS_U8 u8Eng)
1074 {
1075 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1076
1077 _TSO_ENTRY();
1078
1079 HAL_TSO_Recover_TSOutMode(u8Eng);
1080 HAL_TSO_Cfg4_Enable(u8Eng, TSO_CFG4_TS_OUT_EN, FALSE);
1081
1082 _TSO_RETURN(DRVTSO_OK);
1083 }
1084
1085
1086 //-------------------------------------------------------------------------------------------------
1087 /// Control Filein to Abort
1088 /// @param u8Eng \b IN: TSO engine ID
1089 /// @return TSO_Result
1090 /// @note
1091 //-------------------------------------------------------------------------------------------------
MDrv_TSO_Filein_Abort(MS_U8 u8Eng)1092 TSO_Result MDrv_TSO_Filein_Abort(MS_U8 u8Eng)
1093 {
1094 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1095
1096 _TSO_ENTRY();
1097 HAL_TSO_Set_Filein_Ctrl(u8Eng, TSO_FILEIN_ABORT);
1098 _TSO_RETURN(DRVTSO_OK);
1099 }
1100
MDrv_TSO_ResetAll(MS_U8 u8Eng)1101 TSO_Result MDrv_TSO_ResetAll(MS_U8 u8Eng)
1102 {
1103 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1104
1105 _TSO_ENTRY();
1106 HAL_TSO_Reset_All(u8Eng);
1107 _TSO_RETURN(DRVTSO_OK);
1108 }
1109
MDrv_TSO_SelPad(MS_U8 u8Eng,DrvTSO_If_Set * pIfSet)1110 TSO_Result MDrv_TSO_SelPad(MS_U8 u8Eng, DrvTSO_If_Set* pIfSet)
1111 {
1112 #ifndef TSO_HW_BOX_SERIES
1113 MS_U16 u16Pad = 0;
1114 MS_U16 u16clk = 0, u16Cfg = 0;
1115
1116 switch(pIfSet->ePad)
1117 {
1118 case E_DRVTSO_PAD_EXT_INPUT0:
1119 u16Pad = HAL_TSOIN_MUX_TS0;
1120 u16clk = HAL_TSO_CLKIN_TS0;
1121 break;
1122 case E_DRVTSO_PAD_EXT_INPUT1:
1123 u16Pad = HAL_TSOIN_MUX_TS1;
1124 u16clk = HAL_TSO_CLKIN_TS1;
1125 break;
1126 case E_DRVTSO_PAD_EXT_INPUT2:
1127 u16Pad = HAL_TSOIN_MUX_TS2;
1128 u16clk = HAL_TSO_CLKIN_TS2;
1129 break;
1130 case E_DRVTSO_PAD_DEMOD:
1131 u16Pad = HAL_TSOIN_MUX_TSDEMOD0;
1132 u16clk = HAL_TSO_CLKIN_TSDEMOD0;
1133 break;
1134 case E_DRVTSO_MEM:
1135 u16Pad = HAL_TSOIN_MUX_MEM;
1136 break;
1137 default:
1138 return DRVTSO_INVALID_PARAM;
1139 }
1140
1141 _TSO_ENTRY();
1142
1143 HAL_TSO_SelPad(u8Eng, u16Pad, pIfSet->bParallel);
1144 HAL_TSO_Set_InClk(u8Eng, u16clk, FALSE, FALSE);
1145
1146 u16Cfg = TSO_CFG0_EXTERNAL_SYNC_SEL | TSO_CFG0_SOURCE_LIVE;
1147 if(pIfSet->bParallel)
1148 {
1149 u16Cfg |= TSO_CFG0_PARALLEL_SEL;
1150 }
1151 HAL_TSO_Cfg0_Enable(u8Eng, u16Cfg, TRUE);
1152 #endif
1153 _TSO_RETURN(DRVTSO_OK);
1154
1155 }
1156
1157 //-------------------------------------------------------------------------------------------------
1158 /// Set TSO Output enable
1159 /// @param u8Eng \b IN: TSO engine ID
1160 /// @param bEnable \b IN: TRUE is enabled; FALSE is disabled
1161 /// @return TSO_Result
1162 /// @note
1163 //-------------------------------------------------------------------------------------------------
MDrv_TSO_OutputEnable(MS_U8 u8Eng,MS_BOOL bEnable)1164 TSO_Result MDrv_TSO_OutputEnable(MS_U8 u8Eng, MS_BOOL bEnable)
1165 {
1166 TSO_DBGERR(ULOGE("TSO", "[%d]%s\n", __LINE__, __FUNCTION__));
1167
1168 _TSO_ENTRY();
1169 HAL_TSO_Cfg4_Enable(u8Eng, TSO_CFG4_TS_OUT_EN, bEnable);
1170 _TSO_RETURN(DRVTSO_OK);
1171 }
1172
1173
1174