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-2009 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 // Include Files
98 //-------------------------------------------------------------------------------------------------
99 // Common Definition
100 #ifdef MSOS_TYPE_LINUX_KERNEL
101 #include <linux/string.h>
102 #else
103 #include <string.h>
104 #endif
105
106 #include "MsCommon.h"
107 #include "drvMVD_EX.h"
108 #include "drvBDMA.h"
109
110 // Internal Definition
111 #include "regMVD_EX.h"
112 #include "halMVD_EX.h"
113 #include "halVPU_EX.h"
114 #include "osalMVD_EX.h"
115 #include "mvd4_interface.h" //firmware header
116 #include "asmCPU.h"
117 #include "controller.h"
118 #include "MVD_EX_Common.h"
119 #include "halCHIP.h"
120 //#include "drvCMAPool.h"
121 #include "drvCMAPool_v2.h"
122 #if defined(MSOS_TYPE_LINUX)
123 #include "msos/linux/ion_uapi.h"
124 #include "msos/linux/mdrv_cma_pool_st.h"
125 #endif
126
127 #if (!defined(MSOS_TYPE_NUTTX) && !defined(MSOS_TYPE_OPTEE)) || defined(SUPPORT_X_MODEL_FEATURE)
128
129
130 #ifdef MSOS_TYPE_LINUX_KERNEL
131 #define VPRINTF printk
132 #else
133 #ifndef ANDROID
134 #define VPRINTF printf
135 #else
136 #include <sys/mman.h>
137 #include <cutils/ashmem.h>
138 #include <cutils/log.h>
139 #define VPRINTF ALOGD
140 #endif
141 #endif
142 //-------------------------------------------------------------------------------------------------
143 // Driver Compiler Options
144 //-------------------------------------------------------------------------------------------------
145 #define SLQ_NEW_PUSH 1
146 #define VIRTUAL_CMD_TIMEOUT 50
147 #ifdef VDEC3
148 #define v3_temp 1
149 #define v3_thinplayer 0
150 #else
151 #define v3_temp 0
152 #define v3_thinplayer 0
153 #endif
154
155 //-------------------------------------------------------------------------------------------------
156 // Local Defines
157 //-------------------------------------------------------------------------------------------------
158 #define MIU1_BASEADDR pMVDHalContext->stMiuCfg.u32Miu1BaseAddr
159 #define _PA2Offset(x) (((x)>=MIU1_BASEADDR)?(x-MIU1_BASEADDR):(x))
160
161 #ifdef MSOS_TYPE_LINUX_KERNEL
162 #include <asm/div64.h>
163 #define _90K_TO_MS_U64(x) ((x!=MVD_U64_MAX)?(do_div(x,90)):(x)) //90k counter ==> ms
164 #else
165 #define _90K_TO_MS_U64(x) ((x!=MVD_U64_MAX)?(x/=90):(x)) //90k counter ==> ms
166 #endif
167
168 #ifndef MS_ASSERT
169 #ifdef MS_DEBUG
170 #define MS_ASSERT(expr) do { \
171 if(!(expr)) \
172 printf("MVD assert fail %s %d!\n", __FILE__, __LINE__); \
173 } while(0)
174 #else
175 #define MS_ASSERT(expr)
176 #endif
177 #endif
178
179 #ifndef UNUSED
180 #define UNUSED(x) (void)(x)
181 #endif
182 //constant
183 #define MVD_PollingTimes 0x40000UL
184
185 #define MVD_DEBUGVERBAL(x) if (_u8HalDbgLevel>3) { (x); }
186 #define MVD_DEBUG_FWCMD(x) if (_u8HalDbgLevel>2) { (x); }
187 #define MVD_DEBUGINFO(x) if (_u8HalDbgLevel>1) { (x); }
188 #define MVD_DEBUGERROR(x) if (_u8HalDbgLevel>0) { (x); }
189 #define MVD_ERROR(x) x
190
191 #define RIU ((unsigned short volatile *) (u32RiuBaseAdd))
192 #define RIU8 ((unsigned char volatile *) (u32RiuBaseAdd))
193
194 #define MVDCPU_ON_MIU1 ((HAL_MVD_RegReadByte(MIU0_SEL0_H) & BIT0) == BIT0)
195 //#define MVDHW_ON_MIU1 ((HAL_MVD_RegReadByte(MIU0_SEL2_L) & BIT4) == BIT4)
196 #define MVDHW_ON_MIU0 ((HAL_MVD_RegReadByte(MIU0_SEL2_L) & BIT4) == 0)
197 #define MVDHW_ON_MIU1 ((HAL_MVD_RegReadByte(MIU0_SEL2_L) & BIT4) == BIT4)
198
199 // MVD5
200 #define SLQ_TBL_ENTRY_LEN 0x7FFFFFFF //31-bit
201
202 #define MVD_WIDTH_ALIGN_BYTE 16
203 #define MVD_WIDTH_ALIGN_MASK (MVD_WIDTH_ALIGN_BYTE - 1)
204 #define MVD_WIDTH_ALIGN_BITS 4
205
206 #define MVD_FBNUM_DEFAULT 4
207 #define MVD_FBNUM_MAX 5
208 #define MVD_FBNUM_MIN MVD_FBNUM_DEFAULT
209
210 #define MVD_DHD_FBSIZE 0x5FA000 //Framebuffer size minimum for Dual HD: (1920*2)*1088*1.5
211 #define MVD_HD_FBSIZE 0x2FD000 //Framebuffer size minimum for High Definition
212 #define MVD4_VC1_FBSIZE_HDMIN 0xEF1000 //5 * 1920 * 1088 * 1.5 = 14.95MB
213 #define MVD4_VC1_FBSIZE_HDMIN1 0xBF4000 //4 * 1920 * 1088 * 1.5 = 11.96MB
214 #define MVD4_VC1_FBSIZE_SDMIN 0x2F7600 //5 * 720 * 576 * 1.5 = 2.97MB
215 #define MVD4_MPEG_FBSIZE_HDMIN 0xBF4000 //4 * 1920 * 1088 * 1.5 = 11.96MB
216 #define MVD4_MPEG_FBSIZE_SDMIN 0x25F800 //4 * 720 * 576 * 1.5 = 2.38MB
217
218 #define _IS_VC1(x) ((x==E_MVD_CODEC_VC1_ADV) || (x==E_MVD_CODEC_VC1_MAIN))
219
220 #define SLQ_ENTRY_LEN 8 //8-byte per entry
221
222 #define MVD_U32_MAX 0xffffffffUL
223 #define MVD_U64_MAX 0xffffffffffffffffULL
224 #define MVD_GENERAL_MAX ((size_t)(-1))
225
226 #define MAX_ADD_28BIT 0x0fffffffUL
227
228 #define SLQ_ADDR_LEN SLQ_TBL_ENTRY_LEN //Slq address length is the same as SlqTbl
229
230 //Initial value for PTS table
231 #define _INIT_ADDR MVD_U32_MAX
232 #define _INIT_LEN 0
233 #define _INIT_TIMESTAMP MVD_U32_MAX
234 #define _INIT_ID MVD_U32_MAX
235
236 #define _MS_TO_90K(x) (x*90) //ms ==> 90k counter
237 #define _90K_TO_MS(x) ((x!=MVD_U32_MAX)?(x/90):(x)) //90k counter ==> ms
238
239
240 #define MVD_DBG_STS(x) {}
241 #define _SLQTBL_DUMP_PTS FALSE//TRUE
242 #define _SLQTBL_DUMP_PUSHQ FALSE//TRUE
243 #define _SLQTBL_DUMP_PKT FALSE//TRUE
244 #define MVD_TURBO_INIT FALSE//TRUE
245
246 #define SLQ_ENTRY_MAX 1024
247 #define SLQ_ENTRY_LEN 8 //8-byte per entry
248 #define SLQ_TBL_SIZE (SLQ_ENTRY_MAX * SLQ_ENTRY_LEN)
249 #define ES_TBL_SIZE (SLQ_ENTRY_MAX * 8) //8-byte per entry
250
251 #define MVD_FW_SLQTBL_PTS_LEN 32
252
253 #define SLQ_TBL_SAFERANGE (40*SLQ_ENTRY_LEN)
254 //this should be smaller than FW's lookup range (current it's 16 entries)
255
256 #define SLQTBL_CHECKVACANCY_WATERLEVEL (44*SLQ_ENTRY_LEN)
257
258
259 #define DIVX_PATTERN 0x63643030
260 #define FLV_PATTERN 0xffff0000
261 #define MPEG_PATTERN_0 0xC6010000 //this SC just for mpeg2/4
262 #if SLQ_NEW_PUSH
263 #define SLQ_PIC_START_FLAG 0x40000000
264 #define VC1_PATTERN 0x0D010000
265 #define RCV_PATTERN 0xFF00A55A
266 #endif
267 #define VC1_PATTERN_0 0xff010000
268 #define VC1_PATTERN_1 0x0000ffff
269 #define VC1_PATTERN_2 0xffffff01
270 #define VC1_PATTERN_3 0x0000ffee
271
272 #define RCV_PATTERN_0 0x00000000
273 #define RCV_PATTERN_1 0xffffffff
274 #define RCV_PATTERN_2 0x00000000
275 #define RCV_PATTERN_3 0xeeeeeeee
276
277 #define DUMMY_PATTERN 0xBE010000
278 #define DUMMY_SIZE 0x2000 //8K
279
280 #define END_PATTERN_0 0xFF010000
281 #define END_PATTERN_1 0xDDCCBBAA
282 #define END_PATTERN_2 0xBBAAFFEE
283 #define END_PATTERN_3 0xFFEEDDCC
284 #define END_PATTERN_SIZE 256
285
286 #define SKIP_PATTERN_0 0xc5010000
287 #define SKIP_PATTERN_1 0x270608ab
288 #define SKIP_PATTERN_SIZE 8
289
290 #define CMD_TIMEOUT_MS 500
291 #define SKIP_DATA_TIMEOUT_MS 15
292
293 //Length of internal buffers
294 #define MVD_FW_IAP_BUF_LEN (0x4000UL) // 16k
295 #define MVD_FW_DP_BUF_LEN (0x80000UL) //512k
296 #define MVD_FW_MV_BUF_LEN (0x48000UL) //288K
297 //Alignment of HW buffers start address
298 #define MVD_FW_IAP_BUF_ALIGN (0x4000UL) // 16k
299 #define MVD_FW_DP_BUF_ALIGN (0x8000UL) // 32k
300 #define MVD_FW_MV_BUF_ALIGN (0x8000UL) // 32k
301
302 //Three HW buffers are allocated after framebuffer, so we need to
303 //consider these buffers when checking the available framebuffer size/number.
304 #define MVD_HW_BUF_TOTAL_LEN (MVD_FW_IAP_BUF_LEN + MVD_FW_DP_BUF_LEN + MVD_FW_MV_BUF_LEN) //u32HWBuffTotalSize
305
306 #define MVD_FW_CODE_LEN (OFFSET_BASE)//refer to the define in mvd4_interface.h
307 #define MVD_FW_CODE_LEN_V00 (0x70000UL) //length for old layout
308 #define MVD_FW_MPOOL_START_OFFSET (0x90000UL) //576K
309 #define MVD_FW_TASK_OFFSET (0x100000UL) //1M
310
311 #define MVD3_FW_VOL_INFO_BUF_LEN (0x1000UL) // 4K
312 #define MVD3_FW_FRAME_INFO_BUF_LEN (0x1000UL) // 4K
313 #define MVD3_FW_DIVX_INFO_BUF_LEN (0x1000UL) // 4K
314 #define MVD3_FW_USER_DATA_BUF_LEN (0x4000UL) // 16K
315 #define MVD3_FW_USER_DATA_BUF_BACKUP_LEN MVD3_FW_USER_DATA_BUF_LEN // 16K
316 #define MVD3_FW_SLQ_TAB_TMPBUF_LEN (0x200UL)
317 #define MVD_FW_SLQTBL_PTS_BUF_LEN (SLQ_ENTRY_MAX*MVD_FW_SLQTBL_PTS_LEN)
318 #define MVD_FW_DYN_SCALE_BUF_LEN (0x2000UL) // 8K
319 #define MVD_FW_SCALER_INFO_BUF_LEN (0x100UL) // 256bytes reserved
320 #define MVD_FW_DECFRM_INFO_BUF_LEN (0x100UL) // 256bytes reserved
321 #define MVD_FW_VBBU_TABLE_LEN (0x2000UL) // 8K
322
323 #define MVD_FW_USER_DATA_HDR_LEN (6)
324 #define MVD_FW_USER_DATA_PKT_LEN (256)
325 #define MVD_FW_USER_DATA_EXT_HDR_LEN (16)
326 #define FW_BUFF_ALIGN (0x1000) //4k align
327
328 #define SLQ_ENTRY_MAX 1024
329 #define MVD_FW_SLQTBL_PTS_LEN 32
330 #define MVD_NULLPKT_PTS MVD_U32_MAX
331
332 #define MVD_HW_MAX_PIXEL (1920*1088*61000ULL) // FHD@60p
333
334 //Get the start address, and the next start address.
335 #define GET_FW_BUFFADD(cur, size, start) \
336 do { \
337 start = cur; \
338 cur += size; \
339 } while(0)
340
341 //Get the aligned start address, and the next start address.
342 #define GET_FW_BUFFADD_ALIGN(cur, align, size, alignStart) \
343 do { \
344 cur = (MemAlign(cur, align)); \
345 GET_FW_BUFFADD(cur, size, alignStart); \
346 } while(0)
347
348 //Init command arguments
349 #define SETUP_CMDARG(x) \
350 do { \
351 x.Arg0 = 0; \
352 x.Arg1 = 0; \
353 x.Arg2 = 0; \
354 x.Arg3 = 0; \
355 x.Arg4 = 0; \
356 x.Arg5 = 0; \
357 } while(0)
358
359 //Set command arguments
360 #define SET_CMDARG(cmd, u32val, u8Num) \
361 do { \
362 cmd.Arg0 = L_WORD(u32val); \
363 cmd.Arg1 = H_WORD(u32val); \
364 cmd.Arg2 = L_DWORD(u32val); \
365 cmd.Arg3 = H_DWORD(u32val); \
366 cmd.Arg4 = 0; \
367 cmd.Arg5 = u8Num; \
368 } while(0)
369
370 #define SET_CMD_RET_FALSE(_cmdVal, _pStcmdArg) \
371 do { \
372 if (HAL_MVD_MVDCommand(_cmdVal, (_pStcmdArg)) == FALSE) \
373 { \
374 MVD_DEBUGERROR(printf("Command: 0x%x fail!!\r\n", _cmdVal)); \
375 return FALSE; \
376 } \
377 } while(0)
378
379 #define SET_CMD_RET_VOID(_cmdVal, _pStcmdArg) \
380 do { \
381 if (HAL_MVD_MVDCommand(_cmdVal, (_pStcmdArg)) == FALSE) \
382 { \
383 MVD_DEBUGERROR(printf("Command: 0x%x fail!!\r\n", _cmdVal)); \
384 return; \
385 } \
386 } while(0)
387
388 #define HAL_MVD_InvalidBuffRetFalse(x) \
389 do { \
390 if ((x)==0) \
391 { \
392 MVD_DEBUGERROR(printf("%s(%d) error: NULL buffer address.\n", __FUNCTION__, __LINE__)); \
393 return FALSE; \
394 } \
395 } while(0)
396
397 #define _MVD_Memset(pDstAddr, u32value, u32Size) \
398 do { \
399 MS_U32 x = 0; \
400 for (x = 0; x < (u32Size/4); x=x+4) \
401 { \
402 HAL_MVD_Memset4Byte(pDstAddr+x,u32value); \
403 } \
404 HAL_MVD_CPU_Sync(); \
405 HAL_MVD_ReadMemory(); \
406 } while (0)
407
408 #define _MVD_MemResetBit(pDstAddr, mask_num) \
409 do{ \
410 *pDstAddr = (*pDstAddr) & (~(0x1<<mask_num)); \
411 }while(0) \
412
413
414 typedef enum
415 {
416 MVD_HKSLQ_GET_READPTR = 0,
417 MVD_HKSLQ_GET_WRITEPTR = 1,
418 MVD_HKSLQ_NONE = 2,
419 } MVD_HKSLQ_CMD;
420
421 #if SLQ_NEW_PUSH
422 typedef struct _MVD_SLQ_STATUS
423 {
424 MS_BOOL bSlqPicStart;
425 MS_BOOL bSlqPicCollect;
426 MS_BOOL bSlqPicWaitNextStart;
427 MS_BOOL bSlqFireRdy;
428 MS_BOOL bSlqCtrlBit;
429 MS_BOOL bSlqEnLastFrameShow;
430 MS_VIRT u32SlqPatternAddr;
431 MS_U32 u32SlqPushLength;
432 MS_VIRT u32VaildWptrAddr;
433 } MVD_SLQ_STATUS;
434 #endif
435
436 typedef struct _MVD_SLQ_TBL_ST
437 {
438 MS_VIRT u32StAdd;
439 MS_VIRT u32EndAdd;
440 MS_U32 u32EntryCntMax;
441
442 MS_VIRT u32RdPtr;
443 MS_VIRT u32WrPtr;
444 MS_VIRT u32Empty;
445 MS_VIRT* pu32LastEntry;
446 } MVD_SLQ_TBL_ST;
447
448 typedef struct _MVD_ALIVEInfo
449 {
450 MS_U32 u32decode_count;
451 MS_U32 u32searchbuf_count;
452 MS_U32 u32searchcode_count;
453 MS_U32 u32prebuf_count;
454 MS_U32 u32vfifobuf_count;
455 MS_U32 u32searchheader_count;
456 MS_U32 u32flashpattern_count;
457 MS_U32 u32IdleCount;
458 } MVD_ALIVEInfo;
459
460
461 typedef struct _MVD_SLQ_ES_ST
462 {
463 MS_VIRT u32StAdd;
464 MS_VIRT u32EndAdd;
465
466 MS_VIRT u32RdPtr;
467 MS_VIRT u32WrPtr;
468 } MVD_SLQ_ES_ST;
469
470 typedef struct _MVD_FWBuff
471 {
472 MS_VIRT pu8MVDGetVolBufStart;
473 MS_VIRT u32VolAdd;
474 MS_VIRT pu8MVDGetFrameInfoBufStart;
475 MS_VIRT pu8MVDSetHeaderBufStart;
476 MS_VIRT u32UserDataBuf;
477 MS_VIRT u32MVDFWSLQTABTmpbufAdr;
478 MS_VIRT u32MVDFWPtsTblAddr;
479 MS_VIRT u32DynScalingAdd;
480 MS_VIRT u32ScalerInfoAdd;
481 MS_VIRT u32DecFrmInfoAdd;
482 MS_VIRT u32VBBUTableAdd;
483 } MVD_FWBuff;
484
485 typedef enum _FW_BUFF_TYPE
486 {
487 FW_BUFF_VOLINFO,
488 FW_BUFF_FRMINFO,
489 FW_BUFF_HDR,
490 FW_BUFF_USRDATA,
491 FW_BUFF_SLQTBL,
492 FW_BUFF_FWSLQTAB,
493 FW_BUFF_PTSTBL,
494 FW_BUFF_DS,
495 FW_BUFF_XCINFO,
496 FW_BUFF_DECFRMINFO,
497 } FW_BUFF_TYPE;
498
499 typedef struct _MVD_SLQTBLInfo
500 {
501 MS_U32 u32LastPts; ///< record the last PTS to handle the repeat case
502 MS_U32 u32DummyPktCnt; ///< accumulated dummy packet counter
503 MS_U32 u32SlqByteCnt; ///< accumulated byte counter
504 MS_VIRT u32ESBuffEnd; ///< miu offset of ES buffer end, used for report TS read/write ptr.
505 MS_VIRT u32FileEndPtr; ///< write ptr of file-end
506 MS_VIRT u32PreEsRd; ///< previous ES read ptr
507 MS_VIRT u32PreEsWr; ///< previous ES write ptr
508 MS_BOOL bRdyToFireCmd; ///< TRUE after FW is ready to update write pointer
509 MS_BOOL bSlqTblHasValidData; ///< TRUE if the write ptr is not updated
510 MS_BOOL bEnSlqTblHkCtrl;
511 BDMA_CpyType bdmaCpyType;
512 MVD_SLQ_STATUS* pSlqStatus;
513 MVD_SLQ_TBL_ST* pDrvSlqTbl;
514 MVD_SLQ_ES_ST* pDrvEsTbl;
515 MVD_SLQ_ES_ST* pDrvDivxTbl;
516 } MVD_SLQTBLInfo;
517
518 //Only keep one record of MIU setting since there should be only one,
519 //even for multiple decoders.
520 typedef struct _MVDMiuCfg
521 {
522 MS_PHY u32Miu1BaseAddr;
523 MS_PHY u32Miu2BaseAddr;
524 MS_PHY u32Miu3BaseAddr;
525 MS_U8 u8FWMiuSel;
526 MS_U8 u8HWMiuSel;
527 } MVDMiuCfg;
528
529 typedef struct
530 {
531 MS_U64 u64PTS;
532 MS_U32 u32POC;
533 MS_U8 u8FrameType;
534 } MVD_PVR_Seamless_Info;
535
536 typedef enum
537 {
538 E_MVD_DEC_0 = 0,
539 E_MVD_DEC_1,
540 E_MVD_DEC_MAX
541 } MVD_DecNum;
542 #ifdef VDEC3
543 #define MAX_DEC_NUM 16
544 #else
545 #define MAX_DEC_NUM E_MVD_DEC_MAX
546 #endif
547
548 //-------------------------------------------------------------------------------------------------
549 // Local Structures
550 //-------------------------------------------------------------------------------------------------
551
552
553 //-------------------------------------------------------------------------------------------------
554 // Global Variables
555 //-------------------------------------------------------------------------------------------------
556 static MS_VIRT u32RiuBaseAdd = 0;
557 MS_U8 _u8HalDbgLevel = 0;
558 #ifdef VDEC3//#ifdef VDEC3
559 static MS_U32 u32SharememoryBase[MAX_DEC_NUM] ={MVD_U32_MAX,MVD_U32_MAX,MVD_U32_MAX,MVD_U32_MAX};
560 #else
561 static MS_U32 u32SharememoryBase[MAX_DEC_NUM] ={MVD_U32_MAX,MVD_U32_MAX};
562 #endif
563 static MS_U8 u8SHMMiuSel=0;
564 #if 0
565 static MVD_MEMCfg stMemCfg[MAX_DEC_NUM];
566 static MVD_CtrlCfg stCtrlCfg[MAX_DEC_NUM];
567 static MVD_FWCfg stFwCfg[MAX_DEC_NUM];
568
569 // For SLQ table link
570 static MVD_SLQTBLInfo stSlqTblInfo[MAX_DEC_NUM];
571 static MVD_SLQ_STATUS _SlqStatus[MAX_DEC_NUM]; //for SLQ_NEW_PUSH
572 static MVD_SLQ_TBL_ST _drvSlqTbl[MAX_DEC_NUM];
573 static MVD_SLQ_ES_ST _drvEsTbl[MAX_DEC_NUM]; //maintain to report ES read/write ptr
574 static MVD_SLQ_ES_ST _drvDivxTbl[MAX_DEC_NUM]; //header for divx311
575 static FW_DIVX_INFO gdivxInfo[MAX_DEC_NUM];
576
577 MS_BOOL bSlqTblHKCtrl = FALSE; //read/write pointer can be accessed by HK directly
578 static MS_BOOL bStopped = TRUE;
579
580 static HAL_MVD_Stream _stMVDStream[MAX_DEC_NUM] = {
581 {E_HAL_MVD_MAIN_STREAM0, FALSE},
582 {E_HAL_MVD_SUB_STREAM0, FALSE},
583 //{E_HAL_MVD_SUB_STREAM1, FALSE},
584 };
585 static MVD_FWBuff stFWBuff[MAX_DEC_NUM];
586 #endif
587
588 #define FRM_RATE_CODE_NUM 9
589
590 typedef struct
591 {
592 MVD_MEMCfg stMemCfg[MAX_DEC_NUM];
593 MVD_CtrlCfg stCtrlCfg[MAX_DEC_NUM];
594 MVD_FWCfg stFwCfg[MAX_DEC_NUM];
595
596 // For SLQ table link
597 MVD_SLQTBLInfo stSlqTblInfo[MAX_DEC_NUM];
598 MVD_SLQ_STATUS _SlqStatus[MAX_DEC_NUM]; //for SLQ_NEW_PUSH
599 MVD_SLQ_TBL_ST _drvSlqTbl[MAX_DEC_NUM];
600 MVD_SLQ_ES_ST _drvEsTbl[MAX_DEC_NUM]; //maintain to report ES read/write ptr
601 MVD_SLQ_ES_ST _drvDivxTbl[MAX_DEC_NUM]; //header for divx311
602 FW_DIVX_INFO gdivxInfo[MAX_DEC_NUM];
603
604 MS_BOOL bSlqTblHKCtrl[MAX_DEC_NUM]; //read/write pointer can be accessed by HK directly
605 MS_BOOL bStopped[MAX_DEC_NUM];
606
607 HAL_MVD_Stream _stMVDStream[MAX_DEC_NUM];
608
609 MVD_FWBuff stFWBuff[MAX_DEC_NUM];
610
611 #if _SLQTBL_DUMP_PKT
612 MS_U32 u32SendTimes[MAX_DEC_NUM];//HAL_MVD_SLQTblSendPacket
613 #endif
614
615 MS_U32 u32pqTimes[MAX_DEC_NUM];//HAL_MVD_PushQueue
616 MS_BOOL bSetSkip[MAX_DEC_NUM];//MVD_FlushTSQueue
617
618 MS_U32 u32PreVdCnt[MAX_DEC_NUM];//HAL_MVD_DbgDump
619 MS_U32 u32PreErrCnt[MAX_DEC_NUM];
620 MS_BOOL b1stDump[MAX_DEC_NUM];
621 //pre_set
622 HAL_MVD_Pre_Ctrl gMVDPreCtrl[MAX_DEC_NUM];
623 MS_BOOL bAutoInsertDummyPattern[MAX_DEC_NUM];
624 MVDMiuCfg stMiuCfg;
625 MS_BOOL bDropOnePTS[MAX_DEC_NUM];
626 MVD_ALIVEInfo aliveInfo[MAX_DEC_NUM];
627
628 MS_U32 u32DmxFrameRate[MAX_DEC_NUM];
629 MS_U32 u32DmxFrameRateBase[MAX_DEC_NUM];
630 MS_BOOL bCMAUsed;
631
632 struct CMA_Pool_Init_Param cmaInitParam; // support two MIU
633 struct CMA_Pool_Free_Param cmaFreeParam[MAX_DEC_NUM];
634 MS_BOOL bCMATwoMIU[MAX_DEC_NUM];
635 MS_U32 u32LastAliveTime[MAX_DEC_NUM];
636 MS_BOOL bTrickPlay2xAVSync[MAX_DEC_NUM];
637 } MVD_Hal_CTX;
638
639 //global variables
640 MVD_Hal_CTX* pMVDHalContext = NULL;
641 MVD_Hal_CTX gMVDHalContext;
642 const MS_U16 stFrameRateCode[FRM_RATE_CODE_NUM]=
643 {
644 NULL,23976,24000,25000,29976,30000,50000,59947,60000
645 };
646
647
648 #define GET_VOL_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].pu8MVDGetVolBufStart
649 #define GET_VOL_BUFFADD_NONCACHE(idx) pMVDHalContext->stFWBuff[(idx)].u32VolAdd
650 #define GET_FRMINFO_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].pu8MVDGetFrameInfoBufStart
651 #define GET_HDR_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].pu8MVDSetHeaderBufStart
652 #define GET_USRDATA_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].u32UserDataBuf
653 #define GET_SLQ_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].u32MVDFWSLQTABTmpbufAdr
654 #define GET_PTSTBL_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].u32MVDFWPtsTblAddr
655 #define GET_DS_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].u32DynScalingAdd
656 #define GET_XCINFO_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].u32ScalerInfoAdd
657 #define GET_DECFRMINFO_BUFFADD(idx) pMVDHalContext->stFWBuff[(idx)].u32DecFrmInfoAdd
658 #define GET_VBBUTABLEADD(idx) pMVDHalContext->stFWBuff[(idx)].u32VBBUTableAdd
659
660
661
662 //-------------------------------------------------------------------------------------------------
663 // Local Variables
664 //-------------------------------------------------------------------------------------------------
665
666
667 //-------------------------------------------------------------------------------------------------
668 // Debug Functions
669 //-------------------------------------------------------------------------------------------------
670
671
672 //-------------------------------------------------------------------------------------------------
673 // Local Functions
674 //-------------------------------------------------------------------------------------------------
675
HAL_MVD_Context_Init(void)676 static void HAL_MVD_Context_Init(void)
677 {
678 #ifdef VDEC3
679 MS_U8 i;
680
681 for (i = 0; i < MAX_DEC_NUM; i++)
682 {
683 pMVDHalContext->bStopped[i] = TRUE;
684 pMVDHalContext->b1stDump[i] = TRUE;
685 pMVDHalContext->_stMVDStream[i].eStreamId = E_HAL_MVD_N_STREAM0 + i;
686 }
687 #else
688 pMVDHalContext->bStopped[0] = TRUE;
689 pMVDHalContext->bStopped[1] = TRUE;
690 pMVDHalContext->_stMVDStream[0].eStreamId = E_HAL_MVD_MAIN_STREAM0;
691 pMVDHalContext->_stMVDStream[1].eStreamId = E_HAL_MVD_SUB_STREAM0;
692
693 pMVDHalContext->b1stDump[0] = TRUE;
694 pMVDHalContext->b1stDump[1] = TRUE;
695 #endif
696 }
697
698
699
HAL_MVD_SetIsUsed(MS_U8 u8Idx,MS_BOOL bUsed)700 static void HAL_MVD_SetIsUsed(MS_U8 u8Idx, MS_BOOL bUsed)
701 {
702 pMVDHalContext->_stMVDStream[u8Idx].bUsed = bUsed;
703 }
704
705 //Given the start address & the available size for the FW buffers,
706 //return the address of each buffers.
707 //Now only support u8Size==1, 2, 4
MVD_GetFWBuffData(MS_U8 u8Idx,FW_BUFF_TYPE eBuffType,MS_U16 u16Offset,MS_U8 u8Size)708 static MS_U32 MVD_GetFWBuffData(MS_U8 u8Idx, FW_BUFF_TYPE eBuffType, MS_U16 u16Offset, MS_U8 u8Size)
709 {
710 MS_U32 u32Val = 0;
711 MS_VIRT u32BufStart = NULL;
712 switch (eBuffType)
713 {
714 case FW_BUFF_VOLINFO: u32BufStart = GET_VOL_BUFFADD(u8Idx); break;
715 case FW_BUFF_FRMINFO: u32BufStart = GET_FRMINFO_BUFFADD(u8Idx); break;
716 case FW_BUFF_HDR: u32BufStart = GET_HDR_BUFFADD(u8Idx); break;
717 case FW_BUFF_USRDATA: u32BufStart = GET_USRDATA_BUFFADD(u8Idx); break;
718 case FW_BUFF_FWSLQTAB: u32BufStart = GET_SLQ_BUFFADD(u8Idx); break;
719 case FW_BUFF_PTSTBL: u32BufStart = GET_PTSTBL_BUFFADD(u8Idx); break;
720 case FW_BUFF_DS: u32BufStart = GET_DS_BUFFADD(u8Idx); break;
721 case FW_BUFF_XCINFO: u32BufStart = GET_XCINFO_BUFFADD(u8Idx); break;
722 case FW_BUFF_DECFRMINFO: u32BufStart = GET_DECFRMINFO_BUFFADD(u8Idx); break;
723 default:
724 break;
725 }
726 if (NULL == u32BufStart)
727 {
728 printf("%s err: u8Idx=0x%x, bufType=0x%x, offset=%d, size=%d\n",
729 __FUNCTION__, u8Idx, eBuffType, u16Offset, u8Size);
730 return 0;
731 }
732
733 if (u8Size == sizeof(MS_U8))
734 {
735 u32Val = (MS_U32)HAL_MVD_MemReadByte(u32BufStart+u16Offset);
736 }
737 else if (u8Size == sizeof(MS_U32))
738 {
739 u32Val = HAL_MVD_MemRead4Byte(u32BufStart+u16Offset);
740 }
741 else if (u8Size == sizeof(MS_U16))
742 {
743 u32Val = HAL_MVD_MemRead2Byte(u32BufStart+u16Offset);
744 }
745
746 MVD_DEBUGVERBAL(printf("%s: u32Val=%d for u8Idx=0x%x, bufType=0x%x, offset=%d, size=%d\n",
747 __FUNCTION__, u32Val, u8Idx, eBuffType, u16Offset, u8Size));
748 return u32Val;
749 }
750
751 #ifdef VDEC3
MVD_SetFWBuffData(MS_U8 u8Idx,FW_BUFF_TYPE eBuffType,MS_U16 u16Offset,MS_U8 u8Size,MS_U32 u32Value)752 static void MVD_SetFWBuffData(MS_U8 u8Idx, FW_BUFF_TYPE eBuffType, MS_U16 u16Offset, MS_U8 u8Size, MS_U32 u32Value)
753 {
754 MS_VIRT u32BufStart = NULL;
755
756 switch (eBuffType)
757 {
758 case FW_BUFF_VOLINFO: u32BufStart = GET_VOL_BUFFADD(u8Idx); break;
759 case FW_BUFF_FRMINFO: u32BufStart = GET_FRMINFO_BUFFADD(u8Idx); break;
760 case FW_BUFF_HDR: u32BufStart = GET_HDR_BUFFADD(u8Idx); break;
761 case FW_BUFF_USRDATA: u32BufStart = GET_USRDATA_BUFFADD(u8Idx); break;
762 case FW_BUFF_FWSLQTAB: u32BufStart = GET_SLQ_BUFFADD(u8Idx); break;
763 case FW_BUFF_PTSTBL: u32BufStart = GET_PTSTBL_BUFFADD(u8Idx); break;
764 case FW_BUFF_DS: u32BufStart = GET_DS_BUFFADD(u8Idx); break;
765 case FW_BUFF_XCINFO: u32BufStart = GET_XCINFO_BUFFADD(u8Idx); break;
766 case FW_BUFF_DECFRMINFO: u32BufStart = GET_DECFRMINFO_BUFFADD(u8Idx); break;
767 default:
768 break;
769 }
770
771 if (NULL == u32BufStart)
772 {
773 printf("%s err: u8Idx=0x%x, bufType=0x%x, offset=%d, size=%d, value=%d\n",
774 __FUNCTION__, (unsigned int)u8Idx,(unsigned int) eBuffType,(unsigned int) u16Offset,(unsigned int) u8Size,(unsigned int)u32Value);
775 }
776
777 if (pMVDHalContext->stMiuCfg.u8HWMiuSel == MIU_SEL_1)
778 {
779 u32BufStart += HAL_MIU1_BASE;
780 }
781 /* else if (pMVDHalContext->stMiuCfg.u8HWMiuSel == MIU_SEL_2)
782 {
783 u32BufStart += HAL_MIU2_BASE;
784 }*/
785
786 if (u8Size == sizeof(MS_U8))
787 {
788 MS_U8* temp = (MS_U8*)MsOS_PA2KSEG1(u32BufStart+u16Offset);
789 *temp = (MS_U8)u32Value;
790 }
791 else if (u8Size == sizeof(MS_U32))
792 {
793 MS_U32* temp = (MS_U32*)MsOS_PA2KSEG1(u32BufStart+u16Offset);
794 *temp = (MS_U32)u32Value;
795 }
796 else if (u8Size == sizeof(MS_U16))
797 {
798 MS_U16* temp = (MS_U16*)MsOS_PA2KSEG1(u32BufStart+u16Offset);
799 *temp = (MS_U16)u32Value;
800 }
801
802 MVD_DEBUGVERBAL(printf("%s: u8Idx=0x%x, bufType=0x%x, offset=%d, size=%d, value=%d\n",
803 __FUNCTION__, (unsigned int)u8Idx, (unsigned int)eBuffType, (unsigned int)u16Offset, (unsigned int)u8Size,(unsigned int)u32Value));
804 }
805 #endif
806
807
808 //-------------------------------------------------------------------------------------------------
809 // Global Functions
810 //-------------------------------------------------------------------------------------------------
HAL_MVD_SetDbgLevel(MS_U8 level)811 void HAL_MVD_SetDbgLevel(MS_U8 level)
812 {
813 _u8HalDbgLevel = level;
814 return;
815 }
816
817
HAL_MVD_GetCaps(void)818 MS_U8 HAL_MVD_GetCaps(void)
819 {
820 MS_U8 caps = 0;
821
822 caps |= (MVD_SUPPORT_MPEG2|MVD_SUPPORT_MPEG4|MVD_SUPPORT_VC1);
823 return caps;
824 }
825
HAL_MVD_GetMaxPixel(MS_U32 u32Id)826 MS_U64 HAL_MVD_GetMaxPixel(MS_U32 u32Id)
827 {
828 return (MS_U64)MVD_HW_MAX_PIXEL/1000;
829 }
830
HAL_MVD_GetDrvFwVer(void)831 MS_U32 HAL_MVD_GetDrvFwVer(void)
832 {
833 return MVD_FW_VERSION;
834 }
835
836 #if 0
837 MS_U32 HAL_MVD_GetMiu1BaseAdd(void)
838 {
839 return MIU1_BASEADDR;
840 }
841 #endif
842
843 //#if defined(CHIP_MUJI)
HAL_MVD_GetMiu1BaseAdd(void)844 MS_VIRT HAL_MVD_GetMiu1BaseAdd(void)
845 {
846 return MIU1_BASEADDR;
847 }
848
HAL_MVD_GetFWSelMiu1(void)849 MS_BOOL HAL_MVD_GetFWSelMiu1(void)
850 {
851 return MVDCPU_ON_MIU1;
852 }
853 //#endif
854
855
HAL_MVD_GetFWSelMiu(void)856 MS_U8 HAL_MVD_GetFWSelMiu(void)
857 {
858 return pMVDHalContext->stMiuCfg.u8FWMiuSel;
859 }
860
861
862
HAL_MVD_MemGetMap(MS_U8 u8Idx,MS_U8 u8type,MS_VIRT * pu32addr,MS_SIZE * pu32len)863 void HAL_MVD_MemGetMap(MS_U8 u8Idx, MS_U8 u8type, MS_VIRT* pu32addr, MS_SIZE* pu32len)
864 {
865 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
866 MS_VIRT u32StartOffset;
867 MS_U8 u8MiuSel;
868
869 switch (u8type)
870 {
871 case E_MVD_MMAP_ALL:
872 case E_MVD_MMAP_FW:
873 _phy_to_miu_offset(u8MiuSel, u32StartOffset, pstMemCfg->u32FWCodeAddr);
874 *pu32addr = u32StartOffset;
875 *pu32len = pstMemCfg->u32FWCodeSize;
876 break;
877 case E_MVD_MMAP_BS:
878 _phy_to_miu_offset(u8MiuSel, u32StartOffset, pstMemCfg->u32BSAddr);
879 *pu32addr = u32StartOffset;
880 *pu32len = pstMemCfg->u32BSSize;
881 break;
882 case E_MVD_MMAP_FB:
883 _phy_to_miu_offset(u8MiuSel, u32StartOffset, pstMemCfg->u32FBAddr);
884 *pu32addr = u32StartOffset;
885 *pu32len = pstMemCfg->u32FBSize;
886 break;
887 case E_MVD_MMAP_DRV:
888 _phy_to_miu_offset(u8MiuSel, u32StartOffset, pstMemCfg->u32DrvBufAddr);
889 *pu32addr = u32StartOffset;
890 *pu32len = pstMemCfg->u32DrvBufSize;
891 break;
892 default:
893 break;
894 }
895
896 MVD_DEBUGINFO(printf("HAL_MVD_MemGetMap[%d] add=0x%lx len=0x%lx\n",u8type,(unsigned long)*pu32addr,(unsigned long)*pu32len));
897 return;
898 }
899
HAL_MVD_RegSetBase(MS_VIRT u32Base)900 void HAL_MVD_RegSetBase(MS_VIRT u32Base)
901 {
902 u32RiuBaseAdd = u32Base;
903 HAL_VPU_EX_InitRegBase(u32Base);
904 }
905
HAL_MVD_RegWriteByte(MS_VIRT u32Reg,MS_U8 u8Val)906 void HAL_MVD_RegWriteByte(MS_VIRT u32Reg, MS_U8 u8Val)
907 {
908 if ( __builtin_constant_p( u32Reg ) )
909 {
910 RIU8[((u32Reg) * 2) - ((u32Reg) & 1)] = u8Val;
911 }
912 else
913 {
914 RIU8[(u32Reg << 1) - (u32Reg & 1)] = u8Val;
915 }
916 }
917
HAL_MVD_RegReadByte(MS_VIRT u32Reg)918 MS_U8 HAL_MVD_RegReadByte(MS_VIRT u32Reg)
919 {
920 return (__builtin_constant_p( u32Reg ) ?
921 (((u32Reg) & 0x01) ? RIU8[(u32Reg) * 2 - 1] : RIU8[(u32Reg) * 2]) :
922 (RIU8[(u32Reg << 1) - (u32Reg & 1)]));
923 }
924
HAL_MVD_RegWriteBit(MS_VIRT u32Reg,MS_BOOL bEnable,MS_U8 u8Mask)925 void HAL_MVD_RegWriteBit(MS_VIRT u32Reg, MS_BOOL bEnable, MS_U8 u8Mask)
926 {
927 MS_VIRT u32Reg8 = ((u32Reg) * 2) - ((u32Reg) & 1);
928 RIU8[u32Reg8] = (bEnable) ? (RIU8[u32Reg8] | (u8Mask)) :
929 (RIU8[u32Reg8] & ~(u8Mask));
930 }
931
HAL_MVD_RegWriteByteMask(MS_VIRT u32Reg,MS_U8 u8Val,MS_U8 u8Msk)932 void HAL_MVD_RegWriteByteMask(MS_VIRT u32Reg, MS_U8 u8Val, MS_U8 u8Msk)
933 {
934 MS_VIRT u32Reg8 = ((u32Reg) * 2) - ((u32Reg) & 1);
935 RIU8[u32Reg8] = (RIU8[u32Reg8] & ~(u8Msk)) | ((u8Val) & (u8Msk));
936 }
937
HAL_MVD_RegWrite4Byte(MS_VIRT u32Reg,MS_U32 u32Val)938 void HAL_MVD_RegWrite4Byte(MS_VIRT u32Reg, MS_U32 u32Val)
939 {
940 if ( __builtin_constant_p( u32Reg ) && !((u32Reg) & 0x01) )
941 {
942 RIU[u32Reg] = (MS_U16)(u32Val);
943 RIU[(u32Reg) + 2] = (MS_U16)((u32Val) >> 16);
944 }
945 else
946 {
947 if (u32Reg & 0x01)
948 {
949 RIU8[(u32Reg << 1) - 1] = u32Val;
950 RIU[u32Reg + 1] = (u32Val >> 8);
951 RIU8[((u32Reg + 3) << 1)] = (u32Val >> 24);
952 }
953 else
954 {
955 RIU[u32Reg] = u32Val;
956 RIU[u32Reg + 2] = (u32Val >> 16);
957 }
958 }
959 }
960
961
HAL_MVD_MemRead4Byte(MS_VIRT u32Address)962 MS_U32 HAL_MVD_MemRead4Byte(MS_VIRT u32Address)
963 {
964 volatile MS_U32 u32Val;
965 MS_ASSERT(!(u32Address & 0x03UL));
966
967 HAL_MVD_CPU_Sync();
968 HAL_MVD_ReadMemory();
969
970 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32Address,u32Address);
971
972 u32Val = *(volatile MS_U32*) HAL_MVD_PA2NonCacheSeg(u32Address);
973
974 //printf("mvd rd 0x%lx = 0x%lx\n", u32Address, u32Val);
975 return u32Val;
976 }
977
HAL_MVD_MemRead2Byte(MS_VIRT u32Address)978 MS_U16 HAL_MVD_MemRead2Byte(MS_VIRT u32Address)
979 {
980 MS_VIRT u32ReadAddr;
981 MS_U32 u32ReadValue;
982 MS_U16 u16Value;
983 MS_U8 u8Shift;
984 u32ReadAddr = (u32Address >> 2) << 2;
985 u8Shift = (MS_U8)((u32Address & 0x03) * 8);
986 u32ReadValue = HAL_MVD_MemRead4Byte(u32ReadAddr);
987
988 u16Value = (MS_U16)(u32ReadValue >> u8Shift);
989 if(u8Shift == 24)
990 {
991 u32ReadValue = HAL_MVD_MemRead4Byte(u32ReadAddr+4);
992 u16Value = u16Value << 8 || (MS_U16)(u32ReadValue & 0xFF);
993 }
994 return u16Value;
995 }
996
HAL_MVD_MemReadByte(MS_VIRT u32Address)997 MS_U8 HAL_MVD_MemReadByte(MS_VIRT u32Address)
998 {
999 MS_VIRT u32ReadAddr;
1000 MS_U32 u32ReadValue;
1001 MS_U8 u8Value;
1002 MS_U8 u8Shift;
1003 u32ReadAddr = (u32Address >> 2) << 2;
1004 u8Shift = (MS_U8)((u32Address & 0x03) * 8);
1005 u32ReadValue = HAL_MVD_MemRead4Byte(u32ReadAddr);
1006 u8Value = (MS_U8)(u32ReadValue >> u8Shift);
1007
1008 return u8Value;
1009 }
1010
HAL_MVD_MemWrite4Byte(MS_VIRT u32Address,MS_U32 u32Value)1011 MS_BOOL HAL_MVD_MemWrite4Byte(MS_VIRT u32Address, MS_U32 u32Value)
1012 {
1013
1014 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32Address,u32Address);
1015
1016 *(volatile MS_U32 *) HAL_MVD_PA2NonCacheSeg(u32Address) = u32Value;
1017
1018 HAL_MVD_CPU_Sync();
1019 HAL_MVD_FlushMemory();
1020
1021 return TRUE;
1022 }
1023
HAL_MVD_MemWriteByte(MS_VIRT u32Address,MS_U8 u8Value)1024 MS_BOOL HAL_MVD_MemWriteByte(MS_VIRT u32Address, MS_U8 u8Value)
1025 {
1026 MS_VIRT u32ReadAddr;
1027 MS_U32 u32ReadValue;
1028 MS_U8 u8Shift;
1029
1030 u32ReadAddr = (u32Address >> 2) << 2;
1031 u8Shift = (MS_U8)((u32Address & 0x03UL) * 8);
1032 u32ReadValue = HAL_MVD_MemRead4Byte(u32ReadAddr);
1033 u32ReadValue &= ~(0xFFUL << u8Shift);
1034 u32ReadValue |= ((MS_U32)u8Value << u8Shift);
1035 HAL_MVD_MemWrite4Byte(u32ReadAddr, u32ReadValue);
1036 return TRUE;
1037 }
1038
HAL_MVD_MemWrite2Byte(MS_VIRT u32Address,MS_U16 u16Value)1039 MS_BOOL HAL_MVD_MemWrite2Byte(MS_VIRT u32Address, MS_U16 u16Value)
1040 {
1041 MS_VIRT u32ReadAddr;
1042 MS_U32 u32ReadValue;
1043 MS_U8 u8Shift;
1044
1045 u8Shift = (MS_U8)((u32Address & 0x03UL) * 8) ;
1046 if(u8Shift < 24)
1047 {
1048 u32ReadAddr = (u32Address >> 2) << 2;
1049 u32ReadValue = HAL_MVD_MemRead4Byte(u32ReadAddr);
1050 u32ReadValue &= ~(0xFFFF << u8Shift);
1051 u32ReadValue |= ((MS_U32)u16Value << u8Shift);
1052 HAL_MVD_MemWrite4Byte(u32ReadAddr, u32ReadValue);
1053 }
1054 else
1055 {
1056 HAL_MVD_MemWriteByte(u32Address, (MS_U8)(u16Value));
1057 HAL_MVD_MemWriteByte(u32Address+1, (MS_U8)(u16Value >> 8));
1058 }
1059 return TRUE;
1060 }
1061
1062
HAL_MVD_SetReqMask(MS_BOOL bEnMask)1063 void HAL_MVD_SetReqMask(MS_BOOL bEnMask)
1064 {
1065 HAL_VPU_EX_MIU_RW_Protect(bEnMask);
1066
1067 if (MVDHW_ON_MIU1)
1068 {
1069 HAL_MVD_RegWriteBit(MIU1_RQ2_MASK_L, bEnMask, BIT4); //MVD R/W
1070 HAL_MVD_RegWriteBit(MIU1_RQ0_MASK_H, bEnMask, BIT4); //MVD bbu R/W
1071 }
1072 else if(MVDHW_ON_MIU0)
1073 {
1074 HAL_MVD_RegWriteBit(MIU0_RQ2_MASK_L, bEnMask, BIT4); //MVD R/W
1075 HAL_MVD_RegWriteBit(MIU0_RQ0_MASK_H, bEnMask, BIT4); //MVD bbu R/W
1076 }
1077
1078 HAL_MVD_Delayms(1);
1079
1080 return;
1081 }
1082
HAL_MVD_Memset4Byte(MS_VIRT u32Address,MS_U32 u32Value)1083 static MS_BOOL HAL_MVD_Memset4Byte(MS_VIRT u32Address, MS_U32 u32Value)
1084 {
1085 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32Address,u32Address);
1086
1087 *(volatile MS_U32 *) HAL_MVD_PA2NonCacheSeg(u32Address) = u32Value;
1088
1089 return TRUE;
1090 }
1091
1092 //------------------------------------------------------------------------------
1093 /// Initialize MVD
1094 /// @return -result of resetting MVD hardware
1095 //------------------------------------------------------------------------------
HAL_MVD_RstHW(void)1096 MS_BOOL HAL_MVD_RstHW(void)
1097 {
1098 MS_U32 u32Time = 0;
1099
1100 OSAL_MVD_LockHwMutex();
1101
1102 HAL_MVD_SetReqMask(ENABLE);
1103
1104 HAL_MVD_RegWriteBit(MVD_CTRL, 1, MVD_CTRL_DISCONNECT_MIU);//disconnect MIU
1105 HAL_MVD_RegWriteBit(MVD_CTRL, 0, MVD_CTRL_DISCONNECT_MIU);//release reset
1106
1107 HAL_MVD_RegWriteBit(MVD_CTRL, 1, MVD_CTRL_RST);//reset MVD
1108 HAL_MVD_RegWriteBit(MVD_CTRL, 0, MVD_CTRL_RST);//release reset
1109
1110 u32Time = HAL_MVD_GetTime();
1111 while ( ((HAL_MVD_RegReadByte(MVD_STATUS) & MVD_STATUS_READY) == 0)
1112 && ((HAL_MVD_GetTime() - u32Time) < 200) );
1113
1114 #if 0 //bring up
1115 printf("====================>>>>MVD Ctrl status1.5a : 0x%x\n",HAL_MVD_RegReadByte(MVD_STATUS));
1116 HAL_MVD_RegWriteBit(MVD_STATUS, 1, MVD_T8_MIU_128_0);//release reset
1117 HAL_MVD_RegWriteBit(MVD_STATUS, 1, MVD_T8_MIU_128_1);//release reset
1118 MVD_DEBUGINFO(printf("MVD Ctrl status : 0x%x\n",HAL_MVD_RegReadByte(MVD_STATUS)));
1119 printf("====================>>>>MVD Ctrl status1.5b : 0x%x\n",HAL_MVD_RegReadByte(MVD_STATUS));
1120 #endif
1121
1122 HAL_MVD_SetReqMask(DISABLE);
1123
1124 OSAL_MVD_UnlockHwMutex();
1125
1126 return TRUE;
1127 }
1128
1129
1130 //------------------------------------------------------------------------------
1131 /// Release CPU
1132 /// @return -release CPU successfully or not
1133 //------------------------------------------------------------------------------
HAL_MVD_ReleaseFW(void)1134 MS_BOOL HAL_MVD_ReleaseFW(void)
1135 {
1136 //For dual decoder, we only release VPU if it is not released yet.
1137 if (TRUE == HAL_VPU_EX_IsRsted())
1138 {
1139 MVD_DEBUGINFO(printf("%s VPU_IsRsted\n", __FUNCTION__));
1140 return TRUE;
1141 }
1142
1143 HAL_VPU_EX_SwRstRelse();
1144 return TRUE;
1145 }
1146
HAL_MVD_PA2NonCacheSeg(MS_PHY u32PhyAddr)1147 MS_VIRT HAL_MVD_PA2NonCacheSeg(MS_PHY u32PhyAddr)
1148 {
1149 return MS_PA2KSEG1(u32PhyAddr);
1150 }
1151
HAL_MVD_GetTime(void)1152 MS_U32 HAL_MVD_GetTime(void)
1153 {
1154 return MsOS_GetSystemTime();
1155 }
1156
HAL_MVD_Delayms(MS_U32 u32msecs)1157 void HAL_MVD_Delayms(MS_U32 u32msecs)
1158 {
1159 MsOS_DelayTask(u32msecs);
1160 }
1161
HAL_MVD_CPU_Sync(void)1162 void HAL_MVD_CPU_Sync(void)
1163 {
1164 MAsm_CPU_Sync();
1165 }
1166
HAL_MVD_FlushMemory(void)1167 void HAL_MVD_FlushMemory(void)
1168 {
1169 MsOS_FlushMemory();
1170 }
1171
HAL_MVD_ReadMemory(void)1172 void HAL_MVD_ReadMemory(void)
1173 {
1174 MsOS_ReadMemory();
1175 }
1176
1177 //Record the memory layout from system configuration
HAL_MVD_SetMEMCfg(MS_U8 u8Idx,MVD_MEMCfg * pMEMCfg)1178 MS_BOOL HAL_MVD_SetMEMCfg(MS_U8 u8Idx, MVD_MEMCfg* pMEMCfg)
1179 {
1180 memcpy(&(pMVDHalContext->stMemCfg[u8Idx]), pMEMCfg, sizeof(MVD_MEMCfg));
1181 //record the MIU settings
1182 pMVDHalContext->stMiuCfg.u32Miu1BaseAddr = pMEMCfg->u32Miu1BaseAddr;
1183 pMVDHalContext->stMiuCfg.u32Miu2BaseAddr = pMEMCfg->u32Miu2BaseAddr;
1184 pMVDHalContext->stMiuCfg.u32Miu3BaseAddr = pMEMCfg->u32Miu3BaseAddr;
1185 pMVDHalContext->stMiuCfg.u8FWMiuSel = pMEMCfg->u8FWMiuSel;
1186 pMVDHalContext->stMiuCfg.u8HWMiuSel = pMEMCfg->u8HWMiuSel;
1187 return TRUE;
1188 }
1189
HAL_MVD_GetMEMCfg(MS_U8 u8Idx)1190 MVD_MEMCfg* HAL_MVD_GetMEMCfg(MS_U8 u8Idx)
1191 {
1192 //printf("%s: u8Idx=0x%x\n", __FUNCTION__, u8Idx);
1193 MVD_MEMCfg* pInfo = NULL;
1194 pInfo = &(pMVDHalContext->stMemCfg[u8Idx]);
1195 return pInfo;
1196 }
1197
HAL_MVD_SetFWCfg(MS_U8 u8Idx,MVD_FWCfg * pFWCfg)1198 MS_BOOL HAL_MVD_SetFWCfg(MS_U8 u8Idx, MVD_FWCfg* pFWCfg)
1199 {
1200 //printf("%s: u8Idx=0x%x\n", __FUNCTION__, u8Idx);
1201 memcpy(&(pMVDHalContext->stFwCfg[u8Idx]), pFWCfg, sizeof(MVD_FWCfg));
1202 memcpy(&(pMVDHalContext->stFwCfg[u8Idx].stFBReduction), &pFWCfg->stFBReduction,sizeof(MVD_FB_Reduction));
1203 return TRUE;
1204 }
1205
HAL_MVD_GetFWCfg(MS_U8 u8Idx)1206 MVD_FWCfg* HAL_MVD_GetFWCfg(MS_U8 u8Idx)
1207 {
1208 MVD_FWCfg* pInfo = NULL;
1209 //printf("%s: u8Idx=0x%x\n", __FUNCTION__, u8Idx);
1210 pInfo = &(pMVDHalContext->stFwCfg[u8Idx]);
1211 return pInfo;
1212 }
1213
HAL_MVD_GetFBMode(MS_U8 u8Idx)1214 MS_U8 HAL_MVD_GetFBMode(MS_U8 u8Idx)
1215 {
1216 MS_U8 u8Mode = MVD3_SD_MODE;
1217 u8Mode = pMVDHalContext->stFwCfg[u8Idx].u8FBMode;
1218 MVD_DEBUGINFO(printf("FBMode=0x%x\n", u8Mode));
1219 return u8Mode;
1220 }
1221
HAL_MVD_GetCodecType(MS_U8 u8Idx)1222 MVD_CodecType HAL_MVD_GetCodecType(MS_U8 u8Idx)
1223 {
1224 MVD_CodecType eCodecType = E_MVD_CODEC_UNKNOWN;
1225 eCodecType = pMVDHalContext->stFwCfg[u8Idx].eCodecType;
1226 return eCodecType;
1227 }
1228
HAL_MVD_GetSrcMode(MS_U8 u8Idx)1229 MVD_SrcMode HAL_MVD_GetSrcMode(MS_U8 u8Idx)
1230 {
1231 MVD_SrcMode eSrcMode = E_MVD_SRC_UNKNOWN;
1232 eSrcMode = pMVDHalContext->stFwCfg[u8Idx].eSrcMode;
1233 return eSrcMode;
1234 }
1235
HAL_MVD_SetSrcMode(MS_U8 u8Idx,MVD_SrcMode mode)1236 MS_BOOL HAL_MVD_SetSrcMode(MS_U8 u8Idx,MVD_SrcMode mode)
1237 {
1238 if(pMVDHalContext != NULL)
1239 {
1240 pMVDHalContext->stFwCfg[u8Idx].eSrcMode = mode;
1241 return TRUE;
1242 }
1243 else
1244 {
1245 return FALSE;
1246 }
1247 }
1248
1249
HAL_MVD_GetCtrlCfg(MS_U8 u8Idx)1250 MVD_CtrlCfg* HAL_MVD_GetCtrlCfg(MS_U8 u8Idx)
1251 {
1252 MVD_CtrlCfg* pInfo = NULL;
1253 pInfo = &(pMVDHalContext->stCtrlCfg[u8Idx]);
1254 return pInfo;
1255 }
1256
HAL_MVD_GetSlqTblInfo(MS_U8 u8Idx)1257 MVD_SLQTBLInfo* HAL_MVD_GetSlqTblInfo(MS_U8 u8Idx)
1258 {
1259 MVD_SLQTBLInfo* pInfo = NULL;
1260 pInfo = &(pMVDHalContext->stSlqTblInfo[u8Idx]);
1261 return pInfo;
1262 }
1263
HAL_MVD_PowerCtrl(MS_BOOL bOn)1264 void HAL_MVD_PowerCtrl(MS_BOOL bOn)
1265 {
1266 #ifdef CONFIG_MSTAR_CLKM
1267 HAL_VPU_EX_SetClkManagement(E_VPU_EX_CLKPORT_MVD, bOn);
1268 #else
1269 HAL_MVD_RegWriteByteMask(REG_CKG_MVD, CKG_MVD_216MHZ, CKG_MVD_MASK);
1270 HAL_MVD_RegWriteBit(REG_CKG_MVD, !bOn, CKG_MVD_GATED);
1271 HAL_MVD_RegWriteBit(REG_CKG_MVD, !bOn, CKG_MVD_INVERT);
1272 #endif
1273 HAL_MVD_RegWriteBit(REG_CKG_MVD_CHROMA_A, !bOn, CKG_MVD_CHROMA_A_GATED);
1274 HAL_MVD_RegWriteBit(REG_CKG_MVD_CHROMA_A, !bOn, CKG_MVD_CHROMA_A_INVERT);
1275
1276 HAL_MVD_RegWriteBit(REG_CKG_MVD_CHROMA_B, !bOn, CKG_MVD_CHROMA_B_GATED);
1277 HAL_MVD_RegWriteBit(REG_CKG_MVD_CHROMA_B, !bOn, CKG_MVD_CHROMA_B_INVERT);
1278
1279 HAL_MVD_RegWriteBit(REG_CKG_MVD_CHROMA_C, !bOn, CKG_MVD_CHROMA_C_GATED);
1280 HAL_MVD_RegWriteBit(REG_CKG_MVD_CHROMA_C, !bOn, CKG_MVD_CHROMA_C_INVERT);
1281
1282 HAL_MVD_RegWriteBit(REG_CKG_MVD_LUMA_A, !bOn, CKG_MVD_LUMA_A_GATED);
1283 HAL_MVD_RegWriteBit(REG_CKG_MVD_LUMA_A, !bOn, CKG_MVD_LUMA_A_INVERT);
1284
1285 HAL_MVD_RegWriteBit(REG_CKG_MVD_LUMA_B, !bOn, CKG_MVD_LUMA_B_GATED);
1286 HAL_MVD_RegWriteBit(REG_CKG_MVD_LUMA_B, !bOn, CKG_MVD_LUMA_B_INVERT);
1287
1288 HAL_MVD_RegWriteBit(REG_CKG_MVD_LUMA_C, !bOn, CKG_MVD_LUMA_C_GATED);
1289 HAL_MVD_RegWriteBit(REG_CKG_MVD_LUMA_C, !bOn, CKG_MVD_LUMA_C_INVERT);
1290
1291 HAL_MVD_RegWriteBit(REG_CKG_MVD_RMEM, !bOn, CKG_MVD_RMEM_GATED);
1292 HAL_MVD_RegWriteBit(REG_CKG_MVD_RMEM, !bOn, CKG_MVD_RMEM_INVERT);
1293
1294 HAL_MVD_RegWriteBit(REG_CKG_MVD_RMEM1, !bOn, CKG_MVD_RMEM1_GATED);
1295 HAL_MVD_RegWriteBit(REG_CKG_MVD_RMEM1, !bOn, CKG_MVD_RMEM1_INVERT);
1296
1297 HAL_MVD_RegWriteBit(REG_CKG_MVD_RREFDAT, !bOn, CKG_MVD_RREFDAT_GATED);
1298 HAL_MVD_RegWriteBit(REG_CKG_MVD_RREFDAT, !bOn, CKG_MVD_RREFDAT_INVERT);
1299
1300 //Set MVD all clock sources equal to clk_miu_p 0: enable 1: disable
1301 //Per Lawrence, mark this line:
1302 // Sync mode is debug mode, so driver shouldn't write 1 to this register in normal case.
1303 //HAL_MVD_RegWriteBit(REG_CKG_MVD_SYNC, !bOn, CKG_MVD_SYNC_GATED);
1304
1305 return;
1306 }
1307
1308 #if 0
1309 void HAL_MVD_Sleep(MS_U32 u32us)
1310 {
1311 MsOS_DelayTaskUs(u32us);
1312 }
1313 #endif
HAL_MVD_ResetHandShake(MS_U8 u8Idx,MVD_HANDSHAKE_CMD cmd)1314 void HAL_MVD_ResetHandShake(MS_U8 u8Idx, MVD_HANDSHAKE_CMD cmd)
1315 {
1316 MS_U32 u32BufAddr = GET_FRMINFO_BUFFADD(u8Idx);
1317 HAL_MVD_CPU_Sync();
1318 HAL_MVD_ReadMemory();
1319 MVD_CMD_HANDSHADE_INDEX u32CmdState;
1320 u32CmdState.value= HAL_MVD_MemRead4Byte(u32BufAddr + OFFSET_CMD_HANDSHAKE_INDEX);
1321 switch (cmd)
1322 {
1323 case MVD_HANDSHAKE_PAUSE:
1324 (u32CmdState.mvdcmd_handshake_pause) = 0;
1325 break;
1326 case MVD_HANDSHAKE_SLQ_RST:
1327 (u32CmdState.mvdcmd_handshake_slq_reset) = 0;
1328 break;
1329 case MVD_HANDSHAKE_STOP:
1330 (u32CmdState.mvdcmd_handshake_stop) = 0;
1331 break;
1332 case MVD_HANDSHAKE_SKIP_DATA:
1333 (u32CmdState.mvdcmd_handshake_skip_data) = 0;
1334 break;
1335 case MVD_HANDSHAKE_SINGLE_STEP:
1336 (u32CmdState.mvdcmd_handshake_single_step) = 0;
1337 break;
1338 case MVD_HANDSHAKE_SCALER_INFO:
1339 (u32CmdState.mvdcmd_handshake_scaler_data_ready) = 0;
1340 break;
1341 case MVD_HANDSHAKE_GET_NXTDISPFRM:
1342 (u32CmdState.mvdcmd_handshake_get_nextdispfrm_ready) = 0;
1343 break;
1344 case MVD_HANDSHAKE_PARSER_RST:
1345 (u32CmdState.mvdcmd_handshake_parser_rst) = 0;
1346 break;
1347 case MVD_HANDSHAKE_RST_CC608:
1348 (u32CmdState.mvdcmd_handshake_cc608_rst) = 0;
1349 break;
1350 case MVD_HANDSHAKE_RST_CC708:
1351 (u32CmdState.mvdcmd_handshake_cc708_rst) = 0;
1352 break;
1353 case MVD_HANDSHAKE_VIRTUAL_COMMAND:
1354 (u32CmdState.mvdcmd_handshake_virtualCommand) = 0;
1355 break;
1356 case MVD_HANDSHAKE_FLUSHQUEUE_COMMAND:
1357 (u32CmdState.mvdcmd_handshake_flush) = 0;
1358 break;
1359 case MVD_HANDSHAKE_VSYNC_CONTROL:
1360 (u32CmdState.mvdcmd_handshake_vsync_control) = 0;
1361 break;
1362 default:
1363 break;
1364 }
1365 HAL_MVD_MemWrite4Byte(u32BufAddr + OFFSET_CMD_HANDSHAKE_INDEX,u32CmdState.value);
1366 MsOS_FlushMemory();
1367 }
1368
1369 //------------------------------------------------------------------------------
1370 /// Wait MVD command ready or timeout
1371 /// @return -MVD command ready or timeout
1372 //------------------------------------------------------------------------------
HAL_MVD_TimeOut(MS_U8 u8Idx)1373 MS_BOOL HAL_MVD_TimeOut(MS_U8 u8Idx)
1374 {
1375 MS_U32 i;
1376 MS_U32 u32StartTime = MsOS_GetSystemTime();
1377
1378 for ( i = 0; i < MVD_PollingTimes; i++ )
1379 {
1380 ///- wait until MVD command ready or timeout
1381 if ( ( HAL_MVD_RegReadByte(MVD_STATUS) & MVD_STATUS_READY ) == MVD_STATUS_READY )
1382 {
1383 return FALSE;
1384 }
1385
1386 if (/*(TRUE == pMVDHalContext->bStopped[u8Idx]) ||*/ ((MsOS_GetSystemTime()-u32StartTime)>1300))
1387 {
1388 MVD_DEBUGINFO(printf("%s: bStopped(%x) or timeout(%d)\n", __FUNCTION__, pMVDHalContext->bStopped[u8Idx], MsOS_GetSystemTime()-u32StartTime));
1389 return TRUE;
1390 }
1391
1392 //HAL_MVD_Sleep(5);
1393 }
1394 MVD_DEBUGERROR( printf("MVD_TimeOut=%x\n", i) );
1395 return TRUE;
1396 }
1397
1398 //------------------------------------------------------------------------------
1399 /// Set MVD firmware command
1400 /// @param -u8cmd \b IN : MVD command
1401 /// @param -pstCmdArg \b IN : pointer to command argument
1402 //------------------------------------------------------------------------------
HAL_MVD_MVDCommand(MS_U8 u8cmd,MVD_CmdArg * pstCmdArg)1403 MS_BOOL HAL_MVD_MVDCommand ( MS_U8 u8cmd, MVD_CmdArg *pstCmdArg )
1404 {
1405 MS_BOOL bRet = TRUE;
1406 #ifdef VDEC3
1407 MS_U32 u32CmdArg;
1408 MS_U32 u32Ret = FALSE;
1409 MS_U32 u32Timeout;
1410 MS_U8 u8HalIdx = pstCmdArg->Arg5;
1411 MS_U32 u32Id = MVD_GetStreamId(u8HalIdx);
1412 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
1413 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8HalIdx);
1414 CMD_QUEUE *pShm = (CMD_QUEUE *)MsOS_PA2KSEG1(pstMemCfg->u32FWCodeAddr + VCOMMANDQ_INFO_START + u8VPUIdx*0x100000);
1415 MS_VIRT u32BufStart2 = NULL;
1416 MS_BOOL bResponse = FALSE;
1417 #endif
1418 OSAL_MVD_LockHwMutex();
1419
1420 #ifdef VDEC3
1421 if(HAL_MVD_IsDisplayCommand(u8cmd) == TRUE)
1422 {
1423 if(HAL_MVD_IsNeedResponseCommand(u8cmd) == TRUE)
1424 {
1425 // clear handshake dram
1426 u32BufStart2 = GET_VOL_BUFFADD(u8HalIdx);
1427
1428 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32BufStart2,u32BufStart2);
1429
1430 MS_U8* temp2 = (MS_U8*)MsOS_PA2KSEG1(u32BufStart2+OFFSET_VCHANDSHAKE);
1431
1432 *temp2 = 0;
1433
1434 MsOS_FlushMemory();
1435 }
1436
1437
1438 u32CmdArg = pstCmdArg->Arg0 | (pstCmdArg->Arg1<<8) | (pstCmdArg->Arg2 << 16) | (pstCmdArg->Arg3 << 24);
1439
1440 u32Timeout = MsOS_GetSystemTime()+VIRTUAL_CMD_TIMEOUT;
1441
1442 do
1443 {
1444 u32Ret = HAL_VPU_EX_DRAMStreamDispCMDQueueSend(u32Id,(void*)pShm,E_HVD_CMDQ_ARG,u32CmdArg);
1445
1446
1447 if(u32Ret == E_HVD_COMMAND_QUEUE_NOT_INITIALED)
1448 {
1449 bRet = FALSE;
1450 break;
1451 }
1452 else if (MsOS_GetSystemTime() > u32Timeout && u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL )
1453 {
1454 bRet = FALSE;
1455 break;
1456 }
1457 }while(u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL);
1458
1459 if(bRet == FALSE || u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL)
1460 {
1461 bRet = FALSE;
1462 goto _CMD_DONE;
1463 }
1464
1465
1466 u32Timeout = MsOS_GetSystemTime()+VIRTUAL_CMD_TIMEOUT;
1467
1468 do
1469 {
1470 u32Ret = HAL_VPU_EX_DRAMStreamDispCMDQueueSend(u32Id,(void*)pShm,E_HVD_CMDQ_CMD,u8cmd|(u8VPUIdx<<24)|(pstCmdArg->Arg4<<16));
1471
1472 if(u32Ret == E_HVD_COMMAND_QUEUE_NOT_INITIALED)
1473 {
1474 bRet = FALSE;
1475 break;
1476 }
1477 else if (MsOS_GetSystemTime() > u32Timeout && u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL)
1478 {
1479 bRet = FALSE;
1480 break;
1481 }
1482 }while(u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL);
1483
1484 if(bRet == FALSE || u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL)
1485 {
1486 bRet = FALSE;
1487 goto _CMD_DONE;
1488 }
1489
1490 if(HAL_MVD_IsNeedResponseCommand(u8cmd) == TRUE)
1491 {
1492 u32Timeout = MsOS_GetSystemTime()+VIRTUAL_CMD_TIMEOUT;
1493
1494 while(MsOS_GetSystemTime() < u32Timeout)
1495 {
1496 #if 0
1497 if (HAL_MVD_IsCmdFinished(u8HalIdx, MVD_HANDSHAKE_VIRTUAL_COMMAND))
1498 {
1499 bResponse = TRUE;
1500 break;
1501 }
1502 #else
1503 if(MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VCHANDSHAKE, sizeof(MS_U8)) == 1)
1504 {
1505 bResponse = TRUE;
1506 break;
1507 }
1508 #endif
1509 }
1510
1511 if(bResponse == FALSE) // fail case
1512 {
1513 bRet = FALSE;
1514 goto _CMD_DONE;
1515 }
1516
1517 pstCmdArg->Arg0 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG0, sizeof(MS_U8));
1518 pstCmdArg->Arg1 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG1, sizeof(MS_U8));
1519 pstCmdArg->Arg2 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG2, sizeof(MS_U8));
1520 pstCmdArg->Arg3 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG3, sizeof(MS_U8));
1521 pstCmdArg->Arg4 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG4, sizeof(MS_U8));
1522 }
1523
1524 }
1525 else if(HAL_MVD_IsNormalCommand(u8cmd) == TRUE)
1526 {
1527 if(HAL_MVD_IsNeedResponseCommand(u8cmd) == TRUE)
1528 {
1529 // clear handshake dram
1530 u32BufStart2 = GET_VOL_BUFFADD(u8HalIdx);
1531
1532 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32BufStart2,u32BufStart2);
1533
1534 MS_U8* temp2 = (MS_U8*)MsOS_PA2KSEG1(u32BufStart2+OFFSET_VCHANDSHAKE);
1535
1536 *temp2 = 0;
1537
1538 MsOS_ReadMemory();
1539 MsOS_FlushMemory();
1540 }
1541
1542 u32CmdArg = pstCmdArg->Arg0 | (pstCmdArg->Arg1<<8) | (pstCmdArg->Arg2 << 16) | (pstCmdArg->Arg3 << 24);
1543
1544 u32Timeout = MsOS_GetSystemTime()+VIRTUAL_CMD_TIMEOUT;
1545
1546 do
1547 {
1548 //u32Ret = HAL_VPU_EX_DRAMStreamCMDQueueSend_MVD(pstCmdArg->Arg5,E_HVD_CMDQ_ARG,u32CmdArg);
1549 u32Ret = HAL_VPU_EX_DRAMStreamCMDQueueSend(u32Id,(void*)pShm,E_HVD_CMDQ_ARG,u32CmdArg);
1550
1551 if(u32Ret == E_HVD_COMMAND_QUEUE_NOT_INITIALED)
1552 {
1553 bRet = FALSE;
1554 break;
1555 }
1556 else if (MsOS_GetSystemTime() > u32Timeout && u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL )
1557 {
1558 bRet = FALSE;
1559 break;
1560 }
1561 }while(u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL);
1562
1563
1564 if(bRet == FALSE || u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL)
1565 {
1566 bRet = FALSE;
1567 goto _CMD_DONE;
1568 }
1569
1570
1571 u32Timeout = MsOS_GetSystemTime()+VIRTUAL_CMD_TIMEOUT;
1572 do
1573 {
1574 //u32Ret = HAL_VPU_EX_DRAMStreamCMDQueueSend_MVD(pstCmdArg->Arg5,E_HVD_CMDQ_CMD,u8cmd|(pstCmdArg->Arg5<<24)|(pstCmdArg->Arg4<<16));
1575 u32Ret = HAL_VPU_EX_DRAMStreamCMDQueueSend(u32Id,(void*)pShm,E_HVD_CMDQ_CMD,u8cmd|(u8VPUIdx<<24)|(pstCmdArg->Arg4<<16));
1576
1577 if(u32Ret == E_HVD_COMMAND_QUEUE_NOT_INITIALED)
1578 {
1579 bRet = FALSE;
1580 break;
1581 }
1582 else if (MsOS_GetSystemTime() > u32Timeout && u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL)
1583 {
1584 bRet = FALSE;
1585 break;
1586 }
1587 }while(u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL);
1588
1589 if(bRet == FALSE || u32Ret != E_HVD_COMMAND_QUEUE_SEND_SUCCESSFUL)
1590 {
1591 bRet = FALSE;
1592 goto _CMD_DONE;
1593 }
1594
1595 if(HAL_MVD_IsNeedResponseCommand(u8cmd) == TRUE)
1596 {
1597 u32Timeout = MsOS_GetSystemTime()+VIRTUAL_CMD_TIMEOUT;
1598
1599 while(MsOS_GetSystemTime() < u32Timeout)
1600 {
1601 #if 0
1602 if (HAL_MVD_IsCmdFinished(u8HalIdx, MVD_HANDSHAKE_VIRTUAL_COMMAND))
1603 {
1604 bResponse = TRUE;
1605 break;
1606 }
1607 #else
1608 if(MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VCHANDSHAKE, sizeof(MS_U8)) == 1)
1609 {
1610 bResponse = TRUE;
1611 break;
1612 }
1613 #endif
1614 }
1615
1616 if(bResponse == FALSE) // fail case
1617 {
1618 bRet = FALSE;
1619 goto _CMD_DONE;
1620 }
1621
1622 pstCmdArg->Arg0 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG0, sizeof(MS_U8));
1623 pstCmdArg->Arg1 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG1, sizeof(MS_U8));
1624 pstCmdArg->Arg2 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG2, sizeof(MS_U8));
1625 pstCmdArg->Arg3 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG3, sizeof(MS_U8));
1626 pstCmdArg->Arg4 = MVD_GetFWBuffData(u8HalIdx, FW_BUFF_VOLINFO, OFFSET_VIRTUAL_COMMANDARG4, sizeof(MS_U8));
1627 }
1628 }
1629 else
1630 #endif
1631 {
1632 if ( HAL_MVD_TimeOut(pstCmdArg->Arg5) == TRUE )
1633 {
1634 bRet = FALSE;
1635 goto _CMD_DONE;
1636 }
1637
1638 HAL_MVD_RegWriteByte(MVD_ARG0, pstCmdArg->Arg0);
1639 HAL_MVD_RegWriteByte(MVD_ARG1, pstCmdArg->Arg1);
1640 HAL_MVD_RegWriteByte(MVD_ARG2, pstCmdArg->Arg2);
1641 HAL_MVD_RegWriteByte(MVD_ARG3, pstCmdArg->Arg3);
1642 HAL_MVD_RegWriteByte(MVD_ARG4, pstCmdArg->Arg4);
1643 HAL_MVD_RegWriteByte(MVD_ARG5, pstCmdArg->Arg5);
1644 HAL_MVD_RegWriteByte(MVD_COMMAND, u8cmd);
1645 if ((CMD_GET_AFD != u8cmd) && (CMD_SLQ_GET_TBL_RPTR != u8cmd) &&
1646 (CMD_SLQ_UPDATE_TBL_WPTR != u8cmd) && (CMD_GET_NEXTDISPFRM != u8cmd) &&
1647 (CMD_DECODE_STATUS != u8cmd) && (CMD_RD_PTS != u8cmd) &&
1648 (CMD_GET_INT_STAT != u8cmd) && (CMD_RD_IO != u8cmd))
1649 {
1650 MVD_DEBUG_FWCMD(printf("MVD_CMD: %x; %x, %x, %x, %x, %x, %x\n", u8cmd, pstCmdArg->Arg0,
1651 pstCmdArg->Arg1, pstCmdArg->Arg2, pstCmdArg->Arg3, pstCmdArg->Arg4, pstCmdArg->Arg5));
1652 }
1653
1654 if ( HAL_MVD_TimeOut(pstCmdArg->Arg5) == TRUE )
1655 {
1656 bRet = FALSE;
1657 goto _CMD_DONE;
1658 }
1659
1660 pstCmdArg->Arg0 = HAL_MVD_RegReadByte(MVD_ARG0);
1661 pstCmdArg->Arg1 = HAL_MVD_RegReadByte(MVD_ARG1);
1662 pstCmdArg->Arg2 = HAL_MVD_RegReadByte(MVD_ARG2);
1663 pstCmdArg->Arg3 = HAL_MVD_RegReadByte(MVD_ARG3);
1664 pstCmdArg->Arg4 = HAL_MVD_RegReadByte(MVD_ARG4);
1665 pstCmdArg->Arg5 = HAL_MVD_RegReadByte(MVD_ARG5);
1666 }
1667
1668 _CMD_DONE:
1669 OSAL_MVD_UnlockHwMutex();
1670
1671 if (!bRet)
1672 {
1673 MVD_DEBUG_FWCMD(printf("%s timeout dump pc\n", __FUNCTION__));
1674 MS_U32 x=0;
1675 for (x=0; x<30; x++)
1676 MVD_DEBUG_FWCMD(printf("0x%x\n", HAL_VPU_EX_GetProgCnt()));
1677 MVD_DEBUG_FWCMD(printf("###\n"));
1678 }
1679
1680 return bRet;
1681 }
1682
HAL_MVD_SetSyncClk(MS_BOOL bEnable)1683 void HAL_MVD_SetSyncClk(MS_BOOL bEnable)
1684 {
1685 MS_ASSERT(0==bEnable);//Notice: Euclid & T3 have no sync_mode; Bit4 must be 0.
1686
1687 OSAL_MVD_LockHwMutex();
1688 HAL_MVD_RegWriteBit(MVD_CTRL, bEnable, MVD_CTRL_CLK_SYNCMODE);
1689 OSAL_MVD_UnlockHwMutex();
1690
1691 return;
1692 }
1693
HAL_MVD_InitHW(VPU_EX_SourceType SourceType,VPU_EX_DecoderType eDecType)1694 MS_BOOL HAL_MVD_InitHW(VPU_EX_SourceType SourceType,VPU_EX_DecoderType eDecType)
1695 {
1696 //Set MVD Clock @ reg_CHIPTOP
1697 HAL_MVD_PowerCtrl(ENABLE);
1698 #ifdef CONFIG_MSTAR_CLKM
1699 if(eDecType == E_VPU_EX_DECODER_MVD)
1700 {
1701 HAL_VPU_EX_SetClkManagement(E_VPU_EX_CLKPORT_MVD_CORE, ENABLE);
1702 }
1703 if(SourceType == E_VPU_EX_INPUT_TSP)
1704 {
1705 HAL_VPU_EX_SetClkManagement(E_VPU_EX_CLKPORT_MVD_PAS, ENABLE);
1706 }
1707 #endif
1708
1709 #ifdef CONFIG_MSTAR_SRAMPD
1710 HAL_MVD_RegWriteBit(REG_CODEC_SRAM_SD_EN, ENABLE, SRAM_SD_EN_MVD);
1711 HAL_MVD_Delayms(1);
1712 #endif
1713
1714 //Set MVD Clock aync
1715 HAL_MVD_SetSyncClk(DISABLE);
1716
1717 //MVD reset
1718 if(!HAL_MVD_RstHW())
1719 {
1720 MVD_DEBUGERROR(printf("MDrv_MVD_MVDInit:MVD4ResetHW failed\n"));
1721 return FALSE;
1722 }
1723 else
1724 {
1725 MVD_DEBUGINFO(printf("MDrv_MVD_MVDInit:MVD4ResetHW success\n"));
1726 }
1727
1728 return TRUE;
1729 }
1730
1731
1732 //------------------------------------------------------------------------------
1733 /// Get MVD firmware version
1734 /// @return -firmware version
1735 //------------------------------------------------------------------------------
HAL_MVD_GetFWVer(MS_U32 u32VpuSid)1736 MS_U32 HAL_MVD_GetFWVer(MS_U32 u32VpuSid)
1737 {
1738 #if 0
1739 return HAL_VPU_EX_GetFWVer(u32VpuSid, E_VPU_EX_FW_VER_MVD_FW);
1740 #else
1741 UNUSED(u32VpuSid);
1742 MVD_CmdArg mvdcmd;
1743
1744 SETUP_CMDARG(mvdcmd);
1745 mvdcmd.Arg5 = HAL_VPU_EX_GetTaskId(u32VpuSid);
1746 if (HAL_MVD_MVDCommand( CMD_GET_FW_VERSION, &mvdcmd ) == FALSE)
1747 {
1748 MVD_ERROR( printf( "Command: 0x%x fail!!\r\n", CMD_GET_FW_VERSION ) );
1749 return 0;
1750 }
1751 return COMBU32(mvdcmd.Arg3,mvdcmd.Arg2,mvdcmd.Arg1,mvdcmd.Arg0);
1752 #endif
1753 }
1754
1755 //------------------------------------------------------------------------------
1756 /// Get MVD firmware interface version
1757 /// @return -firmware interface version
1758 //------------------------------------------------------------------------------
HAL_MVD_GetFWIfVer(MS_U32 u32VpuSid)1759 MS_U32 HAL_MVD_GetFWIfVer(MS_U32 u32VpuSid)
1760 {
1761 #if 0
1762 return HAL_VPU_EX_GetFWVer(u32VpuSid, E_VPU_EX_FW_VER_MVD_IF);
1763 #else
1764 UNUSED(u32VpuSid);
1765 MVD_CmdArg mvdcmd;
1766
1767 SETUP_CMDARG(mvdcmd);
1768 if (HAL_MVD_MVDCommand( CMD_INTERFACE_VERSION, &mvdcmd ) == FALSE)
1769 {
1770 MVD_ERROR( printf( "Command: 0x%x fail!!\r\n", CMD_INTERFACE_VERSION ) );
1771 return 0;
1772 }
1773 return COMBU32(mvdcmd.Arg3,mvdcmd.Arg2,mvdcmd.Arg1,mvdcmd.Arg0);
1774 #endif
1775 }
1776
1777 //------------------------------------------------------------------------------
1778 /// Check MVD firmware status
1779 /// @return -firmware is ready or not
1780 //------------------------------------------------------------------------------
1781
1782 #ifdef VDEC3
_MVD_Check_FW_Rdy(MS_U32 u32VpuSid)1783 static MS_BOOL _MVD_Check_FW_Rdy(MS_U32 u32VpuSid)
1784 {
1785 MS_U32 u32Id = MVD_GetStreamId(u32VpuSid);
1786 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
1787 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u32VpuSid);
1788 MS_U32 u32TimeOut = MsOS_GetSystemTime() + 500;
1789 unsigned int* pVersion = (unsigned int*)MsOS_PA2KSEG1(pstMemCfg->u32FWCodeAddr + OFFSET_BASE + u8VPUIdx*0x100000);
1790 MS_BOOL ret = FALSE;
1791
1792 while(MsOS_GetSystemTime() < u32TimeOut)
1793 {
1794 if(((*pVersion) == FW_VERSION) && ((*(pVersion+4)) == INTERFACE_VERSION))
1795 {
1796 ret = TRUE;
1797 break;
1798 }
1799 }
1800
1801 if (ret == FALSE)
1802 {
1803 MVD_ERROR(printf("MVD f/w header version is wrong,%x,%x,%x,%x\n",(*(pVersion+4)), INTERFACE_VERSION,(*pVersion), FW_VERSION));
1804 }
1805
1806 return ret;
1807 }
1808
1809 #else
_MVD_Check_FW_Rdy(MS_U32 u32VpuSid)1810 static MS_BOOL _MVD_Check_FW_Rdy(MS_U32 u32VpuSid)
1811 {
1812 MS_U32 u32TimeOut = 2000;
1813
1814 //check firmware version consistent with header file
1815 while ((INTERFACE_VERSION != HAL_MVD_GetFWIfVer(u32VpuSid)) && (--u32TimeOut));
1816 if (u32TimeOut == 0)
1817 {
1818 MVD_ERROR(printf("MVD_FW_IF_Version=%lx inconsistent with header file(%x)!\n",
1819 HAL_MVD_GetFWIfVer(u32VpuSid), INTERFACE_VERSION));
1820 return FALSE;
1821 }
1822
1823 if (FW_VERSION != HAL_MVD_GetFWVer(u32VpuSid))
1824 {
1825 MVD_DEBUGINFO(printf("Warning! FWBinVer(%lx) != FWHdrVer(%x)\n", HAL_MVD_GetFWVer(u32VpuSid), FW_VERSION));
1826 }
1827 MVD_DEBUGINFO(printf("MVD version Interface = %x, FW = %x\n", INTERFACE_VERSION, FW_VERSION));
1828
1829 return TRUE;
1830 }
1831 #endif
_DumpCtrl(MS_U8 u8Idx)1832 MS_BOOL _DumpCtrl(MS_U8 u8Idx)
1833 {
1834 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
1835
1836 //printf("u32VA=0x%lx, PA=0x%x\n", u32VA, pstMemCfg->u32FWCodeAddr);
1837 struct _ctl_info *ctl_ptr = (struct _ctl_info *)
1838 HAL_MVD_PA2NonCacheSeg(pstMemCfg->u32FWCodeAddr + CTL_INFO_ADDR);
1839 MS_U32 u32timeout = HAL_MVD_GetTime() + 1000;//u32HVDCmdTimeout;
1840
1841 HAL_MVD_ReadMemory();
1842
1843 MVD_DEBUGINFO(printf("version=0x%x, statue=0x%x, last_ctl_cmd=0x%x, last_ctl_arg=0x%x\n",
1844 ctl_ptr->verion, ctl_ptr->statue, ctl_ptr->last_ctl_cmd, ctl_ptr->last_ctl_arg));
1845
1846 while (CTL_TASK_CMDRDY != ctl_ptr->statue)
1847 {
1848 if (HAL_MVD_GetTime() > u32timeout)
1849 {
1850 MVD_DEBUGERROR(printf("CTRL timeout!!! %d\n", __LINE__));
1851 return FALSE;
1852 }
1853 }
1854
1855 MVD_DEBUGINFO(printf("Version=0x%x, statue=0x%x, last_ctl_cmd=0x%x, last_ctl_arg=0x%x\n",
1856 ctl_ptr->verion, ctl_ptr->statue, ctl_ptr->last_ctl_cmd, ctl_ptr->last_ctl_arg));
1857
1858 MS_U8 i;
1859
1860 for (i = 0; i < 4; i++)
1861 {
1862 MVD_DEBUGINFO(printf("%s: Task %d, status=%d\n", __FUNCTION__, i, ctl_ptr->task_statue[i]));
1863 }
1864 return TRUE;
1865 }
1866
1867
MVD_MapVpuSrcType(MVD_SrcMode eSrcMode)1868 static VPU_EX_SourceType MVD_MapVpuSrcType(MVD_SrcMode eSrcMode)
1869 {
1870 VPU_EX_SourceType eVpuSrcType = E_VPU_EX_INPUT_NONE;
1871 switch (eSrcMode)
1872 {
1873 case E_MVD_TS_MODE:
1874 case E_MVD_TS_FILE_MODE:
1875 eVpuSrcType = E_VPU_EX_INPUT_TSP;
1876 break;
1877
1878 case E_MVD_SLQ_TBL_MODE:
1879 case E_MVD_SLQ_MODE:
1880 case E_MVD_FILE_MODE:
1881 eVpuSrcType = E_VPU_EX_INPUT_FILE;
1882 break;
1883
1884 case E_MVD_SRC_UNKNOWN:
1885 default:
1886 break;
1887 }
1888 return eVpuSrcType;
1889 }
1890
MVD_GetTaskInfo(VPU_EX_TaskInfo * pstTaskInfo,MS_U8 u8Idx,HAL_VPU_StreamId eVpuId)1891 static void MVD_GetTaskInfo(VPU_EX_TaskInfo* pstTaskInfo, MS_U8 u8Idx, HAL_VPU_StreamId eVpuId)
1892 {
1893 pstTaskInfo->u32Id = (u8Idx << 8 | eVpuId);
1894 pstTaskInfo->eDecType = E_VPU_EX_DECODER_MVD;
1895 pstTaskInfo->eVpuId = eVpuId;
1896 pstTaskInfo->eSrcType = MVD_MapVpuSrcType(HAL_MVD_GetSrcMode(u8Idx));
1897 pstTaskInfo->u32HeapSize = MVD_DRAM_SIZE;
1898 }
1899
1900
HAL_MVD_CreateTask(MS_U8 u8Idx,HAL_VPU_StreamId eVpuId,MS_BOOL bShareBBU)1901 MS_BOOL HAL_MVD_CreateTask(MS_U8 u8Idx, HAL_VPU_StreamId eVpuId, MS_BOOL bShareBBU)
1902 {
1903 MS_BOOL bRet = FALSE;
1904 MS_BOOL bFWdecideFB = FALSE;
1905 MVD_FWCfg* pstCfg = HAL_MVD_GetFWCfg(u8Idx);
1906 HAL_VPU_EX_SetFWReload(!(pstCfg->bNotReload));
1907
1908 MVD_DEBUGINFO(printf("\n\n Create Task(%x)!!!\n", u8Idx));
1909 VPU_EX_TaskInfo stTaskInfo;
1910 MVD_GetTaskInfo(&stTaskInfo, u8Idx, eVpuId);
1911
1912 VPU_EX_FWCodeCfg stVpuFWCfg;
1913 VPU_EX_NDecInitPara stVpuInitPara;
1914 stVpuInitPara.pFWCodeCfg = &stVpuFWCfg;
1915 stVpuInitPara.pTaskInfo = &stTaskInfo;
1916 stVpuInitPara.pVLCCfg = NULL;
1917
1918 MVD_MEMCfg* pMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
1919 stVpuFWCfg.u32BinAddr = HAL_MVD_PA2NonCacheSeg(pMemCfg->u32FWBinAddr);
1920 stVpuFWCfg.u32BinSize = pMemCfg->u32FWBinSize;
1921 stVpuFWCfg.u32DstAddr = HAL_MVD_PA2NonCacheSeg(pMemCfg->u32FWCodeAddr);
1922 stVpuFWCfg.u32DstSize = pMemCfg->u32FWCodeSize;
1923 stVpuFWCfg.u8SrcType = pMemCfg->eFWSrcType;
1924
1925 #ifdef VDEC3
1926 VPU_EX_FBCfg pFBCfg;
1927 stVpuInitPara.pFBCfg = &pFBCfg;
1928
1929 if(pMVDHalContext->bCMAUsed == TRUE)
1930 {
1931 stVpuInitPara.pFBCfg->u32FrameBufAddr = (MS_VIRT)pMVDHalContext->cmaInitParam.heap_miu_start_offset;
1932 stVpuInitPara.pFBCfg->u32FrameBufSize = (MS_VIRT)pMVDHalContext->cmaInitParam.heap_length;
1933 bFWdecideFB = TRUE;
1934
1935 }
1936 stTaskInfo.u8HalId = u8Idx;
1937 pMVDHalContext->_stMVDStream[u8Idx].u32SLQId = HAL_VPU_EX_GetBBUId(stTaskInfo.u32Id, &stTaskInfo, bShareBBU);
1938 if(pMVDHalContext->_stMVDStream[u8Idx].u32SLQId == HAL_VPU_INVALID_BBU_ID)
1939 {
1940 MVD_DEBUGINFO(printf("ERROR!!!MVD GetBBU Id Fail \n"));
1941 }
1942 else
1943 {
1944 bRet = HAL_VPU_EX_TaskCreate((MS_U32)eVpuId, (void*)&stVpuInitPara, bFWdecideFB, pMVDHalContext->_stMVDStream[u8Idx].u32SLQId);
1945 }
1946
1947 if(bRet == FALSE)
1948 {
1949 if(!HAL_VPU_EX_FreeBBUId(stTaskInfo.u32Id, pMVDHalContext->_stMVDStream[u8Idx].u32SLQId, &stTaskInfo))
1950 {
1951 MVD_DEBUGERROR(printf("[%s][%d]ERROR!!! Free BBU Id Fail !!!\n",__FUNCTION__,__LINE__));
1952 }
1953 }
1954 #else
1955 bRet = HAL_VPU_EX_TaskCreate((MS_U32)eVpuId, (void*)&stVpuInitPara);
1956 #endif
1957 MVD_DEBUGINFO(printf(" Create Task!!! bRet=%x ###\n\n", bRet));
1958 _DumpCtrl(u8Idx);
1959
1960 return bRet;
1961 }
1962
HAL_MVD_DeleteTask(MS_U8 u8Idx,HAL_VPU_StreamId eVpuId)1963 MS_BOOL HAL_MVD_DeleteTask(MS_U8 u8Idx, HAL_VPU_StreamId eVpuId)
1964 {
1965 MS_BOOL bRet = FALSE;
1966 MVD_DEBUGINFO(printf("\n\n Delete Task(%x)!!!\n", u8Idx));
1967
1968 VPU_EX_TaskInfo stTaskInfo;
1969 MVD_GetTaskInfo(&stTaskInfo, u8Idx, eVpuId);
1970
1971 VPU_EX_FWCodeCfg stVpuFWCfg;
1972 VPU_EX_NDecInitPara stVpuInitPara;
1973 stVpuInitPara.pFWCodeCfg = &stVpuFWCfg;
1974 stVpuInitPara.pTaskInfo = &stTaskInfo;
1975
1976 MVD_MEMCfg* pMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
1977 stVpuFWCfg.u32BinAddr = HAL_MVD_PA2NonCacheSeg(pMemCfg->u32FWBinAddr);
1978 stVpuFWCfg.u32BinSize = pMemCfg->u32FWBinSize;
1979 stVpuFWCfg.u32DstAddr = HAL_MVD_PA2NonCacheSeg(pMemCfg->u32FWCodeAddr);
1980 stVpuFWCfg.u8SrcType = pMemCfg->eFWSrcType;
1981
1982 #ifdef VDEC3
1983 if(!HAL_VPU_EX_FreeBBUId(stTaskInfo.u32Id, pMVDHalContext->_stMVDStream[u8Idx].u32SLQId, &stTaskInfo))
1984 {
1985 MVD_DEBUGINFO(printf("ERROR!!! Free BBU Id Fail !!!\n"));
1986 }
1987 #endif
1988 bRet = HAL_VPU_EX_TaskDelete((MS_U32) eVpuId, &stVpuInitPara);
1989 MVD_DEBUGINFO(printf(" Delete Task!!! ###\n\n"));
1990 _DumpCtrl(u8Idx);
1991 return bRet;
1992 }
1993
HAL_MVD_InitFW(MS_U32 u32VpuSid)1994 MS_BOOL HAL_MVD_InitFW(MS_U32 u32VpuSid)
1995 {
1996 //to fix the timing issue of getting FWIfVer on Chakra2
1997 HAL_MVD_Delayms(1);
1998
1999 //check FW ready
2000 if ( !_MVD_Check_FW_Rdy(u32VpuSid))
2001 {
2002 MS_ASSERT(0);
2003 return FALSE;
2004 }
2005
2006 #if 0
2007 if(pMVDHalContext->_stMVDStream[0].bUsed == FALSE && pMVDHalContext->_stMVDStream[1].bUsed == FALSE) // no mvd is used
2008 {
2009 MVD_CmdArg mvdcmd;
2010 SETUP_CMDARG(mvdcmd);
2011 mvdcmd.Arg0 = 1; //reset mvd engine,if have only one mvd
2012 SET_DECNUM(mvdcmd, ((MS_U8)u32VpuSid));
2013 if (HAL_MVD_MVDCommand( CMD_SW_RESET, &mvdcmd ) == FALSE)
2014 {
2015 MVD_ERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SW_RESET ) );
2016 return FALSE;
2017 }
2018 }
2019 #endif
2020 return TRUE;
2021 }
2022
2023 #define _MVD_INIT_FAIL_RET() \
2024 do { \
2025 HAL_MVD_SetIsUsed(u8HalIdx, FALSE); \
2026 return FALSE; \
2027 } while (0)
2028
2029
HAL_MVD_Init(MS_U8 u8HalIdx,MVD_CodecType eCodecType,MS_U32 u32VpuSid,MS_BOOL bShareBBU)2030 MS_BOOL HAL_MVD_Init(MS_U8 u8HalIdx, MVD_CodecType eCodecType, MS_U32 u32VpuSid, MS_BOOL bShareBBU)
2031 {
2032 //OSAL_MVD_MutexInit();
2033 MS_BOOL no_use = FALSE;
2034 MS_BOOL ret;
2035
2036 ret = MDrv_MVD_AUTH_IPCheck(eCodecType,&no_use);
2037 if(ret == FALSE)
2038 {
2039 return FALSE;
2040 }
2041
2042 if (!HAL_MVD_CreateTask(u8HalIdx, (HAL_VPU_StreamId)u32VpuSid, bShareBBU))
2043 {
2044 _MVD_INIT_FAIL_RET();
2045 }
2046
2047 pMVDHalContext->bStopped[u8HalIdx] = FALSE;
2048
2049 if (!HAL_MVD_InitFW(u8HalIdx))
2050 {
2051 MVD_DEBUGERROR(printf("%s:HAL_MVD_InitFW(%x) failed\n", __FUNCTION__, u8HalIdx));
2052 if (!HAL_MVD_DeleteTask(u8HalIdx, (HAL_VPU_StreamId)u32VpuSid))
2053 {
2054 MVD_DEBUGERROR(printf("%s:HAL_MVD_DeleteTask failed\n", __FUNCTION__));
2055 }
2056
2057 _MVD_INIT_FAIL_RET();
2058 }
2059 else
2060 {
2061 MVD_DEBUGINFO(printf("%s:HAL_MVD_InitFW(%x) success\n", __FUNCTION__, u8HalIdx));
2062 }
2063
2064 HAL_MVD_SetIsUsed(u8HalIdx, TRUE);
2065
2066 return TRUE;
2067 }
2068
2069 #define _MVD_CMDRDY ((HAL_MVD_RegReadByte(MVD_STATUS) & MVD_STATUS_READY) == MVD_STATUS_READY)
2070 //------------------------------------------------------------------------------
2071 /// Check if MVD command is ready
2072 /// @return TRUE or FALSE
2073 /// - TRUE, Success to process the command
2074 /// - FALSE, Failed due to timeout
2075 //------------------------------------------------------------------------------
HAL_MVD_GetCmdRdy(void)2076 MS_BOOL HAL_MVD_GetCmdRdy(void)
2077 {
2078 MS_U32 timeoutTick = 2000;
2079
2080 while ((!_MVD_CMDRDY) && ((timeoutTick--)!=0));
2081
2082 if (0 == timeoutTick)
2083 return FALSE;
2084 else
2085 return TRUE;
2086 }
2087
HAL_MVD_CheckIdle(void)2088 MS_BOOL HAL_MVD_CheckIdle(void)
2089 {
2090 MS_BOOL bIsIdle = FALSE;
2091 MVD_CmdArg mvdcmd;
2092
2093 //issue CheckIdle command
2094 SETUP_CMDARG(mvdcmd);
2095 SET_CMD_RET_FALSE(CMD_MVD_IDLE, &mvdcmd);
2096
2097 bIsIdle = (mvdcmd.Arg0 == 1);
2098 if (HAL_MVD_GetCmdRdy())
2099 {
2100 return bIsIdle;
2101 }
2102 else
2103 {
2104 return FALSE;
2105 }
2106 }
2107
2108
_MVD_SoftRstHW(void)2109 static MS_BOOL _MVD_SoftRstHW(void)
2110 {
2111 return FALSE;
2112 }
2113
2114 //------------------------------------------------------------------------------
2115 /// Soft-reset MVD
2116 /// Ref AP note p.12 HK2MVD Reset Flow
2117 /// @return TRUE or FALSE
2118 /// - TRUE, Success to soft-reset MVD
2119 /// - FALSE, Failed. Need init MVD again.
2120 //------------------------------------------------------------------------------
HAL_MVD_SoftRstHW(void)2121 MS_BOOL HAL_MVD_SoftRstHW(void)
2122 {
2123 MS_U32 timetick = 2000;
2124
2125 if (HAL_MVD_GetCmdRdy())
2126 {
2127 //idle check
2128 while ((!HAL_MVD_CheckIdle()) && ((timetick--)!=0));
2129
2130 //either MVD is idle or timeout, do ENG/SLQ reset
2131 return _MVD_SoftRstHW(); //Reset HW engine
2132 }
2133 else
2134 {
2135 return FALSE; //here means "CPU hanging"
2136 }
2137 }
2138
2139 //------------------------------------------------------------------------------
2140 /// Clean the IRQ bit (in interrupt handler should call this function while the
2141 /// interrupt has been triggered.
2142 /// @param none
2143 /// @return none
2144 /// @internal
2145 //------------------------------------------------------------------------------
HAL_MVD_ClearIRQ(void)2146 void HAL_MVD_ClearIRQ(void)
2147 {
2148 OSAL_MVD_LockHwMutex();
2149 HAL_MVD_RegWriteBit(MVD_CTRL, 1, MVD_CTRL_CLR_INT);
2150 OSAL_MVD_UnlockHwMutex();
2151 return;
2152 }
2153
2154 //------------------------------------------------------------------------------
2155 /// Set display speed.
2156 ///FW use (# of B frames) / (# of decode frames) < Ratio this formula to adjustment.
2157 ///Once if the ratio is 1, that means, whenever (#Bframes / #decoded) < 1, then
2158 ///FW would drop the B frame.
2159 ///In other words, once AP need to back to normal mode, AP have to set the arg0 to 0.
2160 //------------------------------------------------------------------------------
HAL_MVD_SetSpeed(MS_U8 u8Idx,MVD_SpeedType eSpeedType,MS_U8 u8Multiple)2161 MS_BOOL HAL_MVD_SetSpeed(MS_U8 u8Idx, MVD_SpeedType eSpeedType, MS_U8 u8Multiple)
2162 {
2163 MVD_CmdArg mvdcmd;
2164
2165 SETUP_CMDARG(mvdcmd);
2166
2167 if (E_MVD_SPEED_FAST == eSpeedType)
2168 mvdcmd.Arg0 = 1; //fast forward
2169 else if (E_MVD_SPEED_SLOW == eSpeedType)
2170 mvdcmd.Arg0 = 2; //slow motion
2171 else
2172 mvdcmd.Arg0 = 0; //normal speed
2173
2174 if (u8Multiple == 1)
2175 {
2176 mvdcmd.Arg0 = 0;
2177 //The only way to be NORMAL speed.
2178 }
2179
2180 mvdcmd.Arg1 = u8Multiple;
2181
2182 if(pMVDHalContext->bTrickPlay2xAVSync[u8Idx] == TRUE && eSpeedType == E_MVD_SPEED_FAST && u8Multiple == 2)
2183 {
2184 mvdcmd.Arg2 = 1;
2185 }
2186 else
2187 {
2188 mvdcmd.Arg2 = 0;
2189 }
2190
2191 SET_DECNUM(mvdcmd, u8Idx);
2192 SET_CMD_RET_FALSE(CMD_DISP_SPEED_CTRL, &mvdcmd);
2193 return TRUE;
2194 }
2195
2196 //------------------------------------------------------------------------------
2197 /// Set frame buffer address to MVD
2198 /// @param -u32addr \b IN : start address
2199 //------------------------------------------------------------------------------
HAL_MVD_SetFrameBuffAddr(MS_U8 u8Idx,MS_VIRT u32addr,MS_U8 u8fbMode)2200 void HAL_MVD_SetFrameBuffAddr(MS_U8 u8Idx, MS_VIRT u32addr, MS_U8 u8fbMode)
2201 {
2202 MVD_CmdArg mvdcmd;
2203 if(pMVDHalContext->bCMAUsed)
2204 {
2205 u8fbMode = MVD_CMA_MODE;
2206 }
2207
2208 if ((u32addr>>3) > MAX_ADD_28BIT)// TODO: fixme, in 64bits system, address may be more than 28 bits
2209 {
2210 MVD_DEBUGERROR(printf("MDrv_MVD_SetFrameBuffAddr: only support 28bit add!\n"));
2211 return;
2212 }
2213
2214 MS_ASSERT((u32addr%8)==0);
2215 u32addr >>= 3;
2216
2217 SETUP_CMDARG(mvdcmd);
2218 mvdcmd.Arg0 = L_WORD(u32addr);
2219 mvdcmd.Arg1 = H_WORD(u32addr);
2220 mvdcmd.Arg2 = L_DWORD(u32addr);
2221
2222 //Frame Buffer Mode Setting
2223 mvdcmd.Arg3 = u8fbMode | ((u32addr>>24)&0x0f);
2224 mvdcmd.Arg4 = u8fbMode & 0xff;
2225 MVD_DEBUGINFO(printf("FramebufferAdd 0x%lx, FB Mode 0x%x, arg3=0x%x\n", (unsigned long)u32addr, u8fbMode, mvdcmd.Arg3));
2226 SET_DECNUM(mvdcmd, u8Idx);
2227 if (HAL_MVD_MVDCommand( CMD_FB_BASE, &mvdcmd ) == FALSE)
2228 {
2229 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FB_BASE ) );
2230 return;
2231 }
2232
2233 return;
2234 }
2235
2236 //------------------------------------------------------------------------------
2237 /// Set header buffer address to MVD
2238 /// @param -u32addr \b IN : start address
2239 //------------------------------------------------------------------------------
HAL_MVD_SetHeaderBufferAddr(MS_U8 u8Idx,MS_VIRT u32addr)2240 void HAL_MVD_SetHeaderBufferAddr (MS_U8 u8Idx, MS_VIRT u32addr )
2241 {
2242 MVD_CmdArg mvdcmd;
2243
2244 MS_ASSERT((u32addr%8)==0);
2245 u32addr >>= 3;
2246
2247 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2248 if (HAL_MVD_MVDCommand( CMD_HEADER_INFO_BUF, &mvdcmd ) == FALSE)
2249 {
2250 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_HEADER_INFO_BUF ) );
2251 }
2252 return;
2253 }
2254
2255 //------------------------------------------------------------------------------
2256 /// Set vol info buffer address to MVD
2257 /// @param -u32addr \b IN : start address
2258 //------------------------------------------------------------------------------
HAL_MVD_SetVolInfoBufferAddr(MS_U8 u8Idx,MS_VIRT u32addr)2259 void HAL_MVD_SetVolInfoBufferAddr (MS_U8 u8Idx, MS_VIRT u32addr )
2260 {
2261 MVD_CmdArg mvdcmd;
2262
2263 MS_ASSERT((u32addr%8)==0);
2264 u32addr >>= 3;
2265
2266 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2267 if (HAL_MVD_MVDCommand( CMD_VOL_INFO_BUF, &mvdcmd ) == FALSE)
2268 {
2269 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_VOL_INFO_BUF ) );
2270 }
2271 return;
2272 }
2273
2274 //------------------------------------------------------------------------------
2275 /// Set frame info buffer address to MVD
2276 /// @param -u32addr \b IN : start address
2277 //------------------------------------------------------------------------------
HAL_MVD_SetFrameInfoBufferAddr(MS_U8 u8Idx,MS_VIRT u32addr)2278 void HAL_MVD_SetFrameInfoBufferAddr (MS_U8 u8Idx, MS_VIRT u32addr )
2279 {
2280 MVD_CmdArg mvdcmd;
2281
2282 MS_ASSERT((u32addr%8)==0);
2283 u32addr >>= 3;
2284
2285 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2286 if (HAL_MVD_MVDCommand( CMD_FRAME_INFO_BUF, &mvdcmd ) == FALSE)
2287 {
2288 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FRAME_INFO_BUF ) );
2289 }
2290 return;
2291 }
2292
2293 //------------------------------------------------------------------------------
2294 /// Set IAP buffer address to MVD
2295 /// @param -u32addr \b IN : start address
2296 //------------------------------------------------------------------------------
HAL_MVD_SetIAPBufferAddr(MS_U8 u8Idx,MS_VIRT u32addr)2297 void HAL_MVD_SetIAPBufferAddr (MS_U8 u8Idx, MS_VIRT u32addr )
2298 {
2299 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
2300 MVD_CmdArg mvdcmd;
2301 MS_ASSERT((u32addr%8192)==0);
2302 u32addr >>= 13;
2303
2304 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2305 mvdcmd.Arg4 = pstMemCfg->u8FBMiuSel;
2306 if (HAL_MVD_MVDCommand( CMD_IAP_BUF_START, &mvdcmd ) == FALSE)
2307 {
2308 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_IAP_BUF_START ) );
2309 }
2310 return;
2311 }
2312
2313 //------------------------------------------------------------------------------
2314 /// Set Data Partition buffer address to MVD
2315 /// @param -u32addr \b IN : start address
2316 //------------------------------------------------------------------------------
HAL_MVD_SetDPBufferAddr(MS_U8 u8Idx,MS_VIRT u32addr)2317 void HAL_MVD_SetDPBufferAddr (MS_U8 u8Idx, MS_VIRT u32addr )
2318 {
2319 MVD_CmdArg mvdcmd;
2320 MS_ASSERT((u32addr%8)==0);
2321 u32addr >>= 3;
2322
2323 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2324 if (HAL_MVD_MVDCommand( CMD_DP_BUF_START, &mvdcmd ) == FALSE)
2325 {
2326 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DP_BUF_START ) );
2327 }
2328 return;
2329 }
2330
2331 //------------------------------------------------------------------------------
2332 /// Set Motion Vector buffer address to MVD
2333 /// @param -u32addr \b IN : start address
2334 //------------------------------------------------------------------------------
HAL_MVD_SetMVBufferAddr(MS_U8 u8Idx,MS_VIRT u32addr)2335 void HAL_MVD_SetMVBufferAddr (MS_U8 u8Idx, MS_VIRT u32addr )
2336 {
2337 MVD_CmdArg mvdcmd;
2338 MS_ASSERT((u32addr%2048)==0);
2339 u32addr >>= 3;
2340
2341 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2342 if (HAL_MVD_MVDCommand( CMD_MV_BUF_START, &mvdcmd ) == FALSE)
2343 {
2344 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_MV_BUF_START ) );
2345 }
2346 return;
2347 }
2348
_MVD_SetUserDataBufStart(MS_U8 u8Idx,MS_VIRT u32addr,MS_U8 u8arg3)2349 static void _MVD_SetUserDataBufStart(MS_U8 u8Idx, MS_VIRT u32addr, MS_U8 u8arg3)
2350 {
2351 MVD_CmdArg mvdcmd;
2352
2353 MS_ASSERT((u32addr%8)==0);
2354 u32addr >>= 3;
2355 MVD_DEBUGINFO(printf("%s add=0x%lx arg3=0x%x\n", __FUNCTION__, (unsigned long)u32addr, u8arg3));
2356
2357 SETUP_CMDARG(mvdcmd);
2358 mvdcmd.Arg0 = L_WORD(u32addr);
2359 mvdcmd.Arg1 = H_WORD(u32addr);
2360 mvdcmd.Arg2 = L_DWORD(u32addr);
2361 mvdcmd.Arg4 = H_DWORD(u32addr);
2362 mvdcmd.Arg3 = u8arg3;
2363 SET_DECNUM(mvdcmd, u8Idx);
2364 if (HAL_MVD_MVDCommand( CMD_USER_BUF_START, &mvdcmd ) == FALSE)
2365 {
2366 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_USER_BUF_START ) );
2367 return;
2368 }
2369 return;
2370 }
2371
_MVD_SetUserDataBufSize(MS_U8 u8Idx,MS_U32 u32size,MS_U8 u8arg3)2372 static void _MVD_SetUserDataBufSize(MS_U8 u8Idx, MS_U32 u32size, MS_U8 u8arg3)
2373 {
2374 MVD_CmdArg mvdcmd;
2375
2376 MS_ASSERT((u32size%8)==0);
2377 u32size >>= 3;
2378 MVD_DEBUGINFO(printf("%s add=0x%x arg3=0x%x\n", __FUNCTION__, u32size, u8arg3));
2379
2380 SETUP_CMDARG(mvdcmd);
2381 mvdcmd.Arg0 = L_WORD(u32size);
2382 mvdcmd.Arg1 = H_WORD(u32size);
2383 mvdcmd.Arg2 = L_DWORD(u32size);
2384 mvdcmd.Arg4 = H_DWORD(u32size);
2385 mvdcmd.Arg3 = u8arg3;
2386 if(mvdcmd.Arg3 <= 1) //mean 608 and 708 in MM RVU
2387 {
2388 mvdcmd.Arg2 = 7;//ntsc1+ntsc2+atsc
2389 mvdcmd.Arg4 = 0;
2390 }
2391 SET_DECNUM(mvdcmd, u8Idx);
2392 if (HAL_MVD_MVDCommand( CMD_USER_BUF_SIZE, &mvdcmd ) == FALSE)
2393 {
2394 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_USER_BUF_SIZE ) );
2395 return;
2396 }
2397 return;
2398 }
2399
2400 //------------------------------------------------------------------------------
2401 /// Set user data buffer address to MVD
2402 /// @param -u32addr \b IN : start address
2403 //------------------------------------------------------------------------------
HAL_MVD_SetUserDataBuf(MS_U8 u8Idx,MS_VIRT u32addr,MS_U32 u32size)2404 void HAL_MVD_SetUserDataBuf(MS_U8 u8Idx, MS_VIRT u32addr, MS_U32 u32size)
2405 {
2406 MS_U8 u8ccType = 0;
2407
2408 MS_ASSERT((u32addr%8)==0);
2409 MS_ASSERT((u32size%8)==0);
2410 #ifdef REDLION_LINUX_KERNEL_ENVI
2411 u8ccType = 2;
2412 #elif defined(MVD_SUPPORT_X4_CC)
2413 u8ccType = 4; //display order
2414 #else
2415 u8ccType = 2;// 2 for testing 0;
2416 #endif
2417
2418 #if defined(MVD_SUPPORT_X4_CC)
2419 //set decoding buffer address
2420 _MVD_SetUserDataBufStart(u8Idx, u32addr+u32size, 3);
2421 #endif
2422
2423 //set CC output buffer address
2424 _MVD_SetUserDataBufStart(u8Idx, u32addr, u8ccType);
2425
2426 #if defined(MVD_SUPPORT_X4_CC)
2427 //set decoding buffer size
2428 _MVD_SetUserDataBufSize(u8Idx, u32size, 3);
2429 #endif
2430
2431 //set CC output buffer size
2432 _MVD_SetUserDataBufSize(u8Idx, u32size, u8ccType);
2433
2434 return;
2435 }
2436
HAL_MVD_SetSLQTblBufStartEnd(MS_U8 u8Idx,MS_VIRT u32start,MS_VIRT u32end)2437 void HAL_MVD_SetSLQTblBufStartEnd(MS_U8 u8Idx, MS_VIRT u32start, MS_VIRT u32end)
2438 {
2439 MVD_CmdArg mvdcmd;
2440 MS_U32 u32val = u32end>>3;
2441 MVD_DEBUGINFO(printf("%s st=0x%lx end=0x%lx\n", __FUNCTION__, (unsigned long)u32start, (unsigned long)u32end));
2442
2443 SET_CMDARG(mvdcmd, u32val, u8Idx);
2444 if (HAL_MVD_MVDCommand( CMD_SLQ_TBL_BUF_END, &mvdcmd ) == FALSE)
2445 {
2446 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLQ_TBL_BUF_END ) );
2447 return;
2448 }
2449
2450 u32val = (u32start)>>3;
2451 SET_CMDARG(mvdcmd, u32val, u8Idx);
2452 if (HAL_MVD_MVDCommand( CMD_SLQ_TBL_BUF_START, &mvdcmd ) == FALSE)
2453 {
2454 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLQ_TBL_BUF_START ) );
2455 return;
2456 }
2457
2458 MVD_DEBUGINFO(printf("%s st=0x%lx end=0x%lx OK!!!\n", __FUNCTION__, (unsigned long)u32start, (unsigned long)u32end));
2459 return;
2460 }
2461
2462 //------------------------------------------------------------------------------
2463 /// Issue StepDisplay command.
2464 /// @return -TRUE for success; FALSE for failure.
2465 //------------------------------------------------------------------------------
HAL_MVD_StepDisp(MS_U8 u8Idx)2466 MS_BOOL HAL_MVD_StepDisp(MS_U8 u8Idx)
2467 {
2468 MVD_CmdArg mvdcmd;
2469
2470 MVD_SetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_STEP_DISP_DONE, sizeof(MS_U8), 0);
2471
2472 SETUP_CMDARG(mvdcmd);
2473 SET_DECNUM(mvdcmd, u8Idx);
2474 SET_CMD_RET_FALSE(CMD_STEP_DISP_DECODE_ONE, &mvdcmd);
2475 if (HAL_MVD_Resume(u8Idx) == FALSE)
2476 {
2477 MVD_DEBUGERROR( printf( "Command: HAL_MVD_Resume fail!!\r\n" ) );
2478 return FALSE;
2479 }
2480
2481 return TRUE;
2482 }
2483
2484 //------------------------------------------------------------------------------
2485 /// Get ES read address for TS file mode.
2486 /// @return ES read address
2487 //------------------------------------------------------------------------------
HAL_MVD_GetTsFileESReadPtr(MS_U8 u8Idx)2488 MS_VIRT HAL_MVD_GetTsFileESReadPtr(MS_U8 u8Idx)
2489 {
2490 MS_VIRT u32Add = 0;
2491 MVD_CmdArg mvdcmd;
2492
2493 SETUP_CMDARG(mvdcmd);
2494 mvdcmd.Arg0 = 2; //ES diff
2495 SET_DECNUM(mvdcmd, u8Idx);
2496 if (HAL_MVD_MVDCommand( CMD_PARSER_READ_POSITION, &mvdcmd ) == TRUE)
2497 {
2498 //in order to latch the newest parser status
2499 //u32Diff = (((MS_U32)mvdcmd.Arg3) <<24) | (((MS_U32)mvdcmd.Arg2) <<16) |
2500 // (((MS_U32)mvdcmd.Arg1) << 8) | (((MS_U32)mvdcmd.Arg0));
2501 }
2502 else
2503 {
2504 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail!!\n", CMD_PARSER_READ_POSITION) );
2505 }
2506
2507 SETUP_CMDARG(mvdcmd);
2508 mvdcmd.Arg0 = 1;
2509 SET_DECNUM(mvdcmd, u8Idx);
2510 if (HAL_MVD_MVDCommand( CMD_PARSER_READ_POSITION, &mvdcmd ) == TRUE)
2511 {
2512 u32Add = (((MS_U32)mvdcmd.Arg3) <<24) |
2513 (((MS_U32)mvdcmd.Arg2) <<16) |
2514 (((MS_U32)mvdcmd.Arg1) << 8) |
2515 (((MS_U32)mvdcmd.Arg0));
2516 }
2517 else
2518 {
2519 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail!!\n", CMD_PARSER_READ_POSITION) );
2520 }
2521
2522 return (u32Add*8);
2523 }
2524
2525 //------------------------------------------------------------------------------
2526 /// Get ES write address for TS file mode.
2527 /// @return ES write address
2528 //------------------------------------------------------------------------------
HAL_MVD_GetTsFileESWritePtr(MS_U8 u8Idx)2529 MS_VIRT HAL_MVD_GetTsFileESWritePtr(MS_U8 u8Idx)
2530 {
2531 MS_VIRT u32Diff = 0;
2532 MS_VIRT u32WrPtr = 0;
2533 MVD_CmdArg mvdcmd;
2534 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
2535 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
2536
2537 SETUP_CMDARG(mvdcmd);
2538 mvdcmd.Arg0 = 2; //ES diff
2539 SET_DECNUM(mvdcmd, u8Idx);
2540 if (HAL_MVD_MVDCommand( CMD_PARSER_READ_POSITION, &mvdcmd ) == TRUE)
2541 {
2542 u32Diff = (((MS_U32)mvdcmd.Arg3) <<24) | (((MS_U32)mvdcmd.Arg2) <<16) |
2543 (((MS_U32)mvdcmd.Arg1) << 8) | (((MS_U32)mvdcmd.Arg0));
2544 }
2545 else
2546 {
2547 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail!!\n", CMD_PARSER_READ_POSITION) );
2548 }
2549
2550 u32WrPtr = u32Diff*8 + HAL_MVD_GetTsFileESReadPtr(u8Idx);
2551 if (u32WrPtr > pstSlqTblInfo->u32ESBuffEnd)
2552 {
2553 MVD_DEBUGINFO(printf("ES wrapping Wr=0x%lx ==> ", (unsigned long)u32WrPtr));
2554 u32WrPtr -= pstMemCfg->u32BSSize;
2555 MVD_DEBUGINFO(printf("0x%lx\n", (unsigned long)u32WrPtr));
2556 }
2557 return u32WrPtr;
2558 }
2559
2560 //------------------------------------------------------------------------------
2561 /// Enable/Disable firmware to show the last frame.
2562 /// @return -TRUE for success; FALSE for failure.
2563 //------------------------------------------------------------------------------
HAL_MVD_EnableLastFrameShow(MS_U8 u8Idx,MS_BOOL bEnable)2564 MS_BOOL HAL_MVD_EnableLastFrameShow(MS_U8 u8Idx, MS_BOOL bEnable)
2565 {
2566 MVD_CmdArg mvdcmd;
2567 MVD_SrcMode curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
2568 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
2569 MS_VIRT* pu32FileEndPtr = &pstSlqTblInfo->u32FileEndPtr;
2570
2571 if (E_MVD_SLQ_TBL_MODE == curSrcMode)
2572 {
2573 #if SLQ_NEW_PUSH
2574 if (pstSlqTblInfo->pSlqStatus->bSlqCtrlBit)
2575 {
2576 pstSlqTblInfo->pDrvSlqTbl->u32WrPtr = pstSlqTblInfo->pSlqStatus->u32VaildWptrAddr + SLQ_ENTRY_LEN;
2577 }
2578 #endif //
2579 //save current writePtr
2580 if (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr != pstSlqTblInfo->pDrvSlqTbl->u32EndAdd)
2581 {
2582 *pu32FileEndPtr = pstSlqTblInfo->pDrvSlqTbl->u32WrPtr;
2583 }
2584 else
2585 {
2586 *pu32FileEndPtr = pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
2587 }
2588 MVD_DEBUGINFO(printf("fe=%lx, rd=%lx, wr=%lx\n", (unsigned long)*pu32FileEndPtr,
2589 (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32RdPtr, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32WrPtr));
2590 }
2591
2592 SETUP_CMDARG(mvdcmd);
2593 mvdcmd.Arg0 = bEnable;
2594 SET_DECNUM(mvdcmd, u8Idx);
2595 SET_CMD_RET_FALSE(CMD_ENABLE_LAST_FRAME_SHOW, &mvdcmd);
2596 return TRUE;
2597 }
2598
2599
HAL_MVD_SlqTblRst(MS_U8 u8Idx)2600 MS_BOOL HAL_MVD_SlqTblRst(MS_U8 u8Idx)
2601 {
2602 MVD_CmdArg mvdcmd;
2603 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
2604
2605 SETUP_CMDARG(mvdcmd);
2606 SET_DECNUM(mvdcmd, u8Idx);
2607 SET_CMD_RET_FALSE(CMD_VC1_HW_SLQ_RESET, &mvdcmd);
2608 pstSlqTblInfo->bEnSlqTblHkCtrl = FALSE;
2609 return TRUE;
2610 }
2611
HAL_MVD_SeekToPTS(MS_U8 u8Idx,MS_U32 u32Pts)2612 MS_BOOL HAL_MVD_SeekToPTS(MS_U8 u8Idx, MS_U32 u32Pts)
2613 {
2614 MVD_CmdArg mvdcmd;
2615
2616 SET_CMDARG(mvdcmd, u32Pts, u8Idx);
2617 SET_CMD_RET_FALSE(CMD_STEP_TO_PTS, &mvdcmd);
2618
2619 if (HAL_MVD_Resume(u8Idx) == FALSE)
2620 {
2621 MVD_DEBUGERROR( printf( "Command: HAL_MVD_Resume fail!!\r\n" ) );
2622 return FALSE;
2623 }
2624 return TRUE;
2625 }
2626
HAL_MVD_SkipToPTS(MS_U8 u8Idx,MS_U32 u32Pts)2627 MS_BOOL HAL_MVD_SkipToPTS(MS_U8 u8Idx, MS_U32 u32Pts)
2628 {
2629 MVD_CmdArg mvdcmd;
2630
2631 SET_CMDARG(mvdcmd, u32Pts, u8Idx);
2632 SET_CMD_RET_FALSE(CMD_SKIP_TO_PTS, &mvdcmd);
2633
2634 if (HAL_MVD_Resume(u8Idx) == FALSE)
2635 {
2636 MVD_DEBUGERROR( printf( "Command: HAL_MVD_Resume fail!!\r\n" ) );
2637 return FALSE;
2638 }
2639 return TRUE;
2640 }
2641
HAL_MVD_TrickPlay(MS_U8 u8Idx,MVD_TrickDec trickDec,MS_U8 u8DispDuration)2642 MS_BOOL HAL_MVD_TrickPlay(MS_U8 u8Idx, MVD_TrickDec trickDec, MS_U8 u8DispDuration)
2643 {
2644 MVD_CmdArg mvdcmd;
2645 MS_U8 u8DecType;
2646
2647 switch (trickDec)
2648 {
2649 case E_MVD_TRICK_DEC_ALL:
2650 u8DecType = 0;
2651 break;
2652 case E_MVD_TRICK_DEC_I:
2653 u8DecType = 1;
2654 break;
2655 case E_MVD_TRICK_DEC_IP:
2656 u8DecType = 2;
2657 break;
2658 default:
2659 return FALSE;
2660 break;
2661 }
2662
2663 SETUP_CMDARG(mvdcmd);
2664 mvdcmd.Arg0 = u8DecType;
2665 mvdcmd.Arg1 = u8DispDuration;
2666 SET_DECNUM(mvdcmd, u8Idx);
2667 SET_CMD_RET_FALSE(CMD_FAST_SLOW, &mvdcmd);
2668
2669 pMVDHalContext->stCtrlCfg[u8Idx].eTrickMode = trickDec;
2670 return TRUE;
2671 }
2672
HAL_MVD_FlushDisplayBuf(MS_U8 u8Idx)2673 MS_BOOL HAL_MVD_FlushDisplayBuf(MS_U8 u8Idx)
2674 {
2675 #define STOP_TIMEOUT 500 //ms
2676 MS_U32 u32StartTime = 0;
2677
2678 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_FLUSHQUEUE_COMMAND);
2679 MVD_CmdArg mvdcmd;
2680 SETUP_CMDARG(mvdcmd);
2681 SET_DECNUM(mvdcmd, u8Idx);
2682 SET_CMD_RET_FALSE(CMD_FLUSH_DISP_QUEUE, &mvdcmd);
2683
2684 u32StartTime = HAL_MVD_GetTime();
2685
2686 while(!HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_FLUSHQUEUE_COMMAND))
2687 {
2688 if ((HAL_MVD_GetTime()-u32StartTime)>STOP_TIMEOUT)
2689 {
2690 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail timeout!!\r\n", CMD_FLUSH_DISP_QUEUE ) );
2691 break;
2692 }
2693 }
2694
2695 return TRUE;
2696 }
2697
2698
HAL_MVD_SetFileModeAVSync(MS_U8 u8Idx,MVD_TIMESTAMP_TYPE eSyncMode)2699 MS_BOOL HAL_MVD_SetFileModeAVSync(MS_U8 u8Idx, MVD_TIMESTAMP_TYPE eSyncMode)
2700 {
2701 MVD_CmdArg mvdcmd;
2702 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
2703
2704 pstCtrlCfg->eFileSyncMode = eSyncMode;
2705 MVD_DEBUGINFO(printf("%s eSyncMode=%d\n", __FUNCTION__, eSyncMode));
2706 SETUP_CMDARG(mvdcmd);
2707 switch (eSyncMode)
2708 {
2709 case E_MVD_TIMESTAMP_PTS:
2710 case E_MVD_TIMESTAMP_PTS_RVU:
2711 mvdcmd.Arg0 = FILE_PTS_MODE;
2712 break;
2713
2714 case E_MVD_TIMESTAMP_DTS:
2715 case E_MVD_TIMESTAMP_DTS_RVU:
2716 mvdcmd.Arg0 = FILE_DTS_MODE;
2717 break;
2718 case E_MVD_TIMESTAMP_NEW_STS:
2719 mvdcmd.Arg0 = FILE_STS_MODE;
2720 break;
2721 case E_MVD_TIMESTAMP_FREERUN:
2722 default:
2723 mvdcmd.Arg0 = NONE_FILE_MODE; //Freerun
2724 break;
2725 }
2726 SET_DECNUM(mvdcmd, u8Idx);
2727 SET_CMD_RET_FALSE(CMD_ENABLE_FILE_SYNC, &mvdcmd);
2728
2729 SETUP_CMDARG(mvdcmd);
2730 switch (eSyncMode) //for set RVU mode
2731 {
2732 case E_MVD_TIMESTAMP_PTS_RVU:
2733 mvdcmd.Arg0 = FILE_PTS_MODE;
2734 break;
2735 case E_MVD_TIMESTAMP_DTS_RVU:
2736 mvdcmd.Arg0 = FILE_DTS_MODE;
2737 break;
2738 case E_MVD_TIMESTAMP_FREERUN:
2739 default:
2740 mvdcmd.Arg0 = 0xFF;
2741 break;
2742 }
2743 SET_DECNUM(mvdcmd, u8Idx);
2744 SET_CMD_RET_FALSE(CMD_RVU_EN, &mvdcmd);
2745 return TRUE;
2746 }
2747
2748
2749
2750
2751 //------------------------------------------------------------------------------
2752 /// Set the start address of PTS table used for SLQ table link mode.
2753 /// @return -TRUE for success; FALSE for failure.
2754 //------------------------------------------------------------------------------
HAL_MVD_SetPtsTblAddr(MS_U8 u8Idx,MS_VIRT u32addr)2755 MS_BOOL HAL_MVD_SetPtsTblAddr(MS_U8 u8Idx, MS_VIRT u32addr)
2756 {
2757 MVD_CmdArg mvdcmd;
2758
2759 MS_ASSERT((u32addr%8)==0);
2760 u32addr >>= 3;
2761
2762 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2763 SET_CMD_RET_FALSE(CMD_PTS_TBL_START, &mvdcmd);
2764 return TRUE;
2765 }
2766
HAL_MVD_SkipToIFrame(MS_U8 u8Idx)2767 MS_BOOL HAL_MVD_SkipToIFrame(MS_U8 u8Idx)
2768 {
2769 MVD_CmdArg mvdcmd;
2770 SETUP_CMDARG(mvdcmd);
2771 SET_DECNUM(mvdcmd, u8Idx);
2772 SET_CMD_RET_FALSE(CMD_START_DEC_STRICT, &mvdcmd);
2773 return TRUE;
2774 }
2775
2776 //Map driver FRC (Frame rate conversion) mode to firmware's.
HAL_MVD_MapFrcMode(MVD_FrcMode eFrcMode)2777 MS_U8 HAL_MVD_MapFrcMode(MVD_FrcMode eFrcMode)
2778 {
2779 MS_U8 frcMode = 0xf;
2780 switch (eFrcMode)
2781 {
2782 case E_MVD_FRC_NORMAL:
2783 frcMode = FrcNormal;
2784 break;
2785 case E_MVD_FRC_DISP_TWICE:
2786 frcMode = FrcDisplayTwice;
2787 break;
2788 case E_MVD_FRC_3_2_PULLDOWN: //film 24 -> 50i
2789 frcMode = Frc32Pulldown;
2790 break;
2791 case E_MVD_FRC_PAL_TO_NTSC:
2792 frcMode = FrcPALtoNTSC;
2793 break;
2794 case E_MVD_FRC_NTSC_TO_PAL:
2795 frcMode = FrcNTSCtoPAL;
2796 break;
2797 case E_MVD_FRC_DISP_ONEFIELD:
2798 frcMode = FrcShowOneFiled;
2799 break;
2800 default:
2801 break;
2802 }
2803 return frcMode;
2804 }
2805
HAL_MVD_DispCtrl(MS_U8 u8Idx,MS_BOOL bDecOrder,MS_BOOL bDropErr,MS_BOOL bDropDisp,MVD_FrcMode eFrcMode)2806 MS_BOOL HAL_MVD_DispCtrl(MS_U8 u8Idx, MS_BOOL bDecOrder, MS_BOOL bDropErr, MS_BOOL bDropDisp, MVD_FrcMode eFrcMode)
2807 {
2808 MVD_CmdArg mvdcmd;
2809 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
2810 MS_BOOL* pbDropErrFrm = &pstCtrlCfg->bDropErrFrm;
2811
2812 SETUP_CMDARG(mvdcmd);
2813 mvdcmd.Arg0 = (MS_U8)bDecOrder;
2814 mvdcmd.Arg1 = (MS_U8)bDropErr;
2815 mvdcmd.Arg2 = (MS_U8)bDropDisp;
2816 mvdcmd.Arg3 = HAL_MVD_MapFrcMode(eFrcMode);
2817 SET_DECNUM(mvdcmd, u8Idx);
2818 SET_CMD_RET_FALSE(CMD_DISPLAY_CTL, &mvdcmd);
2819
2820 pstCtrlCfg->eFrcMode = eFrcMode;
2821
2822 if (*pbDropErrFrm != bDropErr)
2823 {
2824 MVD_DEBUGINFO( printf("bDropErrFrm(%d) != bDropErr(%d)\n", *pbDropErrFrm, bDropErr));
2825 *pbDropErrFrm = bDropErr;
2826 }
2827 pstCtrlCfg->bDropDispfrm = bDropDisp;
2828
2829 return TRUE;
2830 }
2831
2832
HAL_MVD_SkipData(MS_U8 u8Idx)2833 MS_BOOL HAL_MVD_SkipData(MS_U8 u8Idx)
2834 {
2835 MS_U32 u32TimeCnt = 0;
2836 MVD_CmdArg mvdcmd;
2837
2838 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_SKIP_DATA);
2839 SETUP_CMDARG(mvdcmd);
2840 SET_DECNUM(mvdcmd, u8Idx);
2841 SET_CMD_RET_FALSE(CMD_SKIP_DATA, &mvdcmd);
2842
2843 u32TimeCnt = HAL_MVD_GetTime();
2844 while ((HAL_MVD_GetTime() - u32TimeCnt) < SKIP_DATA_TIMEOUT_MS)
2845 {
2846 if (HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_SKIP_DATA))
2847 {
2848 MVD_DEBUGINFO(printf("\nSkip data finished!\n"));
2849 break;
2850 }
2851 }
2852 MVD_DEBUGINFO(printf("====> %s (t1=%u t2=%u diff=%u)\n", __FUNCTION__,
2853 u32TimeCnt, HAL_MVD_GetTime(), (HAL_MVD_GetTime() - u32TimeCnt)));
2854 if (TRUE != HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_SKIP_DATA))
2855 {
2856 MVD_DEBUGINFO(printf("\n***** TS flush timeout *****\n\n"));
2857 return FALSE;
2858 }
2859
2860 return TRUE;
2861 }
2862
HAL_MVD_DispRepeatField(MS_U8 u8Idx,MS_BOOL bEnable)2863 MS_BOOL HAL_MVD_DispRepeatField(MS_U8 u8Idx, MS_BOOL bEnable)
2864 {
2865 MVD_CmdArg mvdcmd;
2866 SETUP_CMDARG(mvdcmd);
2867 mvdcmd.Arg0 = bEnable;
2868 SET_DECNUM(mvdcmd, u8Idx);
2869 SET_CMD_RET_FALSE(CMD_REPEAT_MODE, &mvdcmd);
2870 return TRUE;
2871 }
2872
2873 //------------------------------------------------------------------------------
2874 /// Pause display.
2875 /// @return -TRUE for success; FALSE for failure
2876 //------------------------------------------------------------------------------
HAL_MVD_PauseDisp(MS_U8 u8Idx)2877 MS_BOOL HAL_MVD_PauseDisp(MS_U8 u8Idx)
2878 {
2879 MS_BOOL bRst = TRUE;
2880 MVD_CmdArg mvdcmd;
2881
2882 SETUP_CMDARG(mvdcmd);
2883 mvdcmd.Arg0 = DISPLAY_PAUSE_ON;
2884 SET_DECNUM(mvdcmd, u8Idx);
2885 if (HAL_MVD_MVDCommand(CMD_DISPLAY_PAUSE, &mvdcmd)== FALSE)
2886 {
2887 MVD_DEBUGERROR( printf( "Command: 0x%x(ON) fail!!\r\n", CMD_DISPLAY_PAUSE) );
2888 bRst = FALSE;
2889 }
2890 return bRst;
2891 }
2892
2893 //------------------------------------------------------------------------------
2894 /// Issue Pause command.
2895 /// @return -TRUE for success; FALSE for failure
2896 //------------------------------------------------------------------------------
HAL_MVD_Resume(MS_U8 u8Idx)2897 MS_BOOL HAL_MVD_Resume(MS_U8 u8Idx)
2898 {
2899 MS_BOOL bRst = TRUE;
2900 MVD_CmdArg mvdcmd;
2901
2902 SETUP_CMDARG(mvdcmd);
2903 mvdcmd.Arg0 = DISPLAY_PAUSE_OFF;
2904 SET_DECNUM(mvdcmd, u8Idx);
2905 if (HAL_MVD_MVDCommand(CMD_DISPLAY_PAUSE, &mvdcmd)== FALSE)
2906 {
2907 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DISPLAY_PAUSE) );
2908 bRst = FALSE;
2909 }
2910 return bRst;
2911 }
2912
HAL_MVD_Play(MS_U8 u8Idx)2913 MS_BOOL HAL_MVD_Play(MS_U8 u8Idx)
2914 {
2915 MVD_CmdArg mvdcmd;
2916 SETUP_CMDARG(mvdcmd);
2917 mvdcmd.Arg0 = 1;
2918 SET_DECNUM(mvdcmd, u8Idx);
2919 SET_CMD_RET_FALSE(CMD_DIU_WIDTH_ALIGN, &mvdcmd);
2920
2921 SETUP_CMDARG(mvdcmd);
2922 SET_DECNUM(mvdcmd, u8Idx);
2923 SET_CMD_RET_FALSE(CMD_PLAY, &mvdcmd);
2924
2925 if (HAL_MVD_Resume(u8Idx) == FALSE)
2926 {
2927 MVD_DEBUGERROR( printf( "Command: HAL_MVD_Resume fail!!\r\n" ) );
2928 return FALSE;
2929 }
2930
2931 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
2932 pCtrlCfg->bDecodeIFrame = FALSE;
2933
2934 return TRUE;
2935 }
2936
2937 //------------------------------------------------------------------------------
2938 /// Set base address for ScalerInfo structure to f/w
2939 /// @param -u32addr \b IN : start address (units in byte)
2940 //------------------------------------------------------------------------------
HAL_MVD_SetScalerInfoAddr(MS_U8 u8Idx,MS_VIRT u32addr,MS_U8 u8Arg4)2941 MS_BOOL HAL_MVD_SetScalerInfoAddr(MS_U8 u8Idx, MS_VIRT u32addr,MS_U8 u8Arg4)
2942 {
2943 MVD_CmdArg mvdcmd;
2944
2945 MS_ASSERT((u32addr%8)==0);
2946 u32addr >>= 3;
2947
2948 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2949 mvdcmd.Arg4 = u8Arg4;
2950 SET_CMD_RET_FALSE(CMD_SCALER_INFO_BASE, &mvdcmd);
2951 return TRUE;
2952 }
2953
2954 //------------------------------------------------------------------------------
2955 /// Set the dynamic scale base address
2956 /// @return -TRUE for success; FALSE for failure.
2957 //------------------------------------------------------------------------------
HAL_MVD_SetDynamicScaleAddr(MS_U8 u8Idx,MS_VIRT u32addr)2958 MS_BOOL HAL_MVD_SetDynamicScaleAddr(MS_U8 u8Idx, MS_VIRT u32addr)
2959 {
2960 MVD_CmdArg mvdcmd;
2961
2962 MS_ASSERT((u32addr%8)==0);
2963 u32addr >>= 3;
2964
2965 SET_CMDARG(mvdcmd, u32addr, u8Idx);
2966 SET_CMD_RET_FALSE(CMD_DYNAMIC_SCALE_BASE, &mvdcmd);
2967 return TRUE;
2968 }
2969
2970 //------------------------------------------------------------------------------
2971 /// Set virtual box width/height to F/W.
2972 /// F/W will use the same w/h as scaler to calculate scaling factor.
2973 /// @return -TRUE for success; FALSE for failure.
2974 //------------------------------------------------------------------------------
HAL_MVD_SetVirtualBox(MS_U8 u8Idx,MS_U16 u16Width,MS_U16 u16Height)2975 MS_BOOL HAL_MVD_SetVirtualBox(MS_U8 u8Idx, MS_U16 u16Width, MS_U16 u16Height)
2976 {
2977 MVD_CmdArg mvdcmd;
2978
2979 SETUP_CMDARG(mvdcmd);
2980 mvdcmd.Arg0 = L_WORD(u16Width);
2981 mvdcmd.Arg1 = H_WORD(u16Width);
2982 mvdcmd.Arg2 = L_WORD(u16Height);
2983 mvdcmd.Arg3 = H_WORD(u16Height);
2984 SET_DECNUM(mvdcmd, u8Idx);
2985 SET_CMD_RET_FALSE(CMD_DS_VIRTUAL_BOX, &mvdcmd);
2986 return TRUE;
2987 }
2988
2989 //------------------------------------------------------------------------------
2990 /// Enable VC1 dynamic scaling
2991 /// @return -TRUE for success; FALSE for failure.
2992 //------------------------------------------------------------------------------
HAL_MVD_EnableDynamicScale(MS_U8 u8Idx,MS_U8 u8NewDS)2993 MS_BOOL HAL_MVD_EnableDynamicScale(MS_U8 u8Idx,MS_U8 u8NewDS)
2994 {
2995 MVD_CmdArg mvdcmd;
2996
2997 SETUP_CMDARG(mvdcmd);
2998 mvdcmd.Arg0 = TRUE;
2999 mvdcmd.Arg1 = u8NewDS;
3000 SET_DECNUM(mvdcmd, u8Idx);
3001 SET_CMD_RET_FALSE(CMD_ENABLE_DYNAMIC_SCALE, &mvdcmd);
3002 return TRUE;
3003 }
3004
3005
3006 //------------------------------------------------------------------------------
3007 /// Set blue screen
3008 /// @return -TRUE for success; FALSE for failure.
3009 //------------------------------------------------------------------------------
HAL_MVD_SetBlueScreen(MS_U8 u8Idx,MS_BOOL bEn)3010 MS_BOOL HAL_MVD_SetBlueScreen(MS_U8 u8Idx, MS_BOOL bEn)
3011 {
3012 MVD_CmdArg mvdcmd;
3013
3014 SETUP_CMDARG(mvdcmd);
3015 mvdcmd.Arg0 = bEn; //1 -> show MVOP frame color. 0 -> normal case.
3016 SET_DECNUM(mvdcmd, u8Idx);
3017 SET_CMD_RET_FALSE(CMD_FORCE_BLUE_SCREEN, &mvdcmd);
3018 return TRUE;
3019 }
3020
3021
HAL_MVD_SetFreezeDisp(MS_U8 u8Idx,MS_BOOL bEn)3022 MS_BOOL HAL_MVD_SetFreezeDisp(MS_U8 u8Idx, MS_BOOL bEn)
3023 {
3024 MVD_CmdArg mvdcmd;
3025
3026 SETUP_CMDARG(mvdcmd);
3027 mvdcmd.Arg0 = bEn;
3028 SET_DECNUM(mvdcmd, u8Idx);
3029 SET_CMD_RET_FALSE(CMD_FREEZE_DISP, &mvdcmd);
3030 return TRUE;
3031 }
3032
3033
3034 //------------------------------------------------------------------------------
3035 /// Set base address for DecFrameInfo structure to f/w
3036 /// @param -u32addr \b IN : start address (units in byte)
3037 //------------------------------------------------------------------------------
HAL_MVD_SetDecFrmInfoAddr(MS_U8 u8Idx,MS_VIRT u32addr)3038 void HAL_MVD_SetDecFrmInfoAddr(MS_U8 u8Idx, MS_VIRT u32addr)
3039 {
3040 MVD_CmdArg mvdcmd;
3041
3042 MS_ASSERT((u32addr%8)==0);
3043 u32addr >>= 3;
3044
3045 SET_CMDARG(mvdcmd, u32addr, u8Idx);
3046 if (HAL_MVD_MVDCommand( CMD_DEC_FRAME_INFO_BUF, &mvdcmd ) == FALSE)
3047 {
3048 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DEC_FRAME_INFO_BUF ) );
3049 }
3050 return;
3051 }
3052
3053 //Check if the task has interrupt
HAL_MVD_GetHasInt(MS_U8 u8Idx)3054 MS_BOOL HAL_MVD_GetHasInt(MS_U8 u8Idx)
3055 {
3056 MS_BOOL bHasInt = FALSE;
3057 MS_U32 u32IntCnt = 0;
3058 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3059
3060 u32IntCnt = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_INT_CNT, sizeof(MS_U32));
3061 if (u32IntCnt != pCtrlCfg->u32IntCnt)
3062 {
3063 MVD_DEBUGINFO(printf("%s %d--> %d\n", __FUNCTION__, pCtrlCfg->u32IntCnt, u32IntCnt));
3064 bHasInt = TRUE;
3065 pCtrlCfg->u32IntCnt = u32IntCnt;
3066 }
3067 return bHasInt;
3068 }
3069
3070 #ifdef VDEC3
HAL_MVD_GetIntState(MS_U8 u8Idx)3071 MS_U32 HAL_MVD_GetIntState(MS_U8 u8Idx)
3072 {
3073 MS_U32 u32IntStat;
3074
3075 u32IntStat = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_INT_STAT, sizeof(MS_U32));
3076
3077 MVD_SetFWBuffData(u8Idx,FW_BUFF_FRMINFO,OFFSET_INT_STAT,sizeof(MS_U32),0);
3078
3079 return u32IntStat;
3080 }
3081 #else
HAL_MVD_GetIntState(MS_U8 u8Idx)3082 MS_U32 HAL_MVD_GetIntState(MS_U8 u8Idx)
3083 {
3084 MS_U32 u32IntStat = 0;
3085 MVD_CmdArg mvdcmd;
3086
3087 SETUP_CMDARG(mvdcmd);
3088 SET_DECNUM(mvdcmd, u8Idx);
3089 if (HAL_MVD_MVDCommand( CMD_GET_INT_STAT, &mvdcmd ) == TRUE)
3090 {
3091 u32IntStat = (((MS_U32)mvdcmd.Arg4) << 16) |
3092 (((MS_U32)mvdcmd.Arg3) << 8) |
3093 (((MS_U32)mvdcmd.Arg2));
3094 }
3095 else
3096 {
3097 if (FALSE == pMVDHalContext->bStopped[u8Idx])
3098 {
3099 MVD_DEBUGERROR(printf("Ctrl: 0x%x fail!!\n", CMD_GET_INT_STAT));
3100 }
3101 else
3102 {
3103 MVD_DEBUGINFO(printf("Cmd 0x%x normal timeout.\n", CMD_GET_INT_STAT));
3104 }
3105 }
3106
3107 return u32IntStat;
3108 }
3109
3110 #endif
3111
3112 ///// functions to check interrupt status /////
MVD_IntHasUsrDataDisp(MS_U32 u32IntStat)3113 MS_BOOL MVD_IntHasUsrDataDisp(MS_U32 u32IntStat)
3114 {
3115 return (((u32IntStat&INT_USER_DATA_DISP)==INT_USER_DATA_DISP) ? TRUE : FALSE);
3116 }
3117
MVD_IntHasUsrData(MS_U32 u32IntStat)3118 MS_BOOL MVD_IntHasUsrData(MS_U32 u32IntStat)
3119 {
3120 return (((u32IntStat&INT_USER_DATA)==INT_USER_DATA) ? TRUE : FALSE);
3121 }
3122
MVD_IntIsDispRdy(MS_U32 u32IntStat)3123 MS_BOOL MVD_IntIsDispRdy(MS_U32 u32IntStat)
3124 {
3125 return (((u32IntStat&INT_DISP_RDY)==INT_DISP_RDY) ? TRUE : FALSE);
3126 }
3127
MVD_IntHasSeqHdr(MS_U32 u32IntStat)3128 MS_BOOL MVD_IntHasSeqHdr(MS_U32 u32IntStat)
3129 {
3130 return (((u32IntStat&INT_SEQ_FOUND)==INT_SEQ_FOUND) ? TRUE : FALSE);
3131 }
3132
MVD_IntHasESDataInvalid(MS_U32 u32IntStat)3133 MS_BOOL MVD_IntHasESDataInvalid(MS_U32 u32IntStat)
3134 {
3135 return (((u32IntStat&INT_VES_VALID)==INT_VES_VALID) ? TRUE : FALSE);
3136 }
3137
MVD_IntHasDecodeErr(MS_U32 u32IntStat)3138 MS_BOOL MVD_IntHasDecodeErr(MS_U32 u32IntStat)
3139 {
3140 return (((u32IntStat&INT_DEC_ERR)==INT_DEC_ERR) ? TRUE : FALSE);
3141 }
3142 //INT_FIRST_FRAME means "1st frame be push to display queue & ready for display"
3143 //So, (1) in IPB or IP stream, that's I-frame
3144 // (2) in PB only stream, that's first P-frame
MVD_IntHas1stFrame(MS_U32 u32IntStat)3145 MS_BOOL MVD_IntHas1stFrame(MS_U32 u32IntStat)
3146 {
3147 return (((u32IntStat&INT_FIRST_FRAME)==INT_FIRST_FRAME) ? TRUE : FALSE);
3148 }
3149
3150 //INT_XC_LOW_DELAY
MVD_IntHasXcLowDelay(MS_U32 u32IntStat)3151 MS_BOOL MVD_IntHasXcLowDelay(MS_U32 u32IntStat)
3152 {
3153 //printf("MVD_IntHasXcLowDelay=%x \n ", u32IntStat);
3154 return (((u32IntStat&INT_XC_LOW_DELAY)==INT_XC_LOW_DELAY) ? TRUE : FALSE);
3155 }
3156
MVD_IntHasDecodeIframe(MS_U32 u32IntStat)3157 MS_BOOL MVD_IntHasDecodeIframe(MS_U32 u32IntStat)
3158 {
3159 return (((u32IntStat&INT_DEC_I)==INT_DEC_I) ? TRUE : FALSE);
3160 }
3161
3162
MVD_IntVSyncInt(MS_U32 u32IntStat)3163 MS_BOOL MVD_IntVSyncInt(MS_U32 u32IntStat)
3164 {
3165 return (((u32IntStat&INT_DISP_VSYNC)==INT_DISP_VSYNC) ? TRUE : FALSE);
3166 }
3167
MVD_IntDecOneFrmInt(MS_U32 u32IntStat)3168 MS_BOOL MVD_IntDecOneFrmInt(MS_U32 u32IntStat)
3169 {
3170 return (((u32IntStat&INT_DEC_DONE)==INT_DEC_DONE) ? TRUE : FALSE);
3171 }
3172
3173
MVD_GetSyncStat(MS_U8 u8Idx,MS_U8 u8ArgIdx)3174 static MS_U8 MVD_GetSyncStat(MS_U8 u8Idx, MS_U8 u8ArgIdx)
3175 {
3176 MS_U8 u8Val = 0xFF;
3177 MVD_CmdArg mvdcmd;
3178 SETUP_CMDARG(mvdcmd);
3179 SET_DECNUM(mvdcmd, u8Idx);
3180 if (HAL_MVD_MVDCommand( CMD_GET_SYNC_STAT, &mvdcmd ) == FALSE)
3181 {
3182 MVD_DEBUGERROR(printf("Ctrl: 0x%x fail!!\r\n", CMD_GET_SYNC_STAT));
3183 return 0xFF;
3184 }
3185 MVD_DEBUGINFO(printf("Sync On/Off %x, Done %x, Stat %x, diff=%d\n",
3186 mvdcmd.Arg0, mvdcmd.Arg1, mvdcmd.Arg2, (int)HAL_MVD_GetPtsStcDiff(u8Idx)));
3187
3188 if (0==u8ArgIdx)
3189 {
3190 u8Val = mvdcmd.Arg0; //On/Off
3191 }
3192 else if (1==u8ArgIdx)
3193 {
3194 u8Val = mvdcmd.Arg1; //Done
3195 }
3196 else if (2==u8ArgIdx)
3197 {
3198 u8Val = mvdcmd.Arg2; //Stat
3199 }
3200 return u8Val;
3201 }
3202
3203 //------------------------------------------------------------------------------
3204 /// Report avsync status
3205 /// avsync_status=avsync_done|(avsync_skip_picture<<1)|(avsync_repeat_picture<<2),
3206 /// 0 for free run
3207 //------------------------------------------------------------------------------
HAL_MVD_GetAVSyncStatus(MS_U8 u8Idx)3208 MS_U8 HAL_MVD_GetAVSyncStatus(MS_U8 u8Idx)
3209 {
3210 return MVD_GetSyncStat(u8Idx, 2);
3211 }
3212
HAL_MVD_SlqTblLoadWrPtr(MS_U8 u8Idx,MS_VIRT u32WrPtr)3213 void HAL_MVD_SlqTblLoadWrPtr(MS_U8 u8Idx, MS_VIRT u32WrPtr)
3214 {
3215 #if 1
3216 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
3217 MVD_CmdArg mvdcmd;
3218 MS_U16 u16Val = 0;
3219
3220 if (FALSE == pstSlqTblInfo->bEnSlqTblHkCtrl)
3221 {
3222 SETUP_CMDARG(mvdcmd);
3223 mvdcmd.Arg0 = 0x10;
3224 mvdcmd.Arg1 = 0x01;
3225 SET_DECNUM(mvdcmd, u8Idx);
3226 if (HAL_MVD_MVDCommand( CMD_RD_IO, &mvdcmd ) == FALSE)
3227 {
3228 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_RD_IO ) );
3229 return;
3230 }
3231 u16Val = (((MS_U32)mvdcmd.Arg2)) | ((MS_U32)mvdcmd.Arg3 << 8);
3232
3233 SETUP_CMDARG(mvdcmd);
3234 mvdcmd.Arg0 = 0x10;
3235 mvdcmd.Arg1 = 0x01;
3236 mvdcmd.Arg2 = u16Val & 0xff;
3237 mvdcmd.Arg3 = ((u16Val>>8 ) & 0xff) | 0x80;
3238 SET_DECNUM(mvdcmd, u8Idx);
3239 if (HAL_MVD_MVDCommand(CMD_WR_IO, &mvdcmd) == FALSE)
3240 {
3241 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_WR_IO ) );
3242 return;
3243 }
3244
3245 pstSlqTblInfo->bEnSlqTblHkCtrl = TRUE;
3246 //printf("@@@ OPEN HK.SLQ.CTRL!\n");
3247 }
3248 #endif
3249 OSAL_MVD_LockHwMutex();
3250
3251 HAL_MVD_RegWriteByte(MVD_SLQ_WADR0, (u32WrPtr & 0xff));
3252 HAL_MVD_RegWriteByte(MVD_SLQ_WADR1, ((u32WrPtr>>8 ) & 0xff));
3253 HAL_MVD_RegWriteByte(MVD_SLQ_WADR2, ((u32WrPtr>>16) & 0xff));
3254 HAL_MVD_RegWriteByte(MVD_SLQ_WADR3, ((u32WrPtr>>24) & 0x01));
3255 HAL_MVD_RegWriteBit(MVD_SLQCTRL, 1, MVD_SLQCTRL_WADR_RELOAD);
3256 HAL_MVD_RegWriteBit(MVD_SLQCTRL, 0, MVD_SLQCTRL_WADR_RELOAD);
3257
3258 OSAL_MVD_UnlockHwMutex();
3259 }
3260
HAL_MVD_SlqTblProbe(MVD_HKSLQ_CMD eCmd)3261 static MS_VIRT HAL_MVD_SlqTblProbe(MVD_HKSLQ_CMD eCmd)
3262 {
3263 MS_VIRT u32Cadr = 0;
3264 OSAL_MVD_LockHwMutex();
3265
3266 switch (eCmd)
3267 {
3268 case MVD_HKSLQ_GET_READPTR:
3269 HAL_MVD_RegWriteBit(MVD_SLQCTRL, 1, MVD_SLQCTRL_RADR_PROBE);
3270 HAL_MVD_RegWriteBit(MVD_SLQCTRL, 0, MVD_SLQCTRL_RADR_PROBE);
3271 break;
3272 case MVD_HKSLQ_GET_WRITEPTR:
3273 HAL_MVD_RegWriteBit(MVD_SLQCTRL, 1, MVD_SLQCTRL_WADR_PROBE);
3274 HAL_MVD_RegWriteBit(MVD_SLQCTRL, 0, MVD_SLQCTRL_WADR_PROBE);
3275 break;
3276 default:
3277 break;
3278 }
3279 u32Cadr = HAL_MVD_RegReadByte(MVD_SLQ_CADR0) |
3280 (HAL_MVD_RegReadByte(MVD_SLQ_CADR1) << 8) |
3281 (HAL_MVD_RegReadByte(MVD_SLQ_CADR2) <<16) |
3282 ((HAL_MVD_RegReadByte(MVD_SLQ_CADR3) & 0x01) <<24);
3283
3284 OSAL_MVD_UnlockHwMutex();
3285 return u32Cadr;
3286 }
3287
HAL_MVD_SlqTblProbeWrPtr(MS_U8 u8Idx)3288 MS_VIRT HAL_MVD_SlqTblProbeWrPtr(MS_U8 u8Idx)
3289 {
3290 return HAL_MVD_SlqTblProbe(MVD_HKSLQ_GET_WRITEPTR);
3291 }
3292
HAL_MVD_SlqTblProbeRdPtr(MS_U8 u8Idx)3293 MS_VIRT HAL_MVD_SlqTblProbeRdPtr(MS_U8 u8Idx)
3294 {
3295 return HAL_MVD_SlqTblProbe(MVD_HKSLQ_GET_READPTR);
3296 }
3297
3298 //------------------------------------------------------------------------------
3299 /// Set firmware as MStreamer mode
3300 /// @return -TRUE for success; FALSE for failure.
3301 //------------------------------------------------------------------------------
HAL_MVD_SetMStreamerMode(MS_U8 u8Idx,MS_U8 u8Mode)3302 MS_BOOL HAL_MVD_SetMStreamerMode(MS_U8 u8Idx, MS_U8 u8Mode)
3303 {
3304 MVD_CmdArg mvdcmd;
3305 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3306
3307 SETUP_CMDARG(mvdcmd);
3308 mvdcmd.Arg0 = u8Mode; //1: enable, 0:disable MStreamer mode.
3309 SET_DECNUM(mvdcmd, u8Idx);
3310 SET_CMD_RET_FALSE(CMD_SET_MST_MODE, &mvdcmd);
3311
3312 pstCtrlCfg->u8MstMode = u8Mode;
3313 return TRUE;
3314 }
3315
3316 //------------------------------------------------------------------------------
3317 /// Set firmware as MStreamer mode (IP clip mode)
3318 /// @return -TRUE for success; FALSE for failure.
3319 //------------------------------------------------------------------------------
HAL_MVD_ShowDecodeOrder(MS_U8 u8Idx,MS_U8 u8Mode)3320 MS_BOOL HAL_MVD_ShowDecodeOrder(MS_U8 u8Idx, MS_U8 u8Mode)
3321 {
3322 MVD_CmdArg mvdcmd;
3323 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3324
3325 SETUP_CMDARG(mvdcmd);
3326 mvdcmd.Arg0 = pstCtrlCfg->u8MstMode;
3327 mvdcmd.Arg1 = u8Mode;//a u8Mode; //1: clip mode, 0:normal mode.
3328 SET_DECNUM(mvdcmd, u8Idx);
3329 SET_CMD_RET_FALSE(CMD_SET_MST_MODE, &mvdcmd);
3330 return TRUE;
3331
3332 }
3333
HAL_MVD_IsMStreamerMode(MS_U8 u8Idx)3334 MS_BOOL HAL_MVD_IsMStreamerMode(MS_U8 u8Idx)
3335 {
3336 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3337 return (MST_MODE_TRUE == pstCtrlCfg->u8MstMode);
3338 }
3339
HAL_MVD_FrameOpt(MS_U8 u8Idx,MS_U8 u8FrmIdx,MVD_FrmOpt eOpt)3340 MS_BOOL HAL_MVD_FrameOpt(MS_U8 u8Idx, MS_U8 u8FrmIdx, MVD_FrmOpt eOpt)
3341 {
3342 MVD_CmdArg mvdcmd;
3343
3344 SETUP_CMDARG(mvdcmd);
3345 mvdcmd.Arg0 = u8FrmIdx;
3346 mvdcmd.Arg1 = eOpt; // 0 = Flip, 1 = Release.
3347 MVD_DEBUGINFO(printf("FLIP_RELEASE_FRAME: idx=0x%x, opt=0x%x\n", u8FrmIdx, eOpt));
3348 SET_DECNUM(mvdcmd, u8Idx);
3349 SET_CMD_RET_FALSE(CMD_FLIP_RELEASE_FRAME, &mvdcmd);
3350
3351 return TRUE;
3352 }
3353
3354 //------------------------------------------------------------------------------
3355 /// Set firmware dynamic allocate FrameBuffer, now support MCU mode only
3356 /// @return -TRUE for success; FALSE for failure.
3357 //------------------------------------------------------------------------------
_MVD_SetDynamicAllocateFB(MS_U8 u8Idx,MS_BOOL bEnable)3358 MS_BOOL _MVD_SetDynamicAllocateFB(MS_U8 u8Idx,MS_BOOL bEnable)
3359 {
3360 MVD_CmdArg mvdcmd;
3361
3362 SETUP_CMDARG(mvdcmd);
3363 mvdcmd.Arg0 = 1-bEnable; //Arg0 : 0(enable) , 1(disable)
3364 SET_DECNUM(mvdcmd, u8Idx);
3365 if (HAL_MVD_MVDCommand( CMD_FIXED_FRAME_BUFFER, &mvdcmd ) == FALSE)
3366 {
3367 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FIXED_FRAME_BUFFER ) );
3368 return FALSE;
3369 }
3370
3371 return TRUE;
3372 }
3373
3374 //------------------------------------------------------------------------------
3375 /// Set firmware as MCU mode
3376 /// @return -TRUE for success; FALSE for failure.
3377 //------------------------------------------------------------------------------
HAL_MVD_SetMcuMode(MS_U8 u8Idx,MS_U8 u8Mode)3378 MS_BOOL HAL_MVD_SetMcuMode(MS_U8 u8Idx, MS_U8 u8Mode)
3379 {
3380 MVD_CmdArg mvdcmd;
3381 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3382
3383 SETUP_CMDARG(mvdcmd);
3384 mvdcmd.Arg0 = u8Mode; //1: enable, 0:disable MCU
3385 SET_DECNUM(mvdcmd, u8Idx);
3386 SET_CMD_RET_FALSE(CMD_SET_MCU_MODE, &mvdcmd);
3387
3388 pstCtrlCfg->u8McuMode = u8Mode;
3389
3390 return TRUE;
3391 }
3392
HAL_MVD_IsMcuMode(MS_U8 u8Idx)3393 MS_BOOL HAL_MVD_IsMcuMode(MS_U8 u8Idx)
3394 {
3395 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3396 return (TRUE == pstCtrlCfg->u8McuMode);
3397 }
3398
3399 //------------------------------------------------------------------------------
3400 /// Set firmware as ForceInterlace mode
3401 /// @return -TRUE for success; FALSE for failure.
3402 //------------------------------------------------------------------------------
HAL_MVD_ForceInterlaceMode(MS_U8 u8Idx,MS_U8 u8Mode)3403 MS_BOOL HAL_MVD_ForceInterlaceMode(MS_U8 u8Idx, MS_U8 u8Mode)
3404 {
3405 MVD_CmdArg mvdcmd;
3406
3407 SETUP_CMDARG(mvdcmd);
3408 mvdcmd.Arg0 = u8Mode; //1: enable, 0:disable
3409 mvdcmd.Arg1 = 0;
3410 SET_DECNUM(mvdcmd, u8Idx);
3411 SET_CMD_RET_FALSE(CMD_VC1_FORCE_INTLACE_DISP, &mvdcmd);
3412
3413 return TRUE;
3414 }
3415
3416 //------------------------------------------------------------------------------
3417 /// Set firmware as Progressive mode
3418 /// @return -TRUE for success; FALSE for failure.
3419 //------------------------------------------------------------------------------
HAL_MVD_ForceProgressiveMode(MS_U8 u8Idx,MS_U8 u8Mode)3420 MS_BOOL HAL_MVD_ForceProgressiveMode(MS_U8 u8Idx, MS_U8 u8Mode)
3421 {
3422 MVD_CmdArg mvdcmd;
3423
3424 SETUP_CMDARG(mvdcmd);
3425 mvdcmd.Arg0 = 0;
3426 mvdcmd.Arg1 = u8Mode; //1: enable, 0:disable
3427 SET_DECNUM(mvdcmd, u8Idx);
3428 SET_CMD_RET_FALSE(CMD_VC1_FORCE_INTLACE_DISP, &mvdcmd);
3429
3430 return TRUE;
3431 }
3432
3433 //------------------------------------------------------------------------------
3434 /// Inform firwmare that PTS is updated.
3435 /// @return -TRUE for success; FALSE for failure.
3436 //------------------------------------------------------------------------------
HAL_MVD_UpdatePts(MS_U8 u8Idx)3437 MS_BOOL HAL_MVD_UpdatePts(MS_U8 u8Idx)
3438 {
3439 MVD_CmdArg mvdcmd;
3440
3441 SETUP_CMDARG(mvdcmd);
3442 SET_DECNUM(mvdcmd, u8Idx);
3443 SET_CMD_RET_FALSE(CMD_SEND_UNI_PTS, &mvdcmd);
3444
3445 return TRUE;
3446 }
3447
3448
HAL_MVD_FrameCapture(MS_U8 u8Idx,MS_U8 u8FrmIdx,MS_BOOL bEnable)3449 MS_BOOL HAL_MVD_FrameCapture(MS_U8 u8Idx, MS_U8 u8FrmIdx, MS_BOOL bEnable)
3450 {
3451 MVD_CmdArg mvdcmd;
3452
3453 SETUP_CMDARG(mvdcmd);
3454 mvdcmd.Arg0 = bEnable; //0 or 1 to enable/disable the freeze function
3455 mvdcmd.Arg2 = u8FrmIdx; //specify the freezed frame index
3456 MVD_DEBUGINFO(printf("CAPTURE_FRAME: idx=0x%x, enable=0x%x\n", u8FrmIdx, bEnable));
3457 SET_DECNUM(mvdcmd, u8Idx);
3458 SET_CMD_RET_FALSE(CMD_ENABLE_FREEZE_PIC, &mvdcmd);
3459
3460 return TRUE;
3461 }
3462
3463 //------------------------------------------------------------------------------
3464 /// Set HW buffers' start address to MVD FW
3465 /// Return (the end address - 1)
3466 /// @param -u32Addr \b IN : start address (MIU offset)
3467 //------------------------------------------------------------------------------
HAL_MVD_SetHWBuffer(MS_U8 u8Idx,MS_VIRT u32Add)3468 MS_VIRT HAL_MVD_SetHWBuffer(MS_U8 u8Idx, MS_VIRT u32Add)
3469 {
3470 MS_VIRT tmpAdr;
3471
3472 MVD_DEBUGINFO(printf("====> %s u32Add = 0x%lx\n", __FUNCTION__, (unsigned long)u32Add));
3473 tmpAdr = (MemAlign(u32Add, MVD_FW_IAP_BUF_ALIGN));
3474 MVD_DEBUGINFO(printf("set MVD3_FW_IAP_BUF_ADR =%lx\n",(unsigned long)tmpAdr));
3475 HAL_MVD_SetIAPBufferAddr(u8Idx, tmpAdr);
3476 tmpAdr += MVD_FW_IAP_BUF_LEN;
3477
3478 tmpAdr = (MemAlign(tmpAdr, MVD_FW_DP_BUF_ALIGN));
3479 MVD_DEBUGINFO(printf("set MVD3_FW_DP_BUF_ADR=%lx\n",(unsigned long)tmpAdr));
3480 HAL_MVD_SetDPBufferAddr(u8Idx, tmpAdr);
3481 tmpAdr += MVD_FW_DP_BUF_LEN;
3482
3483 tmpAdr = (MemAlign(tmpAdr, MVD_FW_MV_BUF_ALIGN));
3484 MVD_DEBUGINFO(printf("set MVD3_FW_MV_BUF_ADR=%lx\n",(unsigned long)tmpAdr));
3485 HAL_MVD_SetMVBufferAddr(u8Idx, tmpAdr);
3486 tmpAdr += MVD_FW_MV_BUF_LEN;
3487 MVD_DEBUGINFO(printf("====> %s End of HW buffers = 0x%lx\n", __FUNCTION__, (unsigned long)tmpAdr));
3488
3489 return tmpAdr;
3490 }
3491
3492 //------------------------------------------------------------------------------
3493 /// Set the number of framebuffer
3494 /// @param -u8FrmNum \b IN : the number of framebuffer
3495 //------------------------------------------------------------------------------
HAL_MVD_SetFrameBuffNum(MS_U8 u8Idx,MS_U8 u8FrmNum,MS_U32 u32FBUsedSize)3496 void HAL_MVD_SetFrameBuffNum(MS_U8 u8Idx, MS_U8 u8FrmNum,MS_U32 u32FBUsedSize)
3497 {
3498 #define MVD_FBNUM_DEFAULT 4
3499 #define MVD_FBNUM_MIN MVD_FBNUM_DEFAULT
3500
3501 MVD_CmdArg mvdcmd;
3502
3503 MVD_DEBUGINFO(printf("%s u8FrmNum = %d\n", __FUNCTION__, u8FrmNum));
3504 if (u8FrmNum < MVD_FBNUM_MIN)
3505 {
3506 MVD_DEBUGINFO(printf("%s set u8FrmNum as %d instead of %d!\n",
3507 __FUNCTION__, MVD_FBNUM_MIN, u8FrmNum));
3508 u8FrmNum = MVD_FBNUM_MIN;
3509 }
3510 SETUP_CMDARG(mvdcmd);
3511 mvdcmd.Arg0 = u8FrmNum;
3512 mvdcmd.Arg1 = u32FBUsedSize&0xff;
3513 mvdcmd.Arg2 = (u32FBUsedSize>>8)&0xff;
3514 mvdcmd.Arg3 = (u32FBUsedSize>>16)&0xff;
3515 mvdcmd.Arg4 = (u32FBUsedSize>>24)&0xff;
3516 SET_DECNUM(mvdcmd, u8Idx);
3517 if (HAL_MVD_MVDCommand( CMD_FB_NUM, &mvdcmd ) == FALSE)
3518 {
3519 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FB_NUM ) );
3520 return;
3521 }
3522 return;
3523 }
3524
MVD_WriteFWBuffData(MS_U8 u8Idx,FW_BUFF_TYPE eBuffType,MS_U16 u16Offset,MS_U8 u8Size,MS_U32 u32Val)3525 static MS_BOOL MVD_WriteFWBuffData(MS_U8 u8Idx, FW_BUFF_TYPE eBuffType, MS_U16 u16Offset, MS_U8 u8Size, MS_U32 u32Val)
3526 {
3527 MS_BOOL bRet = FALSE;
3528 MS_VIRT u32BufStart = NULL;
3529 switch (eBuffType)
3530 {
3531 case FW_BUFF_VOLINFO: u32BufStart = GET_VOL_BUFFADD(u8Idx); break;
3532 case FW_BUFF_FRMINFO: u32BufStart = GET_FRMINFO_BUFFADD(u8Idx); break;
3533 case FW_BUFF_HDR: u32BufStart = GET_HDR_BUFFADD(u8Idx); break;
3534 case FW_BUFF_USRDATA: u32BufStart = GET_USRDATA_BUFFADD(u8Idx); break;
3535 case FW_BUFF_FWSLQTAB: u32BufStart = GET_SLQ_BUFFADD(u8Idx); break;
3536 case FW_BUFF_PTSTBL: u32BufStart = GET_PTSTBL_BUFFADD(u8Idx); break;
3537 case FW_BUFF_DS: u32BufStart = GET_DS_BUFFADD(u8Idx); break;
3538 case FW_BUFF_XCINFO: u32BufStart = GET_XCINFO_BUFFADD(u8Idx); break;
3539 case FW_BUFF_DECFRMINFO: u32BufStart = GET_DECFRMINFO_BUFFADD(u8Idx); break;
3540 default:
3541 break;
3542 }
3543 if (NULL == u32BufStart)
3544 {
3545 printf("%s err: u8Idx=0x%x, bufType=0x%x, offset=%d, size=%d\n",
3546 __FUNCTION__, u8Idx, eBuffType, u16Offset, u8Size);
3547 return bRet;
3548 }
3549
3550 if (u8Size == sizeof(MS_U8))
3551 {
3552 bRet = HAL_MVD_MemWriteByte(u32BufStart+u16Offset, (MS_U8)u32Val);
3553 }
3554 else if (u8Size == sizeof(MS_U32))
3555 {
3556 bRet = HAL_MVD_MemWrite4Byte(u32BufStart+u16Offset, u32Val);
3557 }
3558
3559 MVD_DEBUGINFO(printf("%s: u32Val=%d for u8Idx=0x%x, bufType=0x%x, offset=%d, size=%d\n",
3560 __FUNCTION__, u32Val, u8Idx, eBuffType, u16Offset, u8Size));
3561 return bRet;
3562 }
3563
3564 //================== Vol Info ==================//
HAL_MVD_GetBitsRate(MS_U8 u8Idx)3565 MS_U32 HAL_MVD_GetBitsRate(MS_U8 u8Idx)
3566 {
3567 //Ref 13818-2, this flag is unit of 400 bits/sec
3568 return MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_BIT_RATE, sizeof(MS_U32))*400;
3569 }
3570
HAL_MVD_GetVideoRange(MS_U8 u8Idx)3571 MS_U8 HAL_MVD_GetVideoRange(MS_U8 u8Idx)
3572 {
3573 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_VIDEO_RANGE, sizeof(MS_U8));
3574 }
3575
HAL_MVD_GetLowDelayFlag(MS_U8 u8Idx)3576 MS_BOOL HAL_MVD_GetLowDelayFlag(MS_U8 u8Idx)
3577 {
3578 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_LOW_DELAY, sizeof(MS_U8));
3579 }
3580
HAL_MVD_GetIs32PullDown(MS_U8 u8Idx)3581 MS_BOOL HAL_MVD_GetIs32PullDown(MS_U8 u8Idx)
3582 {
3583 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_MPEG_FRC_MODE, sizeof(MS_U8));
3584 }
3585
HAL_MVD_GetIsDynScalingEnabled(MS_U8 u8Idx)3586 MS_BOOL HAL_MVD_GetIsDynScalingEnabled(MS_U8 u8Idx)
3587 {
3588 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_DS_ENABLE, sizeof(MS_U8));
3589 }
3590
HAL_MVD_Is1stFrmRdy(MS_U8 u8Idx)3591 MS_BOOL HAL_MVD_Is1stFrmRdy(MS_U8 u8Idx)
3592 {
3593 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_FIRST_DISPLAY, sizeof(MS_U8));
3594 }
3595
3596
3597 //================== FrameInfo ==================//
HAL_MVD_GetPicCounter(MS_U8 u8Idx)3598 MS_U32 HAL_MVD_GetPicCounter(MS_U8 u8Idx)
3599 {
3600 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_FRAME_COUNT, sizeof(MS_U32));
3601 }
3602
HAL_MVD_GetSkipPicCounter(MS_U8 u8Idx)3603 MS_U32 HAL_MVD_GetSkipPicCounter(MS_U8 u8Idx)
3604 {
3605 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SKIP_FRAME_COUNT, sizeof(MS_U32));
3606 }
3607
HAL_MVD_GetPicType(MS_U8 u8Idx)3608 MVD_PicType HAL_MVD_GetPicType(MS_U8 u8Idx)
3609 {
3610 MS_U32 picType = 0xff;
3611 MVD_PicType ret = E_MVD_PIC_UNKNOWN;
3612
3613 if (GET_FRMINFO_BUFFADD(u8Idx)==0)
3614 {
3615 MVD_DEBUGERROR(printf("%s error: pu8MVDGetFrameInfoBufStart=NULL\n", __FUNCTION__));
3616 return E_MVD_PIC_UNKNOWN;
3617 }
3618 picType = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PICTURE_TYPE, sizeof(MS_U32));
3619 switch (picType)
3620 {
3621 case 0:
3622 ret = E_MVD_PIC_I;
3623 break;
3624 case 1:
3625 ret = E_MVD_PIC_P;
3626 break;
3627 case 2:
3628 ret = E_MVD_PIC_B;
3629 break;
3630 default:
3631 break;
3632 }
3633 return ret;
3634 }
3635
HAL_MVD_GetPtsStcDiff(MS_U8 u8Idx)3636 MS_S32 HAL_MVD_GetPtsStcDiff(MS_U8 u8Idx)
3637 {
3638 return (MS_S32)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PTS_STC, sizeof(MS_S32));
3639 }
3640
HAL_MVD_GetDecodedFrameIdx(MS_U8 u8Idx)3641 MS_U8 HAL_MVD_GetDecodedFrameIdx(MS_U8 u8Idx)
3642 {
3643 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_FB_INDEX, sizeof(MS_U8));
3644 }
3645
HAL_MVD_GetVldErrCount(MS_U8 u8Idx)3646 MS_U32 HAL_MVD_GetVldErrCount(MS_U8 u8Idx)
3647 {
3648 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_VLD_ERR_COUNT, sizeof(MS_U32));
3649 }
3650
HAL_MVD_GetValidStreamFlag(MS_U8 u8Idx)3651 MS_BOOL HAL_MVD_GetValidStreamFlag(MS_U8 u8Idx)
3652 {
3653 return !(MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_INVALIDSTREAM, sizeof(MS_U8));
3654 }
3655
HAL_MVD_GetIsIPicFound(MS_U8 u8Idx)3656 MS_U8 HAL_MVD_GetIsIPicFound(MS_U8 u8Idx)
3657 {
3658 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_FIRST_I_FOUND, sizeof(MS_U8));
3659 }
3660
3661 //------------------------------------------------------------------------------
3662 /// Set PTS base to MVD F/W
3663 /// @param -u32pts \b IN : pts unit in 90k counter
3664 //------------------------------------------------------------------------------
HAL_MVD_SetPTSBase(MS_U8 u8Idx,MS_U32 u32pts)3665 void HAL_MVD_SetPTSBase(MS_U8 u8Idx, MS_U32 u32pts)
3666 {
3667 MVD_CmdArg mvdcmd;
3668
3669 SET_CMDARG(mvdcmd, u32pts, u8Idx);
3670 if (HAL_MVD_MVDCommand( CMD_PTS_BASE, &mvdcmd ) == FALSE)
3671 {
3672 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PTS_BASE ) );
3673 }
3674 return;
3675 }
3676
HAL_MVD_GetPTS(MS_U8 u8Idx)3677 MS_U32 HAL_MVD_GetPTS(MS_U8 u8Idx)
3678 {
3679 MS_U32 u32PTS = 0;
3680
3681 u32PTS = (MS_U32)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISP_PTS, sizeof(MS_U32));
3682 u32PTS = _90K_TO_MS(u32PTS);
3683 return u32PTS;
3684 }
3685
HAL_MVD_GetU64PTS(MS_U8 u8Idx,MVD_PtsType eType)3686 MS_U64 HAL_MVD_GetU64PTS(MS_U8 u8Idx,MVD_PtsType eType)
3687 {
3688 MS_U64 u64PTS = 0;
3689 MS_U64 u32_high32_PTS = 0;
3690 MS_U64 u32_low32_PTS = 0;
3691
3692 if(eType==E_MVD_PTS_DISP)
3693 {
3694 u32_low32_PTS = (MS_U64)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISP_PTS, sizeof(MS_U32));
3695 u32_high32_PTS = (MS_U64)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISP_PTS_MSB, sizeof(MS_U32));
3696 }
3697 else if(eType==E_MVD_PTS_PRE_PAS)
3698 {
3699 u32_low32_PTS = (MS_U64)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_WRPTR_PTS_LOW, sizeof(MS_U32));
3700 u32_high32_PTS = (MS_U64)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_WRPTR_PTS_HIGH, sizeof(MS_U32));
3701 }
3702
3703 u64PTS = (u32_high32_PTS<<32)|u32_low32_PTS;
3704 _90K_TO_MS_U64(u64PTS);
3705 return u64PTS;
3706 }
3707
HAL_MVD_GetNextPTS(MS_U8 u8Idx)3708 MS_U32 HAL_MVD_GetNextPTS(MS_U8 u8Idx)
3709 {
3710 return (MS_U32)_90K_TO_MS(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_NEXT_PTS, sizeof(MS_U32)));
3711 }
3712
HAL_MVD_GetChromaFormat(MS_U8 u8Idx)3713 MS_U32 HAL_MVD_GetChromaFormat(MS_U8 u8Idx)
3714 {
3715 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CHROMA_FORMAT, sizeof(MS_U8));
3716 }
3717
HAL_MVD_GetGOPCount(MS_U8 u8Idx)3718 MS_U32 HAL_MVD_GetGOPCount(MS_U8 u8Idx)
3719 {
3720 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_GOP_I_FCNT, sizeof(MS_U32))
3721 + MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_GOP_P_FCNT, sizeof(MS_U32))
3722 + MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_GOP_B_FCNT, sizeof(MS_U32));
3723 }
3724
HAL_MVD_GetColorFormat(MS_U8 u8Idx)3725 MS_U8 HAL_MVD_GetColorFormat(MS_U8 u8Idx)
3726 {
3727 if (GET_FRMINFO_BUFFADD(u8Idx)==0)
3728 {
3729 MVD_DEBUGERROR(printf("%s error: pu8MVDGetFrameInfoBufStart=NULL\n", __FUNCTION__));
3730 return 0xff;
3731 }
3732
3733 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_VIDEO_FORMAT, sizeof(MS_U8));
3734 }
3735
HAL_MVD_GetMatrixCoef(MS_U8 u8Idx)3736 MS_U8 HAL_MVD_GetMatrixCoef(MS_U8 u8Idx)
3737 {
3738 if (GET_FRMINFO_BUFFADD(u8Idx)==0)
3739 {
3740 MVD_DEBUGERROR(printf("%s error: pu8MVDGetFrameInfoBufStart=NULL\n", __FUNCTION__));
3741 return 0xff;
3742 }
3743
3744 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_MATRIX_COEF, sizeof(MS_U8));
3745 }
3746
HAL_MVD_StepDecode(MS_U8 u8Idx)3747 MS_BOOL HAL_MVD_StepDecode(MS_U8 u8Idx)
3748 {
3749 MVD_CmdArg mvdcmd;
3750 SETUP_CMDARG(mvdcmd);
3751 SET_DECNUM(mvdcmd, u8Idx);
3752 SET_CMD_RET_FALSE(CMD_SINGLE_STEP, &mvdcmd);
3753
3754 if (HAL_MVD_Resume(u8Idx) == FALSE)
3755 {
3756 MVD_DEBUGERROR(printf("Command: HAL_MVD_Resume fail!!\r\n"));
3757 return FALSE;
3758 }
3759
3760 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
3761 if (pCtrlCfg)
3762 {
3763 pCtrlCfg->bStepDecode = TRUE;
3764 }
3765
3766 return TRUE;
3767 }
3768
HAL_MVD_IsStepDispDone(MS_U8 u8Idx)3769 MS_BOOL HAL_MVD_IsStepDispDone(MS_U8 u8Idx)
3770 {
3771 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_STEP_DISP_DONE, sizeof(MS_U8));
3772 }
3773
HAL_MVD_IsStep2PtsDone(MS_U8 u8Idx)3774 MS_BOOL HAL_MVD_IsStep2PtsDone(MS_U8 u8Idx)
3775 {
3776 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_STEP_TO_PTS_DONE, sizeof(MS_U8));
3777 }
3778
3779 //Only for RCV.
HAL_MVD_GetPayloadLen(MS_U8 u8Idx)3780 MS_U32 HAL_MVD_GetPayloadLen(MS_U8 u8Idx)
3781 {
3782 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_RCV_PAYLOAD_LENGTH, sizeof(MS_U32));
3783 }
3784
3785 //Only for RCV.
HAL_MVD_GotFileEndPattern(MS_U8 u8Idx)3786 MS_BOOL HAL_MVD_GotFileEndPattern(MS_U8 u8Idx)
3787 {
3788 return (MS_BOOL)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_MEET_FILE_END_SC, sizeof(MS_U8));
3789 }
3790
HAL_MVD_IsCmdFinished(MS_U8 u8Idx,MVD_HANDSHAKE_CMD eCmd)3791 MS_BOOL HAL_MVD_IsCmdFinished(MS_U8 u8Idx, MVD_HANDSHAKE_CMD eCmd)
3792 {
3793 MVD_CMD_HANDSHADE_INDEX u32CmdState;
3794 MS_BOOL bCmdRdy = FALSE;
3795
3796 HAL_MVD_InvalidBuffRetFalse(GET_FRMINFO_BUFFADD(u8Idx));
3797
3798 u32CmdState.value = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CMD_HANDSHAKE_INDEX, sizeof(MS_U32));
3799 MVD_DEBUGINFO(printf("u32CmdState.value = 0x%x\n", u32CmdState.value));
3800 switch (eCmd)
3801 {
3802 case MVD_HANDSHAKE_PAUSE:
3803 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_pause);
3804 break;
3805 case MVD_HANDSHAKE_SLQ_RST:
3806 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_slq_reset);
3807 break;
3808 case MVD_HANDSHAKE_STOP:
3809 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_stop);
3810 break;
3811 case MVD_HANDSHAKE_SKIP_DATA:
3812 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_skip_data);
3813 break;
3814 case MVD_HANDSHAKE_SINGLE_STEP:
3815 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_single_step);
3816 break;
3817 case MVD_HANDSHAKE_SCALER_INFO:
3818 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_scaler_data_ready);
3819 break;
3820 case MVD_HANDSHAKE_GET_NXTDISPFRM:
3821 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_get_nextdispfrm_ready);
3822 break;
3823 case MVD_HANDSHAKE_PARSER_RST:
3824 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_parser_rst);
3825 break;
3826 case MVD_HANDSHAKE_RST_CC608:
3827 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_cc608_rst);
3828 break;
3829 case MVD_HANDSHAKE_RST_CC708:
3830 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_cc708_rst);
3831 break;
3832 case MVD_HANDSHAKE_VIRTUAL_COMMAND:
3833 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_virtualCommand);
3834 break;
3835 case MVD_HANDSHAKE_FLUSHQUEUE_COMMAND:
3836 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_flush);
3837 break;
3838 case MVD_HANDSHAKE_VSYNC_CONTROL:
3839 bCmdRdy = (MS_BOOL)(u32CmdState.mvdcmd_handshake_vsync_control);
3840 break;
3841 default:
3842 bCmdRdy = FALSE;
3843 break;
3844 }
3845 return bCmdRdy;
3846 }
3847
HAL_MVD_ClearCmdFinished(MS_U8 u8Idx,MVD_HANDSHAKE_CMD eCmd)3848 MS_BOOL HAL_MVD_ClearCmdFinished(MS_U8 u8Idx, MVD_HANDSHAKE_CMD eCmd)
3849 {
3850 MVD_CMD_HANDSHADE_INDEX u32CmdState;
3851
3852 HAL_MVD_InvalidBuffRetFalse(GET_FRMINFO_BUFFADD(u8Idx));
3853
3854 u32CmdState.value = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CMD_HANDSHAKE_INDEX, sizeof(MS_U32));
3855 MVD_DEBUGINFO(printf("before CLR u32CmdState.value = 0x%x\n", u32CmdState.value));
3856 switch (eCmd)
3857 {
3858 case MVD_HANDSHAKE_SCALER_INFO:
3859 u32CmdState.mvdcmd_handshake_scaler_data_ready = 0;
3860 break;
3861 default:
3862 break;
3863 }
3864
3865 //write the value back: may it overwrite the value that f/w is supposed to write?
3866 MVD_WriteFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CMD_HANDSHAKE_INDEX, sizeof(MS_U32), u32CmdState.value);
3867 MVD_DEBUGINFO(printf("after CLR u32CmdState.value = 0x%x\n",
3868 MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CMD_HANDSHAKE_INDEX, sizeof(MS_U32))));
3869 return TRUE;
3870 }
3871
3872
HAL_MVD_GetTimeCode(MS_U8 u8Idx,MVD_FrmInfoType eType,MVD_TimeCode * pInfo)3873 MS_BOOL HAL_MVD_GetTimeCode(MS_U8 u8Idx, MVD_FrmInfoType eType, MVD_TimeCode* pInfo)
3874 {
3875 MS_BOOL bRet = FALSE;
3876 MS_VIRT pu8MVDGetFrameInfoBufStart = GET_FRMINFO_BUFFADD(u8Idx);
3877 if (NULL == pInfo)
3878 {
3879 return FALSE;
3880 }
3881
3882 HAL_MVD_InvalidBuffRetFalse(pu8MVDGetFrameInfoBufStart);
3883
3884 if (E_MVD_FRMINFO_DECODE == eType)
3885 {
3886 pInfo->u8TimeCodeHr = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_HOURS);
3887 pInfo->u8TimeCodeMin = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_MINUTES);
3888 pInfo->u8TimeCodeSec = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_SECONDS);
3889 pInfo->u8TimeCodePic = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_PICTURES);
3890 pInfo->u8DropFrmFlag = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_DROP_FRAME_FLAG);
3891 }
3892 else if (E_MVD_FRMINFO_DISPLAY == eType)
3893 {
3894 pInfo->u8TimeCodeHr = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_HOURS_DISP);
3895 pInfo->u8TimeCodeMin = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_MINUTES_DISP);
3896 pInfo->u8TimeCodeSec = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_SECONDS_DISP);
3897 pInfo->u8TimeCodePic = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TIME_CODE_PICTURES_DISP);
3898 pInfo->u8DropFrmFlag = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_DROP_FRAME_FLAG_DISP);
3899 }
3900 else
3901 {
3902 bRet = FALSE;
3903 }
3904
3905 return bRet;
3906 }
3907
HAL_MVD_GetDispCnt(MS_U8 u8Idx)3908 MS_U32 HAL_MVD_GetDispCnt(MS_U8 u8Idx)
3909 {
3910 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISPLAYED_CNT, sizeof(MS_U32));
3911 }
3912
HAL_MVD_GetMinTspDataSize(MS_U8 u8HalIdx)3913 MS_U32 HAL_MVD_GetMinTspDataSize(MS_U8 u8HalIdx)
3914 {
3915 #ifdef OFFSET_CUR_MIN_TSP_DATA_SIZE
3916 return MVD_GetFWBuffData(u8HalIdx, FW_BUFF_FRMINFO, OFFSET_CUR_MIN_TSP_DATA_SIZE, sizeof(MS_U32));
3917 #else
3918 return 0x400;
3919 #endif
3920 }
3921
HAL_MVD_GetDropCnt(MS_U8 u8Idx)3922 MS_U32 HAL_MVD_GetDropCnt(MS_U8 u8Idx)
3923 {
3924 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DROP_FRAME_COUNT, sizeof(MS_U32));
3925 }
3926
HAL_MVD_GetXcLowDelayIntState(MS_U8 u8Idx)3927 MS_U32 HAL_MVD_GetXcLowDelayIntState(MS_U8 u8Idx)
3928 {
3929 MS_VIRT pu8MVDGetFrameInfoBufStart = GET_FRMINFO_BUFFADD(u8Idx);
3930
3931 if(pu8MVDGetFrameInfoBufStart==0)
3932 {
3933 MVD_DEBUGERROR(printf("MDrv_MVD_GetXcLowDelayIntState error: pu8MVDGetFrameInfoBufStart=NULL\n"));
3934 return 0;
3935 }
3936
3937 MVD_DEBUGINFO(printf("MDrv_MVD_GetXcLowDelayIntState()=%x,%x,%x,%x,%x\n",
3938 (HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart+OFFSET_XC_LOW_DELAY_CNT)),
3939 (HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart+OFFSET_XC_LOW_DELAY_INT_STATE)),
3940 (HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart+OFFSET_XC_DIFF_FIELD_NO)),
3941 (HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart+OFFSET_XC_LOW_DELAY_CNT_LATCH)),
3942 (HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart+OFFSET_FRAME_COUNT))));
3943
3944 return HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart+OFFSET_XC_LOW_DELAY_INT_STATE);
3945 }
3946
3947 //Get ErrStatus when ErrCode==ErrShape
MVD_GetErrShapeStat(MS_U32 u32errStat)3948 static MVD_ErrStatus MVD_GetErrShapeStat(MS_U32 u32errStat)
3949 {
3950 MVD_ErrStatus st = E_MVD_ERR_STATUS_UNKOWN;
3951 switch (u32errStat)
3952 {
3953 case 0:
3954 st = E_MVD_ERR_SHAPE_RECTANGULAR;
3955 break;
3956 case 1:
3957 st = E_MVD_ERR_SHAPE_BINARY;
3958 break;
3959 case 2:
3960 st = E_MVD_ERR_SHAPE_BINARY_ONLY;
3961 break;
3962 case 3:
3963 st = E_MVD_ERR_SHAPE_GRAYSCALE;
3964 break;
3965 default:
3966 break;
3967 }
3968 return st;
3969 }
3970
3971 //Get ErrStatus when ErrCode==ErrSprite
MVD_GetErrSpriteStat(MS_U32 u32errStat)3972 static MVD_ErrStatus MVD_GetErrSpriteStat(MS_U32 u32errStat)
3973 {
3974 MVD_ErrStatus st = E_MVD_ERR_STATUS_UNKOWN;
3975 switch (u32errStat)
3976 {
3977 case 0:
3978 st = E_MVD_ERR_USED_SPRITE_UNUSED;
3979 break;
3980 case 1:
3981 st = E_MVD_ERR_USED_SPRITE_STATIC;
3982 break;
3983 case 2:
3984 st = E_MVD_ERR_USED_SPRITE_GMC;
3985 break;
3986 case 3:
3987 st = E_MVD_ERR_USED_SPRITE_RESERVED;
3988 break;
3989 default:
3990 break;
3991 }
3992 return st;
3993 }
3994
HAL_MVD_GetErrInfo(MS_U8 u8Idx,MVD_ErrCode * errCode,MVD_ErrStatus * errStatus)3995 void HAL_MVD_GetErrInfo(MS_U8 u8Idx, MVD_ErrCode *errCode, MVD_ErrStatus *errStatus)
3996 {
3997 MS_U32 errorCode = E_MVD_ERR_UNKNOWN;
3998 MS_U32 errorStatus = E_MVD_ERR_STATUS_UNKOWN;
3999 MS_VIRT pu8MVDGetFrameInfoBufStart = GET_FRMINFO_BUFFADD(u8Idx);
4000
4001 if(pu8MVDGetFrameInfoBufStart==0)
4002 {
4003 MVD_DEBUGERROR(printf("MDrv_MVD_GetErrInfo error!\n"));
4004 return;
4005 }
4006
4007 errorCode = HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart + OFFSET_ERROR_CODE);
4008 errorStatus = HAL_MVD_MemRead4Byte(pu8MVDGetFrameInfoBufStart + OFFSET_ERROR_STATUS);
4009
4010 switch (errorCode)
4011 {
4012 case VOL_SHAPE:
4013 *errCode = E_MVD_ERR_SHAPE;
4014 *errStatus = MVD_GetErrShapeStat(errorStatus);
4015 break;
4016 case VOL_USED_SPRITE:
4017 *errCode = E_MVD_ERR_USED_SPRITE;
4018 *errStatus = MVD_GetErrSpriteStat(errorStatus);
4019 break;
4020 case VOL_NOT_8_BIT:
4021 *errCode = E_MVD_ERR_NOT_8_BIT;
4022 *errStatus = E_MVD_ERR_STATUS_NONE;
4023 break;
4024 case VOL_NERPRED_ENABLE:
4025 *errCode = E_MVD_ERR_NERPRED_ENABLE;
4026 *errStatus = E_MVD_ERR_STATUS_NONE;
4027 break;
4028 case VOL_REDUCED_RES_ENABLE:
4029 *errCode = E_MVD_ERR_REDUCED_RES_ENABLE;
4030 *errStatus = E_MVD_ERR_STATUS_NONE;
4031 break;
4032 case VOL_SCALABILITY:
4033 *errCode = E_MVD_ERR_SCALABILITY;
4034 *errStatus = E_MVD_ERR_STATUS_NONE;
4035 break;
4036 case VOL_H263_ERROR:
4037 *errCode = E_MVD_ERR_H263_ERROR;
4038 *errStatus = E_MVD_ERR_STATUS_NONE;
4039 break;
4040 case VOL_RES_NOT_SUPPORT:
4041 *errCode = E_MVD_ERR_RES_NOT_SUPPORT;
4042 *errStatus = E_MVD_ERR_STATUS_NONE;
4043 break;
4044 case VOL_MPEG4_NOT_SUPPORT:
4045 *errCode = E_MVD_ERR_MPEG4_NOT_SUPPORT;
4046 *errStatus = E_MVD_ERR_STATUS_NONE;
4047 break;
4048 case VOL_PROFILE_NOT_SUPPORT:
4049 *errCode = E_MVD_ERR_PROFILE_NOT_SUPPORT;
4050 *errStatus = E_MVD_ERR_STATUS_NONE;
4051 break;
4052 case VOL_RCV_ERROR_OCCUR:
4053 *errCode = E_MVD_ERR_RCV_ERROR_OCCUR;
4054 *errStatus = E_MVD_ERR_STATUS_NONE;
4055 break;
4056 case VOL_OTHER:
4057 *errCode = E_MVD_ERR_OTHER;
4058 *errStatus = E_MVD_ERR_STATUS_NONE;
4059 break;
4060 default:
4061 *errCode = E_MVD_ERR_UNKNOWN;
4062 *errStatus = E_MVD_ERR_STATUS_UNKOWN;
4063 break;
4064 }
4065
4066 return;
4067 }
4068
4069 //take care MIU1 address
HAL_MVD_GetMemOffset(MS_PHY u32PhyAdd)4070 MS_PHY HAL_MVD_GetMemOffset(MS_PHY u32PhyAdd)
4071 {
4072 if (u32PhyAdd >= pMVDHalContext->stMiuCfg.u32Miu2BaseAddr)
4073 {
4074 return (u32PhyAdd - pMVDHalContext->stMiuCfg.u32Miu2BaseAddr);
4075 }
4076 else if(u32PhyAdd >= pMVDHalContext->stMiuCfg.u32Miu1BaseAddr)
4077 {
4078 return (u32PhyAdd - pMVDHalContext->stMiuCfg.u32Miu1BaseAddr);
4079 }
4080 else
4081 {
4082 return u32PhyAdd;
4083 }
4084 }
4085
4086
HAL_MVD_SLQTblSendPacket(MS_U8 u8Idx,MVD_PacketInfo * pstVideoPKT)4087 MS_BOOL HAL_MVD_SLQTblSendPacket(MS_U8 u8Idx, MVD_PacketInfo *pstVideoPKT)
4088 {
4089 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
4090 MS_VIRT u32EsLast;
4091 MS_VIRT* u32LastEntry = &pstSlqTblInfo->pDrvSlqTbl->u32WrPtr;
4092 MS_VIRT* pu32EsNew = &pstSlqTblInfo->pDrvEsTbl->u32WrPtr;
4093 MS_U32 u32EntryWord = 0;
4094 MS_U32 u32Index = 0;
4095 MS_U32 u32Pts;
4096 MS_VIRT u32MVDFWPtsTblAddr = NULL;
4097 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
4098
4099 MS_U32 u32ESStart=0;
4100 MS_U32 u32ESEnd=0;
4101 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
4102
4103
4104 #if _SLQTBL_DUMP_PKT
4105 // static MS_U32 u32SendTimes[MAX_DEC_NUM]= {0, 0};
4106
4107 printf("Pkt[%x] st=0x%x len=0x%x pts=0x%x id_l=0x%x id_h=0x%x\n", u32SendTimes[u8Idx]++,
4108 pstVideoPKT->u32StAddr, pstVideoPKT->u32Length, pstVideoPKT->u32TimeStamp,
4109 pstVideoPKT->u32ID_L, pstVideoPKT->u32ID_H);
4110 #endif
4111
4112 #ifdef VDEC3
4113 if(pstCtrlCfg->u8McuMode == FALSE)
4114 #endif
4115 {
4116 u32MVDFWPtsTblAddr = GET_PTSTBL_BUFFADD(u8Idx);
4117 MS_ASSERT(u32MVDFWPtsTblAddr != NULL);
4118 if (u32MVDFWPtsTblAddr)
4119 {
4120 MS_VIRT u32PtsTblEntryAddr = 0;
4121 //so far, this is the only place that driver will write f/w 1M area after init.
4122 u32Index = (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr - pstSlqTblInfo->pDrvSlqTbl->u32StAdd)/8;
4123 if(HAL_MVD_IsMcuMode(u8Idx) == FALSE)
4124 {
4125 if (pstVideoPKT->u32TimeStamp != MVD_NULLPKT_PTS)
4126 {
4127 u32Pts = _MS_TO_90K(pstVideoPKT->u32TimeStamp);
4128 }
4129 else
4130 {
4131 u32Pts = MVD_NULLPKT_PTS;
4132 }
4133 }
4134 else
4135 {
4136 u32Pts = pstVideoPKT->u32TimeStamp;
4137 }
4138 u32PtsTblEntryAddr = u32MVDFWPtsTblAddr+u32Index*MVD_FW_SLQTBL_PTS_LEN;
4139 HAL_MVD_MemWrite4Byte(u32PtsTblEntryAddr+4, pstSlqTblInfo->u32DummyPktCnt); //dummyPktCnt
4140 HAL_MVD_MemWrite4Byte(u32PtsTblEntryAddr+8, pstVideoPKT->u32ID_L); //idLow
4141 HAL_MVD_MemWrite4Byte(u32PtsTblEntryAddr+12, pstVideoPKT->u32ID_H); //idHigh
4142 HAL_MVD_MemWrite4Byte(u32PtsTblEntryAddr+16, u32Pts); //PTS
4143 HAL_MVD_MemWrite4Byte(u32PtsTblEntryAddr, (pstSlqTblInfo->u32SlqByteCnt)&0xffffff); //byteCnt
4144 //printf("PTS=0x%x(%x), idx=0x%x add=0x%x\n", pstVideoPKT->u32TimeStamp,
4145 // HAL_MVD_MemRead4Byte(u32PtsTblEntryAddr+16),
4146 // u32Index, u32PtsTblEntryAddr+16);
4147
4148 if ((HAL_MVD_IsMStreamerMode(u8Idx) || HAL_MVD_IsMcuMode(u8Idx))
4149 && (pstCtrlCfg->eFileSyncMode == E_MVD_TIMESTAMP_STS))
4150 {
4151 if(pMVDHalContext->bDropOnePTS[u8Idx] == FALSE)
4152 {
4153 HAL_MVD_MemWrite4Byte(u32MVDFWPtsTblAddr+MVD_FW_SLQTBL_PTS_LEN+12, pstVideoPKT->u32ID_H); //idHigh
4154 HAL_MVD_MemWrite4Byte(u32MVDFWPtsTblAddr+MVD_FW_SLQTBL_PTS_LEN+16, pstVideoPKT->u32TimeStamp); //PTS
4155
4156 MVD_DBG_STS(printf(">>> drvMVD pts,idH = %lu, %lu\n", HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+MVD_FW_SLQTBL_PTS_LEN+16),
4157 HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+MVD_FW_SLQTBL_PTS_LEN+12)));
4158 if (((MVD_NULLPKT_PTS == pstVideoPKT->u32ID_H) && (MVD_NULLPKT_PTS == pstVideoPKT->u32TimeStamp)) == FALSE)
4159 { //Only update PTS to firmware when pts field is valid.
4160 //Plz refer to MDrv_MVD_PushQueue if (u8MstMode == MST_MODE_TRUE) {}
4161 HAL_MVD_UpdatePts(u8Idx); //for uniplayer or MCU mode
4162 }
4163 }
4164
4165 pMVDHalContext->bDropOnePTS[u8Idx] = FALSE;
4166 }
4167 }
4168 #if _SLQTBL_DUMP_PTS
4169 if (u32Index == 0x177)
4170 {
4171 _SLQTbl_DumpPtsTbl(u8Idx, 0, 0x179);
4172 }
4173 #endif
4174 }
4175 pstSlqTblInfo->u32SlqByteCnt += pstVideoPKT->u32Length;
4176
4177 //update SLQ tbl entry
4178 //u32EsLast = (pstVideoPKT->u32StAddr)+pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
4179 u32EsLast = (pstVideoPKT->u32StAddr)+HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr);
4180 HAL_MVD_MemWrite4Byte(*pu32EsNew, u32EsLast-HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr));
4181 u32ESStart = (u32EsLast) & SLQ_TBL_ENTRY_LEN;
4182
4183 u32EsLast += pstVideoPKT->u32Length; //update ES write pointer
4184 //Notice: This is for MVD HW, so no need to minus one.
4185 HAL_MVD_MemWrite4Byte((*pu32EsNew)+4, u32EsLast-HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr));
4186 u32ESEnd = (u32EsLast) & SLQ_TBL_ENTRY_LEN;
4187
4188 *pu32EsNew += 8;
4189 if (*pu32EsNew >= pstSlqTblInfo->pDrvEsTbl->u32EndAdd)
4190 { //wrap to the beginning of the table
4191 MVD_DEBUGINFO(printf("...ES wrapping to the beginning!\n"));
4192 *pu32EsNew = pstSlqTblInfo->pDrvEsTbl->u32StAdd;
4193 }
4194
4195 //printf("===>[%x] u32ESStart=0x%x u32ESEnd=0x%x u32EsLast=0x%x\n",
4196 // pMVDHalContext->u32SendTimes[u8Idx]++, u32ESStart, u32ESEnd, u32EsLast);
4197
4198 u32EntryWord = u32ESEnd;
4199 HAL_MVD_MemWrite4Byte(*u32LastEntry, u32EntryWord);
4200 //printf("===> u32EntryWord1 addr=0x%x\n", (*u32LastEntry));
4201 //printf("===> u32EntryWord0=0x%x\n", u32EntryWord);
4202
4203 u32EntryWord = u32ESStart;
4204 HAL_MVD_MemWrite4Byte((*u32LastEntry)+4, u32EntryWord);
4205 //printf("===> u32EntryWord1 addr=0x%x\n", (*u32LastEntry)+4);
4206 //printf("===> u32EntryWord1=0x%x\n", u32EntryWord);
4207
4208 *u32LastEntry += 8;
4209 if (*u32LastEntry >= pstSlqTblInfo->pDrvSlqTbl->u32EndAdd)
4210 { //wrap to the beginning of the table
4211 MVD_DEBUGINFO(printf("...wrapping to the beginning!\n"));
4212 *u32LastEntry = pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
4213 //also wrap DivX311 pattern table
4214 pstSlqTblInfo->pDrvDivxTbl->u32WrPtr = pstSlqTblInfo->pDrvDivxTbl->u32StAdd;
4215 }
4216
4217 if (pstSlqTblInfo->pDrvSlqTbl->u32Empty)
4218 {
4219 pstSlqTblInfo->pDrvSlqTbl->u32Empty -= SLQ_ENTRY_LEN;
4220 }
4221
4222 return TRUE;
4223 }
4224
4225 //Table of frame rate code for MPEG-2
4226 #if 0
4227 #define FRM_RATE_CODE_NUM 9
4228 static const MS_U16 stFrameRateCode[FRM_RATE_CODE_NUM]=
4229 {
4230 NULL,23976,24000,25000,29976,30000,50000,59947,60000
4231 };
4232 #endif
MVD_GCD(MS_U32 u32A,MS_U32 u32B)4233 static MS_U32 MVD_GCD(MS_U32 u32A, MS_U32 u32B)
4234 {
4235 MS_S32 i;
4236 MS_U32 x[4]; /* need x[0], x[1], x[i-1] */
4237
4238 if (u32A > u32B)
4239 {
4240 x[0] = u32A; x[1] = u32B;
4241 }
4242 else
4243 {
4244 x[0] = u32B; x[1] = u32A;
4245 }
4246
4247 i = 1;
4248
4249 #define w(x) (((x)<4)?(x):(2+((x)&1)))
4250
4251 while( x[w(i)] != 0 )
4252 {
4253 x[w(i+1)] = x[w(i-1)] % x[w(i)];
4254 i++;
4255 }
4256
4257 return x[w(i-1)];
4258
4259 #undef w
4260 }
HAL_MVD_GetFrameInfo(MS_U8 u8Idx,MVD_FrameInfo * pinfo)4261 void HAL_MVD_GetFrameInfo(MS_U8 u8Idx, MVD_FrameInfo *pinfo)
4262 {
4263 FW_VOL_INFO gvolInfo;
4264 FW_DIVX_INFO* pDivxInfo = &(pMVDHalContext->gdivxInfo[u8Idx]);
4265 MS_VIRT temp = 0;
4266 MS_U32 u32DAR_Width=0,u32DAR_Height=0,u32PAR_Width=0,u32PAR_Height=0,u32GCD=0;
4267 MS_U32 u32Vertical_Size=0, u32Horizontal_Size=0;
4268 //13818-2 page 38 Table 6-3
4269 MS_U8 u8DARTable[5][2] = { {1,1}, {1,1}, {4,3}, {16,9}, {221,100} };
4270 MS_U32 pu8MVDGetVolBufStart = NULL;
4271 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
4272
4273 pu8MVDGetVolBufStart = GET_VOL_BUFFADD(u8Idx);
4274 if (pu8MVDGetVolBufStart == NULL)
4275 {
4276 MVD_DEBUGERROR(printf("MDrv_MVD_GetFrameInfo error: pu8MVDGetVolBufStart=NULL\n"));
4277 return;
4278 }
4279
4280 HAL_MVD_CPU_Sync();
4281 HAL_MVD_ReadMemory();
4282
4283 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,GET_VOL_BUFFADD(u8Idx),temp);
4284
4285 gvolInfo = (*(volatile FW_VOL_INFO*)(HAL_MVD_PA2NonCacheSeg(temp)));
4286
4287 pinfo->u16HorSize = (MS_U16) gvolInfo.width;
4288 pinfo->u16VerSize = (MS_U16) gvolInfo.height;
4289 pinfo->u16par_width = (MS_U16) gvolInfo.par_width;
4290 pinfo->u16par_height = (MS_U16) gvolInfo.par_height;
4291 pinfo->u8AspectRate = gvolInfo.aspect_ratio;
4292
4293 pinfo->u16CropBottom = gvolInfo.CropBottom;
4294 pinfo->u16CropTop = 0;
4295 pinfo->u16CropLeft = 0;
4296
4297 if (pinfo->u16HorSize & MVD_WIDTH_ALIGN_MASK)
4298 {
4299 //Notice: Firmware and driver have to be consistent for this part,
4300 // otherwise the pitch will not match and video is noisy.
4301 pinfo->u16CropRight = MVD_WIDTH_ALIGN_BYTE - (pinfo->u16HorSize & MVD_WIDTH_ALIGN_MASK);
4302 pinfo->u16HorSize = ((pinfo->u16HorSize >> MVD_WIDTH_ALIGN_BITS) + 1) << MVD_WIDTH_ALIGN_BITS;
4303 }
4304 else
4305 {
4306 pinfo->u16CropRight = 0;
4307 }
4308
4309 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
4310 if ((curCodecType == E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER) ||
4311 (curCodecType == E_MVD_CODEC_DIVX311) || (curCodecType == E_MVD_CODEC_FLV))
4312 {
4313 pinfo->u8Interlace= FALSE; //divx311/flv/svh just has progressive mode
4314 MS_ASSERT(gvolInfo.progressive_sequence == 1); //FW will init it as 1
4315 }
4316 else
4317 {
4318 if (gvolInfo.progressive_sequence == 0)
4319 {
4320 pinfo->u8Interlace=1;
4321 }
4322 else
4323 {
4324 pinfo->u8Interlace=0;
4325 }
4326 }
4327
4328 ///Calculate PAR info
4329 if (pinfo->u16par_width == 0 || pinfo->u16par_height == 0)
4330 {
4331 if ((pinfo->u8AspectRate > 0) && (pinfo->u8AspectRate < 5 ))
4332 {
4333 if (pinfo->u8AspectRate == 1)
4334 { //SAR=1.0 square sample
4335 u32DAR_Width = (MS_U32)pinfo->u16HorSize;
4336 u32DAR_Height = (MS_U32)pinfo->u16VerSize;
4337 pinfo->u16par_width = 1;
4338 pinfo->u16par_height = 1;
4339 }
4340 else
4341 {
4342 u32DAR_Width = (MS_U32)u8DARTable[pinfo->u8AspectRate][0];
4343 u32DAR_Height = (MS_U32)u8DARTable[pinfo->u8AspectRate][1];
4344 u32Vertical_Size = (MS_U32)pinfo->u16VerSize;
4345 u32Horizontal_Size = (MS_U32)(pinfo->u16HorSize - pinfo->u16CropRight);
4346 u32PAR_Width = u32DAR_Width * u32Vertical_Size;
4347 u32PAR_Height = u32DAR_Height * u32Horizontal_Size;
4348 u32GCD = MVD_GCD(u32PAR_Width, u32PAR_Height);
4349 if (0 == u32GCD)
4350 {
4351 pinfo->u16HorSize = 0xFFFF;
4352 pinfo->u16VerSize = 0xFFFF;
4353
4354 return;
4355 }
4356 else
4357 {
4358 pinfo->u16par_width = (MS_U16) (u32PAR_Width / u32GCD);
4359 pinfo->u16par_height = (MS_U16) (u32PAR_Height / u32GCD);
4360 MVD_DEBUGVERBAL(printf("u32PAR_Width:%d,u32PAR_Height:%d,GCD:%d\n",u32PAR_Width,u32PAR_Height,u32GCD));
4361 }
4362 }
4363 }
4364 else
4365 {
4366 //set to 0 to indicate it's abnormal
4367 u32DAR_Width = 0;
4368 u32DAR_Height = 0;
4369 pinfo->u16par_width = 0;
4370 pinfo->u16par_height = 0;
4371 }
4372 MVD_DEBUGVERBAL(printf("u32DAR_Width:%d,u32DAR_Height%d\n",u32DAR_Width,u32DAR_Height));
4373 }
4374 MVD_DEBUGVERBAL(printf("pinfo->u16par_width:%d, pinfo->u16par_height:%d\n",pinfo->u16par_width, pinfo->u16par_height));
4375
4376 if (curCodecType == E_MVD_CODEC_MPEG2)
4377 {
4378 if (gvolInfo.frame_rate < FRM_RATE_CODE_NUM)
4379 {
4380 pinfo->u32FrameRate = stFrameRateCode[gvolInfo.frame_rate];
4381 }
4382 else
4383 {
4384 pinfo->u32FrameRate = 0;
4385 }
4386 }
4387 else if ((curCodecType == E_MVD_CODEC_VC1_ADV) || (curCodecType == E_MVD_CODEC_VC1_MAIN))
4388 {
4389 if ((gvolInfo.vc1_frame_rate != 0) && (gvolInfo.vc1_frame_rate != MVD_U32_MAX))
4390 {
4391 pinfo->u32FrameRate = gvolInfo.vc1_frame_rate;
4392 }
4393 else if(pMVDHalContext->u32DmxFrameRate[u8Idx] != 0 && pMVDHalContext->u32DmxFrameRateBase[u8Idx] != 0)
4394 {
4395 pinfo->u32FrameRate = (pMVDHalContext->u32DmxFrameRate[u8Idx] * 1000) / pMVDHalContext->u32DmxFrameRateBase[u8Idx];
4396 }
4397 else
4398 {
4399 pinfo->u32FrameRate = pDivxInfo->frame_rate; //report framerate specified in MDrv_MVD_SetFrameInfo()
4400 }
4401
4402 MVD_DEBUGVERBAL(printf("MVD: vc1_frameRate=%d\n", pinfo->u32FrameRate));
4403 }
4404 else if (curCodecType == E_MVD_CODEC_MPEG4)
4405 {
4406 if (pDivxInfo->frame_rate != 0)
4407 {
4408 pinfo->u32FrameRate = pDivxInfo->frame_rate;
4409 //report framerate specified in MDrv_MVD_SetFrameInfo(), which is usually obtained from container
4410 }
4411 else if (gvolInfo.frame_rate != 0)
4412 {
4413 pinfo->u32FrameRate = gvolInfo.frame_rate; //report framerate from f/w
4414 }
4415 else if ((gvolInfo.fixed_vop_time_incr != 0) && (gvolInfo.vol_time_incr_res != 0))
4416 {
4417 pinfo->u32FrameRate = (gvolInfo.vol_time_incr_res * 1000) / gvolInfo.fixed_vop_time_incr;
4418 //calculate framerate according to vol header
4419 }
4420 else if(pMVDHalContext->u32DmxFrameRate[u8Idx] != 0 && pMVDHalContext->u32DmxFrameRateBase[u8Idx] != 0)
4421 {
4422 pinfo->u32FrameRate = (pMVDHalContext->u32DmxFrameRate[u8Idx] * 1000) / pMVDHalContext->u32DmxFrameRateBase[u8Idx];
4423 }
4424 else
4425 {
4426 pinfo->u32FrameRate = 60000; //set default frame rate according to chip capability
4427 }
4428 MVD_DEBUGVERBAL(printf("MVD: vol_time_incr_res=%d, fixed_vop_time_incr=%d\n", gvolInfo.vol_time_incr_res, gvolInfo.fixed_vop_time_incr));
4429 }
4430 else
4431 {
4432 if (gvolInfo.frame_rate != 0)
4433 {
4434 pinfo->u32FrameRate = gvolInfo.frame_rate;
4435 }
4436 else
4437 {
4438 pinfo->u32FrameRate = pDivxInfo->frame_rate; //report framerate specified in MDrv_MVD_SetFrameInfo()
4439 }
4440 }
4441 MVD_DEBUGVERBAL(printf("===> MVD: frameRate=%d curCodecType=0x%x\n", pinfo->u32FrameRate, curCodecType));
4442
4443 //for MM
4444 pinfo->u8MPEG1=gvolInfo.mpeg1;
4445 pinfo->u16PTSInterval=gvolInfo.pts_incr;
4446 pinfo->u8PlayMode=gvolInfo.play_mode;
4447 pinfo->u8FrcMode=gvolInfo.mpeg_frc_mode;
4448
4449 //for dynamic scaling
4450 pinfo->bEnableMIUSel = (MS_BOOL)pMVDHalContext->stMiuCfg.u8FWMiuSel;
4451
4452 if(pMVDHalContext->stMiuCfg.u8FWMiuSel >= E_CHIP_MIU_2)
4453 {
4454 MVD_DEBUGERROR(printf("u8MiuSel is %d !!, but return type is only Boolean. Please use MDrv_HVD_EX_GetDSBufMiuSelect() to get right miu select of DS buffer!\n",pMVDHalContext->stMiuCfg.u8FWMiuSel));
4455 }
4456
4457 if (pstMemCfg->bEnableDynScale)
4458 {
4459 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,GET_DS_BUFFADD(u8Idx),pinfo->u32DynScalingAddr);
4460
4461 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
4462 pinfo->u8DynScalingDepth= pCtrlCfg->u8DynScalingDepth;
4463 pinfo->u32DynScalingBufSize= gvolInfo.DSbufsize;
4464 }
4465 else
4466 {
4467 pinfo->u32DynScalingAddr= NULL;
4468 pinfo->u8DynScalingDepth= 0;
4469 pinfo->u32DynScalingBufSize= 0;
4470 }
4471
4472 return;
4473 }
4474
MVD_RstFrmInfo(MS_U8 u8Idx,MVD_FrmInfoType eType)4475 E_MVD_Result MVD_RstFrmInfo(MS_U8 u8Idx, MVD_FrmInfoType eType)
4476 {
4477 E_MVD_Result eRet = E_MVD_RET_OK;
4478 MS_VIRT u32DecFrmInfoAdd = GET_DECFRMINFO_BUFFADD(u8Idx);
4479 if (NULL == u32DecFrmInfoAdd)
4480 {
4481 return E_MVD_RET_FAIL;
4482 }
4483
4484 //printf("%s u32DecFrmInfoAdd = 0x%x\n", __FUNCTION__, u32DecFrmInfoAdd);
4485 if (E_MVD_FRMINFO_DECODE == eType)
4486 {
4487 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_LUMAADDR), _INIT_ADDR);
4488 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_CHROMAADDR), _INIT_ADDR);
4489 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_TIMESTAMP), _INIT_TIMESTAMP);
4490 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_ID_L), _INIT_ID);
4491 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_ID_H), _INIT_ID);
4492 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_PITCH), _INIT_LEN);
4493 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_WIDTH), _INIT_LEN);
4494 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_HEIGHT), _INIT_LEN);
4495 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_FRAMETYPE), 0xff);
4496 }
4497 else if (E_MVD_FRMINFO_DISPLAY == eType)
4498 {
4499 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_LUMAADDR), _INIT_ADDR);
4500 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_CHROMAADDR), _INIT_ADDR);
4501 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_TIMESTAMP), _INIT_TIMESTAMP);
4502 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_ID_L), _INIT_ID);
4503 HAL_MVD_MemWrite4Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_ID_H), _INIT_ID);
4504 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_PITCH), _INIT_LEN);
4505 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_WIDTH), _INIT_LEN);
4506 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_HEIGHT), _INIT_LEN);
4507 HAL_MVD_MemWrite2Byte((u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_FRAMETYPE), 0xff);
4508 }
4509 else
4510 {
4511 eRet = E_MVD_RET_INVALID_PARAM;
4512 }
4513
4514 return eRet;
4515 }
4516
4517 //Given the start address & the available size for the FW buffers,
4518 //Calculate the start address of each buffers.
MVD_GetFWBuffAdd(MS_VIRT u32Start,MS_U32 u32AvailLen,MVD_FWBuff * pBuff)4519 static MS_BOOL MVD_GetFWBuffAdd(MS_VIRT u32Start, MS_U32 u32AvailLen, MVD_FWBuff* pBuff)
4520 {
4521 MS_VIRT tmpAdr = u32Start;
4522
4523 if(pBuff == NULL)
4524 {
4525 MVD_DEBUGERROR(printf("%s err: NULL pBuff\n", __FUNCTION__));
4526 return FALSE;
4527 }
4528 tmpAdr += MVD_FW_CODE_LEN;
4529 GET_FW_BUFFADD_ALIGN(tmpAdr, FW_BUFF_ALIGN, MVD3_FW_VOL_INFO_BUF_LEN, pBuff->pu8MVDGetVolBufStart);
4530 GET_FW_BUFFADD_ALIGN(tmpAdr, FW_BUFF_ALIGN, MVD3_FW_FRAME_INFO_BUF_LEN, pBuff->pu8MVDGetFrameInfoBufStart);
4531 GET_FW_BUFFADD_ALIGN(tmpAdr, FW_BUFF_ALIGN, MVD3_FW_DIVX_INFO_BUF_LEN, pBuff->pu8MVDSetHeaderBufStart);
4532 GET_FW_BUFFADD_ALIGN(tmpAdr, FW_BUFF_ALIGN,
4533 (MVD3_FW_USER_DATA_BUF_LEN+MVD3_FW_USER_DATA_BUF_BACKUP_LEN), pBuff->u32UserDataBuf);
4534 //MVD3_FW_USER_DATA_BUF_BACKUP_LEN is used as CC decoding buffer for MVD_SUPPORT_X4_CC
4535
4536 GET_FW_BUFFADD_ALIGN(tmpAdr, FW_BUFF_ALIGN, MVD3_FW_SLQ_TAB_TMPBUF_LEN, pBuff->u32MVDFWSLQTABTmpbufAdr);
4537 GET_FW_BUFFADD(tmpAdr, MVD_FW_SLQTBL_PTS_BUF_LEN, pBuff->u32MVDFWPtsTblAddr);
4538 GET_FW_BUFFADD(tmpAdr, MVD_FW_DYN_SCALE_BUF_LEN, pBuff->u32DynScalingAdd);
4539 GET_FW_BUFFADD(tmpAdr, MVD_FW_SCALER_INFO_BUF_LEN, pBuff->u32ScalerInfoAdd);
4540 GET_FW_BUFFADD(tmpAdr, MVD_FW_DECFRM_INFO_BUF_LEN, pBuff->u32DecFrmInfoAdd);
4541 GET_FW_BUFFADD(tmpAdr, MVD_FW_VBBU_TABLE_LEN, pBuff->u32VBBUTableAdd);
4542
4543
4544 MVD_DEBUGINFO(printf("set pu8MVDGetVolBufStart=%lx\n", (unsigned long)pBuff->pu8MVDGetVolBufStart));
4545 MVD_DEBUGINFO(printf("set pu8MVDGetFrameInfoBufStart=%lx\n", (unsigned long)pBuff->pu8MVDGetFrameInfoBufStart));
4546 MVD_DEBUGINFO(printf("set pu8MVDSetHeaderBufStart=%lx\n", (unsigned long)pBuff->pu8MVDSetHeaderBufStart));
4547 MVD_DEBUGINFO(printf("u32UserDataBuf start=%lx\n", (unsigned long)pBuff->u32UserDataBuf));
4548 MVD_DEBUGINFO(printf("u32MVDFWSLQTABTmpbufAdr start=%lx\n", (unsigned long)pBuff->u32MVDFWSLQTABTmpbufAdr));
4549 MVD_DEBUGINFO(printf("PtsTblAddr start=%lx\n", (unsigned long)pBuff->u32MVDFWPtsTblAddr));
4550 MVD_DEBUGINFO(printf("u32DynScalingAdd start=%lx\n", (unsigned long)pBuff->u32DynScalingAdd));
4551 MVD_DEBUGINFO(printf("ScalerInfo start=%lx end=%lx\n",
4552 (unsigned long)pBuff->u32ScalerInfoAdd, (pBuff->u32ScalerInfoAdd+MVD_FW_SCALER_INFO_BUF_LEN)));
4553 MVD_DEBUGINFO(printf("DecFrmInfo start=%lx end=%lx\n",
4554 (unsigned long)pBuff->u32DecFrmInfoAdd, (pBuff->u32DecFrmInfoAdd+MVD_FW_DECFRM_INFO_BUF_LEN)));
4555
4556 MS_U32 u32ShMemBoundary = (MVD_FW_CODE_LEN==MVD_FW_CODE_LEN_V00) ? MVD_FW_MPOOL_START_OFFSET : MVD_FW_TASK_OFFSET;
4557 #if v3_temp
4558
4559 if ((pBuff->u32VBBUTableAdd+MVD_FW_VBBU_TABLE_LEN-u32Start) > u32ShMemBoundary)
4560 {
4561 //shared memory should not overlap with FW memory pool.
4562 MVD_DEBUGERROR(printf("%s err: 0x%lx out of memory boundary!\n", __FUNCTION__,
4563 (pBuff->u32VBBUTableAdd+MVD_FW_VBBU_TABLE_LEN-u32Start)));
4564 return FALSE;
4565 }
4566 #else
4567 if ((pBuff->u32DecFrmInfoAdd+MVD_FW_DECFRM_INFO_BUF_LEN-u32Start) > u32ShMemBoundary)
4568 {
4569 //shared memory should not overlap with FW memory pool.
4570 MVD_DEBUGERROR(printf("%s err: 0x%x out of memory boundary!\n", __FUNCTION__,
4571 (pBuff->u32DecFrmInfoAdd+MVD_FW_DECFRM_INFO_BUF_LEN-u32Start)));
4572 return FALSE;
4573 }
4574 #endif
4575
4576 return TRUE;
4577 }
4578
4579 //Set buffer address to f/w
4580 //Init the memory erea if necessary
MVD_SetFWBuffAdd(MS_U8 u8Idx,MVD_FWBuff * pBuff)4581 static MS_BOOL MVD_SetFWBuffAdd(MS_U8 u8Idx, MVD_FWBuff* pBuff)
4582 {
4583 MS_U32 i;
4584 MVD_SrcMode curSrcMode = E_MVD_SRC_UNKNOWN;
4585 MVD_MEMCfg* pstMemCfg = NULL;
4586 MVD_CtrlCfg* pCtrlCfg = NULL;
4587
4588 if(pBuff == NULL)
4589 {
4590 MVD_DEBUGERROR(printf("%s err: NULL pBuff\n", __FUNCTION__));
4591 return FALSE;
4592 }
4593
4594 pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
4595
4596 MVD_DEBUGINFO(printf("\nMIU is (shm,hw,fw)=(%x,%x,%x)\n",u8SHMMiuSel,pstMemCfg->u8HWMiuSel,pstMemCfg->u8FWMiuSel));
4597
4598 curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
4599
4600 HAL_MVD_SetVolInfoBufferAddr(u8Idx, pBuff->pu8MVDGetVolBufStart);
4601 _MVD_Memset(pBuff->pu8MVDGetVolBufStart, 0, MVD3_FW_VOL_INFO_BUF_LEN);
4602
4603 pBuff->u32VolAdd = pBuff->pu8MVDGetVolBufStart;
4604
4605 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,pBuff->u32VolAdd,pBuff->u32VolAdd);
4606
4607 pBuff->u32VolAdd = HAL_MVD_PA2NonCacheSeg(pBuff->u32VolAdd);
4608 MVD_DEBUGINFO(printf("gvolInfo = 0x%lx, volBuf=0x%lx\n", (unsigned long)pBuff->u32VolAdd, (unsigned long)pBuff->pu8MVDGetVolBufStart));
4609
4610 HAL_MVD_SetFrameInfoBufferAddr(u8Idx, pBuff->pu8MVDGetFrameInfoBufStart);
4611 _MVD_Memset(pBuff->pu8MVDGetFrameInfoBufStart, 0, MVD3_FW_FRAME_INFO_BUF_LEN);
4612
4613 HAL_MVD_SetHeaderBufferAddr(u8Idx, pBuff->pu8MVDSetHeaderBufStart);
4614 HAL_MVD_SetUserDataBuf(u8Idx, pBuff->u32UserDataBuf, MVD3_FW_USER_DATA_BUF_LEN);
4615 pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
4616 pCtrlCfg->u32UsrDataRd = pBuff->u32UserDataBuf;
4617
4618
4619 if((curSrcMode != E_MVD_TS_FILE_MODE)
4620 && (curSrcMode != E_MVD_TS_MODE))
4621 {
4622 _MVD_Memset(pBuff->u32MVDFWSLQTABTmpbufAdr, 0, MVD3_FW_SLQ_TAB_TMPBUF_LEN);
4623 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWSLQTABTmpbufAdr, 0xBE010000UL);
4624 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWSLQTABTmpbufAdr+4, 0x000000FAUL);
4625
4626 HAL_MVD_SetPtsTblAddr(u8Idx, pBuff->u32MVDFWPtsTblAddr);
4627 for (i=0; i<MVD_FW_SLQTBL_PTS_BUF_LEN; i+=MVD_FW_SLQTBL_PTS_LEN)
4628 {
4629 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i, 0); //byteCnt
4630 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+4, 0); //dummyPktCnt
4631 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+8, 0); //idLow
4632 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+12, 0); //idHigh
4633
4634 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+16, MVD_NULLPKT_PTS); //PTS
4635 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+20, 0); //reserved0
4636 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+24, 0); //reserved1
4637 HAL_MVD_MemWrite4Byte(pBuff->u32MVDFWPtsTblAddr+i+28, 0); //reserved2
4638 }
4639 //MS_ASSERT((u32MVDFWPtsTblAddr+MVD_FW_SLQTBL_PTS_BUF_LEN)<=(u32start+u32len));
4640 MVD_DEBUGINFO(printf("PTS tbl start=%lx end=%lx\n",
4641 (unsigned long)pBuff->u32MVDFWPtsTblAddr, (unsigned long)(pBuff->u32MVDFWPtsTblAddr+MVD_FW_SLQTBL_PTS_BUF_LEN)));
4642
4643 pBuff->u32VBBUTableAdd = VBBU_TABLE_START+u8Idx*0x100000;
4644 }
4645
4646 if (pstMemCfg->bEnableDynScale)
4647 {
4648 HAL_MVD_SetDynamicScaleAddr(u8Idx, pBuff->u32DynScalingAdd);
4649 HAL_MVD_EnableDynamicScale(u8Idx,0); //default old DS style
4650 pCtrlCfg->u8DynScalingDepth = 32; //HAL_MVD_GetDynamicScaleDepth
4651 MVD_DEBUGINFO(printf("u8EnableMIUSel = 0x%x\n", pMVDHalContext->stMiuCfg.u8FWMiuSel));
4652 MVD_DEBUGINFO(printf("u32DynScalingAddr= 0x%lx\n", (unsigned long)pBuff->u32DynScalingAdd));
4653 MVD_DEBUGINFO(printf("u8DynScalingDepth= 0x%x\n", pCtrlCfg->u8DynScalingDepth));
4654 }
4655 MVD_DEBUGINFO(printf("DynScaling start=%lx end=%lx\n",
4656 (unsigned long)pBuff->u32DynScalingAdd, (unsigned long)(pBuff->u32DynScalingAdd+MVD_FW_DYN_SCALE_BUF_LEN)));
4657
4658 HAL_MVD_SetDecFrmInfoAddr(u8Idx, pBuff->u32DecFrmInfoAdd);
4659
4660 MVD_RstFrmInfo(u8Idx, E_MVD_FRMINFO_DECODE);
4661 MVD_RstFrmInfo(u8Idx, E_MVD_FRMINFO_DISPLAY);
4662 MVD_DEBUGINFO(printf("DecFrmInfo start=%lx\n", (unsigned long)pBuff->u32DecFrmInfoAdd));
4663
4664 if (curSrcMode == E_MVD_SLQ_TBL_MODE)
4665 {
4666 HAL_MVD_SLQTblInit(u8Idx);
4667 }
4668
4669 return TRUE;
4670 }
4671
4672 #ifdef VDEC3
4673 #else
MVD_IsNextDispFrmRdy(MS_U8 u8Idx)4674 static MS_BOOL MVD_IsNextDispFrmRdy(MS_U8 u8Idx)
4675 {
4676 #define NXT_DISP_TIMEOUT 20000//0x20
4677 MS_U32 u32TimeOut = 0;
4678 MVD_CmdArg mvdcmd;
4679
4680 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_GET_NXTDISPFRM);
4681 SETUP_CMDARG(mvdcmd);
4682 SET_DECNUM(mvdcmd, u8Idx);
4683 SET_CMD_RET_FALSE(CMD_GET_NEXTDISPFRM, &mvdcmd);
4684
4685 while(!HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_GET_NXTDISPFRM) && (u32TimeOut < NXT_DISP_TIMEOUT))
4686 {
4687 u32TimeOut++;
4688 }
4689 if(u32TimeOut >= NXT_DISP_TIMEOUT)
4690 {
4691 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail!!\r\n", CMD_GET_NEXTDISPFRM ) );
4692 return FALSE;
4693 }
4694 return TRUE;
4695 }
4696 #endif
4697
HAL_MVD_GetExtDispInfo(MS_U8 u8Idx,MVD_ExtDispInfo * pInfo)4698 void HAL_MVD_GetExtDispInfo(MS_U8 u8Idx, MVD_ExtDispInfo* pInfo)
4699 {
4700 pInfo->u16VSize = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISP_V_SIZE, sizeof(MS_U16));
4701 pInfo->u16HSize = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISP_H_SIZE, sizeof(MS_U16));
4702 pInfo->u16VOffset = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CENTRE_V_OFFSET, sizeof(MS_U16));
4703 pInfo->u16HOffset = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CENTRE_H_OFFSET, sizeof(MS_U16));
4704 }
4705
HAL_MVD_GetFrmInfo(MS_U8 u8Idx,MVD_FrmInfoType eType,MVD_FrmInfo * pInfo)4706 E_MVD_Result HAL_MVD_GetFrmInfo(MS_U8 u8Idx, MVD_FrmInfoType eType, MVD_FrmInfo* pInfo)
4707 {
4708 MS_U32 u32Id = MVD_GetStreamId(u8Idx);
4709 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
4710 E_MVD_Result eRet = E_MVD_RET_OK;
4711 MS_VIRT u32DecFrmInfoAdd = GET_DECFRMINFO_BUFFADD(u8Idx);
4712 #if v3_temp
4713 MVD_MEMCfg* pstMemCfg = NULL;
4714 pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
4715 #endif
4716 if (NULL == pInfo)
4717 {
4718 MVD_DEBUGERROR(printf("GetFrmInfo NULL pInfo!\n"));
4719 return E_MVD_RET_INVALID_PARAM;
4720 }
4721 if (NULL == u32DecFrmInfoAdd)
4722 {
4723 MVD_DEBUGERROR(printf("GetFrmInfo NULL u32DecFrmInfoAdd!\n"));
4724 return E_MVD_RET_FAIL;
4725 }
4726 //printf("%s u32DecFrmInfoAdd = 0x%x\n", __FUNCTION__, u32DecFrmInfoAdd);
4727
4728 if (E_MVD_FRMINFO_DECODE == eType)
4729 {
4730 pInfo->u32LumaAddr = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_LUMAADDR);
4731 pInfo->u32ChromaAddr= HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_CHROMAADDR);
4732 pInfo->u32TimeStamp = _90K_TO_MS(HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_TIMESTAMP));
4733 pInfo->u32ID_L = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_ID_L);
4734 pInfo->u32ID_H = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_ID_H);
4735 pInfo->u16Pitch = HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_PITCH);
4736 pInfo->u16Width = HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_WIDTH);
4737 pInfo->u16Height= HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_HEIGHT);
4738 pInfo->eFrmType = (MVD_PicType)HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DEC_FRAMETYPE);
4739 }
4740 else if (E_MVD_FRMINFO_DISPLAY == eType)
4741 {
4742 pInfo->u32LumaAddr = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_LUMAADDR);
4743 pInfo->u32ChromaAddr= HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_CHROMAADDR);
4744 pInfo->u32TimeStamp = _90K_TO_MS(HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_TIMESTAMP));
4745 pInfo->u32ID_L = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_ID_L);
4746 pInfo->u32ID_H = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_ID_H);
4747 pInfo->u16Pitch = HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_PITCH);
4748 pInfo->u16Width = HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_WIDTH);
4749 pInfo->u16Height= HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_HEIGHT);
4750 pInfo->eFrmType = (MVD_PicType)HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_DISP_FRAMETYPE);
4751 }
4752
4753 else if (E_MVD_FRMINFO_NEXT_DISPLAY == eType)
4754 {
4755 #if v3_temp
4756 DISPQ_IN_DRAM* pTemp = (DISPQ_IN_DRAM*)(MS_PA2KSEG1(pstMemCfg->u32FWCodeAddr+DISP_QUEUE_START+ u8VPUIdx*0x100000));
4757 if (pTemp->dispQ_rd == pTemp->dispQ_wr)
4758 {
4759 MVD_DEBUGINFO(printf("NextDispFrm not ready!\n"));
4760 return E_MVD_RET_FAIL;
4761 }
4762 pInfo->u16FrmIdx = pTemp->disp_info[pTemp->dispQ_rd].u16NextDispFrameIdx;
4763
4764 pInfo->u32LumaAddr = pTemp->disp_info[pTemp->dispQ_rd].u32NextDispLumaAddr;
4765
4766 pInfo->u32ChromaAddr= pTemp->disp_info[pTemp->dispQ_rd].u32NextDispChromaAddr;
4767 // 64BIT_PTS = (TimeStamp | (ID_H<<32)) , unit: 90K
4768 pInfo->u32TimeStamp = pTemp->disp_info[pTemp->dispQ_rd].u32NextDispTimeStamp;
4769
4770 pInfo->u32ID_H = pTemp->disp_info[pTemp->dispQ_rd].u32NextDispID_H;
4771
4772 pInfo->u16Width = pTemp->disp_info[pTemp->dispQ_rd].u16NextDispWidth;
4773
4774 if(HAL_MVD_IsMcuMode(u8Idx))
4775 {
4776 //bit[19-20] Picture format,
4777 //bit[18-17] Disp times, 1~3
4778 //bit[16] Top field first , 0-> bottom first, 1-> top first
4779 //bit[15:8] Range reduction of luma data
4780 //bit[7:0] Range reduction of chroma data
4781 pInfo->u32ID_L = (MS_U32)pTemp->disp_info[pTemp->dispQ_rd].u8NextDispRangeRed_UV
4782 | (MS_U32)(pTemp->disp_info[pTemp->dispQ_rd].u8NextDispRangeRed_Y << 8)
4783 | (MS_U32)(pTemp->disp_info[pTemp->dispQ_rd].u16ExtData << 16)
4784 | (MS_U32)(pTemp->disp_info[pTemp->dispQ_rd].u8Progressive << 19);
4785
4786 if (pInfo->u16Width & MVD_WIDTH_ALIGN_MASK)
4787 {
4788 pInfo->u16Width = ((pInfo->u16Width >> MVD_WIDTH_ALIGN_BITS) + 1) << MVD_WIDTH_ALIGN_BITS;
4789 }
4790 }
4791 else
4792 {
4793 pInfo->u32ID_L = pTemp->disp_info[pTemp->dispQ_rd].u32DispID_L;
4794 }
4795 pInfo->u16Pitch = pTemp->disp_info[pTemp->dispQ_rd].u16NextDispPitch;
4796 pInfo->u16Height= pTemp->disp_info[pTemp->dispQ_rd].u16NextDispHeight;
4797 pInfo->eFrmType = pTemp->disp_info[pTemp->dispQ_rd].u16NextDispeFrameType;
4798
4799 pTemp->bUsedByOutside[pInfo->u16FrmIdx]++;
4800
4801 pTemp->dispQ_rd = (pTemp->dispQ_rd+1)%DISPQ_SIZE;
4802 MsOS_FlushMemory();
4803 #else
4804 if (!MVD_IsNextDispFrmRdy(u8Idx))
4805 {
4806 MVD_DEBUGINFO(printf("NextDispFrm not ready!\n"));
4807 return E_MVD_RET_FAIL;
4808 }
4809 pInfo->u16FrmIdx= HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_FRAMEIDX);
4810 if (pInfo->u16FrmIdx == 0xFFFF)
4811 {
4812 MVD_DEBUGINFO(printf("GetFrmInfo no available frame!\n"));
4813 return E_MVD_RET_FAIL;
4814 }
4815 pInfo->u32LumaAddr = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_LUMAADDR);
4816 pInfo->u32ChromaAddr= HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_CHROMAADDR);
4817 // 64BIT_PTS = (TimeStamp | (ID_H<<32)) , unit: 90K
4818 pInfo->u32TimeStamp = (HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_TIMESTAMP));
4819 pInfo->u32ID_H = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_ID_H);
4820 pInfo->u16Width = HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_WIDTH);
4821 if(HAL_MVD_IsMcuMode(u8Idx))
4822 {
4823 //bit[18-17] Disp times, 1~3
4824 //bit[16] Top field first , 0-> bottom first, 1-> top first
4825 //bit[15:8] Range reduction of luma data
4826 //bit[7:0] Range reduction of chroma data
4827 pInfo->u32ID_L = (MS_U32)HAL_MVD_MemReadByte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_RANGERED_UV)
4828 | (MS_U32)(HAL_MVD_MemReadByte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_RANGERED_Y) << 8)
4829 | (MS_U32)(HAL_MVD_MemReadByte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_EXT_DATA) << 16);
4830 if (pInfo->u16Width & MVD_WIDTH_ALIGN_MASK)
4831 {
4832 pInfo->u16Width = ((pInfo->u16Width >> MVD_WIDTH_ALIGN_BITS) + 1) << MVD_WIDTH_ALIGN_BITS;
4833 }
4834 }
4835 else
4836 {
4837 pInfo->u32ID_L = HAL_MVD_MemRead4Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_ID_L);
4838 }
4839 pInfo->u16Pitch = HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_PITCH);
4840 pInfo->u16Height= HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_HEIGHT);
4841 pInfo->eFrmType = (MVD_PicType)HAL_MVD_MemRead2Byte(u32DecFrmInfoAdd + OFFSET_DECFRAMEINFO_NEXTDISP_FRAMETYPE);
4842 #endif
4843 #if 0
4844 printf("NxtFrm:: Idx=0x%x, ", pInfo->u16FrmIdx);
4845 printf("Type=0x%x, ", pInfo->eFrmType );
4846 printf("Luma=0x%x, ", pInfo->u32LumaAddr );
4847 printf("Chroma=0x%x, ", pInfo->u32ChromaAddr);
4848 printf("Pts=%lu, ", pInfo->u32TimeStamp );
4849 printf("ID_H=%lu, ", pInfo->u32ID_H );
4850 printf("ID_L=0x%x\n", pInfo->u32ID_L );
4851 #endif
4852 MVD_DBG_STS(printf("<<< drvMVD pts,idH = %lu, %lu\n", pInfo->u32TimeStamp, pInfo->u32ID_H));
4853 }
4854 else
4855 {
4856 eRet = E_MVD_RET_INVALID_PARAM;
4857 }
4858
4859 if ((pInfo->u32LumaAddr == _INIT_ADDR) || (pInfo->u32ChromaAddr== _INIT_ADDR) ||
4860 (pInfo->u16Pitch == _INIT_LEN) || (pInfo->u16Width == _INIT_LEN) ||
4861 (pInfo->u16Height== _INIT_LEN))
4862 {
4863 MVD_DEBUGINFO(printf("GetFrmInfo not ready!\n"));
4864 return E_MVD_RET_FAIL;
4865 }
4866
4867 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,(pInfo->u32LumaAddr * 8),pInfo->u32LumaAddr);
4868 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,(pInfo->u32ChromaAddr * 8),pInfo->u32ChromaAddr);
4869
4870 //printf("===> Luma=0x%x, Chroma=0x%x\n", pInfo->u32LumaAddr, pInfo->u32ChromaAddr);
4871 return eRet;
4872 }
4873
4874
4875
HAL_MVD_SetDynScalingParam(MS_U8 u8Idx,MS_PHY u32StAddr,MS_SIZE u32Size)4876 E_MVD_Result HAL_MVD_SetDynScalingParam(MS_U8 u8Idx, MS_PHY u32StAddr, MS_SIZE u32Size)
4877 {
4878 #define SCALER_INFO_TIMEOUT 0x1000
4879 MS_U32 u32TimeOut = 0;
4880 MS_VIRT u32SrcAdd = NULL;
4881 MS_U32 i;
4882 MS_VIRT u32ScalerInfoAdd = GET_XCINFO_BUFFADD(u8Idx);
4883 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
4884
4885 if ((u32StAddr==NULL) || (u32Size==0) || (u32Size>MVD_FW_SCALER_INFO_BUF_LEN))
4886 {
4887 MVD_DEBUGERROR(printf("%s invalid para u32StAddr=0x%lx, u32Size=0x%lx\n",
4888 __FUNCTION__, (unsigned long)u32StAddr, (unsigned long)u32Size));
4889 return E_MVD_RET_INVALID_PARAM;
4890 }
4891 if (TRUE != pstMemCfg->bEnableDynScale)
4892 {
4893 MVD_DEBUGERROR(printf("%s !bEnableDynScale\n", __FUNCTION__));
4894 return E_MVD_RET_FAIL;
4895 }
4896
4897 //copy data
4898 u32SrcAdd = HAL_MVD_PA2NonCacheSeg(u32StAddr);
4899 u32Size = ((u32Size+3)>>2)<<2;
4900 MVD_DEBUGINFO(printf("u32Size= 0x%lx, u32SrcAdd= 0x%lx\n", (unsigned long)u32Size, (unsigned long)u32SrcAdd));
4901 for (i=0; i<u32Size; i=i+4)
4902 {
4903 HAL_MVD_MemWrite4Byte(u32ScalerInfoAdd+i, *(volatile MS_U32*)(u32SrcAdd+i));
4904 MVD_DEBUGINFO(printf("0x%lx = 0x%x\n", (unsigned long)(u32ScalerInfoAdd+i), HAL_MVD_MemRead4Byte(u32ScalerInfoAdd+i)));
4905 }
4906
4907 //notify f/w
4908 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_SCALER_INFO);
4909 if (TRUE!=HAL_MVD_SetScalerInfoAddr(u8Idx, u32ScalerInfoAdd,((MS_U8*)u32SrcAdd)[0])) //Set the buffer address (MIU offset) to f/w
4910 {
4911 MVD_DEBUGERROR(printf("%s fail to set ScalerInfoAdd\n", __FUNCTION__));
4912 return E_MVD_RET_FAIL;
4913 }
4914
4915 //check f/w already handle the data
4916 while((TRUE!=HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_SCALER_INFO)) && (u32TimeOut < SCALER_INFO_TIMEOUT))
4917 {
4918 u32TimeOut++;
4919 }
4920 if(u32TimeOut >= SCALER_INFO_TIMEOUT)
4921 {
4922 MVD_DEBUGERROR(printf("%s timeout!!!\n", __FUNCTION__));
4923 return E_MVD_RET_FAIL;
4924 }
4925
4926 //clear ack bit
4927 HAL_MVD_ClearCmdFinished(u8Idx, MVD_HANDSHAKE_SCALER_INFO);
4928
4929 MVD_DEBUGINFO(printf("=====> %s u32TimeOut = 0x%x\n", __FUNCTION__, u32TimeOut));
4930 return E_MVD_RET_OK;
4931 }
4932
4933 //Map driver CodecType to firmware CodecType
MVD_MapCodecType(MVD_CodecType type)4934 static MS_U8 MVD_MapCodecType(MVD_CodecType type)
4935 {
4936 MS_U8 u8type = 0xff;
4937 switch (type)
4938 {
4939 case E_MVD_CODEC_MPEG2:
4940 u8type = CODEC_MPEG2;
4941 break;
4942 case E_MVD_CODEC_MPEG4:
4943 u8type = CODEC_MPEG4;
4944 break;
4945 case E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER:
4946 u8type = CODEC_MPEG4_SHORT_VIDEO_HEADER;
4947 break;
4948 case E_MVD_CODEC_DIVX311:
4949 u8type = CODEC_DIVX311;
4950 break;
4951
4952 case E_MVD_CODEC_FLV:
4953 u8type = 0x03;
4954 break;
4955
4956 case E_MVD_CODEC_VC1_MAIN: //RCV
4957 u8type = 0x05;
4958 break;
4959
4960 case E_MVD_CODEC_VC1_ADV: //VC1
4961 u8type = 0x04;
4962 break;
4963
4964 default:
4965 break;
4966 }
4967
4968 return u8type;
4969 }
4970
4971 //Map driver SrcType to firmware SrcType
MVD_MapSrcMode(MVD_SrcMode mode)4972 static MS_U8 MVD_MapSrcMode(MVD_SrcMode mode)
4973 {
4974 MS_U8 u8mode = 0xff;
4975 switch (mode)
4976 {
4977 case E_MVD_TS_MODE:
4978 u8mode = STREAM_MODE;
4979 break;
4980 case E_MVD_FILE_MODE:
4981 u8mode = FILE_MODE;
4982 break;
4983 case E_MVD_SLQ_MODE:
4984 u8mode = SLQ_MODE;
4985 break;
4986 case E_MVD_SLQ_TBL_MODE:
4987 u8mode = SLQ_TBL_MODE;
4988 break;
4989 case E_MVD_TS_FILE_MODE:
4990 u8mode = TS_FILE_MODE;
4991 break;
4992
4993 default:
4994 break;
4995 }
4996
4997 return u8mode;
4998 }
4999
5000
MVD_CheckFrmBuffSizeMin(MVD_FWCfg * fwCfg,MVD_MEMCfg * memCfg)5001 static MS_BOOL MVD_CheckFrmBuffSizeMin(MVD_FWCfg* fwCfg, MVD_MEMCfg* memCfg)
5002 {
5003 MS_BOOL ret = TRUE;
5004
5005 if (_IS_VC1(fwCfg->eCodecType))
5006 {
5007 MVD_DEBUGERROR(printf("Framebuffer size(0x%lx) < (0x%x+0x%lx)!\n",
5008 (unsigned long)memCfg->u32FBSize, (MVD_HD_FBSIZE*MVD_FBNUM_MIN), MVD_HW_BUF_TOTAL_LEN));
5009 ret = FALSE;
5010 }
5011 else if (memCfg->u32FBSize < (MVD4_MPEG_FBSIZE_SDMIN+MVD_HW_BUF_TOTAL_LEN))
5012 {
5013 MVD_DEBUGERROR(printf("Framebuffer size(0x%lx) < (0x%x+0x%lx)\n",
5014 (unsigned long)memCfg->u32FBSize, MVD4_MPEG_FBSIZE_SDMIN, MVD_HW_BUF_TOTAL_LEN));
5015 ret = FALSE;
5016 }
5017 return ret;
5018 }
5019
MVD_GetUsedFrmBuffSize(MS_U8 u8FBMode,MS_U8 u8FBNum)5020 MS_U32 MVD_GetUsedFrmBuffSize(MS_U8 u8FBMode, MS_U8 u8FBNum)
5021 {
5022 MS_U32 u32Size = 0;
5023 if (MVD3_DHD_MODE == u8FBMode)
5024 {
5025 u32Size = MVD_DHD_FBSIZE;
5026 if (MVD_FBNUM_MAX == u8FBNum)
5027 {
5028 u32Size *= MVD_FBNUM_MAX;
5029 }
5030 else if (MVD_FBNUM_MIN == u8FBNum)
5031 {
5032 u32Size *= MVD_FBNUM_MIN;
5033 }
5034 }
5035 else if (MVD3_HD_MODE == u8FBMode)
5036 {
5037 u32Size = MVD_HD_FBSIZE;
5038 if (MVD_FBNUM_MAX == u8FBNum)
5039 {
5040 u32Size *= MVD_FBNUM_MAX;
5041 }
5042 else if (MVD_FBNUM_MIN == u8FBNum)
5043 {
5044 u32Size *= MVD_FBNUM_MIN;
5045 }
5046 }
5047 else if (MVD3_SD_MODE == u8FBMode)
5048 {
5049 u32Size = MVD4_MPEG_FBSIZE_SDMIN;
5050 }
5051 return u32Size;
5052 }
5053
5054 //------------------------------------------------------------------------------
5055 /// Determine u8FBMode & u8FBNum according to the assigned FBSize
5056 //------------------------------------------------------------------------------
HAL_MVD_CheckFrmBuffSize(MS_U8 u8Idx,MVD_FWCfg * fwCfg,MVD_MEMCfg * memCfg)5057 MS_BOOL HAL_MVD_CheckFrmBuffSize(MS_U8 u8Idx, MVD_FWCfg* fwCfg, MVD_MEMCfg* memCfg)
5058 {
5059 MS_BOOL ret = TRUE;
5060 MS_U8* pu8FBMode = &(fwCfg->u8FBMode);
5061 MS_U8* pu8FBNum = &(fwCfg->u8FBNum);
5062 MS_U32 u32AvailFrmBuffSize = memCfg->u32FBSize - MVD_HW_BUF_TOTAL_LEN;
5063
5064 ret = MDrv_MVD_AUTH_IPCheck(fwCfg->eCodecType,&(memCfg->bSupportSDModeOnly));
5065 if(ret == FALSE)
5066 {
5067 return FALSE;
5068 }
5069
5070 *pu8FBMode = 0xff;
5071
5072 #if defined(MVD_SUPPORT_SD_ONLY)
5073 *pu8FBMode = MVD3_SD_MODE;
5074 #else
5075 if(memCfg->bSupportSDModeOnly)
5076 {
5077 *pu8FBMode = MVD3_SD_MODE;
5078 }
5079 #endif //MVD_SUPPORT_SD_ONLY
5080
5081 //For SD only cases: defined(MVD_SUPPORT_SD_ONLY) and bSupportSDModeOnly
5082 if (MVD3_SD_MODE == *pu8FBMode)
5083 {
5084 ret = MVD_CheckFrmBuffSizeMin(fwCfg, memCfg);
5085
5086 //set frmBuffNum as 4
5087 *pu8FBNum = MVD_FBNUM_MIN;
5088 MVD_DEBUGINFO(printf("[MVD_SD_MODE] u8FBNum=%d, FBSize=0x%lx\n", *pu8FBNum, (unsigned long)memCfg->u32FBSize));
5089 goto _GET_USED_SIZE;
5090 }
5091
5092 if (u32AvailFrmBuffSize >= (MVD_DHD_FBSIZE*MVD_FBNUM_MAX))
5093 {
5094 MVD_DEBUGINFO(printf("%s(%d) DHD*5\n", __FUNCTION__, __LINE__));
5095 //Dual HD: (1920*2)*1088 or 1920*(1088*2)
5096 if (!_IS_VC1(fwCfg->eCodecType)) //mpeg2/4
5097 {
5098 *pu8FBMode = MVD3_DHD_MODE;
5099 }
5100 else
5101 {
5102 *pu8FBMode = MVD3_DHD_MODE_MIN;
5103 }
5104 *pu8FBNum = MVD_FBNUM_MAX;
5105 }
5106 else if (u32AvailFrmBuffSize >= (MVD_DHD_FBSIZE*MVD_FBNUM_MIN))
5107 {
5108 MVD_DEBUGINFO(printf("%s(%d) DHD*4\n", __FUNCTION__, __LINE__));
5109 //Dual HD: (1920*2)*1088 or 1920*(1088*2)
5110 if (!_IS_VC1(fwCfg->eCodecType)) //mpeg2/4
5111 {
5112 *pu8FBMode = MVD3_DHD_MODE;
5113 }
5114 else
5115 {
5116 *pu8FBMode = MVD3_DHD_MODE_MIN;
5117 }
5118 *pu8FBNum = MVD_FBNUM_MIN;
5119 }
5120 else if (u32AvailFrmBuffSize >= (MVD_HD_FBSIZE*MVD_FBNUM_MAX))
5121 {
5122 MVD_DEBUGINFO(printf("%s(%d) HD*5\n", __FUNCTION__, __LINE__));
5123 *pu8FBMode = MVD3_HD_MODE;
5124 *pu8FBNum = MVD_FBNUM_MAX;
5125 }
5126 else if (u32AvailFrmBuffSize >= (MVD_HD_FBSIZE*MVD_FBNUM_MIN))
5127 {
5128 MVD_DEBUGINFO(printf("%s(%d) HD*4\n", __FUNCTION__, __LINE__));
5129 *pu8FBMode = MVD3_HD_MODE;
5130 *pu8FBNum = MVD_FBNUM_MIN;
5131 }
5132 else
5133 {
5134 MVD_DEBUGINFO(printf("%s(%d) SD\n", __FUNCTION__, __LINE__));
5135 ret = MVD_CheckFrmBuffSizeMin(fwCfg, memCfg);
5136 if (TRUE == ret)
5137 {
5138 *pu8FBMode = MVD3_SD_MODE;
5139 *pu8FBNum = MVD_FBNUM_MIN;
5140 MVD_DEBUGINFO(printf("Framebuffer [SD] mode\n"));
5141 }
5142 }
5143
5144
5145 //Keep FBNum=4 for mpeg2/4, not-mstreamer/uniplayer/mcu mode.
5146 if (!_IS_VC1(fwCfg->eCodecType)) //mpeg2/4
5147 {
5148 if (*pu8FBNum != MVD_FBNUM_DEFAULT)
5149 {
5150 *pu8FBNum = MVD_FBNUM_DEFAULT;
5151 }
5152 }
5153
5154 _GET_USED_SIZE:
5155 fwCfg->u32FBUsedSize = u32AvailFrmBuffSize;
5156
5157 MVD_DEBUGINFO(printf("%s u8FBMode=0x%x, u8FBNum=%d, FBSize=0x%lx, used=0x%lx\n",
5158 __FUNCTION__, fwCfg->u8FBMode, fwCfg->u8FBNum, (unsigned long)memCfg->u32FBSize, (unsigned long)fwCfg->u32FBUsedSize));
5159 return ret;
5160 }
5161
HAL_MVD_SetCodecInfo(MS_U8 u8Idx,MVD_CodecType eCodecType,MVD_SrcMode eSrcMode,MS_U8 bDisablePESParsing)5162 MS_BOOL HAL_MVD_SetCodecInfo(MS_U8 u8Idx, MVD_CodecType eCodecType, MVD_SrcMode eSrcMode, MS_U8 bDisablePESParsing)
5163 {
5164 MVD_CmdArg stCmdArg;
5165 //printf("u8CodecType=0x%x\n", u8CodecType);
5166 //printf("eSrcMode=0x%x\n", eSrcMode);
5167 SETUP_CMDARG(stCmdArg);
5168 stCmdArg.Arg0 = MVD_MapCodecType(eCodecType);
5169 stCmdArg.Arg1 = MVD_MapSrcMode(eSrcMode);
5170 stCmdArg.Arg2 = bDisablePESParsing;
5171 //arg2 is only valid for STREAM_MODE and TS_FILE_MODE
5172 //set as 0 to enable MVD parser and parser interrupt
5173 stCmdArg.Arg3 = 0;
5174 MVD_DEBUGINFO(printf("MDrv_MVD_SetCodecInfo: Cmd: %x, Arg0: %x, Arg1: %x. Arg2: %x\n",
5175 CMD_CODEC_INFO, stCmdArg.Arg0, stCmdArg.Arg1, stCmdArg.Arg2));
5176 SET_DECNUM(stCmdArg, u8Idx);
5177 SET_CMD_RET_FALSE(CMD_CODEC_INFO, &stCmdArg);
5178
5179 HAL_MVD_SetSrcMode(u8Idx,eSrcMode);
5180
5181 //set code offset to MVD
5182 MS_VIRT u32Addr, u32Len;
5183 HAL_MVD_MemGetMap(u8Idx, E_MVD_MMAP_FW, &u32Addr, &u32Len);
5184
5185 if (u32Len==0) printf("%s err: u32Len=0!\n", __FUNCTION__);
5186 MS_U32 i=0;
5187 i = u32Addr >> 3;
5188 SET_CMDARG(stCmdArg, i, u8Idx);
5189 SET_CMD_RET_FALSE(CMD_CODE_OFFSET, &stCmdArg);
5190
5191 #define _mvdAssert(x) if(!x) printf("%s(%d) inconsistent cfg!\n", __FUNCTION__, __LINE__);
5192 MVD_FWCfg* pCurFwCfg = HAL_MVD_GetFWCfg(u8Idx);
5193 _mvdAssert(pCurFwCfg->eCodecType == eCodecType);
5194 _mvdAssert(pCurFwCfg->eSrcMode == eSrcMode);
5195 _mvdAssert(pCurFwCfg->bDisablePESParsing == bDisablePESParsing);
5196
5197 //Refer to msAPI_VDPlayer_DecodeMPEG4.c (core\kernel\api\videoplayer)
5198 if (eSrcMode == E_MVD_SLQ_TBL_MODE)
5199 {
5200 if ((eCodecType == E_MVD_CODEC_MPEG4) ||
5201 (eCodecType == E_MVD_CODEC_DIVX311) ||
5202 (eCodecType == E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER))
5203 {
5204 // Enable PackMode
5205 SETUP_CMDARG(stCmdArg);
5206 stCmdArg.Arg0 = 3;
5207 SET_DECNUM(stCmdArg, u8Idx);
5208 if (HAL_MVD_MVDCommand( CMD_PARSE_M4V_PACKMD, &stCmdArg ) == FALSE)
5209 {
5210 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PARSE_M4V_PACKMD ) );
5211 return FALSE;
5212 }
5213
5214 // Set DIU width of rounding mode (align to 8byte)
5215 SETUP_CMDARG(stCmdArg);
5216 stCmdArg.Arg0 = 1;
5217 SET_DECNUM(stCmdArg, u8Idx);
5218 if (HAL_MVD_MVDCommand(CMD_DIU_WIDTH_ALIGN, &stCmdArg) == FALSE)
5219 {
5220 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DIU_WIDTH_ALIGN ) );
5221 return FALSE;
5222 }
5223 }
5224 }
5225
5226 //set internal buffers after setting codecinfo for V3
5227 if (!HAL_MVD_SetInternalBuffAddr(u8Idx, u32Addr, u32Len))
5228 {
5229 MVD_DEBUGERROR(printf("MDrv_MVD_Init:_MVD_MVDSetInternalBuffAddr failed\n"));
5230 return FALSE;
5231 }
5232 else
5233 {
5234 MVD_DEBUGINFO(printf("MDrv_MVD_Init:_MVD_MVDSetInternalBuffAddr success\n"));
5235 }
5236
5237 return TRUE;
5238 }
5239
MVD_GetBDMAType(void)5240 BDMA_CpyType MVD_GetBDMAType(void)
5241 {
5242 BDMA_CpyType bdmaCpyType = E_BDMA_CPYTYPE_MAX;
5243
5244 if (pMVDHalContext->stMiuCfg.u8HWMiuSel == MIU_SEL_0)
5245 {
5246 if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_0)
5247 {
5248 bdmaCpyType = E_BDMA_SDRAM2SDRAM;
5249 }
5250 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_1)
5251 {
5252 bdmaCpyType = E_BDMA_SDRAM2SDRAM1;
5253 }
5254 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_2)
5255 {
5256 bdmaCpyType = E_BDMA_SDRAM2SDRAM2;
5257 }
5258 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_3)
5259 {
5260 bdmaCpyType = E_BDMA_SDRAM2SDRAM3;
5261 }
5262 else
5263 {
5264 MS_ASSERT(0);
5265 }
5266 }
5267 else if (pMVDHalContext->stMiuCfg.u8HWMiuSel == MIU_SEL_1)
5268 {
5269 if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_0)
5270 {
5271 bdmaCpyType = E_BDMA_SDRAM12SDRAM;
5272 }
5273 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_1)
5274 {
5275 bdmaCpyType = E_BDMA_SDRAM12SDRAM1;
5276 }
5277 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_2)
5278 {
5279 bdmaCpyType = E_BDMA_SDRAM12SDRAM2;
5280 }
5281 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_3)
5282 {
5283 bdmaCpyType = E_BDMA_SDRAM12SDRAM3;
5284 }
5285 else
5286 {
5287 MS_ASSERT(0);
5288 }
5289 }
5290 else if (pMVDHalContext->stMiuCfg.u8HWMiuSel == MIU_SEL_2)
5291 {
5292 if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_0)
5293 {
5294 bdmaCpyType = E_BDMA_SDRAM22SDRAM;
5295 }
5296 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_1)
5297 {
5298 bdmaCpyType = E_BDMA_SDRAM22SDRAM1;
5299 }
5300 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_2)
5301 {
5302 bdmaCpyType = E_BDMA_SDRAM22SDRAM2;
5303 }
5304 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_3)
5305 {
5306 bdmaCpyType = E_BDMA_SDRAM22SDRAM3;
5307 }
5308 else
5309 {
5310 MS_ASSERT(0);
5311 }
5312 }
5313 else if (pMVDHalContext->stMiuCfg.u8HWMiuSel == MIU_SEL_3)
5314 {
5315 if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_0)
5316 {
5317 bdmaCpyType = E_BDMA_SDRAM32SDRAM;
5318 }
5319 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_1)
5320 {
5321 bdmaCpyType = E_BDMA_SDRAM32SDRAM1;
5322 }
5323 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_2)
5324 {
5325 bdmaCpyType = E_BDMA_SDRAM32SDRAM2;
5326 }
5327 else if (pMVDHalContext->stMiuCfg.u8FWMiuSel == MIU_SEL_3)
5328 {
5329 bdmaCpyType = E_BDMA_SDRAM32SDRAM3;
5330 }
5331 else
5332 {
5333 MS_ASSERT(0);
5334 }
5335 }
5336 else
5337 {
5338 MS_ASSERT(0);
5339 }
5340
5341 return bdmaCpyType;
5342 }
5343
5344 //Init static variables.
5345 //Exception: stMemCfg & stMiuCfg since they are set before calling this function.
HAL_MVD_InitVar(MS_U8 u8Idx)5346 void HAL_MVD_InitVar(MS_U8 u8Idx)
5347 {
5348 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
5349 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
5350
5351 memset(pstCtrlCfg, 0, sizeof(MVD_CtrlCfg));
5352 pstCtrlCfg->eTrickMode = E_MVD_TRICK_DEC_ALL;
5353 pstCtrlCfg->eFrcMode = E_MVD_FRC_NORMAL;
5354 pstCtrlCfg->ePreSpeedType = E_MVD_SPEED_DEFAULT;
5355 pstCtrlCfg->eFileSyncMode = E_MVD_TIMESTAMP_FREERUN;
5356
5357 //determine if we need to BDMA SLQ table from DrvProcBuff to BitstreamBuff
5358 #ifndef MSOS_TYPE_LINUX_KERNEL//BDMA
5359 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
5360 pstCtrlCfg->bSlqTblSync = ((pstMemCfg->u32DrvBufAddr < pstMemCfg->u32BSAddr) ||
5361 ((pstMemCfg->u32DrvBufAddr+pstMemCfg->u32DrvBufSize) > (pstMemCfg->u32BSAddr+pstMemCfg->u32BSSize)));
5362 MVD_DEBUGINFO(printf("bSlqTblSync = %x\n", pstCtrlCfg->bSlqTblSync));
5363 if (pstCtrlCfg->bSlqTblSync)
5364 {
5365 const BDMA_Info* pBDMA;
5366 pBDMA = MDrv_BDMA_GetInfo();
5367 if ((pBDMA == NULL) || (pBDMA->bInit != TRUE))
5368 {
5369 if (E_BDMA_OK != MDrv_BDMA_Init(pstMemCfg->u32Miu1BaseAddr))
5370 {
5371 printf("%s fail at MDrv_BDMA_Init!!!\n", __FUNCTION__);
5372 }
5373 }
5374 pstSlqTblInfo->bdmaCpyType = MVD_GetBDMAType();
5375 }
5376 #else
5377 pstCtrlCfg->bSlqTblSync = 0;
5378 #endif
5379 memset(pstSlqTblInfo, 0, sizeof(MVD_SLQTBLInfo));
5380 pstSlqTblInfo->u32LastPts = MVD_NULLPKT_PTS;
5381 pstSlqTblInfo->u32PreEsRd = MVD_U32_MAX;
5382 pstSlqTblInfo->u32PreEsWr = 0;
5383 pstSlqTblInfo->pSlqStatus = &(pMVDHalContext->_SlqStatus[u8Idx]);
5384 pstSlqTblInfo->pDrvSlqTbl = &(pMVDHalContext->_drvSlqTbl[u8Idx]);
5385 pstSlqTblInfo->pDrvEsTbl = &(pMVDHalContext->_drvEsTbl[u8Idx]);
5386 pstSlqTblInfo->pDrvDivxTbl = &(pMVDHalContext->_drvDivxTbl[u8Idx]);
5387 #if SLQ_NEW_PUSH
5388 pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr = 0;
5389 pstSlqTblInfo->pSlqStatus->u32SlqPushLength = 0;
5390 pstSlqTblInfo->pSlqStatus->bSlqPicStart = FALSE;
5391 pstSlqTblInfo->pSlqStatus->bSlqPicCollect = FALSE;
5392 pstSlqTblInfo->pSlqStatus->bSlqPicWaitNextStart = FALSE;
5393 pstSlqTblInfo->pSlqStatus->bSlqEnLastFrameShow =FALSE;
5394 pstSlqTblInfo->pSlqStatus->bSlqFireRdy = FALSE;
5395 pstSlqTblInfo->pSlqStatus->bSlqCtrlBit =FALSE;
5396 #endif
5397 }
5398
5399 //------------------------------------------------------------------------------
5400 /// Issue Stop command.
5401 //------------------------------------------------------------------------------
HAL_MVD_Stop(MS_U8 u8Idx)5402 MS_BOOL HAL_MVD_Stop(MS_U8 u8Idx)
5403 {
5404 MVD_CmdArg mvdcmd;
5405 MS_BOOL bRet = TRUE;
5406
5407 #define STOP_TIMEOUT 500 //ms
5408 MS_U32 u32StartTime = 0;
5409 u32StartTime = HAL_MVD_GetTime();
5410
5411 SETUP_CMDARG(mvdcmd);
5412 SET_DECNUM(mvdcmd, u8Idx);
5413 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_STOP);
5414
5415 if (HAL_MVD_MVDCommand(CMD_STOP, &mvdcmd) == FALSE)
5416 {
5417 MVD_DEBUGERROR(printf("Command: 0x%x fail!!\r\n", CMD_STOP));
5418 HAL_MVD_Delayms(1);
5419 if ( HAL_MVD_TimeOut(u8Idx) == TRUE )
5420 {
5421 MVD_DEBUGERROR(printf("*** MVD ERR: STOP TIMEOUT!!! ***\n"));
5422 }
5423 }
5424
5425 while(!HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_STOP))
5426 {
5427 if ((HAL_MVD_GetTime()-u32StartTime)>STOP_TIMEOUT)
5428 {
5429 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail timeout!!\r\n", CMD_STOP ) );
5430 break;
5431 }
5432 }
5433
5434 pMVDHalContext->bStopped[u8Idx] = TRUE;
5435 return bRet;
5436 }
5437
HAL_MVD_DeinitHW(VPU_EX_SourceType SourceType,VPU_EX_DecoderType eDecType)5438 MS_BOOL HAL_MVD_DeinitHW(VPU_EX_SourceType SourceType, VPU_EX_DecoderType eDecType)
5439 {
5440 //MVD HW reset
5441 if (!HAL_MVD_RstHW())
5442 {
5443 MVD_DEBUGERROR(printf("MDrv_MVD_Exit:MVD4ResetHW failed\n"));
5444 }
5445 else
5446 {
5447 MVD_DEBUGINFO(printf("MDrv_MVD_Exit:MVD4ResetHW success\n"));
5448 }
5449 HAL_MVD_PowerCtrl(DISABLE);
5450 #ifdef CONFIG_MSTAR_CLKM
5451 if(eDecType == E_VPU_EX_DECODER_MVD)
5452 {
5453 HAL_VPU_EX_SetClkManagement(E_VPU_EX_CLKPORT_MVD_CORE, DISABLE);
5454 }
5455 if(SourceType == E_VPU_EX_INPUT_TSP)
5456 {
5457 HAL_VPU_EX_SetClkManagement(E_VPU_EX_CLKPORT_MVD_PAS, DISABLE);
5458 }
5459 #endif
5460
5461 #ifdef CONFIG_MSTAR_SRAMPD
5462 HAL_MVD_RegWriteBit(REG_CODEC_SRAM_SD_EN, DISABLE, SRAM_SD_EN_MVD);
5463 HAL_MVD_Delayms(1);
5464 #endif
5465 return TRUE;
5466 }
5467
HAL_MVD_Exit(MS_U8 u8Idx)5468 MS_BOOL HAL_MVD_Exit(MS_U8 u8Idx)
5469 {
5470 MVD_DEBUGINFO(printf("MDrv_MVD_Exit:start\n"));
5471
5472 HAL_MVD_SetIsUsed(u8Idx, FALSE);
5473 pMVDHalContext->bAutoInsertDummyPattern[u8Idx] = FALSE;
5474 pMVDHalContext->bDropOnePTS[u8Idx] = FALSE;
5475 pMVDHalContext->u32DmxFrameRate[u8Idx] = 0;
5476 pMVDHalContext->u32DmxFrameRateBase[u8Idx] = 0;
5477 pMVDHalContext->bTrickPlay2xAVSync[u8Idx] = FALSE;
5478
5479 return TRUE;
5480 }
5481
5482
5483 //------------------------------------------------------------------------------
5484 /// Set DivX311 stream info.
5485 /// @param divxInfo \b IN : DivX311 stream info.
5486 //------------------------------------------------------------------------------
MVD_WriteDivx311Data(MS_U8 u8Idx,FW_DIVX_INFO * divxInfo)5487 static void MVD_WriteDivx311Data(MS_U8 u8Idx, FW_DIVX_INFO *divxInfo)
5488 {
5489 MS_VIRT pu8MVDSetHeaderBufStart = GET_HDR_BUFFADD(u8Idx);
5490 HAL_MVD_MemWrite4Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_VOL_HANDLE_DONE,divxInfo->vol_handle_done);
5491 HAL_MVD_MemWrite4Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_WIDTH,divxInfo->width);
5492 HAL_MVD_MemWrite4Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_HEIGHT,divxInfo->height);
5493 HAL_MVD_MemWrite4Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_FRAME_COUNT,divxInfo->frame_count);
5494 HAL_MVD_MemWrite4Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_FRAME_TIME,divxInfo->frame_time);
5495 HAL_MVD_MemWrite2Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_PTS_INCR,divxInfo->pts_incr);
5496 HAL_MVD_MemWrite4Byte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_FRAME_RATE,divxInfo->frame_rate);
5497 HAL_MVD_MemWriteByte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_ASPECT_RATIO,divxInfo->aspect_ratio);
5498 HAL_MVD_MemWriteByte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_PROGRESSIVE_SEQUENCE,divxInfo->progressive_sequence);
5499 HAL_MVD_MemWriteByte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_MPEG1,divxInfo->mpeg1);
5500 HAL_MVD_MemWriteByte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_PLAY_MODE,divxInfo->play_mode);
5501 HAL_MVD_MemWriteByte(pu8MVDSetHeaderBufStart+OFFSET_DIVX_MPEG_FRC_MODE,divxInfo->mpeg_frc_mode);
5502 return;
5503 }
5504
HAL_MVD_SetFrameInfo(MS_U8 u8Idx,MVD_FrameInfo * pinfo)5505 void HAL_MVD_SetFrameInfo(MS_U8 u8Idx, MVD_FrameInfo *pinfo )
5506 {
5507 if (GET_HDR_BUFFADD(u8Idx)==0)
5508 {
5509 MVD_DEBUGERROR(printf("MDrv_MVD_SetFrameInfo error: pu8MVDSetHeaderBufStart=NULL\n"));
5510 return;
5511 }
5512
5513 FW_DIVX_INFO* pDivxInfo = &(pMVDHalContext->gdivxInfo[u8Idx]);
5514 pDivxInfo->width=pinfo->u16HorSize;
5515 pDivxInfo->height=pinfo->u16VerSize;
5516 pDivxInfo->aspect_ratio=pinfo->u8AspectRate;
5517 pDivxInfo->frame_rate = pinfo->u32FrameRate;
5518
5519 //for MM
5520 pDivxInfo->mpeg1=pinfo->u8MPEG1;
5521 pDivxInfo->pts_incr=pinfo->u16PTSInterval;
5522 pDivxInfo->play_mode=pinfo->u8PlayMode;
5523 pDivxInfo->mpeg_frc_mode=pinfo->u8FrcMode;
5524
5525 if(pinfo->u8Interlace==0)
5526 pDivxInfo->progressive_sequence=1;
5527 else
5528 pDivxInfo->progressive_sequence=0;
5529
5530 pDivxInfo->frame_count=0;
5531 pDivxInfo->frame_time=0;
5532 pDivxInfo->vol_handle_done=0;
5533 // pDivxInfo->invalidstream=0;
5534 MVD_DEBUGINFO(printf("set vol info,pts_incr=%d,\n",pDivxInfo->pts_incr));
5535 MVD_DEBUGINFO(printf("set vol info,width=%x,height=%x,frame_rate=%d,aspect_ratio=%x,\n",
5536 (unsigned int)pDivxInfo->width,(unsigned int)pDivxInfo->height,pDivxInfo->frame_rate,pDivxInfo->aspect_ratio));
5537 MVD_DEBUGINFO(printf("set vol info,progressive_sequence=%x,mpeg1=%x,play_mode=%x,\n",
5538 pDivxInfo->progressive_sequence,pDivxInfo->mpeg1,pDivxInfo->play_mode));
5539
5540 MVD_WriteDivx311Data(u8Idx, pDivxInfo);
5541 return;
5542 }
5543
5544
5545
5546 ///////////////////////////////////////////////////////////////////////////////
5547 /// Get Hardware Pointer of MVD CC Ring Buffer
5548 /// Return value:: The HW Pointer Address of MVD CC Ring Buffer
5549 /// @param u8CC608 \b IN
5550 /// - # TRUE for CC608 parser
5551 /// - # FALSE for CC708 parser
5552 ///////////////////////////////////////////////////////////////////////////////
HAL_CC_CM_GetMVDRB_HWAddr(MS_U8 u8CC608)5553 MS_VIRT HAL_CC_CM_GetMVDRB_HWAddr(MS_U8 u8CC608)
5554 {
5555 #if 1
5556 MVD_CmdArg mvdcmd;
5557 MS_VIRT u32CCWrPtr = 0;
5558
5559 SETUP_CMDARG(mvdcmd);
5560 mvdcmd.Arg3 = u8CC608;
5561 if (HAL_MVD_MVDCommand( CMD_RD_USER_WP, &mvdcmd ) == FALSE)
5562 {
5563 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_RD_USER_WP ) );
5564 return MVD_U32_MAX;
5565 }
5566 u32CCWrPtr = COMBU32(mvdcmd.Arg3, mvdcmd.Arg2, mvdcmd.Arg1, mvdcmd.Arg0);
5567 return u32CCWrPtr;
5568 #else
5569 MS_U32 u32MVDCC_Temp1 = 0;
5570 if (HAL_MVD_TimeOut(pstCmdArg->Arg5) == FALSE)
5571 {
5572 //HAL_MVD_ARGINIT();
5573 HAL_MVD_RegWriteByte(MVD_ARG5, 0);
5574 HAL_MVD_RegWriteByte(MVD_ARG4, 0);
5575 HAL_MVD_RegWriteByte(MVD_ARG3, (MS_U8)u8CC608);
5576 HAL_MVD_RegWriteByte(MVD_COMMAND, (MS_U8)(CMD_RD_USER_WP));//CMD_GET_CCBUF_HWADDR
5577
5578 if (HAL_MVD_TimeOut(pstCmdArg->Arg5) == FALSE)
5579 {
5580 u32MVDCC_Temp1 = 0;
5581 u32MVDCC_Temp1 = (((MS_U32)HAL_MVD_RegReadByte(MVD_ARG0)) & 0x000000FF);
5582 u32MVDCC_Temp1 += ((((MS_U32)HAL_MVD_RegReadByte(MVD_ARG1)) & 0x000000FF) << 8);
5583 u32MVDCC_Temp1 += ((((MS_U32)HAL_MVD_RegReadByte(MVD_ARG2)) & 0x000000FF) << 16);
5584 u32MVDCC_Temp1 = (u32MVDCC_Temp1 << 3);
5585 return (u32MVDCC_Temp1);
5586 }
5587 else
5588 {
5589 MVD_DEBUGINFO(printf("\nF:GHAV"));
5590 }
5591 }
5592 else
5593 {
5594 MVD_DEBUGINFO(printf("\nF:GHA"));
5595 }
5596
5597 return 0xffffffff;
5598 #endif
5599 }
5600
HAL_MVD_GetUsrDataIsAvailable(MS_U8 u8Idx)5601 MS_BOOL HAL_MVD_GetUsrDataIsAvailable(MS_U8 u8Idx)
5602 {
5603 volatile MVD_CtrlCfg* pCtrlCfg = (volatile MVD_CtrlCfg*)HAL_MVD_GetCtrlCfg(u8Idx);
5604 MS_VIRT u32UsrDataWr = 0;
5605 MS_BOOL bIsAvail = FALSE;
5606
5607 #if defined(MVD_SUPPORT_X4_CC)
5608 u32UsrDataWr = HAL_CC_CM_GetMVDRB_HWAddr(4);
5609 #else
5610 u32UsrDataWr = HAL_CC_CM_GetMVDRB_HWAddr(2);
5611 #endif
5612 bIsAvail = !(pCtrlCfg->u32UsrDataRd == u32UsrDataWr);
5613 MVD_DEBUGINFO(printf("IsAvail:%x rd=%lx wr=%lx\n", bIsAvail,
5614 (unsigned long)pCtrlCfg->u32UsrDataRd, (unsigned long)u32UsrDataWr));
5615 return bIsAvail;
5616 }
5617
5618 //------------------------------------------------------------------------------
5619 /// Get info of user data
5620 //------------------------------------------------------------------------------
HAL_MVD_GetUsrDataInfo(MS_U8 u8Idx,MVD_UsrDataInfo * pUsrInfo)5621 MS_BOOL HAL_MVD_GetUsrDataInfo(MS_U8 u8Idx, MVD_UsrDataInfo* pUsrInfo)
5622 {
5623 MS_VIRT u32UsrData = NULL;
5624 MS_VIRT u32UsrDataWr = 0;
5625 #if defined(MVD_SUPPORT_X4_CC)
5626 FW_USER_DATA_BUF_EXT stUsrDataExt;
5627 #else
5628 FW_USER_DATA_BUF stUsrDataInfo;
5629 #endif
5630 volatile MVD_CtrlCfg* pCtrlCfg = (volatile MVD_CtrlCfg*)HAL_MVD_GetCtrlCfg(u8Idx);
5631
5632 if ((!pUsrInfo) || (GET_FRMINFO_BUFFADD(u8Idx)==0))
5633 {
5634 MVD_DEBUGERROR(printf("%s: NULL ptr.\n", __FUNCTION__));
5635 return FALSE;
5636 }
5637
5638 //get write pointer
5639 #if defined(MVD_SUPPORT_X4_CC)
5640 u32UsrDataWr = HAL_CC_CM_GetMVDRB_HWAddr(4);
5641 #else
5642 u32UsrDataWr = HAL_CC_CM_GetMVDRB_HWAddr(2);
5643 #endif
5644 if (pCtrlCfg->u32UsrDataRd == (GET_USRDATA_BUFFADD(u8Idx)+MVD3_FW_USER_DATA_BUF_LEN))
5645 {
5646 pCtrlCfg->u32UsrDataRd = GET_USRDATA_BUFFADD(u8Idx); //wrap to BufStart
5647 }
5648 MVD_DEBUGINFO(printf("CC Rd=0x%lx Wr=0x%lx\n", (unsigned long)pCtrlCfg->u32UsrDataRd, (unsigned long)u32UsrDataWr));
5649
5650 if (pCtrlCfg->u32UsrDataRd == u32UsrDataWr)
5651 {
5652 MVD_DEBUGERROR(printf("%s: no data? Rd=0x%lx Wr=0x%lx\n", __FUNCTION__, (unsigned long)pCtrlCfg->u32UsrDataRd, (unsigned long)u32UsrDataWr));
5653 return FALSE;
5654 }
5655
5656 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,pCtrlCfg->u32UsrDataRd,u32UsrData);
5657
5658 u32UsrData = HAL_MVD_PA2NonCacheSeg(u32UsrData);
5659
5660 HAL_MVD_CPU_Sync();
5661 HAL_MVD_ReadMemory();
5662
5663 #if defined(MVD_SUPPORT_X4_CC)
5664 stUsrDataExt = *(volatile FW_USER_DATA_BUF_EXT*)u32UsrData;
5665
5666 pUsrInfo->u32Pts = stUsrDataExt.pts;
5667 pUsrInfo->u8PicStruct = stUsrDataExt.PicStruct;
5668 pUsrInfo->u8PicType = stUsrDataExt.picType;
5669 pUsrInfo->u8TopFieldFirst = stUsrDataExt.top_ff;
5670 pUsrInfo->u8RptFirstField = stUsrDataExt.rpt_ff;
5671 pUsrInfo->u16TmpRef = stUsrDataExt.tmpRef;
5672 pUsrInfo->u8ByteCnt = stUsrDataExt.userdatabytecnt;
5673 pUsrInfo->u32DataBuf = u32UsrData + MVD_FW_USER_DATA_EXT_HDR_LEN;
5674 #else
5675 stUsrDataInfo = *(volatile FW_USER_DATA_BUF*)u32UsrData;
5676
5677 pUsrInfo->u8PicType = stUsrDataInfo.picType;
5678 pUsrInfo->u8TopFieldFirst = stUsrDataInfo.top_ff;
5679 pUsrInfo->u8RptFirstField = stUsrDataInfo.rpt_ff;
5680 pUsrInfo->u16TmpRef = stUsrDataInfo.tmpRef;
5681 pUsrInfo->u8ByteCnt = stUsrDataInfo.userdatabytecnt;
5682 pUsrInfo->u32DataBuf = u32UsrData + MVD_FW_USER_DATA_HDR_LEN;
5683 #endif
5684 //update read pointer
5685 pCtrlCfg->u32UsrDataRd += MVD_FW_USER_DATA_PKT_LEN;
5686 #if 0
5687 printf("xxInfo: ");
5688 printf("%02d, ", pUsrInfo->u16TmpRef);
5689 printf("%d, ", pUsrInfo->u8PicStruct);
5690 printf("%d, ", pUsrInfo->u8TopFieldFirst);
5691 printf("0x%x, ", pUsrInfo->u32DataBuf);
5692 printf("%d, ", pUsrInfo->u8ByteCnt);
5693 printf("%ld, ", pUsrInfo->u32Pts);
5694 printf("%d\n", pUsrInfo->u8PicType);
5695 #endif
5696 return TRUE;
5697 }
5698
5699
HAL_MVD_Map2DrvSlqTbl(MS_U8 u8Idx,MS_VIRT u32HWPtr)5700 MS_VIRT HAL_MVD_Map2DrvSlqTbl(MS_U8 u8Idx, MS_VIRT u32HWPtr)
5701 {
5702 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
5703 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
5704 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
5705 MS_VIRT u32HWSt = HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr);
5706 MS_VIRT u32DrvPtr;
5707
5708 if ((u32HWPtr<u32HWSt) && (u32HWPtr!=0))
5709 {
5710 MVD_DEBUGERROR(printf("Invalid u32HWPtr=0x%lx\n", (unsigned long)u32HWPtr));
5711 return 0;
5712 }
5713 if ((pstCtrlCfg->bSlqTblSync) && (u32HWPtr!=0))
5714 {
5715 u32DrvPtr = pstSlqTblInfo->pDrvSlqTbl->u32StAdd + (u32HWPtr - u32HWSt);
5716 return u32DrvPtr;
5717 }
5718 return u32HWPtr;
5719 }
5720
5721
MVD_SLQTblGetFileEndPkt(MS_U8 u8Idx,MVD_PacketInfo * pFileEnd)5722 static void MVD_SLQTblGetFileEndPkt(MS_U8 u8Idx, MVD_PacketInfo* pFileEnd)
5723 {
5724 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
5725 MS_VIRT u32EndPattern = HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr+SLQ_TBL_SIZE*3);
5726
5727 pFileEnd->u32StAddr = SLQ_TBL_SIZE*3;//u32EndPattern - HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr);
5728 pFileEnd->u32Length = END_PATTERN_SIZE;
5729 pFileEnd->u32TimeStamp = MVD_NULLPKT_PTS;
5730 pFileEnd->u32ID_L = MVD_U32_MAX;
5731 pFileEnd->u32ID_H = MVD_U32_MAX;
5732 MVD_DEBUGINFO(printf("u32EndPattern(0x%lx)=0x%x 0x%x 0x%x 0x%x\n", (unsigned long)pFileEnd->u32StAddr,
5733 HAL_MVD_MemRead4Byte(u32EndPattern), HAL_MVD_MemRead4Byte(u32EndPattern+4),
5734 HAL_MVD_MemRead4Byte(u32EndPattern+8), HAL_MVD_MemRead4Byte(u32EndPattern+12)));
5735 }
5736
5737
MVD_SLQTblGetDummyPkt(MVD_PacketInfo * pDummy)5738 static void MVD_SLQTblGetDummyPkt(MVD_PacketInfo* pDummy)
5739 {
5740 //MS_U32 u32DummyES = HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr+SLQ_TBL_SIZE*2);
5741
5742 pDummy->u32StAddr = SLQ_TBL_SIZE*2;//u32DummyES - HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr);
5743 pDummy->u32Length = DUMMY_SIZE;
5744 pDummy->u32TimeStamp = MVD_NULLPKT_PTS;
5745 pDummy->u32ID_L = MVD_U32_MAX;
5746 pDummy->u32ID_H = MVD_U32_MAX;
5747 #if 0
5748 printf("u32DummyES(0x%x-->0x%x, size=0x%x)=0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", u32DummyES,
5749 pDummy->u32StAddr, pDummy->u32Length, HAL_MVD_MemRead4Byte(u32DummyES),
5750 HAL_MVD_MemRead4Byte(u32DummyES+4),HAL_MVD_MemRead4Byte(u32DummyES+8),HAL_MVD_MemRead4Byte(u32DummyES+12));
5751 #endif
5752
5753 }
5754
5755
HAL_MVD_SLQTblInsertPattern(MS_U8 u8Idx,MVD_PatternType ePattern)5756 MS_BOOL HAL_MVD_SLQTblInsertPattern(MS_U8 u8Idx, MVD_PatternType ePattern)
5757 {
5758 MS_U32 i;
5759 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
5760
5761 if (pstSlqTblInfo->pDrvSlqTbl->u32Empty < SLQ_TBL_SAFERANGE)
5762 {
5763 MVD_DEBUGINFO(printf("SLQTbl full!(0x%lx) Cannot insert pattern any more!\n", (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32Empty));
5764 return FALSE;
5765 }
5766
5767 #if SLQ_NEW_PUSH
5768 if(pstSlqTblInfo->pSlqStatus->bSlqCtrlBit)
5769 {
5770 if(pstSlqTblInfo->pSlqStatus->bSlqPicWaitNextStart)
5771 {
5772 pstSlqTblInfo->pDrvSlqTbl->u32WrPtr = pstSlqTblInfo->pSlqStatus->u32VaildWptrAddr;
5773 }
5774 pstSlqTblInfo->pSlqStatus->bSlqCtrlBit = FALSE;
5775 }
5776 #endif // #if SLQ_NEW_PUSH
5777 for (i =0; i<2; i++)
5778 { //insert dummy pattern
5779 MVD_PacketInfo stDummyPkt;
5780
5781 if (E_MVD_PATTERN_FLUSH == ePattern)
5782 {
5783 MVD_SLQTblGetDummyPkt(&stDummyPkt);
5784 }
5785 else if (E_MVD_PATTERN_FILEEND == ePattern)
5786 {
5787 MVD_SLQTblGetFileEndPkt(u8Idx, &stDummyPkt);
5788 }
5789 else
5790 {
5791 MVD_DEBUGERROR(printf("Invalid MVD_PatternType! Won't insert pattern!\n"));
5792 return FALSE;
5793 }
5794 #if SLQ_NEW_PUSH
5795 pstSlqTblInfo->pSlqStatus->bSlqFireRdy = TRUE;
5796 #endif
5797 //printf("WrPtr 0x%x ", pstSlqTblInfo->pDrvSlqTbl->u32WrPtr);
5798 HAL_MVD_SLQTblSendPacket(u8Idx, &stDummyPkt);
5799 //printf("==> 0x%x\n", pstSlqTblInfo->pDrvSlqTbl->u32WrPtr);
5800 HAL_MVD_SetSLQWritePtr(u8Idx, FALSE);
5801 }
5802 return TRUE;
5803 }
5804
5805
5806 #define FLAG_LAST_FRM_SHOW (MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CMD_LAST_FRAME_SHOW, sizeof(MS_U32)))
HAL_MVD_IsDispFinish(MS_U8 u8Idx)5807 E_MVD_Result HAL_MVD_IsDispFinish(MS_U8 u8Idx)
5808 {
5809 MS_U32 u32TimeCnt;
5810 MVD_SrcMode curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
5811 MS_U32 u32FeByteCnt = 0;
5812 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
5813 MS_VIRT u32FileEndPtr = pstSlqTblInfo->u32FileEndPtr;
5814 MS_U32 u32Id = MVD_GetStreamId(u8Idx);
5815 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
5816 #ifdef VDEC3
5817 MS_VIRT u32VBBUAddr = HAL_MVD_GetVBBUTableAddr(u8VPUIdx);
5818 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
5819 #endif
5820
5821 //printf("MDrv_MVD_IsDispFinish::");
5822 if (GET_FRMINFO_BUFFADD(u8Idx)==0)
5823 {
5824 MVD_DEBUGERROR(printf("%s err: pu8MVDGetFrameInfoBufStart=NULL\n", __FUNCTION__));
5825 return E_MVD_RET_FAIL;
5826 }
5827
5828 //printf("0x%x\n", FLAG_LAST_FRM_SHOW);
5829 if ((E_MVD_SLQ_TBL_MODE == curSrcMode) && (TRUE != FLAG_LAST_FRM_SHOW))
5830 {
5831 //insert pattern when each time checking IsDispFinish
5832 #ifdef VDEC3
5833 if(pstCtrlCfg->u8McuMode == TRUE)
5834 {
5835 u32TimeCnt= HAL_MVD_GetTime();
5836 while ((HAL_MVD_GetTime() - u32TimeCnt) < 20) // timeout 20 ms
5837 {
5838 if(HAL_VPU_EX_GetVBBUVacancy(u32VBBUAddr) > 0)
5839 {
5840 HAL_VPU_EX_PacketInfo stVpuPkt;
5841 MVD_PacketInfo stDummyPkt;
5842 MVD_SLQTblGetFileEndPkt(u8Idx,&stDummyPkt);
5843
5844 stVpuPkt.u32Offset = stDummyPkt.u32StAddr;
5845 stVpuPkt.u32Length = stDummyPkt.u32Length;
5846 stVpuPkt.u64TimeStamp = (MS_U64)stDummyPkt.u32TimeStamp;
5847 //If in display queue mode
5848 stVpuPkt.u64TimeStamp |= ((MS_U64)stDummyPkt.u32ID_H << 32);
5849 stVpuPkt.u32ID_H = stDummyPkt.u32ID_H;
5850 stVpuPkt.u32ID_L = stDummyPkt.u32ID_L;
5851
5852 HAL_VPU_EX_Push2VBBU(u32Id, &stVpuPkt,u32VBBUAddr);
5853 }
5854
5855 if (TRUE == FLAG_LAST_FRM_SHOW)
5856 {
5857 break;
5858 }
5859 }
5860
5861 if (TRUE != FLAG_LAST_FRM_SHOW)
5862 {
5863 MVD_DEBUGERROR(printf("MDrv_MVD_IsDispFinish TIMEOUT\n"));
5864 return E_MVD_RET_TIME_OUT;
5865 }
5866 else
5867 {
5868 return E_MVD_RET_OK;
5869 }
5870 }
5871 else
5872 #endif
5873 {
5874 //insert pattern when each time checking IsDispFinish
5875 if (HAL_MVD_SLQTblInsertPattern(u8Idx, E_MVD_PATTERN_FILEEND))
5876 {
5877 u32FeByteCnt += END_PATTERN_SIZE;
5878 }
5879
5880 if ((u32FileEndPtr == HAL_MVD_Map2DrvSlqTbl(u8Idx, HAL_MVD_GetSLQReadPtr(u8Idx))) &&
5881 (HAL_MVD_IsMcuMode(u8Idx) == FALSE) &&
5882 (HAL_MVD_IsMStreamerMode(u8Idx) == FALSE))
5883 {
5884 //insert padding pattern until timeout
5885 u32TimeCnt= HAL_MVD_GetTime();
5886 while ((HAL_MVD_GetTime() - u32TimeCnt) < CMD_TIMEOUT_MS)
5887 {
5888 if (TRUE == FLAG_LAST_FRM_SHOW)
5889 {
5890 //printf("\nDisp finished!\n");
5891 break;
5892 }
5893 //insert file-end pattern again
5894 if (HAL_MVD_SLQTblInsertPattern(u8Idx, E_MVD_PATTERN_FILEEND))
5895 {
5896 u32FeByteCnt += END_PATTERN_SIZE;
5897 }
5898 }
5899 if ((HAL_MVD_GetTime() - u32TimeCnt) >= CMD_TIMEOUT_MS)
5900 {
5901 MVD_DEBUGERROR(printf("\n***** MDrv_MVD_IsDispFinish TIMEOUT!!! *****\n\n"));
5902 if (E_MVD_CODEC_VC1_MAIN == HAL_MVD_GetCodecType(u8Idx))
5903 {
5904 if ((HAL_MVD_GetPayloadLen(u8Idx) > 0x200000)
5905 && (TRUE != HAL_MVD_GotFileEndPattern(u8Idx)))
5906 {
5907 MVD_DEBUGERROR(printf("RCV payloadLen(0x%x) invalid!\n",
5908 HAL_MVD_GetPayloadLen(u8Idx)));
5909 }
5910 }
5911 MVD_DEBUGERROR(printf("***** fe=%lx, rd=%lx(%lx,%lx), wr=%lx, empty=%lx, u32FeByteCnt=%x\n",
5912 (unsigned long)u32FileEndPtr, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32RdPtr, (unsigned long)HAL_MVD_Map2DrvSlqTbl(u8Idx, HAL_MVD_GetSLQReadPtr(u8Idx)),
5913 (unsigned long)HAL_MVD_GetSLQReadPtr(u8Idx), (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32WrPtr, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32Empty, u32FeByteCnt));
5914 return E_MVD_RET_TIME_OUT;
5915 }
5916 else
5917 {
5918 return E_MVD_RET_OK;
5919 }
5920 }
5921 else
5922 {
5923 //just return fail if readPtr is not closed to file-end ptr
5924 MVD_DEBUGINFO(printf("fe=%lx, rd=%lx(%lx), wr=%lx, empty=%lx\n", (unsigned long)u32FileEndPtr, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32RdPtr,
5925 (unsigned long)HAL_MVD_Map2DrvSlqTbl(u8Idx, (unsigned long)HAL_MVD_GetSLQReadPtr(u8Idx)), (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32WrPtr, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32Empty));
5926 return E_MVD_RET_FAIL;
5927 }
5928 }
5929 }
5930
5931 if (FLAG_LAST_FRM_SHOW)
5932 {
5933 return E_MVD_RET_OK;
5934 }
5935 else
5936 {
5937 return E_MVD_RET_FAIL;
5938 }
5939 }
5940
5941 //------------------------------------------------------------------------------
5942 /// Set MVD SLQ start & end address
5943 /// @param -u32start \b IN : start address
5944 /// @param -u32end \b IN : end address
5945 //------------------------------------------------------------------------------
HAL_MVD_SetSLQStartEnd(MS_U8 u8Idx,MS_U32 u32start,MS_U32 u32end)5946 static void HAL_MVD_SetSLQStartEnd(MS_U8 u8Idx, MS_U32 u32start, MS_U32 u32end)
5947 {
5948 MVD_CmdArg mvdcmd;
5949
5950 if ((u32start > SLQ_ADDR_LEN) || ((u32end+1) > SLQ_ADDR_LEN))
5951 {
5952 MVD_DEBUGERROR(printf("MDrv_MVD_SetSLQStartEnd: only support 27bit add!\n"));
5953 }
5954
5955 SET_CMDARG(mvdcmd, (u32end+1), u8Idx);
5956 if (HAL_MVD_MVDCommand( CMD_SLQ_END, &mvdcmd ) == FALSE)
5957 {
5958 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLQ_END ) );
5959 return;
5960 }
5961
5962 SET_CMDARG(mvdcmd, u32start, u8Idx);
5963 if (HAL_MVD_MVDCommand( CMD_SLQ_START, &mvdcmd ) == FALSE)
5964 {
5965 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLQ_START ) );
5966 return;
5967 }
5968
5969 return;
5970 }
5971
HAL_MVD_DecodeIFrame(MS_U8 u8Idx,MS_PHY u32FrameBufAddr,MS_PHY u32StreamBufAddr,MS_PHY u32StreamBufEndAddr)5972 MS_BOOL HAL_MVD_DecodeIFrame(MS_U8 u8Idx, MS_PHY u32FrameBufAddr, MS_PHY u32StreamBufAddr, MS_PHY u32StreamBufEndAddr )
5973 {
5974 MS_U32 u32deley = 0;
5975 MS_U32 u32time = 0;
5976 MVD_CmdArg mvdcmd;
5977 MS_VIRT u32MVDFWSLQTABTmpbufAdr = GET_SLQ_BUFFADD(u8Idx);
5978
5979 MVD_DEBUGINFO(printf("%s offset FBAdd=0x%lx streamStart=0x%lx streamEnd=0x%lx\n",
5980 __FUNCTION__, (unsigned long)u32FrameBufAddr, (unsigned long)u32StreamBufAddr, (unsigned long)u32StreamBufEndAddr));
5981
5982 HAL_MVD_SetCodecInfo(u8Idx, E_MVD_CODEC_MPEG2, E_MVD_SLQ_MODE, DISABLE_PARSER);
5983 HAL_MVD_SetFrameBuffAddr(u8Idx, u32FrameBufAddr, HAL_MVD_GetFBMode(u8Idx));
5984
5985 SETUP_CMDARG(mvdcmd);
5986 mvdcmd.Arg0 = 1;
5987 SET_DECNUM(mvdcmd, u8Idx);
5988 SET_CMD_RET_FALSE(CMD_DISPLAY_CTL, &mvdcmd);
5989
5990 if (HAL_MVD_StepDecode(u8Idx) == FALSE)
5991 {
5992 MVD_DEBUGERROR( printf( "HAL_MVD_StepDecode fail!!\r\n") );
5993 return FALSE;
5994 }
5995
5996 SETUP_CMDARG(mvdcmd);
5997 mvdcmd.Arg0 = 1;
5998 mvdcmd.Arg1 = 1;
5999 SET_DECNUM(mvdcmd, u8Idx);
6000 SET_CMD_RET_FALSE(CMD_FAST_SLOW, &mvdcmd);
6001
6002 //set data
6003 HAL_MVD_Delayms(2);
6004
6005 HAL_MVD_CPU_Sync();
6006 HAL_MVD_FlushMemory();
6007
6008 //wait vld init success or data may lost!
6009 #define WAIT_INIT_SUCCESS_TIME 100 //100ms
6010 u32deley = HAL_MVD_GetTime();
6011 while ((HAL_MVD_GetDecodeStatus(u8Idx)==DEC_STAT_IDLE) && (u32time<WAIT_INIT_SUCCESS_TIME))
6012 {
6013 u32time = HAL_MVD_GetTime()-u32deley;
6014 }
6015 if (u32time>=WAIT_INIT_SUCCESS_TIME)
6016 {
6017 MVD_DEBUGERROR(printf("%s: wait init_success timeout!!!\n", __FUNCTION__));
6018 }
6019 HAL_MVD_SetSLQStartEnd(u8Idx, u32StreamBufAddr, u32StreamBufEndAddr);
6020 MVD_DEBUGINFO(printf("set MVD3_FW_SLQ_TAB_TMPBUF_ADR=%lx\n",(unsigned long)u32MVDFWSLQTABTmpbufAdr));
6021
6022 HAL_MVD_CPU_Sync();
6023 HAL_MVD_FlushMemory();
6024 HAL_MVD_SetSLQStartEnd(u8Idx, u32MVDFWSLQTABTmpbufAdr, u32MVDFWSLQTABTmpbufAdr+MVD3_FW_SLQ_TAB_TMPBUF_LEN);
6025
6026 HAL_MVD_CPU_Sync();
6027 HAL_MVD_ReadMemory();
6028
6029 // wait decode complete
6030 #define WAIT_DECODE_DONE_TIME 33 //To decode 1 frame should take less than 33ms
6031 u32deley = HAL_MVD_GetTime();
6032 u32time = 0;
6033 while (HAL_MVD_GetPicCounter(u8Idx)<1 && (u32time<WAIT_DECODE_DONE_TIME))
6034 {
6035 u32time = HAL_MVD_GetTime()-u32deley;
6036 }
6037 if (u32time >= WAIT_DECODE_DONE_TIME)
6038 {
6039 MVD_DEBUGERROR(printf ("MDrv_MVD_DecodeIFrame time out(du=%d, st=%d, now=%d)\n", u32time, u32deley, HAL_MVD_GetTime()));
6040 MVD_DEBUGERROR(printf("frmCnt=%d state=0x%x lastCmd=0x%x\n", HAL_MVD_GetPicCounter(u8Idx), HAL_MVD_GetDecodeStatus(u8Idx), HAL_MVD_GetLastCmd(u8Idx)));
6041 return FALSE;
6042 }
6043 MVD_DEBUGINFO(printf ("MDrv_MVD_DecodeIFrame time (%d, %d)\n", u32time, u32deley));
6044 //printf("frmCnt=%ld state=0x%x lastCmd=0x%x\n", HAL_MVD_GetPicCounter(u8Idx), HAL_MVD_GetDecodeStatus(u8Idx), HAL_MVD_GetLastCmd(u8Idx));
6045
6046 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
6047 pCtrlCfg->bDecodeIFrame = TRUE;
6048
6049 return TRUE;
6050 }
6051
6052
6053 //------------------------------------------------------------------------------
6054 /// Set bit stream buffer address to MVD
6055 /// @param -u32start \b IN : start address
6056 /// @param -u32end \b IN : end address
6057 //------------------------------------------------------------------------------
MVD_SetBitStreamAddr(MS_U8 u8Idx,MS_VIRT u32start,MS_VIRT u32end)6058 static void MVD_SetBitStreamAddr(MS_U8 u8Idx, MS_VIRT u32start, MS_VIRT u32end)
6059 {
6060 MVD_CmdArg mvdcmd;
6061 MS_ASSERT((u32start%8)==0);
6062 u32start >>= 3;
6063 SET_CMDARG(mvdcmd, u32start, u8Idx);
6064 if (HAL_MVD_MVDCommand( CMD_STREAM_BUF_START, &mvdcmd ) == FALSE)
6065 {
6066 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_STREAM_BUF_START ) );
6067 return;
6068 }
6069
6070 MS_ASSERT((u32end%8)==0);
6071 u32end >>= 3;
6072 SET_CMDARG(mvdcmd, u32end, u8Idx);
6073 if (HAL_MVD_MVDCommand( CMD_STREAM_BUF_END, &mvdcmd ) == FALSE)
6074 {
6075 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_STREAM_BUF_END ) );
6076 return;
6077 }
6078 return;
6079 }
6080
HAL_MVD_SetInternalBuffAddr(MS_U8 u8Idx,MS_VIRT u32start,MS_U32 u32len)6081 MS_BOOL HAL_MVD_SetInternalBuffAddr(MS_U8 u8Idx, MS_VIRT u32start, MS_U32 u32len)
6082 {
6083 MS_VIRT tmpAdr, tmpLen;
6084 MVD_FWCfg* pFwCfg = NULL;
6085 MVD_FWBuff* pBuff = &(pMVDHalContext->stFWBuff[u8Idx]);
6086 MVD_MEMCfg* pstMemCfg = NULL;
6087 MVD_SLQTBLInfo* pstSlqTblInfo = NULL;
6088 MS_U32 u32Id = MVD_GetStreamId(u8Idx);
6089 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
6090 MS_VIRT u32BuffStart = u32start+(MVD_FW_TASK_OFFSET*u8VPUIdx);
6091 MS_VIRT VPUSHMAddr = HAL_VPU_EX_GetSHMAddr();
6092 MS_VIRT u32StartOffset;
6093 MS_U8 u8MiuSel;
6094
6095 if(VPUSHMAddr != 0)
6096 {
6097 _phy_to_miu_offset(u8MiuSel, u32StartOffset, VPUSHMAddr);
6098
6099 u32StartOffset -= MVD_FW_CODE_LEN;
6100
6101 if(u8Idx == 0)
6102 {
6103 u32BuffStart = u32StartOffset; // for main decoder
6104 }
6105 else if(u8Idx == 1)
6106 {
6107 u32BuffStart = u32StartOffset + 0x20000; // VPUSHMAddr+128K bytes
6108 }
6109 }
6110
6111 MVD_DEBUGINFO(printf("MVD FW shared mem start = 0x%lx\n", (unsigned long)u32BuffStart));
6112 MVD_GetFWBuffAdd(u32BuffStart, u32len, pBuff);
6113 MVD_SetFWBuffAdd(u8Idx, pBuff);
6114
6115 tmpAdr = pBuff->u32DecFrmInfoAdd + MVD_FW_DECFRM_INFO_BUF_LEN;
6116
6117 HAL_MVD_MemGetMap(u8Idx, E_MVD_MMAP_FB, &tmpAdr, &tmpLen);
6118 MVD_DEBUGINFO(printf("set MVD_FRAMEBUFFER_ADR=%lx\n",(unsigned long)tmpAdr));
6119 HAL_MVD_SetFrameBuffAddr(u8Idx, tmpAdr, HAL_MVD_GetFBMode(u8Idx));
6120 pFwCfg = HAL_MVD_GetFWCfg(u8Idx);
6121 HAL_MVD_SetFrameBuffNum(u8Idx, pFwCfg->u8FBNum,pFwCfg->u32FBUsedSize);
6122
6123 // If VD_MHEG5(CPU) and MVD HW engine are run on different MIU,
6124 // IAP, DP, and MV buffers are allocated after FB.
6125 // The reason is that these 3 buffers are used by MVD HW engine.
6126 if(pMVDHalContext->bCMAUsed == FALSE)
6127 {
6128 tmpAdr += pFwCfg->u32FBUsedSize;
6129 pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
6130 if (pstMemCfg->u32FBSize < (pFwCfg->u32FBUsedSize + MVD_HW_BUF_TOTAL_LEN))
6131 {
6132 MVD_DEBUGERROR(printf("MVD HW buffers larger than FB size!!!\n"));
6133 }
6134 MVD_DEBUGINFO(printf("MVD FB boundary =0x%lx\n",(unsigned long)tmpAdr));
6135 tmpAdr = HAL_MVD_SetHWBuffer(u8Idx, tmpAdr);
6136 }
6137
6138 HAL_MVD_MemGetMap(u8Idx, E_MVD_MMAP_BS, &tmpAdr, &tmpLen);
6139 MVD_DEBUGINFO(printf("set MVD_BITSTREAM_ADR=%lx\n",(unsigned long)tmpAdr));
6140 MVD_SetBitStreamAddr(u8Idx, tmpAdr,tmpAdr+tmpLen);
6141 pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
6142 pstSlqTblInfo->u32ESBuffEnd = tmpAdr+tmpLen;
6143
6144 if((pFwCfg->stFBReduction.LumaFBReductionMode != E_MVD_FB_REDUCTION_NONE)
6145 || (pFwCfg->stFBReduction.ChromaFBReductionMode != E_MVD_FB_REDUCTION_NONE))
6146 {
6147 //for chips not support reduction mode, just ignore related config.
6148 MVD_DEBUGERROR(printf("MVD Err: Not support FB reduction mode!!\n"));
6149 }
6150
6151 return TRUE;
6152 }
6153
6154 //------------------------------------------------------------------------------
6155 /// Issue "Decode Pause" command.
6156 //------------------------------------------------------------------------------
HAL_MVD_DecodePause(MS_U8 u8Idx)6157 void HAL_MVD_DecodePause(MS_U8 u8Idx)
6158 {
6159 MVD_CmdArg mvdcmd;
6160 SETUP_CMDARG(mvdcmd);
6161 SET_DECNUM(mvdcmd, u8Idx);
6162 if (HAL_MVD_MVDCommand(CMD_PAUSE, &mvdcmd)== FALSE)
6163 {
6164 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PAUSE) );
6165 return;
6166 }
6167
6168 return;
6169 }
6170
6171
6172 //------------- Below functions are for MediaCodec SLQ Table --------------------
6173 #if _SLQTBL_DUMP_PTS
_SLQTbl_DumpPtsTbl(MS_U8 u8Idx,MS_U32 u32EntryStart,MS_U32 u32EntryEnd)6174 static void _SLQTbl_DumpPtsTbl(MS_U8 u8Idx, MS_U32 u32EntryStart, MS_U32 u32EntryEnd)
6175 {
6176 MS_U32 i;
6177 MS_VIRT u32EsRp, u32EsStart, u32EsEnd;
6178 MS_VIRT u32MVDFWPtsTblAddr = GET_PTSTBL_BUFFADD(u8Idx);
6179
6180 for (i=u32EntryStart; i<u32EntryEnd; i++)
6181 {
6182 u32EsRp = pstSlqTblInfo->pDrvEsTbl->u32StAdd + i*8;
6183
6184 u32EsEnd = HAL_MVD_MemRead4Byte(u32EsRp+4);
6185 u32EsStart = HAL_MVD_MemRead4Byte(u32EsRp); //report StartAdd as read_pointer
6186 printf("ES[%x] Start=0x%x End=0x%x u32EsRp=%x\n",
6187 i, u32EsStart, u32EsEnd, u32EsRp);
6188 }
6189
6190 printf("\n=======Dump PTS table========\n");
6191 printf("addr\t byte_cnt\t dummy_cnt\t id_low\t id_high\t time_stamp\n");
6192 for (i=u32EntryStart; i<u32EntryEnd; i++)
6193 {
6194 printf("0x%x\t 0x%08lx\t 0x%08lx\t 0x%08lx\t 0x%08lx\t 0x%08lx\n", u32MVDFWPtsTblAddr+i*MVD_FW_SLQTBL_PTS_LEN,
6195 HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+i*MVD_FW_SLQTBL_PTS_LEN), //byteCnt
6196 HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+i*MVD_FW_SLQTBL_PTS_LEN+4), //dummyPktCnt
6197 HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+i*MVD_FW_SLQTBL_PTS_LEN+8), //idLow
6198 HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+i*MVD_FW_SLQTBL_PTS_LEN+12),//idHigh
6199 HAL_MVD_MemRead4Byte(u32MVDFWPtsTblAddr+i*MVD_FW_SLQTBL_PTS_LEN+16) //pts
6200 );
6201 }
6202 printf("=====================================\n");
6203 }
6204 #endif
6205
6206
6207 #if SLQ_NEW_PUSH
MVD_SLQTblGetHdrPkt(MS_U8 u8Idx,MVD_PacketInfo * pDivxHdr,MVD_PacketInfo * pDivxData)6208 void MVD_SLQTblGetHdrPkt(MS_U8 u8Idx, MVD_PacketInfo* pDivxHdr, MVD_PacketInfo* pDivxData)
6209 #else
6210 static void MVD_SLQTblGetDivxHdrPkt(MS_U8 u8Idx, MVD_PacketInfo* pDivxHdr, MVD_PacketInfo* pDivxData)
6211 #endif
6212 {
6213 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
6214 MS_VIRT u32DivXPattern = pstSlqTblInfo->pDrvDivxTbl->u32WrPtr;
6215 MS_U32 u32FrmSize = pDivxData->u32Length;
6216 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
6217 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
6218 #ifdef VDEC3
6219 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
6220 #endif
6221 #if SLQ_NEW_PUSH
6222 if(pstSlqTblInfo->pSlqStatus->bSlqCtrlBit && pstCtrlCfg->u8McuMode == FALSE)
6223 {
6224 if(pstSlqTblInfo->pSlqStatus->bSlqPicWaitNextStart && pstSlqTblInfo->pSlqStatus->bSlqPicStart)
6225 {
6226 //printf("Show KC the SlqPushLength = 0x%x\n",pstSlqTblInfo->pSlqStatus->u32SlqPushLength);
6227 if (E_MVD_CODEC_DIVX311 == curCodecType)
6228 {
6229 HAL_MVD_MemWrite4Byte(pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr +4, pstSlqTblInfo->pSlqStatus->u32SlqPushLength);
6230 HAL_MVD_MemWrite4Byte(pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr , DIVX_PATTERN);
6231 }
6232 else if(E_MVD_CODEC_VC1_MAIN == curCodecType)
6233 {//rcv
6234 HAL_MVD_MemWrite4Byte(pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr +4, RCV_PATTERN);
6235 HAL_MVD_MemWrite4Byte(pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr , pstSlqTblInfo->pSlqStatus->u32SlqPushLength);
6236 }
6237 else if (E_MVD_CODEC_VC1_ADV == curCodecType)
6238 {
6239 HAL_MVD_MemWrite4Byte(pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr , VC1_PATTERN);
6240 }
6241 pstSlqTblInfo->pSlqStatus->u32SlqPushLength = 0;
6242 pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr = 0;
6243 pstSlqTblInfo->pSlqStatus->bSlqFireRdy =TRUE;
6244 pstSlqTblInfo->pSlqStatus->u32VaildWptrAddr = pstSlqTblInfo->pDrvSlqTbl->u32WrPtr;// - 16;
6245 pstSlqTblInfo->pSlqStatus->bSlqPicWaitNextStart = FALSE;
6246 pstSlqTblInfo->pSlqStatus->bSlqPicCollect = FALSE;
6247 }
6248
6249 if(pstSlqTblInfo->pSlqStatus->bSlqPicStart)
6250 {
6251 pstSlqTblInfo->pSlqStatus->u32SlqPatternAddr = u32DivXPattern;
6252 pstSlqTblInfo->pSlqStatus->u32SlqPushLength += u32FrmSize;
6253 pstSlqTblInfo->pSlqStatus->bSlqPicCollect = TRUE;
6254 pstSlqTblInfo->pSlqStatus->bSlqPicWaitNextStart =TRUE;
6255 }
6256 else if(pstSlqTblInfo->pSlqStatus->bSlqPicCollect)
6257 {
6258 pstSlqTblInfo->pSlqStatus->u32SlqPushLength += u32FrmSize;
6259 pstSlqTblInfo->pSlqStatus->bSlqPicWaitNextStart =TRUE;
6260 }
6261 }
6262 else
6263 {
6264 HAL_MVD_MemWrite4Byte(u32DivXPattern, DIVX_PATTERN);
6265 HAL_MVD_MemWrite4Byte(u32DivXPattern +4,u32FrmSize);
6266 }
6267 #else
6268 HAL_MVD_MemWrite4Byte(u32DivXPattern, DIVX_PATTERN);
6269 HAL_MVD_MemWrite4Byte(u32DivXPattern+4, u32FrmSize);
6270 #endif
6271 pDivxHdr->u32StAddr = u32DivXPattern - HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr);
6272 pDivxHdr->u32TimeStamp = pDivxData->u32TimeStamp; //unit: ms
6273 pDivxHdr->u32ID_L = pDivxData->u32ID_L;
6274 pDivxHdr->u32ID_H = pDivxData->u32ID_H;
6275 //printf("u32DivXPattern(0x%x==>0x%x)=0x%x 0x%x\n", u32DivXPattern, pDivxHdr->u32StAddr,
6276 // HAL_MVD_MemRead4Byte(u32DivXPattern), HAL_MVD_MemRead4Byte(u32DivXPattern+4));
6277 if (E_MVD_CODEC_VC1_ADV == curCodecType)
6278 {
6279 pstSlqTblInfo->pDrvDivxTbl->u32WrPtr += 4;
6280 pDivxHdr->u32Length = 4;
6281 }
6282 else
6283 {
6284 pstSlqTblInfo->pDrvDivxTbl->u32WrPtr += 8;
6285 if(pstCtrlCfg->u8McuMode == TRUE)
6286 {
6287 pDivxHdr->u32Length = 64;
6288 if (pstSlqTblInfo->pDrvDivxTbl->u32WrPtr >= pstSlqTblInfo->pDrvDivxTbl->u32EndAdd)
6289 {
6290 pstSlqTblInfo->pDrvDivxTbl->u32WrPtr = pstSlqTblInfo->pDrvDivxTbl->u32StAdd;
6291 }
6292 }
6293 else
6294 {
6295 pDivxHdr->u32Length = 8;
6296 }
6297 }
6298
6299 #if SLQ_NEW_PUSH
6300 if(pstSlqTblInfo->pSlqStatus->bSlqPicStart && pstCtrlCfg->u8McuMode == FALSE)
6301 {
6302 if (E_MVD_CODEC_VC1_ADV == curCodecType)
6303 {
6304 pstSlqTblInfo->pDrvDivxTbl->u32WrPtr += 4;
6305 pDivxHdr->u32Length = 4;
6306 }
6307 else
6308 {
6309 pstSlqTblInfo->pDrvDivxTbl->u32WrPtr += 8;
6310 pDivxHdr->u32Length = 8;
6311 }
6312 }
6313 #endif
6314 }
6315
MVD_SLQTblInitFileEndPkt(MS_U8 u8Idx,MVD_CodecType eType)6316 static void MVD_SLQTblInitFileEndPkt(MS_U8 u8Idx, MVD_CodecType eType)
6317 {
6318 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
6319 MS_PHY u32EndPattern = HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr+SLQ_TBL_SIZE*3);
6320 MS_PHY temp = 0;
6321
6322 #if 0
6323 _MVD_Memset(u32EndPattern, 0xff, END_PATTERN_SIZE);
6324 #else
6325 //_miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32EndPattern,temp);
6326 temp = u32EndPattern+pMVDHalContext->stMiuCfg.u8FWMiuSel*HAL_MIU1_BASE;
6327 memset((void*)(MS_PA2KSEG1(temp)),0xff,END_PATTERN_SIZE);
6328 MsOS_FlushMemory();
6329 MsOS_ReadMemory();
6330 #endif
6331
6332 if ((E_MVD_CODEC_FLV == eType)||(E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER == eType))
6333 {
6334 HAL_MVD_MemWrite4Byte(u32EndPattern, FLV_PATTERN);
6335 HAL_MVD_MemWrite4Byte(u32EndPattern+4, 0xffffffff);
6336 HAL_MVD_MemWrite4Byte(u32EndPattern+8, END_PATTERN_1); //scw
6337 HAL_MVD_MemWrite4Byte(u32EndPattern+12,END_PATTERN_2); //scw
6338 HAL_MVD_MemWrite4Byte(u32EndPattern+16,END_PATTERN_3); //scw
6339 //printf("##########FileEnd for FLV/SVH!, u32EndPattern=%x\n",u32EndPattern);
6340 }
6341 else if (E_MVD_CODEC_DIVX311 == eType)
6342 {
6343 HAL_MVD_MemWrite4Byte(u32EndPattern, DIVX_PATTERN);
6344 HAL_MVD_MemWrite4Byte(u32EndPattern+4, 0xffffffff);
6345 HAL_MVD_MemWrite4Byte(u32EndPattern+8, END_PATTERN_1); //scw
6346 HAL_MVD_MemWrite4Byte(u32EndPattern+12,END_PATTERN_2); //scw
6347 HAL_MVD_MemWrite4Byte(u32EndPattern+16,END_PATTERN_3); //scw
6348 //printf("##########FileEnd for DIVX311!, u32EndPattern=%x\n",u32EndPattern);
6349 }
6350 else if ((E_MVD_CODEC_MPEG2 == eType)||(E_MVD_CODEC_MPEG4 == eType))
6351 {
6352 HAL_MVD_MemWrite4Byte(u32EndPattern, MPEG_PATTERN_0);
6353 HAL_MVD_MemWrite4Byte(u32EndPattern+4, END_PATTERN_1);
6354 HAL_MVD_MemWrite4Byte(u32EndPattern+8, END_PATTERN_2);
6355 HAL_MVD_MemWrite4Byte(u32EndPattern+12,END_PATTERN_3);
6356 //printf("##########FileEnd for MPEG2/4!, u32EndPattern=%x\n",u32EndPattern);
6357 }
6358 else
6359 {
6360 HAL_MVD_MemWrite4Byte(u32EndPattern, END_PATTERN_0);
6361 HAL_MVD_MemWrite4Byte(u32EndPattern+4, END_PATTERN_1);
6362 HAL_MVD_MemWrite4Byte(u32EndPattern+8, END_PATTERN_2); //scw
6363 HAL_MVD_MemWrite4Byte(u32EndPattern+12,END_PATTERN_3); //scw
6364 //printf("##########FileEnd for VC1!, u32EndPattern=%x\n",u32EndPattern);
6365 }
6366
6367 MVD_DEBUGINFO(printf("u32EndPattern(0x%lx)=0x%x 0x%x\n", (unsigned long)u32EndPattern,
6368 HAL_MVD_MemRead4Byte(u32EndPattern), HAL_MVD_MemRead4Byte(u32EndPattern+4)));
6369 }
6370
6371
MVD_SLQTblInitDummyPkt(MS_U8 u8Idx,MVD_CodecType eType)6372 static void MVD_SLQTblInitDummyPkt(MS_U8 u8Idx, MVD_CodecType eType)
6373 {
6374 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
6375 MS_PHY u32DummyES = HAL_MVD_GetMemOffset(pstMemCfg->u32DrvBufAddr+SLQ_TBL_SIZE*2);
6376 MS_U32 u32DummyPattern[3];
6377 MS_U32 u32PatternSize;
6378 MS_U32 i;
6379 MS_PHY temp = 0;
6380
6381 //printf("eType = 0x%x\n", eType);
6382 //initial content for dummy packet
6383 #if 0
6384 _MVD_Memset(u32DummyES, 0xff, DUMMY_SIZE);
6385 #else
6386 temp = u32DummyES+pMVDHalContext->stMiuCfg.u8FWMiuSel*HAL_MIU1_BASE;
6387 memset((void*)(MS_PA2KSEG1(temp)),0xff,DUMMY_SIZE);
6388 MsOS_FlushMemory();
6389 MsOS_ReadMemory();
6390 #endif
6391
6392 switch (eType)
6393 {
6394 case E_MVD_CODEC_FLV:
6395 case E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER:
6396 u32DummyPattern[0] = FLV_PATTERN;
6397 u32PatternSize = 1;
6398 break;
6399
6400 case E_MVD_CODEC_DIVX311:
6401 u32DummyPattern[0] = DIVX_PATTERN;
6402 u32PatternSize = 1;
6403 break;
6404
6405 case E_MVD_CODEC_VC1_ADV: //vc1
6406 u32DummyPattern[0] = VC1_PATTERN_0;
6407 u32DummyPattern[1] = VC1_PATTERN_1;
6408 u32DummyPattern[2] = VC1_PATTERN_2;
6409 u32PatternSize = 3;
6410 break;
6411
6412 case E_MVD_CODEC_VC1_MAIN: //rcv
6413 u32DummyPattern[0] = RCV_PATTERN_0;
6414 u32DummyPattern[1] = RCV_PATTERN_1;
6415 u32DummyPattern[2] = RCV_PATTERN_2;
6416 u32PatternSize = 3;
6417 break;
6418
6419 default:
6420 u32DummyPattern[0] = DUMMY_PATTERN;
6421 u32PatternSize = 1;
6422 break;
6423 }
6424 for (i=0; i<u32PatternSize; i++)
6425 {
6426 HAL_MVD_MemWrite4Byte(u32DummyES+i*4, u32DummyPattern[i]);
6427 }
6428 #if 0
6429 printf("u32DummyES(0x%x)=0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", u32DummyES, HAL_MVD_MemRead4Byte(u32DummyES),
6430 HAL_MVD_MemRead4Byte(u32DummyES+4),HAL_MVD_MemRead4Byte(u32DummyES+8),HAL_MVD_MemRead4Byte(u32DummyES+12));
6431 #endif
6432
6433 }
6434
MVD_SLQTblInitDrvSlqTbl(MVD_SLQ_TBL_ST * pDrvSlqTbl,MS_U32 u32Addr)6435 static void MVD_SLQTblInitDrvSlqTbl(MVD_SLQ_TBL_ST* pDrvSlqTbl, MS_U32 u32Addr)
6436 {
6437 MS_PHY temp = 0;
6438 pDrvSlqTbl->u32StAdd = u32Addr;
6439 pDrvSlqTbl->u32EndAdd = u32Addr + SLQ_TBL_SIZE;
6440 pDrvSlqTbl->u32EntryCntMax = SLQ_ENTRY_MAX;
6441
6442 //reset SLQ table read/write pointers
6443 pDrvSlqTbl->u32RdPtr = pDrvSlqTbl->u32StAdd;
6444 pDrvSlqTbl->u32WrPtr = pDrvSlqTbl->u32StAdd;
6445 pDrvSlqTbl->pu32LastEntry = &pDrvSlqTbl->u32WrPtr;
6446
6447 #if (!MVD_TURBO_INIT)
6448 //reset SLQ table
6449 #if 0
6450 _MVD_Memset(pDrvSlqTbl->u32StAdd, 0, SLQ_TBL_SIZE);
6451 #else
6452 temp = pDrvSlqTbl->u32StAdd+pMVDHalContext->stMiuCfg.u8FWMiuSel*HAL_MIU1_BASE;
6453 memset((void*)(MS_PA2KSEG1(temp)),0,SLQ_TBL_SIZE);
6454 MsOS_FlushMemory();
6455 MsOS_ReadMemory();
6456 #endif
6457 #endif
6458 pDrvSlqTbl->u32Empty = SLQ_TBL_SIZE;
6459 //_SLQTbl_DumpInfo(pDrvSlqTbl);
6460 }
6461
MVD_SLQTblInitSlqStatus(MVD_SLQ_STATUS * pSlqStatus,MS_VIRT u32WrPtr)6462 static void MVD_SLQTblInitSlqStatus(MVD_SLQ_STATUS* pSlqStatus, MS_VIRT u32WrPtr)
6463 {
6464 #if SLQ_NEW_PUSH
6465 pSlqStatus->u32VaildWptrAddr = u32WrPtr ;
6466 pSlqStatus->bSlqPicWaitNextStart = FALSE;
6467 pSlqStatus->bSlqCtrlBit = FALSE;
6468 pSlqStatus->u32SlqPushLength = 0;
6469 pSlqStatus->bSlqPicStart = FALSE;
6470 pSlqStatus->bSlqPicCollect = FALSE;
6471 pSlqStatus->bSlqEnLastFrameShow =FALSE;
6472 pSlqStatus->bSlqFireRdy = FALSE;
6473 #endif
6474 }
6475
MVD_SLQTblInitDrvDivxTbl(MVD_SLQ_ES_ST * pDrvDivxTbl,MS_U32 u32StAdd,MS_U32 u32Val)6476 static void MVD_SLQTblInitDrvDivxTbl(MVD_SLQ_ES_ST* pDrvDivxTbl, MS_U32 u32StAdd, MS_U32 u32Val)
6477 {
6478 MS_PHY temp = 0;
6479 ///// init SLQ entries for DivX311
6480 pDrvDivxTbl->u32StAdd = u32StAdd;
6481 pDrvDivxTbl->u32EndAdd= pDrvDivxTbl->u32StAdd + SLQ_TBL_SIZE;
6482 pDrvDivxTbl->u32WrPtr = pDrvDivxTbl->u32StAdd;
6483 //pDrvDivxTbl->u32RdPtr = pDrvDivxTbl->u32StAdd;
6484 #if (!MVD_TURBO_INIT)
6485 //reset DivX311 pattern table
6486 #if 0
6487 _MVD_Memset(pDrvDivxTbl->u32StAdd, 0, u32Val);
6488 #else
6489 temp = pDrvDivxTbl->u32StAdd+pMVDHalContext->stMiuCfg.u8FWMiuSel*HAL_MIU1_BASE;
6490 memset((void*)(MS_PA2KSEG1(temp)),0,u32Val);
6491 MsOS_FlushMemory();
6492 MsOS_ReadMemory();
6493 #endif
6494 #endif
6495 }
6496
MVD_SLQTblInitDrvEsTbl(MVD_SLQ_ES_ST * pDrvEsTbl,MS_U32 u32StAdd,MS_U32 u32Val)6497 static void MVD_SLQTblInitDrvEsTbl(MVD_SLQ_ES_ST* pDrvEsTbl, MS_U32 u32StAdd, MS_U32 u32Val)
6498 {
6499 UNUSED(u32Val);
6500 MS_PHY temp = 0;
6501 ///// init ES table
6502 pDrvEsTbl->u32StAdd = u32StAdd;
6503 pDrvEsTbl->u32EndAdd= pDrvEsTbl->u32StAdd + ES_TBL_SIZE;
6504 pDrvEsTbl->u32WrPtr = pDrvEsTbl->u32StAdd;
6505 //reset ES table
6506 #if 0
6507 _MVD_Memset(pDrvEsTbl->u32StAdd, 0, ES_TBL_SIZE);
6508 #else
6509 temp = pDrvEsTbl->u32StAdd+pMVDHalContext->stMiuCfg.u8FWMiuSel*HAL_MIU1_BASE;
6510 memset((void*)(MS_PA2KSEG1(temp)),0,ES_TBL_SIZE);
6511 MsOS_FlushMemory();
6512 MsOS_ReadMemory();
6513 #endif
6514 }
6515
6516 //------------------------------------------------------------------------------------------------------------
6517 // Layout of drvProcBuffer
6518 // -----------------
6519 // drvProcBuff | SlqTbl entries | <- pstSlqTblInfo->pDrvSlqTbl->u32StAdd
6520 // | 8K bytes |
6521 // | (1024 entries) |
6522 // | |
6523 // |-----------------|
6524 // | DivX311 | <- pstSlqTblInfo->pDrvSlqTbl->u32EndAdd <- pstSlqTblInfo->pDrvDivxTbl->u32StAdd
6525 // | 8K bytes |
6526 // | (1024 entries) |
6527 // | |
6528 // |-----------------|
6529 // | Flush Patterns |... <- pstSlqTblInfo->pDrvDivxTbl->u32EndAdd <- _drvDummy.u32StAdd
6530 // | 8K bytes |
6531 // | (1024 entries) |
6532 // | |
6533 // |-----------------|
6534 // | FileEnd Pattern |... <- _drvDummy.u32EndAdd <- _drvFileEnd.u32StAdd
6535 // | 8K bytes |
6536 // | (1024 entries) |
6537 // | |
6538 // |-----------------|
6539 // | ES table |... <- _drvFileEnd.u32EndAdd <- pstSlqTblInfo->pDrvEsTbl->u32StAdd
6540 // | 8K bytes |
6541 // | (1024 entries) |
6542 // | |
6543 // |-----------------|
6544 // | |........ End of drvProcBuff
6545 //
6546 //------------------------------------------------------------------------------------------------------------
HAL_MVD_SLQTblInit(MS_U8 u8Idx)6547 MS_BOOL HAL_MVD_SLQTblInit(MS_U8 u8Idx)
6548 {
6549 MS_VIRT u32Addr, u32Len;
6550 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
6551 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
6552 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
6553
6554 if(curCodecType == E_MVD_CODEC_UNKNOWN)
6555 {
6556 MVD_DEBUGERROR(printf("%s: unknow codec type!\n", __FUNCTION__));
6557 return FALSE;
6558 }
6559 pstSlqTblInfo->u32DummyPktCnt = 0;//reset dummy packet counter
6560 pstSlqTblInfo->u32SlqByteCnt = 0; //reset SLQ table byte counter
6561 pstSlqTblInfo->bSlqTblHasValidData = FALSE;
6562
6563 HAL_MVD_MemGetMap(u8Idx, E_MVD_MMAP_DRV, &u32Addr, &u32Len);
6564
6565 //init SLQ table attributes & reset SLQ table read/write pointers
6566 MVD_SLQTblInitDrvSlqTbl(pstSlqTblInfo->pDrvSlqTbl, u32Addr);
6567 pstSlqTblInfo->u32FileEndPtr = pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
6568
6569 MVD_SLQTblInitSlqStatus(pstSlqTblInfo->pSlqStatus, pstSlqTblInfo->pDrvSlqTbl->u32WrPtr);
6570
6571 //set SLQ table start/end to F/W
6572 HAL_MVD_SetSLQTblBufStartEnd(u8Idx, HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr), HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr+SLQ_TBL_SIZE));
6573
6574 ///// init SLQ entries for DivX311
6575 MVD_SLQTblInitDrvDivxTbl(pstSlqTblInfo->pDrvDivxTbl, pstSlqTblInfo->pDrvSlqTbl->u32EndAdd, SLQ_TBL_SIZE);
6576
6577 ///// init flush pattern
6578 MVD_SLQTblInitDummyPkt(u8Idx, curCodecType);
6579
6580 ///// init file-end pattern
6581 MVD_SLQTblInitFileEndPkt(u8Idx, curCodecType);
6582
6583 MVD_SLQTblInitDrvEsTbl(pstSlqTblInfo->pDrvEsTbl, (pstSlqTblInfo->pDrvDivxTbl->u32EndAdd + DUMMY_SIZE*2), pstMemCfg->u32DrvBufSize);
6584
6585 pstSlqTblInfo->u32PreEsRd = MVD_U32_MAX; //reset ES read pointer
6586 pstSlqTblInfo->u32PreEsWr = 0; //reset ES write pointer
6587
6588 return TRUE;
6589 }
6590
6591
6592 #if 0
6593 static void _SLQTbl_DumpInfo(MVD_SLQ_TBL_ST* pInfo)
6594 {
6595 printf("str=0x%x\n", pInfo->u32StAdd);
6596 printf("end=0x%x\n", pInfo->u32EndAdd);
6597 printf("cnt=0x%x\n", pInfo->u32EntryCntMax);
6598 printf("rd =0x%x\n", pInfo->u32RdPtr);
6599 printf("wr =0x%x\n", pInfo->u32WrPtr);
6600 return;
6601 }
6602 #endif
6603
6604
HAL_MVD_GetQueueVacancy(MS_U8 u8Idx,MS_BOOL bCached)6605 MS_U32 HAL_MVD_GetQueueVacancy(MS_U8 u8Idx, MS_BOOL bCached)
6606 {
6607 MS_U32 u32Empty;
6608 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
6609
6610 #if 0
6611 if (MDrv_MVD_GetVldErrCount()!=0)
6612 {
6613 printf("QQQ wPtr= 0x%x(0x%x) rPtr=0x%x(0x%x) vldErr=0x%x\n", writePtrLast[u8Idx], pstSlqTblInfo->pDrvSlqTbl->u32WrPtr,
6614 HAL_MVD_GetSLQReadPtr(u8Idx), pstSlqTblInfo->pDrvSlqTbl->u32RdPtr, MDrv_MVD_GetVldErrCount(u8Idx));
6615 printf("Previous EsRead=0x%x EsWrite=0x%x\n", pstSlqTblInfo->u32PreEsRd, pstSlqTblInfo->u32PreEsWr);
6616 _SLQTbl_DumpPtsTbl(u8Idx, 0x0, 0x620);
6617 while(1);
6618 }
6619 #endif
6620
6621 u32Empty = pstSlqTblInfo->pDrvSlqTbl->u32Empty;
6622 if ((TRUE == bCached) && (u32Empty > SLQTBL_CHECKVACANCY_WATERLEVEL))
6623 {
6624 //To have better performance, we only query F/W read pointer
6625 //when queue_vacancy is lower than water_level
6626 if (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr > pstSlqTblInfo->pDrvSlqTbl->u32RdPtr)
6627 {
6628 u32Empty = SLQ_TBL_SIZE - (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr - pstSlqTblInfo->pDrvSlqTbl->u32RdPtr);
6629 }
6630 else
6631 {
6632 u32Empty = pstSlqTblInfo->pDrvSlqTbl->u32RdPtr - pstSlqTblInfo->pDrvSlqTbl->u32WrPtr;
6633 }
6634
6635 if (u32Empty == 0)// && (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr == pstSlqTblInfo->pDrvSlqTbl->u32StAdd))
6636 {
6637 u32Empty = SLQ_TBL_SIZE;
6638 }
6639 u32Empty -= SLQ_TBL_SAFERANGE;
6640 return (u32Empty / SLQ_ENTRY_LEN);
6641 }
6642
6643 pstSlqTblInfo->pDrvSlqTbl->u32RdPtr = HAL_MVD_Map2DrvSlqTbl(u8Idx, HAL_MVD_GetSLQReadPtr(u8Idx));
6644 //printf("QV=0x%x rd=0x%x==>", u32Empty, pstSlqTblInfo->pDrvSlqTbl->u32RdPtr);
6645 if (pstSlqTblInfo->pDrvSlqTbl->u32RdPtr >= (pstSlqTblInfo->pDrvSlqTbl->u32StAdd+SLQ_ENTRY_LEN))
6646 {
6647 if (pstSlqTblInfo->pDrvSlqTbl->u32RdPtr >= pstSlqTblInfo->pDrvSlqTbl->u32EndAdd)
6648 {
6649 MVD_DEBUGERROR(printf("%s: readPtr 0x%lx out of range: too large!\n",
6650 __FUNCTION__, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32RdPtr));
6651 }
6652 pstSlqTblInfo->pDrvSlqTbl->u32RdPtr -= SLQ_ENTRY_LEN;
6653 }
6654 else if (pstSlqTblInfo->pDrvSlqTbl->u32RdPtr == pstSlqTblInfo->pDrvSlqTbl->u32StAdd)
6655 {
6656 pstSlqTblInfo->pDrvSlqTbl->u32RdPtr = pstSlqTblInfo->pDrvSlqTbl->u32EndAdd - SLQ_ENTRY_LEN;
6657 }
6658 else
6659 {
6660 MVD_DEBUGERROR(printf("%s: readPtr 0x%lx out of range: too small!\n",
6661 __FUNCTION__, (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32RdPtr));
6662 pstSlqTblInfo->pDrvSlqTbl->u32RdPtr = pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
6663 }
6664 //printf("0x%x\n", pstSlqTblInfo->pDrvSlqTbl->u32RdPtr);
6665
6666 if (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr > pstSlqTblInfo->pDrvSlqTbl->u32RdPtr)
6667 {
6668 u32Empty = SLQ_TBL_SIZE - (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr - pstSlqTblInfo->pDrvSlqTbl->u32RdPtr);
6669 }
6670 else
6671 {
6672 u32Empty = pstSlqTblInfo->pDrvSlqTbl->u32RdPtr - pstSlqTblInfo->pDrvSlqTbl->u32WrPtr;
6673 }
6674
6675 if (u32Empty == 0)// && (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr == pstSlqTblInfo->pDrvSlqTbl->u32StAdd))
6676 {
6677 u32Empty = SLQ_TBL_SIZE;
6678 }
6679
6680 pstSlqTblInfo->pDrvSlqTbl->u32Empty = u32Empty;
6681
6682 if (u32Empty < SLQ_TBL_SAFERANGE)
6683 {//to avoid write_pointer catch up to read_pointer
6684 u32Empty= 0;
6685 }
6686 else
6687 {
6688 u32Empty -= SLQ_TBL_SAFERANGE;
6689 }
6690
6691 //printf("%s r=0x%x w=0x%x u32Empty=0x%x\n", __FUNCTION__,
6692 // pstSlqTblInfo->pDrvSlqTbl->u32RdPtr, pstSlqTblInfo->pDrvSlqTbl->u32WrPtr, u32Empty);
6693 return (u32Empty / SLQ_ENTRY_LEN);
6694 }
6695
HAL_MVD_PushQueue(MS_U8 u8Idx,MVD_PacketInfo * pInfo)6696 E_MVD_Result HAL_MVD_PushQueue(MS_U8 u8Idx, MVD_PacketInfo* pInfo)
6697 {
6698 E_MVD_Result eRet=E_MVD_RET_INVALID_PARAM;
6699 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
6700 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
6701 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
6702 MS_U32 u32Id = MVD_GetStreamId(u8Idx);
6703 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
6704 #ifdef VDEC3
6705 MS_VIRT u32VBBUAddr = HAL_MVD_GetVBBUTableAddr(u8VPUIdx);
6706 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
6707 #endif
6708 if (pInfo == NULL)
6709 {
6710 MVD_DEBUGERROR(printf("PushQueue NULL pInfo\n"));
6711 return E_MVD_RET_INVALID_PARAM;
6712 }
6713
6714 #ifndef VDEC3
6715 if(pMVDHalContext->bAutoInsertDummyPattern[u8Idx] == TRUE)
6716 #else
6717 if(pstCtrlCfg->u8McuMode == TRUE)
6718 #endif
6719 {
6720 MS_U8* temp = (MS_U8*)(MS_PA2KSEG1( (MS_PHY)(pInfo->u32StAddr)+pstMemCfg->u32BSAddr));
6721 MS_U32 i;
6722 MS_U32 u32DummyPattern[3];
6723 MS_U32 u32PatternSize;
6724
6725 switch (curCodecType)
6726 {
6727 case E_MVD_CODEC_FLV:
6728 case E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER:
6729 u32DummyPattern[0] = FLV_PATTERN;
6730 u32PatternSize = 1;
6731 break;
6732
6733 case E_MVD_CODEC_DIVX311:
6734 u32DummyPattern[0] = DIVX_PATTERN;
6735 u32PatternSize = 1;
6736 break;
6737
6738 case E_MVD_CODEC_VC1_ADV: //vc1
6739 u32DummyPattern[0] = VC1_PATTERN_0;
6740 u32DummyPattern[1] = VC1_PATTERN_3;
6741 u32PatternSize = 2;
6742 break;
6743 case E_MVD_CODEC_VC1_MAIN: //rcv
6744 u32DummyPattern[0] = RCV_PATTERN_3;
6745 u32DummyPattern[1] = RCV_PATTERN_1;
6746 u32DummyPattern[2] = RCV_PATTERN_3;
6747 u32PatternSize = 3;
6748 break;
6749
6750 default:
6751 u32DummyPattern[0] = DUMMY_PATTERN;
6752 u32DummyPattern[1] = DUMMY_PATTERN;
6753 u32PatternSize = 2;
6754 break;
6755 }
6756
6757
6758 for (i=0; i<u32PatternSize; i++)
6759 {
6760 temp[4*i+pInfo->u32Length] = ((u32DummyPattern[i])&0xff);
6761 temp[4*i+pInfo->u32Length+1] = ((u32DummyPattern[i]>>8)&0xff);
6762 temp[4*i+pInfo->u32Length+2] = ((u32DummyPattern[i]>>16)&0xff);
6763 temp[4*i+pInfo->u32Length+3] = ((u32DummyPattern[i]>>24)&0xff);
6764 }
6765
6766 for(i=u32PatternSize*4;i<256;i++)
6767 {
6768 temp[pInfo->u32Length+i] = 0xFF;
6769 }
6770
6771 pInfo->u32Length += 256;
6772 }
6773
6774
6775 #if _SLQTBL_DUMP_PUSHQ
6776 {
6777 //static MS_U32 u32pqTimes[MAX_DEC_NUM]= {0, 0};
6778
6779 printf("Push[%x] st=0x%x len=0x%x pts=0x%x\n", pMVDHalContext->u32pqTimes[u8Idx]++,
6780 pInfo->u32StAddr, pInfo->u32Length, pInfo->u32TimeStamp);
6781 }
6782 #endif
6783
6784 #if SLQ_NEW_PUSH
6785 if((pInfo->u32StAddr & SLQ_PIC_START_FLAG) == SLQ_PIC_START_FLAG)
6786 {
6787 pInfo->u32StAddr = pInfo->u32StAddr&~SLQ_PIC_START_FLAG;
6788 pstSlqTblInfo->pSlqStatus->bSlqPicStart =TRUE;
6789 pstSlqTblInfo->pSlqStatus->bSlqCtrlBit = TRUE;
6790 }
6791 else
6792 {
6793 pstSlqTblInfo->pSlqStatus->bSlqPicStart = FALSE;
6794 }
6795 #endif
6796 //check input parameters
6797 if (pInfo->u32StAddr >= pstMemCfg->u32BSSize)
6798 {
6799 //since u32StAddr is offset, it shouldn't be larger than size.
6800 MVD_DEBUGERROR(printf("PushQueue invalid u32StAddr=0x%lx, bsSize=0x%lx\n", (unsigned long)pInfo->u32StAddr, (unsigned long)pstMemCfg->u32BSSize));
6801 return E_MVD_RET_INVALID_PARAM;
6802 }
6803 else if ((pInfo->u32TimeStamp == MVD_NULLPKT_PTS) && (pInfo->u32Length==0))
6804 {
6805 // AVI NULL packet.
6806 pstSlqTblInfo->u32DummyPktCnt++;
6807 //printf("Pos:0x%x%08x; PTS:%08d; NullPKT:%d\n", pInfo->u32ID_H, pInfo->u32ID_L, pInfo->u32TimeStamp, pstSlqTblInfo->u32DummyPktCnt);
6808 return E_MVD_RET_OK;
6809 }
6810
6811 if (FALSE == (HAL_MVD_IsMStreamerMode(u8Idx) ||HAL_MVD_IsMcuMode(u8Idx)))
6812 { //Check repeat PTS for non-MStreamer/Mcu mode.
6813 //printf(".Pos:0x%x%08x; PTS:%08d; NullPKT:%d\n", pInfo->u32ID_H, pInfo->u32ID_L, pInfo->u32TimeStamp, pstSlqTblInfo->u32DummyPktCnt);
6814 if (pInfo->u32TimeStamp == pstSlqTblInfo->u32LastPts)
6815 {
6816 //printf("Repeat PTS!\n");
6817 if (pInfo->u32TimeStamp != MVD_NULLPKT_PTS)
6818 pInfo->u32TimeStamp = MVD_NULLPKT_PTS; //repeat PTS
6819 }
6820 else
6821 {
6822 pstSlqTblInfo->u32LastPts = pInfo->u32TimeStamp;
6823 }
6824 }
6825
6826 //check queue vacancy
6827 if (pstSlqTblInfo->pDrvSlqTbl->u32Empty >= SLQ_TBL_SAFERANGE)
6828 { //put packets
6829 #if SLQ_NEW_PUSH
6830 if (E_MVD_CODEC_DIVX311 == curCodecType
6831 ||E_MVD_CODEC_VC1_MAIN == curCodecType //rcv
6832 ||E_MVD_CODEC_VC1_ADV == curCodecType)
6833 {
6834 MVD_PacketInfo stHdr;
6835 if((pstSlqTblInfo->pSlqStatus->bSlqCtrlBit) || (E_MVD_CODEC_DIVX311 == curCodecType))
6836 {
6837 MVD_SLQTblGetHdrPkt(u8Idx, &stHdr, pInfo);
6838
6839 if(pstSlqTblInfo->pSlqStatus->bSlqPicStart||(!pstSlqTblInfo->pSlqStatus->bSlqCtrlBit))
6840 {
6841 if (HAL_MVD_IsMStreamerMode(u8Idx) || HAL_MVD_IsMcuMode(u8Idx))
6842 { //to mark this packet's pts as unused.
6843 stHdr.u32TimeStamp = MVD_NULLPKT_PTS;
6844 stHdr.u32ID_H = MVD_NULLPKT_PTS;
6845 }
6846 #ifdef VDEC3
6847 if(pstCtrlCfg->u8McuMode == TRUE)
6848 {
6849 if(HAL_VPU_EX_GetVBBUVacancy(u32VBBUAddr) > 1)
6850 {
6851 HAL_VPU_EX_PacketInfo stVpuPkt;
6852
6853 stVpuPkt.u32Offset = stHdr.u32StAddr;
6854 stVpuPkt.u32Length = stHdr.u32Length;
6855 stVpuPkt.u64TimeStamp = (MS_U64)stHdr.u32TimeStamp;
6856 //If in display queue mode
6857 stVpuPkt.u64TimeStamp |= ((MS_U64)stHdr.u32ID_H << 32);
6858 stVpuPkt.u32ID_H = stHdr.u32ID_H;
6859 stVpuPkt.u32ID_L = stHdr.u32ID_L;
6860
6861 pstSlqTblInfo->bSlqTblHasValidData = TRUE;
6862 eRet = (E_MVD_Result)HAL_VPU_EX_Push2VBBU(u32Id, &stVpuPkt, u32VBBUAddr);
6863 }
6864 else
6865 {
6866 return E_MVD_RET_FAIL;
6867 }
6868 }
6869 else
6870 #endif
6871 {
6872 HAL_MVD_SLQTblSendPacket(u8Idx, &stHdr);
6873 }
6874 }
6875 }
6876 }
6877 #else
6878 if (E_MVD_CODEC_DIVX311 == curCodecType)
6879 {
6880 MVD_PacketInfo stDivxHdr;
6881 MVD_SLQTblGetDivxHdrPkt(u8Idx, &stDivxHdr, pInfo);
6882 if (HAL_MVD_IsMStreamerMode(u8Idx) || HAL_MVD_IsMcuMode(u8Idx))
6883 { //to mark this packet's pts as unused.
6884 stDivxHdr.u32TimeStamp = MVD_NULLPKT_PTS;
6885 stDivxHdr.u32ID_H = MVD_NULLPKT_PTS;
6886 }
6887 HAL_MVD_SLQTblSendPacket(u8Idx, &stDivxHdr);
6888 }
6889 #endif
6890
6891 #ifdef VDEC3
6892 if(pstCtrlCfg->u8McuMode == TRUE)
6893 {
6894 if(HAL_VPU_EX_GetVBBUVacancy(u32VBBUAddr) > 0)
6895 {
6896 HAL_VPU_EX_PacketInfo stVpuPkt;
6897
6898 stVpuPkt.u32Offset = pInfo->u32StAddr;
6899 stVpuPkt.u32Length = pInfo->u32Length;
6900 stVpuPkt.u64TimeStamp = (MS_U64)pInfo->u32TimeStamp;
6901 //If in display queue mode
6902 stVpuPkt.u64TimeStamp |= ((MS_U64)pInfo->u32ID_H << 32);
6903 stVpuPkt.u32ID_H = pInfo->u32ID_H;
6904 stVpuPkt.u32ID_L = pInfo->u32ID_L;
6905
6906 pstSlqTblInfo->bSlqTblHasValidData = TRUE;
6907 eRet = (E_MVD_Result)HAL_VPU_EX_Push2VBBU(u32Id, &stVpuPkt, u32VBBUAddr);
6908 //VPRINTF("[%d]%s[%d],ret=%d,u32StAddr %x,u32Length %d,u32TimeStamp %d\n",u8Idx,__FUNCTION__,__LINE__,eRet,(unsigned int)pInfo->u32StAddr,(unsigned int)pInfo->u32Length,(unsigned int)pInfo->u32TimeStamp);
6909 return eRet;
6910 }
6911 else
6912 {
6913 return E_MVD_RET_FAIL;
6914 }
6915 }
6916 else
6917 #endif
6918 {
6919 HAL_MVD_SLQTblSendPacket(u8Idx, pInfo);
6920 eRet=E_MVD_RET_OK;
6921 pstSlqTblInfo->bSlqTblHasValidData = TRUE;
6922 }
6923 }
6924 else
6925 {
6926 MS_ASSERT(0); //shouldn't be here!
6927 MVD_DEBUGERROR(printf("PushQueue FULL!!! empty=0x%lx\n", (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32Empty));
6928 //Player will only push queue when queue vacancy != 0
6929 eRet=E_MVD_RET_QUEUE_FULL;
6930 }
6931
6932 if (E_MVD_RET_OK != eRet)
6933 {
6934 MVD_DEBUGERROR(printf("%s ret = %d\n", __FUNCTION__, eRet));
6935 }
6936 return eRet;
6937 }
6938
6939
MVD_FlushTSQueue(MS_U8 u8Idx)6940 static E_MVD_Result MVD_FlushTSQueue(MS_U8 u8Idx)
6941 {
6942 if (HAL_MVD_GetLastCmd(u8Idx)!=CMD_PAUSE)
6943 {
6944 HAL_MVD_PauseDisp(u8Idx);
6945 HAL_MVD_DecodePause(u8Idx);
6946 HAL_MVD_FlushDisplayBuf(u8Idx);
6947 }
6948
6949 if(HAL_MVD_SkipData(u8Idx) == FALSE)
6950 {
6951 return E_MVD_RET_FAIL;
6952 }
6953 else
6954 {
6955 return E_MVD_RET_OK;
6956 }
6957 }
6958
6959
MVD_PatternLenIsValid(MS_U8 u8Idx,MS_U32 u32Len)6960 static MS_BOOL MVD_PatternLenIsValid(MS_U8 u8Idx, MS_U32 u32Len)
6961 {
6962 MS_U32 u32ValidLen = 0;
6963 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
6964 #define MAX_VALIDLEN 0x200000 //2M
6965
6966 if (E_MVD_CODEC_VC1_MAIN != curCodecType)
6967 {
6968 return TRUE;
6969 }
6970 else
6971 {
6972 //only RCV has to check this
6973 u32ValidLen = HAL_MVD_GetPayloadLen(u8Idx);
6974 if (u32ValidLen > MAX_VALIDLEN)
6975 { //avoid the extreme large value due to error bitstream
6976 u32ValidLen = MAX_VALIDLEN;
6977 }
6978 MVD_DEBUGINFO(printf("(%x) ValidLen=0x%x CurLen=0x%x\n",
6979 (u32Len > u32ValidLen), u32ValidLen, u32Len));
6980 return (u32Len > u32ValidLen);
6981 }
6982 }
6983
MVD_FlushSlqTblQueue(MS_U8 u8Idx)6984 static E_MVD_Result MVD_FlushSlqTblQueue(MS_U8 u8Idx)
6985 {
6986 MS_U32 u32TimeCnt;
6987 MS_U32 u32PatternByteCnt = 0;
6988 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
6989 MS_U32 u32Id = MVD_GetStreamId(u8Idx);
6990 MS_U8 u8VPUIdx = HAL_VPU_EX_GetTaskId(u32Id);
6991 #ifdef VDEC3
6992 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
6993 MS_VIRT u32VBBUAddr = HAL_MVD_GetVBBUTableAddr(u8VPUIdx);
6994 #endif
6995 HAL_MVD_ResetHandShake(u8Idx,MVD_HANDSHAKE_PAUSE);
6996 HAL_MVD_PauseDisp(u8Idx);
6997 HAL_MVD_DecodePause(u8Idx);
6998 HAL_MVD_FlushDisplayBuf(u8Idx);
6999
7000 u32TimeCnt = HAL_MVD_GetTime();
7001 while (((HAL_MVD_GetTime() - u32TimeCnt) < CMD_TIMEOUT_MS) ||
7002 (TRUE != MVD_PatternLenIsValid(u8Idx, u32PatternByteCnt)))
7003 {
7004 if (HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_PAUSE))
7005 {
7006 MVD_DEBUGINFO(printf("\nPause finished!\n"));
7007 break;
7008 }
7009
7010 #ifdef VDEC3
7011 if(pstCtrlCfg->u8McuMode == TRUE)
7012 {
7013 if(HAL_VPU_EX_GetVBBUVacancy(u32VBBUAddr) > 0)
7014 {
7015 HAL_VPU_EX_PacketInfo stVpuPkt;
7016 MVD_PacketInfo stDummyPkt;
7017 MVD_SLQTblGetDummyPkt(&stDummyPkt);
7018
7019 stVpuPkt.u32Offset = stDummyPkt.u32StAddr;
7020 stVpuPkt.u32Length = stDummyPkt.u32Length;
7021 stVpuPkt.u64TimeStamp = (MS_U64)stDummyPkt.u32TimeStamp;
7022 //If in display queue mode
7023 stVpuPkt.u64TimeStamp |= ((MS_U64)stDummyPkt.u32ID_H << 32);
7024 stVpuPkt.u32ID_H = stDummyPkt.u32ID_H;
7025 stVpuPkt.u32ID_L = stDummyPkt.u32ID_L;
7026
7027 HAL_VPU_EX_Push2VBBU(u32Id, &stVpuPkt,u32VBBUAddr);
7028 }
7029 }
7030 else
7031 #endif
7032 {
7033 if (pstSlqTblInfo->pDrvSlqTbl->u32Empty < SLQ_TBL_SAFERANGE)
7034 {
7035 HAL_MVD_GetQueueVacancy(u8Idx, FALSE); //update pstSlqTblInfo->pDrvSlqTbl->u32Empty
7036 HAL_MVD_Delayms(1); //avoid busy query
7037 }
7038 //insert dummy pattern
7039 if (TRUE == HAL_MVD_SLQTblInsertPattern(u8Idx, E_MVD_PATTERN_FLUSH))
7040 {
7041 u32PatternByteCnt += DUMMY_SIZE*2; //2 dummy were inserted
7042 }
7043 }
7044
7045
7046 //Timeout for RCV
7047 if ((HAL_MVD_GetTime() - u32TimeCnt) > (CMD_TIMEOUT_MS*10))
7048 {
7049 MVD_DEBUGERROR(printf("RCV timeout!!! pl=%d, pbc=%d, emp=%ld\n",
7050 HAL_MVD_GetPayloadLen(u8Idx), u32PatternByteCnt,
7051 (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32Empty));
7052 break;
7053 }
7054 }
7055 MVD_DEBUGINFO(printf("====> %s (t1=%u t2=%u diff=%u)\n", __FUNCTION__,
7056 u32TimeCnt, HAL_MVD_GetTime(), (HAL_MVD_GetTime() - u32TimeCnt)));
7057 //if ((HAL_MVD_GetTime() - u32TimeCnt) >= CMD_TIMEOUT_MS)
7058 if (TRUE != HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_PAUSE))
7059 {
7060 MVD_DEBUGERROR(printf("\n***** MDrv_MVD_FlushQueue PAUSE TIMEOUT!!! *****\n\n"));
7061 MVD_DEBUGERROR(printf("ValidLen=0x%x CurPatternLen=0x%x\n",
7062 HAL_MVD_GetPayloadLen(u8Idx), u32PatternByteCnt));
7063
7064 return E_MVD_RET_FAIL;
7065 }
7066
7067 //flush ES buffer & reset SLQ tbl
7068 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_SLQ_RST);
7069 if (HAL_MVD_SlqTblRst(u8Idx) == TRUE)
7070 {
7071 //return E_MVD_RET_OK;
7072 }
7073
7074 u32TimeCnt = HAL_MVD_GetTime();
7075 while (((HAL_MVD_GetTime() - u32TimeCnt) < CMD_TIMEOUT_MS))
7076 {
7077 if (HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_SLQ_RST))
7078 {
7079 MVD_DEBUGINFO(printf("\nSlqRst finished!\n"));
7080 break;
7081 }
7082 }
7083 MVD_DEBUGINFO(printf("====> %s (t1=%u t2=%u diff=%u)\n", __FUNCTION__,
7084 u32TimeCnt, HAL_MVD_GetTime(), (HAL_MVD_GetTime() - u32TimeCnt)));
7085 if (TRUE != HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_SLQ_RST))
7086 {
7087 MVD_DEBUGERROR(printf("\n***** MDrv_MVD_FlushQueue SlqRst TIMEOUT!!! *****\n\n"));
7088 return E_MVD_RET_FAIL;
7089 }
7090
7091 HAL_MVD_SLQTblInit(u8Idx); //reset related buffers
7092
7093 return E_MVD_RET_OK;
7094 }
7095
HAL_MVD_FlushQueue(MS_U8 u8Idx)7096 E_MVD_Result HAL_MVD_FlushQueue(MS_U8 u8Idx)
7097 {
7098 E_MVD_Result eRet = E_MVD_RET_OK;
7099 MVD_SrcMode curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
7100
7101 if (HAL_MVD_GetDecodeStatus(u8Idx) == E_MVD_STAT_IDLE)
7102 {
7103 return eRet;
7104 }
7105
7106 //flush ES buffer (and cmd queue if used)
7107 if (E_MVD_SLQ_TBL_MODE == curSrcMode)
7108 {
7109 eRet = MVD_FlushSlqTblQueue(u8Idx);
7110 }
7111 else if (E_MVD_TS_FILE_MODE == curSrcMode)
7112 {
7113 eRet = MVD_FlushTSQueue(u8Idx);
7114 }
7115 if (E_MVD_RET_OK != eRet)
7116 {
7117 return eRet;
7118 }
7119
7120 MVD_RstFrmInfo(u8Idx, E_MVD_FRMINFO_DECODE);
7121 //flush display buffer
7122
7123 if (HAL_MVD_FlushDisplayBuf(u8Idx) != TRUE)
7124 {
7125 return E_MVD_RET_FAIL;
7126 }
7127
7128 if (TRUE == HAL_MVD_SkipToIFrame(u8Idx))
7129 {
7130 return E_MVD_RET_OK;
7131 }
7132 else
7133 {
7134 return E_MVD_RET_FAIL;
7135 }
7136 }
7137
HAL_MVD_IsAllBufferEmpty(MS_U8 u8Idx)7138 MS_BOOL HAL_MVD_IsAllBufferEmpty(MS_U8 u8Idx)
7139 {
7140 return HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_SKIP_DATA);
7141 }
7142
HAL_MVD_EnableInt(MS_U8 u8Idx,MS_U32 bEn)7143 MS_BOOL HAL_MVD_EnableInt(MS_U8 u8Idx, MS_U32 bEn)
7144 {
7145 MVD_CmdArg mvdcmd;
7146 MS_U32 u32IntFlag = 0;
7147
7148 u32IntFlag = (((bEn & E_MVD_EVENT_USER_DATA) == E_MVD_EVENT_USER_DATA) ? INT_USER_DATA : 0) |
7149 (((bEn & E_MVD_EVENT_USER_DATA_DISP) == E_MVD_EVENT_USER_DATA_DISP) ? INT_USER_DATA_DISP : 0) |
7150 (((bEn & E_MVD_EVENT_PIC_FOUND) == E_MVD_EVENT_PIC_FOUND) ? INT_PIC_FOUND : 0) |
7151 (((bEn & E_MVD_EVENT_FIRST_FRAME) == E_MVD_EVENT_FIRST_FRAME) ? INT_FIRST_FRAME : 0) |
7152 (((bEn & E_MVD_EVENT_DISP_RDY) == E_MVD_EVENT_DISP_RDY) ? INT_DISP_RDY : 0) |
7153 (((bEn & E_MVD_EVENT_SEQ_FOUND) == E_MVD_EVENT_SEQ_FOUND) ? INT_SEQ_FOUND : 0)|
7154 (((bEn & E_MVD_EVENT_DEC_ONE_FRAME) == E_MVD_EVENT_DEC_ONE_FRAME) ? INT_DEC_DONE : 0)|
7155 (((bEn & E_MVD_EVENT_DEC_ERR) == E_MVD_EVENT_DEC_ERR) ? INT_DEC_ERR : 0)|
7156 (((bEn & E_MVD_EVENT_DEC_DATA_ERR) == E_MVD_EVENT_DEC_DATA_ERR) ? INT_VES_INVALID : 0)|
7157 (((bEn & E_MVD_EVENT_XC_LOW_DEALY) == E_MVD_EVENT_XC_LOW_DEALY) ? INT_XC_LOW_DELAY : 0)|
7158 (((bEn & E_MVD_EVENT_DEC_I) == E_MVD_EVENT_DEC_I) ? INT_DEC_I : 0);
7159 if (((bEn & E_MVD_EVENT_DISP_VSYNC) == E_MVD_EVENT_DISP_VSYNC) ||
7160 ((bEn & E_MVD_EVENT_UNMUTE) == E_MVD_EVENT_UNMUTE))
7161 {
7162 u32IntFlag |= INT_DISP_VSYNC;
7163 }
7164
7165 MVD_DEBUGINFO(printf("u32IntFlag = 0x%x\n", u32IntFlag));
7166 SETUP_CMDARG(mvdcmd);
7167 mvdcmd.Arg0 = u32IntFlag & 0xff;
7168 mvdcmd.Arg1 = (u32IntFlag>>8) & 0xff;
7169 mvdcmd.Arg2 = (u32IntFlag>>16) & 0xff;
7170 SET_DECNUM(mvdcmd, u8Idx);
7171 SET_CMD_RET_FALSE(CMD_ENABLE_INT_STAT, &mvdcmd);
7172
7173 return TRUE;
7174 }
7175
HAL_MVD_EnablePTSDetector(MS_U8 u8Idx,MS_BOOL bEn)7176 E_MVD_Result HAL_MVD_EnablePTSDetector(MS_U8 u8Idx, MS_BOOL bEn)
7177 {
7178 MVD_CmdArg stCmdArg;
7179
7180 SETUP_CMDARG(stCmdArg);
7181 if(TRUE == bEn)
7182 {
7183 stCmdArg.Arg0 = 1;
7184 }
7185 SET_DECNUM(stCmdArg, u8Idx);
7186 if (HAL_MVD_MVDCommand(CMD_PTS_DETECTOR_EN, &stCmdArg) == FALSE)
7187 {
7188 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PTS_DETECTOR_EN ) );
7189 return E_MVD_RET_FAIL;
7190 }
7191 return E_MVD_RET_OK;
7192 }
7193
HAL_MVD_DisablePBFrameMode(MS_U8 u8Idx,MS_BOOL bEn)7194 E_MVD_Result HAL_MVD_DisablePBFrameMode(MS_U8 u8Idx, MS_BOOL bEn)
7195 {
7196 MVD_CmdArg stCmdArg;
7197
7198 SETUP_CMDARG(stCmdArg);
7199 if(TRUE == bEn)
7200 {
7201 stCmdArg.Arg0 = 1;
7202 }
7203 SET_DECNUM(stCmdArg, u8Idx);
7204 if (HAL_MVD_MVDCommand(CMD_DISABLE_PATCH_PBFRAME, &stCmdArg) == FALSE)
7205 {
7206 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PTS_DETECTOR_EN ) );
7207 return E_MVD_RET_FAIL;
7208 }
7209 return E_MVD_RET_OK;
7210 }
7211
HAL_MVD_EnableDispOneField(MS_U8 u8Idx,MS_BOOL bEn)7212 E_MVD_Result HAL_MVD_EnableDispOneField(MS_U8 u8Idx, MS_BOOL bEn)
7213 {
7214 MVD_CmdArg stCmdArg;
7215
7216 SETUP_CMDARG(stCmdArg);
7217 if(TRUE == bEn)
7218 {
7219 stCmdArg.Arg0 = 1;
7220 }
7221 SET_DECNUM(stCmdArg, u8Idx);
7222 if (HAL_MVD_MVDCommand(CMD_SHOW_ONE_FIELD, &stCmdArg) == FALSE)
7223 {
7224 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SHOW_ONE_FIELD ) );
7225 return E_MVD_RET_FAIL;
7226 }
7227 return E_MVD_RET_OK;
7228 }
7229
HAL_MVD_SetFdMaskDelayCount(MS_U8 u8Idx,MS_U16 u16Cnt)7230 E_MVD_Result HAL_MVD_SetFdMaskDelayCount(MS_U8 u8Idx, MS_U16 u16Cnt)
7231 {
7232 MVD_CmdArg stCmdArg;
7233
7234 SETUP_CMDARG(stCmdArg);
7235 //16bits and unit in vsync for mute the fd_mask
7236 stCmdArg.Arg0 = u16Cnt & 0xff;
7237 stCmdArg.Arg1 = (u16Cnt>>8) & 0xff;
7238 SET_DECNUM(stCmdArg, u8Idx);
7239 if (HAL_MVD_MVDCommand(CMD_FD_MASK_DELAY_CNT, &stCmdArg) == FALSE)
7240 {
7241 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FD_MASK_DELAY_CNT ) );
7242 return E_MVD_RET_FAIL;
7243 }
7244 return E_MVD_RET_OK;
7245 }
7246
HAL_MVD_SetOutputFRCMode(MS_U8 u8Idx,MS_U8 u8FrameRate,MS_U8 u8Interlace)7247 E_MVD_Result HAL_MVD_SetOutputFRCMode(MS_U8 u8Idx, MS_U8 u8FrameRate, MS_U8 u8Interlace)
7248 {
7249 MVD_CmdArg stCmdArg;
7250 if((u8Interlace != 0) && (u8Interlace != 1))
7251 {
7252 return E_MVD_RET_FAIL;
7253 }
7254 SETUP_CMDARG(stCmdArg);
7255 stCmdArg.Arg0 = u8FrameRate;
7256 stCmdArg.Arg1 = u8Interlace;
7257 SET_DECNUM(stCmdArg, u8Idx);
7258 if (HAL_MVD_MVDCommand(CMD_FRC_OUPUT, &stCmdArg) == FALSE)
7259 {
7260 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FRC_OUPUT ) );
7261 return E_MVD_RET_FAIL;
7262 }
7263 return E_MVD_RET_OK;
7264 }
7265
7266
HAL_MVD_SetFRCDropType(MS_U8 u8Idx,MS_U8 u8DropType)7267 E_MVD_Result HAL_MVD_SetFRCDropType(MS_U8 u8Idx, MS_U8 u8DropType)
7268 {
7269 MVD_CmdArg stCmdArg;
7270
7271 if((u8DropType != FRC_DROP_FRAME)
7272 && (u8DropType != FRC_DROP_FIELD))
7273 {
7274 return E_MVD_RET_FAIL;
7275 }
7276
7277 SETUP_CMDARG(stCmdArg);
7278 stCmdArg.Arg0 = u8DropType;
7279 SET_DECNUM(stCmdArg, u8Idx);
7280 if (HAL_MVD_MVDCommand(CMD_FRC_DROP_BEHAVIOR, &stCmdArg) == FALSE)
7281 {
7282 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FRC_DROP_BEHAVIOR ) );
7283 return E_MVD_RET_FAIL;
7284 }
7285 return E_MVD_RET_OK;
7286 }
7287
HAL_MVD_SetDisableSeqChange(MS_U8 u8Idx,MS_BOOL bEnable)7288 E_MVD_Result HAL_MVD_SetDisableSeqChange(MS_U8 u8Idx, MS_BOOL bEnable)
7289 {
7290 MVD_CmdArg stCmdArg;
7291
7292 SETUP_CMDARG(stCmdArg);
7293 stCmdArg.Arg0 = bEnable;
7294 SET_DECNUM(stCmdArg, u8Idx);
7295 if (HAL_MVD_MVDCommand(CMD_FORBID_RESOLUTION_CHANGE, &stCmdArg) == FALSE)
7296 {
7297 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_FORBID_RESOLUTION_CHANGE ) );
7298 return E_MVD_RET_FAIL;
7299 }
7300 MVD_DEBUGINFO(printf("MVD CMD_FORBID_RESOLUTION_CHANGE(0x%x) OK\n", bEnable));
7301
7302 return E_MVD_RET_OK;
7303 }
7304
HAL_MVD_DbgGetData(MS_VIRT u32Addr,MS_U32 * u32Data)7305 E_MVD_Result HAL_MVD_DbgGetData(MS_VIRT u32Addr, MS_U32* u32Data)
7306 {
7307 MVD_CmdArg mvdcmd;
7308 MS_U32 u32Val;
7309
7310 if (!u32Data)
7311 {
7312 return E_MVD_RET_INVALID_PARAM;
7313 }
7314
7315 SET_CMDARG(mvdcmd, u32Addr, 0); //FIXME
7316 if (HAL_MVD_MVDCommand( CMD_RD_IO, &mvdcmd ) == FALSE)
7317 {
7318 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_RD_IO ) );
7319 return E_MVD_RET_FAIL;
7320 }
7321
7322 u32Val = (((MS_U32)mvdcmd.Arg2)) | ((MS_U32)mvdcmd.Arg3 << 8) |
7323 (((MS_U32)mvdcmd.Arg4) << 16) | (((MS_U32)mvdcmd.Arg5) << 24);
7324 *u32Data = u32Val;
7325
7326 return E_MVD_RET_OK;
7327 }
7328
7329
HAL_MVD_DbgDumpBits(MS_U8 u8Idx,MS_PHY u32base,MS_U32 u32size)7330 void HAL_MVD_DbgDumpBits(MS_U8 u8Idx, MS_PHY u32base, MS_U32 u32size)
7331 {
7332 MVD_CmdArg mvdcmd;
7333
7334 u32base = HAL_MVD_GetMemOffset(u32base);
7335 printf("%s base=0x%lx size=0x%x\n", __FUNCTION__, (unsigned long)u32base, u32size);
7336 MS_ASSERT((u32base%8)==0);
7337 u32base >>= 3;
7338 SET_CMDARG(mvdcmd, u32base, u8Idx);
7339 if (HAL_MVD_MVDCommand( CMD_DUMP_BITSTREAM_BASE, &mvdcmd ) == FALSE)
7340 {
7341 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\n", CMD_DUMP_BITSTREAM_BASE ) );
7342 return;
7343 }
7344
7345 MS_ASSERT((u32size%8)==0);
7346 u32size >>= 3;
7347 SET_CMDARG(mvdcmd, u32size, u8Idx);
7348 if (HAL_MVD_MVDCommand( CMD_DUMP_BITSTREAM_LENGTH, &mvdcmd ) == FALSE)
7349 {
7350 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\n", CMD_DUMP_BITSTREAM_LENGTH ) );
7351 return;
7352 }
7353 return;
7354 }
7355
7356
HAL_MVD_GetActiveFormat(MS_U8 u8Idx)7357 MS_U8 HAL_MVD_GetActiveFormat(MS_U8 u8Idx)
7358 {
7359 MVD_CmdArg mvdcmd;
7360 MS_U8 u8Afd = 0;
7361
7362 SETUP_CMDARG(mvdcmd);
7363 SET_DECNUM(mvdcmd, u8Idx);
7364 if (HAL_MVD_MVDCommand( CMD_GET_AFD, &mvdcmd ) == FALSE)
7365 {
7366 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail!!\r\n", CMD_GET_AFD ) );
7367 return 0xff;
7368 }
7369 u8Afd = mvdcmd.Arg0;
7370 return u8Afd;
7371 }
7372
HAL_MVD_EnableAVSync(MS_U8 u8Idx,MS_BOOL bEnable)7373 MS_BOOL HAL_MVD_EnableAVSync(MS_U8 u8Idx, MS_BOOL bEnable)
7374 {
7375 MVD_CmdArg mvdcmd;
7376 SETUP_CMDARG(mvdcmd);
7377 mvdcmd.Arg0 = bEnable;
7378 SET_DECNUM(mvdcmd, u8Idx);
7379 SET_CMD_RET_FALSE(CMD_SYNC_ON, &mvdcmd);
7380
7381 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
7382 pCtrlCfg->bAVSyncOn = bEnable;
7383
7384 return TRUE;
7385 }
7386
HAL_MVD_SetAVSyncDelay(MS_U8 u8Idx,MS_U32 u32Delay)7387 MS_BOOL HAL_MVD_SetAVSyncDelay(MS_U8 u8Idx, MS_U32 u32Delay)
7388 {
7389 MVD_CmdArg mvdcmd;
7390 SET_CMDARG(mvdcmd, _MS_TO_90K(u32Delay), u8Idx); //u32Delay ms ==> 90k counter
7391 SET_CMD_RET_FALSE(CMD_SYNC_OFFSET, &mvdcmd);
7392 return TRUE;
7393 }
7394
HAL_MVD_SetAVSyncThreshold(MS_U8 u8Idx,MS_U32 u32Th)7395 MS_BOOL HAL_MVD_SetAVSyncThreshold(MS_U8 u8Idx, MS_U32 u32Th)
7396 {
7397 MVD_CmdArg mvdcmd;
7398
7399 if (u32Th == 0x00)
7400 {
7401 return FALSE; //invalid parameter, do nothing
7402 }
7403 if (u32Th > 0xff)
7404 {
7405 u32Th = 0xff; //set to maximum
7406 }
7407
7408 SETUP_CMDARG(mvdcmd);
7409 mvdcmd.Arg3 = u32Th;
7410 SET_DECNUM(mvdcmd, u8Idx);
7411 SET_CMD_RET_FALSE(CMD_SYN_THRESHOLD, &mvdcmd);
7412 return TRUE;
7413 }
7414
HAL_MVD_SetAVSyncFreerunThreshold(MS_U8 u8Idx,MS_U32 u32Th)7415 MS_BOOL HAL_MVD_SetAVSyncFreerunThreshold(MS_U8 u8Idx, MS_U32 u32Th)
7416 {
7417 MVD_CmdArg mvdcmd;
7418 SET_CMDARG(mvdcmd, u32Th, u8Idx);
7419 SET_CMD_RET_FALSE(CMD_AVSYNC_FREERUN_THRESHOLD, &mvdcmd);
7420 return TRUE;
7421 }
7422
HAL_MVD_ChangeAVsync(MS_U8 u8Idx,MS_BOOL bEnable,MS_U16 u16PTS)7423 MS_BOOL HAL_MVD_ChangeAVsync(MS_U8 u8Idx, MS_BOOL bEnable, MS_U16 u16PTS)
7424 {
7425 MVD_CmdArg mvdcmd;
7426
7427 u16PTS = _MS_TO_90K(u16PTS); //u16PTS ms ==> 90k counter
7428 SETUP_CMDARG(mvdcmd);
7429 mvdcmd.Arg0 = (MS_U8)bEnable;
7430 mvdcmd.Arg1 = 0;
7431 mvdcmd.Arg2 = (MS_U8)(u16PTS&0xff);
7432 mvdcmd.Arg3 = (MS_U8)((u16PTS&0xff00)>>8);
7433 SET_DECNUM(mvdcmd, u8Idx);
7434 SET_CMD_RET_FALSE(CMD_MVD_FAST_INT, &mvdcmd);
7435 return TRUE;
7436 }
7437
HAL_MVD_GetIsSyncRep(MS_U8 u8Idx)7438 MS_BOOL HAL_MVD_GetIsSyncRep(MS_U8 u8Idx)
7439 {
7440 MS_U32 u32IntStat = 0;
7441 MS_BOOL bRet = FALSE;
7442
7443 u32IntStat = HAL_MVD_GetIntState(u8Idx);
7444 if (u32IntStat != 0)
7445 {
7446 bRet = ((u32IntStat&INT_SYN_REP)==INT_SYN_REP) ? TRUE : FALSE;
7447 }
7448 return bRet;
7449 }
7450
HAL_MVD_GetIsSyncSkip(MS_U8 u8Idx)7451 MS_BOOL HAL_MVD_GetIsSyncSkip(MS_U8 u8Idx)
7452 {
7453 MS_U32 u32IntStat = 0;
7454 MS_BOOL bRet = FALSE;
7455
7456 u32IntStat = HAL_MVD_GetIntState(u8Idx);
7457 if (u32IntStat != 0)
7458 {
7459 bRet = ((u32IntStat&INT_SYN_SKIP)==INT_SYN_SKIP) ? TRUE : FALSE;
7460 }
7461
7462 return bRet;
7463 }
7464
HAL_MVD_GetIsSyncReach(MS_U8 u8Idx)7465 MS_U8 HAL_MVD_GetIsSyncReach(MS_U8 u8Idx)
7466 {
7467 #define MVD_SYNC_DONE 1
7468 if(MVD_GetSyncStat(u8Idx, 1) == MVD_SYNC_DONE)
7469 return 1;
7470 else
7471 return 0xFF;
7472 }
7473
HAL_MVD_GetDispRdy(MS_U8 u8Idx)7474 MS_U8 HAL_MVD_GetDispRdy(MS_U8 u8Idx)
7475 {
7476 if (HAL_MVD_GetPicCounter(u8Idx) > 0)
7477 {
7478 return 1;
7479 }
7480 else
7481 {
7482 return 0;
7483 }
7484 }
7485
HAL_MVD_GetDecodeStatus(MS_U8 u8Idx)7486 MVD_DecStat HAL_MVD_GetDecodeStatus(MS_U8 u8Idx)
7487 {
7488 MVD_CmdArg mvdcmd;
7489 MVD_DecStat stat = E_MVD_STAT_UNKNOWN;
7490
7491 SETUP_CMDARG(mvdcmd);
7492 SET_DECNUM(mvdcmd, u8Idx);
7493 if (HAL_MVD_MVDCommand(CMD_DECODE_STATUS, &mvdcmd) == FALSE)
7494 {
7495 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DECODE_STATUS ) );
7496 return E_MVD_STAT_UNKNOWN;
7497 }
7498
7499 switch(mvdcmd.Arg1)
7500 {
7501 case DEC_STAT_IDLE:
7502 stat = E_MVD_STAT_IDLE;
7503 break;
7504 case DEC_STAT_FIND_SC:
7505 stat = E_MVD_STAT_FIND_STARTCODE;
7506 break;
7507 case DEC_STAT_FIND_SPE_SC:
7508 stat = E_MVD_STAT_FIND_SPECIALCODE;
7509 break;
7510 case DEC_STAT_FIND_FRAMEBUFFER:
7511 stat = E_MVD_STAT_FIND_FRAMEBUFFER;
7512 break;
7513 case DEC_STAT_WAIT_DECODE_DONE:
7514 stat = E_MVD_STAT_WAIT_DECODEDONE;
7515 break;
7516 case DEC_STAT_DECODE_DONE:
7517 stat = E_MVD_STAT_DECODE_DONE;
7518 break;
7519 case DEC_STAT_WAIT_VDFIFO:
7520 stat = E_MVD_STAT_WAIT_VDFIFO;
7521 break;
7522 case DEC_STAT_INIT_SUCCESS:
7523 stat = E_MVD_STAT_INIT_SUCCESS;
7524 break;
7525 default:
7526 break;
7527 }
7528
7529 return stat;
7530 }
7531
HAL_MVD_GetLastCmd(MS_U8 u8Idx)7532 MS_U8 HAL_MVD_GetLastCmd(MS_U8 u8Idx)
7533 {
7534 MVD_CmdArg mvdcmd;
7535 SETUP_CMDARG(mvdcmd);
7536 SET_DECNUM(mvdcmd, u8Idx);
7537 if (HAL_MVD_MVDCommand( CMD_DECODE_STATUS, &mvdcmd ) == FALSE)
7538 {
7539 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DECODE_STATUS ) );
7540 return 0xff;
7541 }
7542
7543 return (mvdcmd.Arg0);
7544 }
7545
HAL_MVD_GetParserByteCnt(MS_U8 u8Idx)7546 MS_U32 HAL_MVD_GetParserByteCnt(MS_U8 u8Idx)
7547 {
7548 MVD_CmdArg mvdcmd;
7549 MS_U32 u32Cnt = 0;
7550
7551 SETUP_CMDARG(mvdcmd);
7552
7553 //To be accurate, it's "VLD byte count", instead of "parser byte count".
7554 mvdcmd.Arg0 = 0x34;
7555 mvdcmd.Arg1 = 0x2;
7556 SET_DECNUM(mvdcmd, u8Idx);
7557 if (HAL_MVD_MVDCommand( CMD_RD_IO, &mvdcmd ) == FALSE)
7558 {
7559 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail!!\r\n", CMD_RD_IO ) );
7560 return 0;
7561 }
7562 u32Cnt = (((MS_U32)mvdcmd.Arg2)) | ((MS_U32)mvdcmd.Arg3 << 8) |
7563 (((MS_U32)mvdcmd.Arg4) << 16) | (((MS_U32)mvdcmd.Arg5) << 24);
7564
7565 //printf(" parser byte count = %lu byte \n", u32Cnt);
7566 return u32Cnt;
7567 }
7568
HAL_MVD_DropErrorFrame(MS_U8 u8Idx,MS_BOOL bDrop)7569 MS_BOOL HAL_MVD_DropErrorFrame(MS_U8 u8Idx, MS_BOOL bDrop)
7570 {
7571 MVD_CmdArg mvdcmd;
7572 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
7573
7574 SETUP_CMDARG(mvdcmd);
7575 mvdcmd.Arg1 = (MS_U8)bDrop;
7576 mvdcmd.Arg2 = (MS_U8)pstCtrlCfg->bDropDispfrm;
7577 mvdcmd.Arg3 = (MS_U8)pstCtrlCfg->eFrcMode;
7578 SET_DECNUM(mvdcmd, u8Idx);
7579 SET_CMD_RET_FALSE(CMD_DISPLAY_CTL, &mvdcmd);
7580 return TRUE;
7581 }
7582
HAL_MVD_SetDivXCfg(MS_U8 u8Idx,MS_U8 u8MvAdjust,MS_U8 u8IdctSel)7583 void HAL_MVD_SetDivXCfg(MS_U8 u8Idx, MS_U8 u8MvAdjust, MS_U8 u8IdctSel)
7584 {
7585 MVD_CmdArg stCmdArg;
7586
7587 SETUP_CMDARG(stCmdArg);
7588 stCmdArg.Arg0 = u8MvAdjust;
7589 SET_DECNUM(stCmdArg, u8Idx);
7590 if (HAL_MVD_MVDCommand(CMD_DIVX_PATCH, &stCmdArg) == FALSE)
7591 {
7592 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DIVX_PATCH ) );
7593 return;
7594 }
7595
7596 SETUP_CMDARG(stCmdArg);
7597 stCmdArg.Arg0 = u8IdctSel;
7598 SET_DECNUM(stCmdArg, u8Idx);
7599 if (HAL_MVD_MVDCommand(CMD_IDCT_SEL, &stCmdArg) == FALSE)
7600 {
7601 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_IDCT_SEL ) );
7602 return;
7603 }
7604
7605 return;
7606 }
7607
7608 #define _IsNotInStreamBuff(x) \
7609 (((x) < pstMemCfg->u32DrvBufSize) || \
7610 ((x) > pstMemCfg->u32BSSize) )
7611
7612 //------------------------------------------------------------------------------
7613 /// Get read pointer in ElementaryStream buffer for SLQ table mode
7614 /// @return -the read pointer
7615 //------------------------------------------------------------------------------
MVD_GetSlqTblESReadPtr(MS_U8 u8Idx)7616 MS_VIRT MVD_GetSlqTblESReadPtr(MS_U8 u8Idx)
7617 {
7618 MS_U32 u32Idx;
7619 MS_U32 u32SlqRp = 0, u32SlqRp1 = 0;
7620 MS_VIRT u32EsRp;
7621 MS_VIRT u32EsStart;
7622 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
7623 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
7624 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
7625
7626 u32SlqRp1 = HAL_MVD_GetSLQReadPtr(u8Idx);
7627
7628 if (u32SlqRp1 == 0)
7629 {
7630 return MVD_U32_MAX;
7631 }
7632 else
7633 {
7634 u32SlqRp = HAL_MVD_Map2DrvSlqTbl(u8Idx, u32SlqRp1);
7635 }
7636
7637 pstSlqTblInfo->pDrvSlqTbl->u32RdPtr = u32SlqRp; //update pstSlqTblInfo->pDrvSlqTbl->u32RdPtr
7638
7639 //report (readPtr-1) for HW may still use (readPtr)
7640 if (u32SlqRp > (pstSlqTblInfo->pDrvSlqTbl->u32StAdd))
7641 {
7642 u32Idx = ((u32SlqRp - pstSlqTblInfo->pDrvSlqTbl->u32StAdd)/SLQ_ENTRY_LEN) - 1;
7643 }
7644 else
7645 {
7646 u32Idx = SLQ_ENTRY_MAX - 1;
7647 }
7648 u32EsRp = pstSlqTblInfo->pDrvEsTbl->u32StAdd + u32Idx*8;
7649
7650 u32EsStart = HAL_MVD_MemRead4Byte(u32EsRp); //report StartAdd as read_pointer
7651 #if 0
7652 MS_U32 u32EsEnd;
7653 u32EsEnd = HAL_MVD_MemRead4Byte(u32EsRp+4);
7654 printf("GetESReadPtr ES[%x] Start=0x%x End=0x%x u32EsRp=%x u32SlqRp=%x\n",
7655 u32Idx, HAL_MVD_MemRead4Byte(u32EsRp), u32EsEnd, u32EsRp, u32SlqRp);
7656 #endif
7657
7658 if ((_IsNotInStreamBuff(u32EsStart)) && (u32EsStart != 0))
7659 { //ESRead is not in BS buffer, so this entry is a divx or dummy pattern.
7660 //Report the last ESRead, instead of this one.
7661 if(curCodecType == E_MVD_CODEC_DIVX311)
7662 {
7663 //update last slq index es end address
7664 if(u32Idx == 0)
7665 {
7666 u32Idx = SLQ_ENTRY_MAX-1;
7667 }
7668 else
7669 {
7670 u32Idx = u32Idx-1;
7671 }
7672 u32EsRp = pstSlqTblInfo->pDrvEsTbl->u32StAdd + u32Idx*8;
7673 u32EsStart = HAL_MVD_MemRead4Byte(u32EsRp); //report StartAdd as read_pointer
7674 if(_IsNotInStreamBuff(u32EsStart))
7675 {
7676 return (pstSlqTblInfo->u32PreEsRd);
7677 }
7678 }
7679 else
7680 {
7681 MVD_DEBUGINFO(printf("0x%lx Not in BS, report u32PreEsRd=0x%lx\n", (unsigned long)u32EsStart, (unsigned long)pstSlqTblInfo->u32PreEsRd));
7682 return (pstSlqTblInfo->u32PreEsRd);
7683 }
7684 }
7685 pstSlqTblInfo->u32PreEsRd = u32EsStart;
7686
7687 return u32EsStart;
7688 }
7689
7690 //------------------------------------------------------------------------------
7691 /// Get write pointer in ElementaryStream buffer for SLQ table mode
7692 /// @return -the read pointer
7693 //------------------------------------------------------------------------------
MVD_GetSlqTblESWritePtr(MS_U8 u8Idx)7694 MS_VIRT MVD_GetSlqTblESWritePtr(MS_U8 u8Idx)
7695 {
7696 MS_VIRT u32EsWp;
7697 MS_VIRT u32EsEnd;
7698 MS_U32 u32Idx;
7699 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
7700 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
7701
7702 if (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr > (pstSlqTblInfo->pDrvSlqTbl->u32StAdd))
7703 {
7704 u32Idx = ((pstSlqTblInfo->pDrvSlqTbl->u32WrPtr - pstSlqTblInfo->pDrvSlqTbl->u32StAdd)/SLQ_ENTRY_LEN) - 1;
7705 }
7706 else
7707 {
7708 u32Idx = SLQ_ENTRY_MAX - 1;
7709 }
7710 u32EsWp = pstSlqTblInfo->pDrvEsTbl->u32StAdd + u32Idx*8;
7711
7712 u32EsEnd = HAL_MVD_MemRead4Byte(u32EsWp+4);
7713 #if 0
7714 printf("GetESWritePtr[%x] ES Start=0x%x End=0x%x u32EsWp=%x\n",
7715 (u32EsWp - pstSlqTblInfo->pDrvEsTbl->u32StAdd)/8,
7716 HAL_MVD_MemRead4Byte(u32EsWp), u32EsEnd, u32EsWp);
7717 #endif
7718
7719 if ((_IsNotInStreamBuff(u32EsEnd)) && (u32EsEnd != 0))
7720 { //ESRead is not in BS buffer, so this entry is a divx pattern.
7721 //Report the last ESRead, instead of this one.
7722 MVD_DEBUGINFO(printf("0x%lx Not in BS, report u32PreEsWr=0x%lx\n", (unsigned long)u32EsEnd, (unsigned long)pstSlqTblInfo->u32PreEsWr));
7723 return (pstSlqTblInfo->u32PreEsWr);
7724 }
7725 pstSlqTblInfo->u32PreEsWr = u32EsEnd;
7726
7727 return u32EsEnd;
7728 }
7729
7730
HAL_MVD_GetSLQReadPtr(MS_U8 u8Idx)7731 MS_VIRT HAL_MVD_GetSLQReadPtr(MS_U8 u8Idx)
7732 {
7733 MS_VIRT u32RdPtr = 0;
7734
7735 if (!(pMVDHalContext->bSlqTblHKCtrl[u8Idx]))
7736 {
7737 #ifndef VDEC3
7738 MVD_CmdArg mvdcmd;
7739 SETUP_CMDARG(mvdcmd);
7740 SET_DECNUM(mvdcmd, u8Idx);
7741 if (HAL_MVD_MVDCommand( CMD_SLQ_GET_TBL_RPTR, &mvdcmd ) == FALSE)
7742 {
7743 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLQ_GET_TBL_RPTR ) );
7744 return 0;
7745 }
7746 u32RdPtr = mvdcmd.Arg0 | (mvdcmd.Arg1<<8) | (mvdcmd.Arg2<<16) | (mvdcmd.Arg3<<24);
7747 #else
7748 u32RdPtr = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SLQ_TBL_RPTR, sizeof(MS_U32));
7749 #endif
7750 }
7751 else
7752 {
7753 u32RdPtr = HAL_MVD_SlqTblProbeRdPtr(u8Idx);
7754 }
7755
7756 //printf("##### HAL_MVD_GetSLQReadPtr 0x%x\n", readPtr);
7757
7758 if(u32RdPtr == 0)//not start decode yet,MVD return 0
7759 {
7760 u32RdPtr = 0;
7761 }
7762 else
7763 {
7764 u32RdPtr = u32RdPtr << 3;
7765 }
7766
7767 return u32RdPtr;
7768 }
7769
7770
HAL_MVD_SetSLQWritePtr(MS_U8 u8Idx,MS_BOOL bCheckData)7771 MS_BOOL HAL_MVD_SetSLQWritePtr(MS_U8 u8Idx, MS_BOOL bCheckData)
7772 {
7773 MVD_CmdArg mvdcmd;
7774 MS_VIRT u32WrPtr;
7775 MVD_MEMCfg* pstMemCfg = HAL_MVD_GetMEMCfg(u8Idx);
7776 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
7777 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
7778
7779 if (FALSE == pstSlqTblInfo->bRdyToFireCmd)
7780 {
7781 //check FW is init success and thus ready to update write pointer
7782 MS_U32 u32TimeCnt;
7783
7784 u32TimeCnt = HAL_MVD_GetTime();
7785 while ((HAL_MVD_GetTime() - u32TimeCnt) < CMD_TIMEOUT_MS)
7786 {
7787 if (HAL_MVD_GetDecodeStatus(u8Idx) != E_MVD_STAT_IDLE)
7788 {
7789 pstSlqTblInfo->bRdyToFireCmd = TRUE;
7790 MVD_DEBUGVERBAL(printf("time=0x%x ms, ", (HAL_MVD_GetTime() - u32TimeCnt)));
7791 break;
7792 }
7793 }
7794 if (FALSE == pstSlqTblInfo->bRdyToFireCmd)
7795 {
7796 MVD_DEBUGERROR(printf("%s: err timeout(%d)! stat=0x%x\n", __FUNCTION__,
7797 HAL_MVD_GetTime() - u32TimeCnt, HAL_MVD_GetDecodeStatus(u8Idx)));
7798 return FALSE;
7799 }
7800 else
7801 {
7802 MVD_DEBUGVERBAL(printf("%s: ready to update WrPtr.\n", __FUNCTION__));
7803 }
7804 }
7805
7806
7807 MS_ASSERT(pstSlqTblInfo->pDrvSlqTbl->u32WrPtr < pstSlqTblInfo->pDrvSlqTbl->u32EndAdd);
7808 MS_ASSERT(pstSlqTblInfo->pDrvSlqTbl->u32WrPtr >= pstSlqTblInfo->pDrvSlqTbl->u32StAdd);
7809 #if SLQ_NEW_PUSH
7810 if((!pstSlqTblInfo->pSlqStatus->bSlqFireRdy)&&pstSlqTblInfo->pSlqStatus->bSlqCtrlBit)
7811 {
7812 MVD_DEBUGINFO(printf("**** pstSlqTblInfo->pSlqStatus->bSlqFireRdy is not Ready ** \n"));
7813 return FALSE;
7814 }
7815 pstSlqTblInfo->pSlqStatus->bSlqFireRdy = FALSE;
7816 #endif
7817 if ((bCheckData==TRUE) && (FALSE==pstSlqTblInfo->bSlqTblHasValidData))
7818 {
7819 MVD_DEBUGINFO(printf("**** SlqWrPtr(0x%lx) is not update!(%x, %x) ****\n",
7820 (unsigned long)pstSlqTblInfo->pDrvSlqTbl->u32WrPtr, bCheckData, pstSlqTblInfo->bSlqTblHasValidData));
7821 return FALSE;
7822 }
7823 pstSlqTblInfo->bSlqTblHasValidData = FALSE;
7824
7825 if (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr != pstSlqTblInfo->pDrvSlqTbl->u32EndAdd)
7826 {
7827 u32WrPtr = pstSlqTblInfo->pDrvSlqTbl->u32WrPtr;
7828 }
7829 else
7830 {
7831 u32WrPtr = pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
7832 }
7833
7834 if (pstCtrlCfg->bSlqTblSync)
7835 {
7836 //Update SLQ table, DivX311 patterns, and dummy patterns to bitstream buffer
7837 MS_VIRT u32SrcOffset = pstSlqTblInfo->pDrvSlqTbl->u32StAdd;
7838 MS_VIRT u32SrcAdd = u32SrcOffset;
7839 MS_VIRT u32DstAdd = pstMemCfg->u32BSAddr;
7840 MS_VIRT u32DstOffset = HAL_MVD_GetMemOffset(pstMemCfg->u32BSAddr);
7841 MS_VIRT u32TblWr;
7842
7843 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32SrcOffset,u32SrcAdd);
7844
7845
7846 HAL_MVD_CPU_Sync();
7847
7848 #ifndef MSOS_TYPE_LINUX_KERNEL//BDMA
7849 BDMA_Result bdmaRlt;
7850
7851 bdmaRlt = MDrv_BDMA_CopyHnd(u32SrcAdd, u32DstAdd, pstMemCfg->u32DrvBufSize, pstSlqTblInfo->bdmaCpyType, BDMA_OPCFG_DEF);
7852
7853 if (E_BDMA_OK != bdmaRlt)
7854 {
7855 MVD_DEBUGERROR(printf("%s MDrv_BDMA_MemCopy fail ret=%x!\n", __FUNCTION__, bdmaRlt));
7856 }
7857 #endif
7858 MVD_DEBUGINFO(printf("SlqWrPtr_BDMA src=0x%lx dst=0x%lx size=0x%lx cpyType=0x%x\n",
7859 (unsigned long)u32SrcAdd, (unsigned long)u32DstAdd, (unsigned long)pstMemCfg->u32DrvBufSize, pstSlqTblInfo->bdmaCpyType));
7860
7861 u32TblWr = u32DstOffset + (u32WrPtr - pstSlqTblInfo->pDrvSlqTbl->u32StAdd);
7862
7863 u32WrPtr = u32TblWr;
7864 }
7865 //printf("wPtr= 0x%x(0x%x) rPtr=0x%x(0x%x)\n", writePtr, pstSlqTblInfo->pDrvSlqTbl->u32WrPtr,
7866 // HAL_MVD_GetSLQReadPtr(u8Idx), pstSlqTblInfo->pDrvSlqTbl->u32RdPtr);
7867
7868
7869 //writePtrLast[u8Idx] = u32WrPtr;
7870 #if SLQ_NEW_PUSH
7871 if(!pstSlqTblInfo->pSlqStatus->bSlqEnLastFrameShow && pstSlqTblInfo->pSlqStatus->bSlqCtrlBit)
7872 {
7873 u32WrPtr = pstSlqTblInfo->pSlqStatus->u32VaildWptrAddr;
7874 }
7875 #endif
7876 MS_ASSERT((u32WrPtr%8)==0);
7877 u32WrPtr >>= 3;
7878
7879 if (!(pMVDHalContext->bSlqTblHKCtrl[u8Idx]))
7880 {
7881 SET_CMDARG(mvdcmd, u32WrPtr, u8Idx);
7882 HAL_MVD_CPU_Sync();
7883 SET_CMD_RET_FALSE(CMD_SLQ_UPDATE_TBL_WPTR, &mvdcmd);
7884 }
7885 else
7886 {
7887 HAL_MVD_SlqTblLoadWrPtr(u8Idx, u32WrPtr);
7888 if (HAL_MVD_SlqTblProbeWrPtr(u8Idx) != u32WrPtr)
7889 {
7890 MVD_DEBUGERROR(printf("Ooops! SlqWrPtr update fail!!! 0x%lx != 0x%lx\n", (unsigned long)HAL_MVD_SlqTblProbeWrPtr(u8Idx), (unsigned long)u32WrPtr));
7891 return FALSE;
7892 }
7893 }
7894
7895 return TRUE;
7896 }
7897
HAL_MVD_SetOverflowTH(MS_U8 u8Idx,MS_U32 u32Threshold)7898 void HAL_MVD_SetOverflowTH(MS_U8 u8Idx, MS_U32 u32Threshold)
7899 {
7900 MVD_CmdArg mvdcmd;
7901
7902 MS_ASSERT((u32Threshold%8)==0);
7903 u32Threshold >>= 3;
7904 SET_CMDARG(mvdcmd, u32Threshold, u8Idx);
7905 if (HAL_MVD_MVDCommand( CMD_DMA_OVFTH, &mvdcmd ) == FALSE)
7906 {
7907 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DMA_OVFTH ) );
7908 return;
7909 }
7910 return;
7911 }
7912
7913 //------------------------------------------------------------------------------
7914 /// Set bitstream buffer underflow threshold
7915 /// @return -none
7916 //------------------------------------------------------------------------------
HAL_MVD_SetUnderflowTH(MS_U8 u8Idx,MS_U32 u32Threshold)7917 void HAL_MVD_SetUnderflowTH(MS_U8 u8Idx, MS_U32 u32Threshold)
7918 {
7919 MVD_CmdArg mvdcmd;
7920
7921 MS_ASSERT((u32Threshold%8)==0);
7922 u32Threshold >>= 3;
7923 SET_CMDARG(mvdcmd, u32Threshold, u8Idx);
7924 if (HAL_MVD_MVDCommand( CMD_DMA_UNFTH, &mvdcmd ) == FALSE)
7925 {
7926 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DMA_UNFTH ) );
7927 return;
7928 }
7929 return;
7930 }
7931
HAL_MVD_GenPattern(MS_U8 u8Idx,MVD_PatternType ePattern,MS_PHY u32PAddr,MS_U32 * pu32Size)7932 MS_BOOL HAL_MVD_GenPattern(MS_U8 u8Idx, MVD_PatternType ePattern, MS_PHY u32PAddr, MS_U32* pu32Size)
7933 {
7934 MS_U8* pu8DummyData = NULL;
7935 MVD_CodecType curCodecType = HAL_MVD_GetCodecType(u8Idx);
7936
7937 if ((!pu32Size) || (*pu32Size < SKIP_PATTERN_SIZE))
7938 {
7939 return FALSE;
7940 }
7941
7942 pu8DummyData = (MS_U8*) HAL_MVD_PA2NonCacheSeg(u32PAddr);
7943
7944 if(pu8DummyData == NULL)
7945 {
7946 printf("%s %d NULL Address\n",__FILE__,__LINE__);
7947 return FALSE;
7948 }
7949
7950 switch (ePattern)
7951 {
7952 case E_MVD_PATTERN_FLUSH:
7953 #if 0
7954 *pu8DummyData = SKIP_PATTERN_0;
7955 pu8DummyData++;
7956 *pu8DummyData = SKIP_PATTERN_1;
7957 *pu32Size = SKIP_PATTERN_SIZE;
7958 #else
7959 pu8DummyData[0] = SKIP_PATTERN_0&0xff;
7960 pu8DummyData[1] = (SKIP_PATTERN_0>>8)&0xff;
7961 pu8DummyData[2] = (SKIP_PATTERN_0>>16)&0xff;
7962 pu8DummyData[3] = (SKIP_PATTERN_0>>24)&0xff;
7963
7964 pu8DummyData[4] = SKIP_PATTERN_1&0xff;
7965 pu8DummyData[5] = (SKIP_PATTERN_1>>8)&0xff;
7966 pu8DummyData[6] = (SKIP_PATTERN_1>>16)&0xff;
7967 pu8DummyData[7] = (SKIP_PATTERN_1>>24)&0xff;
7968
7969 *pu32Size = SKIP_PATTERN_SIZE;
7970 #endif
7971 break;
7972 case E_MVD_PATTERN_FILEEND:
7973 if ((E_MVD_CODEC_FLV == curCodecType)||(E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER == curCodecType))
7974 {
7975 #if 0
7976 *pu8DummyData = FLV_PATTERN;
7977 pu8DummyData++;
7978 *pu8DummyData = 0xffffffff;
7979 pu8DummyData++;
7980 *pu8DummyData = END_PATTERN_1;
7981 pu8DummyData++;
7982 *pu8DummyData = END_PATTERN_2;
7983 pu8DummyData++;
7984 *pu8DummyData = END_PATTERN_3;
7985 #else
7986 pu8DummyData[0] = FLV_PATTERN&0xff;
7987 pu8DummyData[1] = (FLV_PATTERN>>8)&0xff;
7988 pu8DummyData[2] = (FLV_PATTERN>>16)&0xff;
7989 pu8DummyData[3] = (FLV_PATTERN>>24)&0xff;
7990
7991 pu8DummyData[4] = 0xffffffff&0xff;
7992 pu8DummyData[5] = (0xffffffff>>8)&0xff;
7993 pu8DummyData[6] = (0xffffffff>>16)&0xff;
7994 pu8DummyData[7] = (0xffffffff>>24)&0xff;
7995
7996 pu8DummyData[8] = END_PATTERN_1&0xff;
7997 pu8DummyData[9] = (END_PATTERN_1>>8)&0xff;
7998 pu8DummyData[10] = (END_PATTERN_1>>16)&0xff;
7999 pu8DummyData[11] = (END_PATTERN_1>>24)&0xff;
8000
8001 pu8DummyData[12] = END_PATTERN_2&0xff;
8002 pu8DummyData[13] = (END_PATTERN_2>>8)&0xff;
8003 pu8DummyData[14] = (END_PATTERN_2>>16)&0xff;
8004 pu8DummyData[15] = (END_PATTERN_2>>24)&0xff;
8005
8006 pu8DummyData[16] = END_PATTERN_3&0xff;
8007 pu8DummyData[17] = (END_PATTERN_3>>8)&0xff;
8008 pu8DummyData[18] = (END_PATTERN_3>>16)&0xff;
8009 pu8DummyData[19] = (END_PATTERN_3>>24)&0xff;
8010
8011 #endif
8012
8013 }
8014 else if (E_MVD_CODEC_DIVX311 == curCodecType)
8015 {
8016 #if 0
8017 *pu8DummyData = DIVX_PATTERN;
8018 pu8DummyData++;
8019 *pu8DummyData = 0xffffffff;
8020 pu8DummyData++;
8021 *pu8DummyData = END_PATTERN_1;
8022 pu8DummyData++;
8023 *pu8DummyData = END_PATTERN_2;
8024 pu8DummyData++;
8025 *pu8DummyData = END_PATTERN_3;
8026 #else
8027 pu8DummyData[0] = DIVX_PATTERN&0xff;
8028 pu8DummyData[1] = (DIVX_PATTERN>>8)&0xff;
8029 pu8DummyData[2] = (DIVX_PATTERN>>16)&0xff;
8030 pu8DummyData[3] = (DIVX_PATTERN>>24)&0xff;
8031
8032 pu8DummyData[4] = 0xffffffff&0xff;
8033 pu8DummyData[5] = (0xffffffff>>8)&0xff;
8034 pu8DummyData[6] = (0xffffffff>>16)&0xff;
8035 pu8DummyData[7] = (0xffffffff>>24)&0xff;
8036
8037 pu8DummyData[8] = END_PATTERN_1&0xff;
8038 pu8DummyData[9] = (END_PATTERN_1>>8)&0xff;
8039 pu8DummyData[10] = (END_PATTERN_1>>16)&0xff;
8040 pu8DummyData[11] = (END_PATTERN_1>>24)&0xff;
8041
8042 pu8DummyData[12] = END_PATTERN_2&0xff;
8043 pu8DummyData[13] = (END_PATTERN_2>>8)&0xff;
8044 pu8DummyData[14] = (END_PATTERN_2>>16)&0xff;
8045 pu8DummyData[15] = (END_PATTERN_2>>24)&0xff;
8046
8047 pu8DummyData[16] = END_PATTERN_3&0xff;
8048 pu8DummyData[17] = (END_PATTERN_3>>8)&0xff;
8049 pu8DummyData[18] = (END_PATTERN_3>>16)&0xff;
8050 pu8DummyData[19] = (END_PATTERN_3>>24)&0xff;
8051 #endif
8052 }
8053 else if ((E_MVD_CODEC_MPEG2 == curCodecType)||(E_MVD_CODEC_MPEG4 == curCodecType))
8054 {
8055 #if 0
8056 *pu8DummyData = MPEG_PATTERN_0;
8057 pu8DummyData++;
8058 *pu8DummyData = END_PATTERN_1;
8059 pu8DummyData++;
8060 *pu8DummyData = END_PATTERN_2;
8061 pu8DummyData++;
8062 *pu8DummyData = END_PATTERN_3;
8063 #else
8064 pu8DummyData[0] = MPEG_PATTERN_0&0xff;
8065 pu8DummyData[1] = (MPEG_PATTERN_0>>8)&0xff;
8066 pu8DummyData[2] = (MPEG_PATTERN_0>>16)&0xff;
8067 pu8DummyData[3] = (MPEG_PATTERN_0>>24)&0xff;
8068
8069 pu8DummyData[4] = END_PATTERN_1&0xff;
8070 pu8DummyData[5] = (END_PATTERN_1>>8)&0xff;
8071 pu8DummyData[6] = (END_PATTERN_1>>16)&0xff;
8072 pu8DummyData[7] = (END_PATTERN_1>>24)&0xff;
8073
8074 pu8DummyData[8] = END_PATTERN_2&0xff;
8075 pu8DummyData[9] = (END_PATTERN_2>>8)&0xff;
8076 pu8DummyData[10] = (END_PATTERN_2>>16)&0xff;
8077 pu8DummyData[11] = (END_PATTERN_2>>24)&0xff;
8078
8079 pu8DummyData[12] = END_PATTERN_3&0xff;
8080 pu8DummyData[13] = (END_PATTERN_3>>8)&0xff;
8081 pu8DummyData[14] = (END_PATTERN_3>>16)&0xff;
8082 pu8DummyData[15] = (END_PATTERN_3>>24)&0xff;
8083 #endif
8084 }
8085 else
8086 {
8087 #if 0
8088 *pu8DummyData = END_PATTERN_0;
8089 pu8DummyData++;
8090 *pu8DummyData = END_PATTERN_1;
8091 pu8DummyData++;
8092 *pu8DummyData = END_PATTERN_2;
8093 pu8DummyData++;
8094 *pu8DummyData = END_PATTERN_3;
8095 #else
8096 pu8DummyData[0] = END_PATTERN_0&0xff;
8097 pu8DummyData[1] = (END_PATTERN_0>>8)&0xff;
8098 pu8DummyData[2] = (END_PATTERN_0>>16)&0xff;
8099 pu8DummyData[3] = (END_PATTERN_0>>24)&0xff;
8100
8101 pu8DummyData[4] = END_PATTERN_1&0xff;
8102 pu8DummyData[5] = (END_PATTERN_1>>8)&0xff;
8103 pu8DummyData[6] = (END_PATTERN_1>>16)&0xff;
8104 pu8DummyData[7] = (END_PATTERN_1>>24)&0xff;
8105
8106 pu8DummyData[8] = END_PATTERN_2&0xff;
8107 pu8DummyData[9] = (END_PATTERN_2>>8)&0xff;
8108 pu8DummyData[10] = (END_PATTERN_2>>16)&0xff;
8109 pu8DummyData[11] = (END_PATTERN_2>>24)&0xff;
8110
8111 pu8DummyData[12] = END_PATTERN_3&0xff;
8112 pu8DummyData[13] = (END_PATTERN_3>>8)&0xff;
8113 pu8DummyData[14] = (END_PATTERN_3>>16)&0xff;
8114 pu8DummyData[15] = (END_PATTERN_3>>24)&0xff;
8115 #endif
8116 }
8117 *pu32Size = 16;
8118 break;
8119 default:
8120 break;
8121 }
8122
8123 return TRUE;
8124 }
8125
8126
8127
HAL_MVD_DbgDump(MS_U8 u8Idx)8128 void HAL_MVD_DbgDump(MS_U8 u8Idx)
8129 {
8130 MS_U32 u32VdCnt=0;
8131 //static MS_U32 u32PreVdCnt[MAX_DEC_NUM]= {0, 0};
8132 MS_U32 u32ErrCnt=0;
8133 //static MS_U32 u32PreErrCnt[MAX_DEC_NUM]= {0, 0};
8134 //static MS_BOOL b1stDump[MAX_DEC_NUM]= {TRUE, TRUE};
8135 MVD_FrmInfo stFrm = {_INIT_ADDR, _INIT_ADDR, _INIT_TIMESTAMP, _INIT_ID,
8136 _INIT_ID, _INIT_LEN, _INIT_LEN, _INIT_LEN, 0xff, E_MVD_PIC_UNKNOWN};
8137 MVD_SrcMode curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
8138 #ifndef VDEC3
8139 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
8140 #endif
8141 if (pMVDHalContext->b1stDump[u8Idx])
8142 {
8143 MVD_FWCfg* pFwCfg = NULL;
8144 pFwCfg = HAL_MVD_GetFWCfg(u8Idx);
8145 printf("curDisablePESParsing = %d\n", pFwCfg->bDisablePESParsing);
8146 pMVDHalContext->b1stDump[u8Idx] = FALSE;
8147 }
8148
8149 u32VdCnt = HAL_MVD_GetParserByteCnt(u8Idx);
8150 u32ErrCnt= HAL_MVD_GetVldErrCount(u8Idx);
8151 printf("input: vfifo=%d(full=%d,empty=%d), vdCnt=%d(%d), vldErr=%d(%d); ",
8152 HAL_MVD_RegReadByte(0x1564)>>6, HAL_MVD_RegReadByte(0x1564)&0x20,
8153 HAL_MVD_RegReadByte(0x1564)&0x10, u32VdCnt, (u32VdCnt-pMVDHalContext->u32PreVdCnt[u8Idx]),
8154 u32ErrCnt, (u32ErrCnt-pMVDHalContext->u32PreErrCnt[u8Idx]));
8155 pMVDHalContext->u32PreVdCnt[u8Idx] = u32VdCnt;
8156 pMVDHalContext->u32PreErrCnt[u8Idx] = u32ErrCnt;
8157
8158 printf("state: fw=0x%x, lastCmd=0x%x, pc=0x%x\n",
8159 HAL_MVD_GetDecodeStatus(u8Idx), HAL_MVD_GetLastCmd(u8Idx), HAL_VPU_EX_GetProgCnt());
8160 printf("cnt: dec=%d, skip=%d, drop=%ld\n", HAL_MVD_GetPicCounter(u8Idx), HAL_MVD_GetSkipPicCounter(u8Idx), 0x0UL);
8161 HAL_MVD_GetFrmInfo(u8Idx, E_MVD_FRMINFO_DECODE, &stFrm);
8162 printf("frm Dec Y=%lx UV=%lx Pitch=%x; ", (unsigned long)stFrm.u32LumaAddr, (unsigned long)stFrm.u32ChromaAddr, stFrm.u16Pitch);
8163 HAL_MVD_GetFrmInfo(u8Idx, E_MVD_FRMINFO_DISPLAY, &stFrm);
8164 printf("Disp Y=%lx UV=%lx Pitch=%x\n", (unsigned long)stFrm.u32LumaAddr, (unsigned long)stFrm.u32ChromaAddr, stFrm.u16Pitch);
8165 if (curSrcMode == E_MVD_SLQ_TBL_MODE)
8166 {
8167 #ifndef VDEC3
8168 printf("fe=%x, rd=%x(%x), wr=%x, empty=%x; ", pstSlqTblInfo->u32FileEndPtr, pstSlqTblInfo->pDrvSlqTbl->u32RdPtr,
8169 HAL_MVD_Map2DrvSlqTbl(u8Idx, HAL_MVD_GetSLQReadPtr(u8Idx)), pstSlqTblInfo->pDrvSlqTbl->u32WrPtr, pstSlqTblInfo->pDrvSlqTbl->u32Empty);
8170
8171 printf("es rd=0x%lx, wr=0x%lx\n", (unsigned long)MVD_GetSlqTblESReadPtr(u8Idx), (unsigned long)MVD_GetSlqTblESWritePtr(u8Idx));
8172 #endif
8173 }
8174 else if (curSrcMode == E_MVD_TS_FILE_MODE)
8175 {
8176 printf("es rd=0x%lx, wr=0x%lx\n", (unsigned long)HAL_MVD_GetTsFileESReadPtr(u8Idx), (unsigned long)HAL_MVD_GetTsFileESWritePtr(u8Idx));
8177 }
8178 }
8179
8180 #ifdef MS_DEBUG
8181 #define _STRINGIFY_HAL_SID(x) \
8182 (x==E_HAL_MVD_MAIN_STREAM0)?"E_HAL_MVD_MAIN_STREAM0": \
8183 ((x==E_HAL_MVD_SUB_STREAM0)?"E_HAL_MVD_SUB_STREAM0":"E_HAL_MVD_STREAM_NONE")
MVD_DumpMVDStream(void)8184 void MVD_DumpMVDStream(void)
8185 {
8186 //if (_u8HalDbgLevel == 0) return;
8187 MS_U8 i = 0;
8188 for (i=0; i< MAX_DEC_NUM; i++)
8189 {
8190 MVD_DEBUGINFO(printf("[%d] eStreamId=0x%x(%s) bUsed=0x%x\n", i, pMVDHalContext->_stMVDStream[i].eStreamId,
8191 _STRINGIFY_HAL_SID(pMVDHalContext->_stMVDStream[i].eStreamId), pMVDHalContext->_stMVDStream[i].bUsed));
8192 }
8193 }
8194 #endif
HAL_MVD_Init_Share_Mem(void)8195 MS_BOOL HAL_MVD_Init_Share_Mem(void)
8196 {
8197 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS) || defined(MSOS_TYPE_LINUX_KERNEL))
8198 #if !defined(SUPPORT_X_MODEL_FEATURE)
8199 MS_U32 u32ShmId;
8200 MS_VIRT u32Addr;
8201 MS_U32 u32BufSize;
8202
8203
8204 if (FALSE == MsOS_SHM_GetId( (MS_U8*)"Linux MVD HAL",
8205 sizeof(MVD_Hal_CTX),
8206 &u32ShmId,
8207 &u32Addr,
8208 &u32BufSize,
8209 MSOS_SHM_QUERY))
8210 {
8211 if (FALSE == MsOS_SHM_GetId((MS_U8*)"Linux MVD HAL",
8212 sizeof(MVD_Hal_CTX),
8213 &u32ShmId,
8214 &u32Addr,
8215 &u32BufSize,
8216 MSOS_SHM_CREATE))
8217 {
8218 printf("[%s]SHM allocation failed!!! use global structure instead!!!\n",__FUNCTION__);
8219 if(pMVDHalContext == NULL)
8220 {
8221 pMVDHalContext = &gMVDHalContext;
8222 memset(pMVDHalContext,0,sizeof(MVD_Hal_CTX));
8223 HAL_MVD_Context_Init();
8224 printf("[%s]Global structure init Success!!!\n",__FUNCTION__);
8225 }
8226 else
8227 {
8228 printf("[%s]Global structure exists!!!\n",__FUNCTION__);
8229 }
8230 //return FALSE;
8231 }
8232 else
8233 {
8234 memset((MS_U8*)u32Addr,0,sizeof(MVD_Hal_CTX));
8235 pMVDHalContext = (MVD_Hal_CTX*)u32Addr; // for one process
8236 HAL_MVD_Context_Init();
8237 }
8238 }
8239 else
8240 {
8241 pMVDHalContext = (MVD_Hal_CTX*)u32Addr; // for another process
8242 }
8243 #else
8244 if(pMVDHalContext == NULL)
8245 {
8246 pMVDHalContext = &gMVDHalContext;
8247 memset(pMVDHalContext,0,sizeof(MVD_Hal_CTX));
8248 HAL_MVD_Context_Init();
8249 }
8250 #endif
8251 OSAL_MVD_MutexInit();
8252 #else
8253 if(pMVDHalContext == NULL)
8254 {
8255 pMVDHalContext = &gMVDHalContext;
8256 memset(pMVDHalContext,0,sizeof(MVD_Hal_CTX));
8257 HAL_MVD_Context_Init();
8258 }
8259 #endif
8260
8261
8262 return TRUE;
8263
8264 }
8265
8266 //------------------------------------------------------------------------------
HAL_MVD_GetFreeStream(HAL_MVD_StreamType eStreamType)8267 HAL_MVD_StreamId HAL_MVD_GetFreeStream(HAL_MVD_StreamType eStreamType)
8268 {
8269 MS_U32 i = 0;
8270
8271 #ifdef MS_DEBUG
8272 MVD_DumpMVDStream();
8273 #endif
8274 if (eStreamType == E_HAL_MVD_MAIN_STREAM)
8275 {
8276 for (i = 0;
8277 i <
8278 ((E_HAL_MVD_MAIN_STREAM_MAX - E_HAL_MVD_MAIN_STREAM_BASE) +
8279 (E_HAL_MVD_SUB_STREAM_MAX - E_HAL_MVD_SUB_STREAM_BASE)); i++)
8280 {
8281 if ((E_HAL_MVD_MAIN_STREAM_BASE & pMVDHalContext->_stMVDStream[i].eStreamId) && (FALSE == pMVDHalContext->_stMVDStream[i].bUsed))
8282 {
8283 return pMVDHalContext->_stMVDStream[i].eStreamId;
8284 }
8285 }
8286 }
8287 else if (eStreamType == E_HAL_MVD_SUB_STREAM)
8288 {
8289 for (i = 0;
8290 i <
8291 ((E_HAL_MVD_MAIN_STREAM_MAX - E_HAL_MVD_MAIN_STREAM_BASE) +
8292 (E_HAL_MVD_SUB_STREAM_MAX - E_HAL_MVD_SUB_STREAM_BASE)); i++)
8293 {
8294 if ((E_HAL_MVD_SUB_STREAM_BASE & pMVDHalContext->_stMVDStream[i].eStreamId) && (FALSE == pMVDHalContext->_stMVDStream[i].bUsed))
8295 {
8296 return pMVDHalContext->_stMVDStream[i].eStreamId;
8297 }
8298 }
8299 }
8300 #ifdef VDEC3
8301 else if ((eStreamType >= E_HAL_MVD_N_STREAM) && (eStreamType < E_HAL_MVD_N_STREAM + MAX_DEC_NUM))
8302 {
8303 i = eStreamType - E_HAL_MVD_N_STREAM;
8304 if (!pMVDHalContext->_stMVDStream[i].bUsed)
8305 {
8306 return pMVDHalContext->_stMVDStream[i].eStreamId;
8307 }
8308 }
8309 #endif
8310
8311 return E_HAL_MVD_STREAM_NONE;
8312 }
8313
HAL_MVD_SidToIdx(HAL_MVD_StreamId eSID)8314 MS_U8 HAL_MVD_SidToIdx(HAL_MVD_StreamId eSID)
8315 {
8316 #ifdef VDEC3
8317 return eSID - E_HAL_MVD_N_STREAM_BASE;
8318 #else
8319 MS_U8 u8Idx = 0;
8320 switch (eSID)
8321 {
8322 case E_HAL_MVD_MAIN_STREAM0:
8323 u8Idx = 0;
8324 break;
8325 case E_HAL_MVD_SUB_STREAM0:
8326 u8Idx = 1;
8327 break;
8328 #if 0
8329 case E_HAL_MVD_SUB_STREAM1:
8330 u8Idx = 2;
8331 break;
8332 #endif
8333 default:
8334 u8Idx = 0;
8335 break;
8336 }
8337 return u8Idx;
8338 #endif
8339 }
8340
HAL_MVD_ReleaseFdMask(MS_U8 u8Idx,MS_BOOL bRls)8341 MS_BOOL HAL_MVD_ReleaseFdMask(MS_U8 u8Idx, MS_BOOL bRls)
8342 {
8343 MVD_CmdArg mvdcmd;
8344
8345 SETUP_CMDARG(mvdcmd);
8346 mvdcmd.Arg0 = bRls; //1 to release the fd mask
8347 MVD_DEBUGINFO(printf("%s: release=0x%x\n", __FUNCTION__, bRls));
8348 SET_DECNUM(mvdcmd, u8Idx);
8349 SET_CMD_RET_FALSE(CMD_UPDATE_FRAME, &mvdcmd);
8350
8351 return TRUE;
8352 }
8353
HAL_MVD_ParserRstDone(MS_U8 u8Idx,MS_BOOL bEnable)8354 MS_BOOL HAL_MVD_ParserRstDone(MS_U8 u8Idx, MS_BOOL bEnable)
8355 {
8356 #define PARSER_RST_TIMEOUT 0x40000
8357 MS_U32 u32TimeOut = 0;
8358 MVD_CmdArg mvdcmd;
8359
8360 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_PARSER_RST);
8361 SETUP_CMDARG(mvdcmd);
8362 mvdcmd.Arg1 = bEnable;
8363 SET_DECNUM(mvdcmd, u8Idx);
8364 SET_CMD_RET_FALSE(CMD_PTS_TBL_RESET, &mvdcmd);
8365
8366 while ((TRUE != HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_PARSER_RST)) && (u32TimeOut < PARSER_RST_TIMEOUT))
8367 {
8368 u32TimeOut++;
8369 }
8370 if (u32TimeOut >= PARSER_RST_TIMEOUT)
8371 {
8372 MVD_DEBUGERROR( printf( "Ctrl: 0x%x fail timeout!!\r\n", CMD_PTS_TBL_RESET ) );
8373 return FALSE;
8374 }
8375 return TRUE;
8376 }
8377
HAL_MVD_FlushPTSBuf(MS_U8 u8Idx,MS_BOOL bEnable)8378 MS_BOOL HAL_MVD_FlushPTSBuf(MS_U8 u8Idx, MS_BOOL bEnable)
8379 {
8380 #ifdef VDEC3
8381 MVD_CtrlCfg* pstCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
8382
8383 if(pstCtrlCfg->u8McuMode == FALSE)
8384 #endif
8385 {
8386 MVD_CmdArg mvdcmd;
8387 SETUP_CMDARG(mvdcmd);
8388 mvdcmd.Arg0 = bEnable;
8389 if (HAL_MVD_MVDCommand( CMD_SEND_UNI_PTS, &mvdcmd ) == FALSE)
8390 {
8391 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SEND_UNI_PTS ) );
8392 return FALSE;
8393 }
8394 }
8395 return TRUE;
8396 }
8397
8398
HAL_MVD_GetSLQNum(MS_U8 u8Idx)8399 MS_U32 HAL_MVD_GetSLQNum(MS_U8 u8Idx)
8400 {
8401 MVD_SLQTBLInfo* pstSlqTblInfo = HAL_MVD_GetSlqTblInfo(u8Idx);
8402 MS_VIRT u32RdPtr = HAL_MVD_GetSLQReadPtr(u8Idx);
8403 MS_VIRT u32Diff = 0;
8404
8405 if (pstSlqTblInfo->pDrvSlqTbl->u32WrPtr >= u32RdPtr)
8406 {
8407 u32Diff = pstSlqTblInfo->pDrvSlqTbl->u32WrPtr - u32RdPtr;
8408 }
8409 else
8410 {
8411 u32Diff = SLQ_TBL_SIZE - (u32RdPtr - pstSlqTblInfo->pDrvSlqTbl->u32WrPtr);
8412 }
8413
8414 // printf("slq wptr = 0x%x, rptr = 0x%x\n", pstSlqTblInfo->pDrvSlqTbl->u32WrPtr, u32RdPtr);
8415
8416 return (u32Diff/SLQ_ENTRY_LEN);
8417 }
8418
8419
HAL_MVD_GetDispQNum(MS_U8 u8Idx)8420 MS_U32 HAL_MVD_GetDispQNum(MS_U8 u8Idx)
8421 {
8422 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DISPQ_NUM, sizeof(MS_U8));
8423 }
HAL_MVD_SetAutoMute(MS_U8 u8Idx,MS_BOOL bEn)8424 MS_BOOL HAL_MVD_SetAutoMute(MS_U8 u8Idx, MS_BOOL bEn)
8425 {
8426 MVD_CmdArg mvdcmd;
8427
8428 SETUP_CMDARG(mvdcmd);
8429 mvdcmd.Arg0 = bEn; //1 to enable
8430 MVD_DEBUGINFO(printf("%s: bEn=%x\n", __FUNCTION__, bEn));
8431 SET_DECNUM(mvdcmd, u8Idx);
8432 SET_CMD_RET_FALSE(CMD_ENABLE_AUTO_MUTE, &mvdcmd);
8433
8434 return TRUE;
8435 }
8436
HAL_MVD_SetVSizeAlign(MS_U8 u8Idx,MS_BOOL bEn)8437 MS_BOOL HAL_MVD_SetVSizeAlign(MS_U8 u8Idx, MS_BOOL bEn)
8438 {
8439 MVD_CmdArg mvdcmd;
8440
8441 SETUP_CMDARG(mvdcmd);
8442 mvdcmd.Arg0 = bEn; //1 to enable VSize alignment to 4x
8443 MVD_DEBUGINFO(printf("%s: bEn=%x\n", __FUNCTION__, bEn));
8444 SET_DECNUM(mvdcmd, u8Idx);
8445 SET_CMD_RET_FALSE(CMD_FORCE_ALIGN_VSIZE, &mvdcmd);
8446
8447 return TRUE;
8448 }
8449
HAL_MVD_GetFrmRateIsSupported(MS_U16 u16HSize,MS_U16 u16VSize,MS_U32 u32FrmRate)8450 MS_BOOL HAL_MVD_GetFrmRateIsSupported(MS_U16 u16HSize, MS_U16 u16VSize, MS_U32 u32FrmRate)
8451 {
8452 MVD_DEBUGINFO(printf("%s w:%d, h:%d, fr:%d, MAX:%lld\n", __FUNCTION__, u16HSize, u16VSize, u32FrmRate, MVD_HW_MAX_PIXEL));
8453 return (((MS_U64)u16HSize*(MS_U64)u16VSize*(MS_U64)u32FrmRate) <= MVD_HW_MAX_PIXEL);
8454 }
8455
HAL_MVD_GetColorInfo(MS_U8 u8Idx,MVD_Color_Info * pstColorInfo)8456 MS_BOOL HAL_MVD_GetColorInfo(MS_U8 u8Idx, MVD_Color_Info* pstColorInfo)
8457 {
8458 MS_VIRT pu8MVDGetFrameInfoBufStart = GET_FRMINFO_BUFFADD(u8Idx);
8459
8460 if((pu8MVDGetFrameInfoBufStart==0) || (pstColorInfo==0))
8461 {
8462 MVD_DEBUGERROR(printf("HAL_MVD_GetColorInfo error: pu8MVDGetFrameInfoBufStart=NULL\n"));
8463 return FALSE;
8464 }
8465
8466 pstColorInfo->bColor_Descript = (MS_BOOL)(HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_COLOR_DESCRIPT));
8467
8468 if(pstColorInfo->bColor_Descript)
8469 {
8470 pstColorInfo->u8Color_Primaries = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_COLOR_PRIMARIES);
8471 pstColorInfo->u8Transfer_Char = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_TRANSFER_CHAR);
8472 pstColorInfo->u8Matrix_Coef = HAL_MVD_MemReadByte(pu8MVDGetFrameInfoBufStart+OFFSET_MATRIX_COEF);
8473 }
8474 return TRUE;
8475
8476 }
8477
8478
8479 //------------------------------------------------------------------------------
8480 /// Wait MVD generate CRC done or timeout
8481 /// @return -MVD generate CRC done or timeout
8482 //------------------------------------------------------------------------------
_HAL_MVD_CrcTimeOut(MS_U8 u8Idx)8483 MS_BOOL _HAL_MVD_CrcTimeOut(MS_U8 u8Idx)
8484 {
8485 MS_U32 i;
8486 MS_U32 u32StartTime = MsOS_GetSystemTime();
8487
8488 for ( i = 0; i < MVD_PollingTimes; i++ )
8489 {
8490 ///- wait until MVD generate CRC done or timeout
8491 if ( ( HAL_MVD_RegReadByte(MVD_CRC_CTL) & MVD_CRC_CTL_DONE ) == MVD_CRC_CTL_DONE )
8492 {
8493 return FALSE;
8494 }
8495
8496 if ((TRUE == pMVDHalContext->bStopped[u8Idx]) || ((MsOS_GetSystemTime()-u32StartTime)>1300))
8497 {
8498 MVD_DEBUGINFO(printf("%s: bStopped(%x) or timeout(%d)\n", __FUNCTION__, pMVDHalContext->bStopped[u8Idx], MsOS_GetSystemTime()-u32StartTime));
8499 return TRUE;
8500 }
8501
8502 }
8503 MVD_DEBUGERROR( printf("_HAL_MVD_CrcTimeOut=%x\n", i) );
8504 return TRUE;
8505 }
8506
HAL_MVD_GetCrcValue(MS_U8 u8Idx,MVD_CrcIn * pCrcIn,MVD_CrcOut * pCrcOut)8507 E_MVD_Result HAL_MVD_GetCrcValue(MS_U8 u8Idx, MVD_CrcIn *pCrcIn, MVD_CrcOut *pCrcOut)
8508 {
8509 E_MVD_Result eRet = E_MVD_RET_OK;
8510 MS_U32 u32tmp = 0;
8511
8512 OSAL_MVD_LockHwMutex();
8513
8514 MVD_DEBUGINFO(printf("%s width=0x%x, height=0x%x, pitch=0x%x, luma=0x%lx, chroma=0x%lx\n",
8515 __FUNCTION__, pCrcIn->u32HSize, pCrcIn->u32VSize, pCrcIn->u32Strip, (unsigned long)pCrcIn->u32YStartAddr, (unsigned long)pCrcIn->u32UVStartAddr));
8516
8517 //Set generate CRC value
8518 u32tmp = ((pCrcIn->u32HSize + MVD_WIDTH_ALIGN_MASK) >> MVD_WIDTH_ALIGN_BITS) << MVD_WIDTH_ALIGN_BITS;
8519 HAL_MVD_RegWriteByte(MVD_CRC_HSIZE, u32tmp & 0xf0);
8520 HAL_MVD_RegWriteByte(MVD_CRC_HSIZE+1, (u32tmp >> 8) & 0x3f);
8521
8522 u32tmp = ((pCrcIn->u32VSize + MVD_WIDTH_ALIGN_MASK) >> MVD_WIDTH_ALIGN_BITS) << MVD_WIDTH_ALIGN_BITS;
8523 HAL_MVD_RegWriteByte(MVD_CRC_VSIZE, u32tmp & 0xff);
8524 HAL_MVD_RegWriteByte(MVD_CRC_VSIZE+1, (u32tmp >> 8) & 0xff);
8525
8526 u32tmp = (pCrcIn->u32Strip) >> 3;
8527 HAL_MVD_RegWriteByte(MVD_CRC_STRIP, u32tmp & 0xff);
8528 HAL_MVD_RegWriteByte((MVD_CRC_STRIP+1), (u32tmp >> 8) & 0xff);
8529
8530 u32tmp = (pCrcIn->u32YStartAddr) >> 3;
8531 HAL_MVD_RegWrite4Byte(MVD_CRC_Y_START, u32tmp & MVD_CRC_Y_START_LEN);
8532
8533 u32tmp = (pCrcIn->u32UVStartAddr) >> 3;
8534 HAL_MVD_RegWrite4Byte(MVD_CRC_UV_START, u32tmp & MVD_CRC_UV_START_LEN);
8535
8536 //Fire
8537 HAL_MVD_RegWriteBit(MVD_CRC_CTL, 1, MVD_CRC_CTL_FIRE);
8538
8539 //Check CRC done
8540 if ( _HAL_MVD_CrcTimeOut(u8Idx) == TRUE )
8541 {
8542 eRet = E_MVD_RET_TIME_OUT;
8543 goto _CRC_DONE;
8544 }
8545
8546 //Get CRC value
8547 pCrcOut->u32YCrc = HAL_MVD_RegReadByte(MVD_CRC_Y_L) |
8548 (HAL_MVD_RegReadByte(MVD_CRC_Y_L+1) << 8) |
8549 (HAL_MVD_RegReadByte(MVD_CRC_Y_H) <<16) |
8550 (HAL_MVD_RegReadByte(MVD_CRC_Y_H+1) <<24);
8551
8552 pCrcOut->u32UVCrc = HAL_MVD_RegReadByte(MVD_CRC_UV_L) |
8553 (HAL_MVD_RegReadByte(MVD_CRC_UV_L+1) << 8) |
8554 (HAL_MVD_RegReadByte(MVD_CRC_UV_H) <<16) |
8555 (HAL_MVD_RegReadByte(MVD_CRC_UV_H+1) <<24);
8556
8557 MVD_DEBUGINFO(printf("%s Y=0x%x, UV=0x%x\n", __FUNCTION__, pCrcOut->u32YCrc, pCrcOut->u32UVCrc));
8558
8559 _CRC_DONE:
8560 OSAL_MVD_UnlockHwMutex();
8561 return eRet;
8562 }
8563
8564
HAL_MVD_SuspendDynamicScale(MS_U8 u8Idx,MS_BOOL bEn)8565 MS_BOOL HAL_MVD_SuspendDynamicScale(MS_U8 u8Idx, MS_BOOL bEn)
8566 {
8567 MVD_CmdArg mvdcmd;
8568
8569 SETUP_CMDARG(mvdcmd);
8570 mvdcmd.Arg0 = bEn;
8571 MVD_DEBUGINFO(printf("%s: bEn=%x\n", __FUNCTION__, bEn));
8572 SET_DECNUM(mvdcmd, u8Idx);
8573 SET_CMD_RET_FALSE(CMD_SUSPEND_DS, &mvdcmd);
8574
8575 return TRUE;
8576 }
8577
HAL_MVD_GetSuspendDynamicScale(MS_U8 u8Idx)8578 MS_U8 HAL_MVD_GetSuspendDynamicScale(MS_U8 u8Idx)
8579 {
8580 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_SUSPEND_DS, sizeof(MS_U8));
8581 }
8582
HAL_MVD_GetStereoType(MS_U8 u8Idx)8583 MS_U8 HAL_MVD_GetStereoType(MS_U8 u8Idx)
8584 {
8585 return (MS_U8)MVD_GetFWBuffData(u8Idx, FW_BUFF_VOLINFO, OFFSET_STEREO_TYPE, sizeof(MS_U8));
8586 }
8587
HAL_MVD_GetDivxVer(MS_U8 u8Idx)8588 MS_U32 HAL_MVD_GetDivxVer(MS_U8 u8Idx)
8589 {
8590 return MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DIVX_VER_5X, sizeof(MS_U32));
8591 }
8592
HAL_MVD_SetIdctMode(MS_U8 u8Idx,MS_U8 u8Mode)8593 MS_BOOL HAL_MVD_SetIdctMode(MS_U8 u8Idx, MS_U8 u8Mode)
8594 {
8595 MVD_CmdArg mvdcmd;
8596
8597 SETUP_CMDARG(mvdcmd);
8598 mvdcmd.Arg0 = u8Mode;
8599 SET_DECNUM(mvdcmd, u8Idx);
8600
8601 MVD_DEBUGINFO(printf("%s CMD_IDCT_SEL arg0=%x)\n", __FUNCTION__, u8Mode));
8602 SET_CMD_RET_FALSE(CMD_IDCT_SEL, &mvdcmd);
8603
8604 return TRUE;
8605 }
8606
HAL_MVD_EX_SetClockSpeed(HAL_MVD_EX_ClockSpeed eClockSpeed)8607 E_MVD_Result HAL_MVD_EX_SetClockSpeed(HAL_MVD_EX_ClockSpeed eClockSpeed)
8608 {
8609 UNUSED(eClockSpeed);
8610 printf("This chip does not support mvd clock presetting~\n");
8611 return E_MVD_RET_FAIL;
8612 }
8613
HAL_MVD_GetIsAVSyncOn(MS_U8 u8Idx)8614 MS_BOOL HAL_MVD_GetIsAVSyncOn(MS_U8 u8Idx)
8615 {
8616 MS_BOOL bAVSyncOn = FALSE;
8617 MVD_CtrlCfg* pCtrlCfg = HAL_MVD_GetCtrlCfg(u8Idx);
8618 if (pCtrlCfg)
8619 {
8620 bAVSyncOn = pCtrlCfg->bAVSyncOn;
8621 }
8622
8623 return bAVSyncOn;
8624 }
8625
HAL_MVD_SetExternalDSBuff(MS_U8 u8Idx,MS_VIRT u32VPUAddr,MS_VIRT u32DrvAddr)8626 MS_BOOL HAL_MVD_SetExternalDSBuff(MS_U8 u8Idx, MS_VIRT u32VPUAddr, MS_VIRT u32DrvAddr)
8627 {
8628 MS_BOOL bRet = TRUE;
8629 MVD_FWBuff* pBuff = &(pMVDHalContext->stFWBuff[u8Idx]);
8630
8631 pBuff->u32DynScalingAdd = u32DrvAddr;
8632 bRet = HAL_MVD_SetDynamicScaleAddr(u8Idx, u32VPUAddr);
8633 return bRet;
8634 }
8635
HAL_MVD_ShowFirstFrameDirect(MS_U8 u8Idx,MS_U8 bEnable)8636 MS_BOOL HAL_MVD_ShowFirstFrameDirect(MS_U8 u8Idx, MS_U8 bEnable)
8637 {
8638 MVD_CmdArg mvdcmd;
8639
8640 SETUP_CMDARG(mvdcmd);
8641 mvdcmd.Arg0 = bEnable;
8642 SET_DECNUM(mvdcmd, u8Idx);
8643
8644 MVD_DEBUGINFO(printf("%s CMD_PUSH_FIRST_FRAME_DISP arg0=%x)\n", __FUNCTION__, bEnable));
8645 SET_CMD_RET_FALSE(CMD_PUSH_FIRST_FRAME_DISP, &mvdcmd);
8646
8647 return TRUE;
8648 }
8649
HAL_MVD_SetXCLowDelayPara(MS_U8 u8Idx,MS_U32 u32Para)8650 E_MVD_Result HAL_MVD_SetXCLowDelayPara(MS_U8 u8Idx,MS_U32 u32Para)
8651 {
8652 MVD_CmdArg mvdcmd;
8653
8654 SETUP_CMDARG(mvdcmd);
8655 mvdcmd.Arg0 = L_WORD(u32Para); // for set the XC diff_field_number
8656 mvdcmd.Arg1 = H_WORD(u32Para); // for set XC UCNR diff field no
8657 SET_DECNUM(mvdcmd, u8Idx);
8658
8659 SET_CMD_RET_FALSE(CMD_XC_LOW_DELAY_PARA, &mvdcmd);
8660
8661 return TRUE;
8662 }
8663
HAL_MVD_GetESBufferStatus(MS_U8 u8Idx)8664 MS_U8 HAL_MVD_GetESBufferStatus(MS_U8 u8Idx)
8665 {
8666 return (MS_U8)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_CURRENT_ES_BUFFER_STATUS, sizeof(MS_U8)));
8667 }
8668
HAL_MVD_Field_Polarity_Display_One_field(MS_U8 u8Idx,MS_BOOL bEn,MS_U8 top_bottom)8669 MS_BOOL HAL_MVD_Field_Polarity_Display_One_field(MS_U8 u8Idx, MS_BOOL bEn,MS_U8 top_bottom)
8670 {
8671 MVD_CmdArg mvdcmd;
8672
8673 SETUP_CMDARG(mvdcmd);
8674 mvdcmd.Arg2 = bEn;
8675 mvdcmd.Arg3 = top_bottom;
8676 MVD_DEBUGINFO(printf("%s: bEn=%x,top_bottom=%x\n", __FUNCTION__, bEn,top_bottom));
8677 SET_DECNUM(mvdcmd, u8Idx);
8678 SET_CMD_RET_FALSE(CMD_FP_FILTER, &mvdcmd);
8679
8680 return TRUE;
8681 }
8682
8683
HAL_MVD_SetShareMemoryBase(MS_U8 u8Idx,MS_VIRT u32base,MS_U8 u8sel)8684 MS_BOOL HAL_MVD_SetShareMemoryBase(MS_U8 u8Idx, MS_VIRT u32base, MS_U8 u8sel)
8685 {
8686 u8SHMMiuSel = u8sel;
8687 u32SharememoryBase[u8Idx] = u32base - MVD_FW_CODE_LEN;
8688 return TRUE;
8689 }
8690
HAL_MVD_GetShareMemoryOffset(MS_U8 u8Idx,MS_VIRT * u32base)8691 MS_BOOL HAL_MVD_GetShareMemoryOffset(MS_U8 u8Idx, MS_VIRT *u32base)
8692 {
8693 *u32base=u32SharememoryBase[u8Idx];
8694 return TRUE;
8695 }
8696
HAL_MVD_Support2ndMVOPInterface(void)8697 MS_BOOL HAL_MVD_Support2ndMVOPInterface(void)
8698 {
8699 return TRUE;
8700 }
8701
HAL_MVD_SetExternal_CC_Buffer(MS_U8 u8Idx,MS_VIRT u32base,MS_U8 u8size,MS_U8 cc_type)8702 MS_BOOL HAL_MVD_SetExternal_CC_Buffer(MS_U8 u8Idx, MS_VIRT u32base, MS_U8 u8size, MS_U8 cc_type)
8703 {
8704 MVD_CmdArg mvdcmd;
8705 MS_U32 u32cc_size=0;
8706 MS_VIRT u32StartOffset;
8707 MS_U8 u8MiuSel;
8708
8709 SETUP_CMDARG(mvdcmd);
8710 if (u8size !=0)
8711 {
8712 mvdcmd.Arg0 = TRUE; //enable
8713 }
8714 else
8715 {
8716 mvdcmd.Arg0 = FALSE; //disable
8717 }
8718 mvdcmd.Arg1 = cc_type; //608->1,708->0
8719
8720 SET_DECNUM(mvdcmd, u8Idx);
8721 SET_CMD_RET_FALSE(CMD_CC_ENABLE_EXTERNAL_BUFFER, &mvdcmd);
8722
8723 if (u8size ==0)
8724 {
8725 SET_CMD_RET_FALSE(CMD_CLOSE_CC, &mvdcmd);
8726 return E_MVD_RET_OK;
8727 }
8728
8729 u32base *= (1<<10); //unit is bytes
8730 u32cc_size = u8size * (1<<10); //unit is bytes
8731
8732
8733 MS_U32 *pu32ReadPtr = (MS_U32 *)(HAL_MVD_PA2NonCacheSeg(u32base));
8734 MS_U32 *pu32WritePtr = (MS_U32 *)(HAL_MVD_PA2NonCacheSeg(u32base+sizeof(MS_U32)));
8735 MS_U32 *pu32LatchOverflow = (MS_U32 *)(HAL_MVD_PA2NonCacheSeg(u32base+sizeof(MS_U32)*2));
8736 MS_U32 *pu32CpuBaseAddr = (MS_U32 *)(HAL_MVD_PA2NonCacheSeg(u32base+sizeof(MS_U32)*3));
8737
8738 //rptr,wptr,overflow,latch 16 bytes
8739 if(cc_type==1)
8740 {
8741 u32base += (4*sizeof(MS_U32));
8742 u32cc_size -= (4*sizeof(MS_U32));
8743 }
8744
8745 if(cc_type==0) // 708: start from 128 bytes
8746 {
8747 u32base += 128;
8748 u32cc_size -=128;
8749 }
8750
8751 *pu32ReadPtr = *pu32WritePtr = u32base;
8752 *pu32LatchOverflow = 0;
8753 *pu32CpuBaseAddr = HAL_MVD_GetMEMCfg(u8Idx)->u32FWBinAddr;
8754
8755 _phy_to_miu_offset(u8MiuSel, u32StartOffset, u32base);
8756 _MVD_SetUserDataBufStart(u8Idx,u32StartOffset,cc_type);
8757 _MVD_SetUserDataBufSize(u8Idx,u32cc_size,cc_type);
8758 //MVD_DEBUGINFO(printf("%s: u32base=%x,u32size=%x,cc_type=%x\n", __FUNCTION__,u32base,u32cc_size,cc_type));
8759
8760 return E_MVD_RET_OK;
8761 }
8762
HAL_MVD_GetPVRSeamlessInfo(MS_U8 u8Idx,void * param)8763 MS_BOOL HAL_MVD_GetPVRSeamlessInfo(MS_U8 u8Idx,void* param)
8764 {
8765
8766 MVD_PVR_Seamless_Info* temp = (MVD_PVR_Seamless_Info*)param;
8767
8768 temp->u64PTS = ((MS_U64)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PVRSEAMLESSTARGETPTS, sizeof(MS_U32))) |
8769 (((MS_U64)MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PVRSEAMLESSTARGETPTSHIGH, sizeof(MS_U8)))<<32);
8770
8771 temp->u32POC = 0xFF; // not support in mvd
8772 temp->u8FrameType = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PVRSEAMLESSTARGETFRAMETYPE, sizeof(MS_U8));
8773
8774 return TRUE;
8775 }
8776
HAL_MVD_HWBuffer_ReMappingMode(MS_U8 u8Idx,MS_BOOL bEnable)8777 E_MVD_Result HAL_MVD_HWBuffer_ReMappingMode(MS_U8 u8Idx,MS_BOOL bEnable)
8778 {
8779 pMVDHalContext->gMVDPreCtrl[u8Idx].bHWBufferReMapping = bEnable;
8780 return E_MVD_RET_OK;
8781 }
8782
HAL_MVD_SetPrebufferSize(MS_U8 u8Idx,MS_U32 size)8783 MS_BOOL HAL_MVD_SetPrebufferSize(MS_U8 u8Idx, MS_U32 size)
8784 {
8785 MVD_CmdArg mvdcmd;
8786
8787 SETUP_CMDARG(mvdcmd);
8788 mvdcmd.Arg0 = size&0xff;
8789 mvdcmd.Arg1 = (size>>8)&0xff;
8790 mvdcmd.Arg2 = (size>>16)&0xff;
8791 mvdcmd.Arg3 = (size>>24)&0xff;
8792 SET_DECNUM(mvdcmd, u8Idx);
8793 if (HAL_MVD_MVDCommand( CMD_PREBUFFER_SIZE, &mvdcmd ) == FALSE)
8794 {
8795 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PREBUFFER_SIZE ) );
8796 return FALSE;
8797 }
8798 return TRUE;
8799 }
8800
HAL_MVD_GetVsyncAddrOffset(void)8801 MS_VIRT HAL_MVD_GetVsyncAddrOffset(void)
8802 {
8803 MS_VIRT VPUSHMAddr = HAL_VPU_EX_GetSHMAddr();
8804 MS_VIRT VsyncBridgeOffset = 0;
8805
8806 if(VPUSHMAddr != 0) // TEE project
8807 {
8808 VsyncBridgeOffset = VSYNC_BRIDGE_OFFSET;
8809 }
8810 else // normal project
8811 {
8812 VsyncBridgeOffset = COMMON_AREA_START + VSYNC_BRIDGE_OFFSET;
8813 }
8814
8815 return VsyncBridgeOffset;
8816 }
8817
HAL_MVD_GetVsyncExtAddrOffset(void)8818 MS_VIRT HAL_MVD_GetVsyncExtAddrOffset(void)
8819 {
8820 MS_VIRT VsyncBridgeExtOffset = 0;
8821 MS_VIRT VPUSHMAddr = HAL_VPU_EX_GetSHMAddr();
8822
8823 if(VPUSHMAddr != 0) // TEE project
8824 {
8825 VsyncBridgeExtOffset = VSYNC_BRIDGE_EXT_OFFSET;
8826 }
8827 else // normal project
8828 {
8829 VsyncBridgeExtOffset = COMMON_AREA_START + VSYNC_BRIDGE_EXT_OFFSET;
8830 }
8831
8832 return VsyncBridgeExtOffset;
8833 }
8834
HAL_MVD_SetTimeIncPredictParam(MS_U8 u8Idx,MS_U32 u32time)8835 E_MVD_Result HAL_MVD_SetTimeIncPredictParam(MS_U8 u8Idx, MS_U32 u32time)
8836 {
8837 MVD_CmdArg mvdcmd;
8838 SETUP_CMDARG(mvdcmd);
8839
8840 mvdcmd.Arg0 = L_WORD(u32time); // Arg0(enable), 1 for enable, default is 0...
8841 mvdcmd.Arg1 = H_WORD(u32time); // Arg1(vop_time_incr_predict_count), 1 for predict once, 2 for twice...0xff for always guess the vop_time_incr even with the vol_header, default is 0...
8842 mvdcmd.Arg2 = L_DWORD(u32time);// Arg2(vop_time_incr_follow_vol_header), // 0 for follow vol_header...1 for bypass vol_header, default is 0...
8843 mvdcmd.Arg3 = H_DWORD(u32time);// Arg3, reserve...
8844 MVD_DEBUGINFO(printf("CMD_TIME_INCR_PREDICT=%x\n",u32time));
8845 if (HAL_MVD_MVDCommand(CMD_TIME_INCR_PREDICT, &mvdcmd) == FALSE)
8846 {
8847 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_TIME_INCR_PREDICT ) );
8848 return E_MVD_RET_FAIL;
8849 }
8850 return E_MVD_RET_OK;
8851
8852 }
8853
HAL_MVD_SetDecodeTimeoutParam(MS_U8 u8Idx,MS_BOOL enable,MS_U32 u32timeout)8854 MS_BOOL HAL_MVD_SetDecodeTimeoutParam(MS_U8 u8Idx, MS_BOOL enable,MS_U32 u32timeout)
8855 {
8856 MVD_CmdArg mvdcmd;
8857
8858 SETUP_CMDARG(mvdcmd);
8859
8860 if(enable == TRUE)
8861 {
8862 mvdcmd.Arg0 = 2; //0:disable, 2: enable decode timeout
8863 mvdcmd.Arg1 = u32timeout&0xff;
8864 mvdcmd.Arg2 = (u32timeout>>8)&0xff;
8865 mvdcmd.Arg3 = (u32timeout>>16)&0xff;
8866 }
8867 else
8868 {
8869 mvdcmd.Arg0 = 0; //0:disable, 2: enable decode timeout
8870 }
8871
8872 SET_DECNUM(mvdcmd, u8Idx);
8873
8874 if (HAL_MVD_MVDCommand( CMD_ENABLE_VLD_TIMEOUT, &mvdcmd ) == FALSE)
8875 {
8876 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_ENABLE_VLD_TIMEOUT ) );
8877 return FALSE;
8878 }
8879
8880 return TRUE;
8881 }
8882
HAL_MVD_Set_Smooth_Rewind(MS_U8 u8Idx,MS_U8 btype)8883 E_MVD_Result HAL_MVD_Set_Smooth_Rewind(MS_U8 u8Idx, MS_U8 btype)
8884 {
8885 MVD_CmdArg mvdcmd;
8886 SETUP_CMDARG(mvdcmd);
8887 mvdcmd.Arg0 = btype;
8888 MVD_DEBUGINFO(printf("%s: btype=%x\n", __FUNCTION__, btype));
8889 SET_DECNUM(mvdcmd, u8Idx);
8890 if (HAL_MVD_MVDCommand(CMD_SMOOTH_REWIND, &mvdcmd) == FALSE)
8891 {
8892 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SMOOTH_REWIND ) );
8893 return E_MVD_RET_FAIL;
8894 }
8895 return E_MVD_RET_OK;
8896 }
8897
HAL_MVD_IsAlive(MS_U8 u8Idx)8898 E_MVD_Result HAL_MVD_IsAlive(MS_U8 u8Idx)
8899 {
8900 MVD_ALIVEInfo* pAliveInfo = &(pMVDHalContext->aliveInfo[u8Idx]);
8901 MVD_SrcMode curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
8902
8903 if (E_MVD_SLQ_TBL_MODE == curSrcMode || E_MVD_TS_FILE_MODE == curSrcMode)
8904 {
8905 if(pMVDHalContext->u32LastAliveTime[u8Idx] == 0 || ((MsOS_GetSystemTime()-pMVDHalContext->u32LastAliveTime[u8Idx]) < 500))
8906 {
8907
8908 if(pMVDHalContext->u32LastAliveTime[u8Idx] == 0 )
8909 {
8910 pMVDHalContext->u32LastAliveTime[u8Idx] = MsOS_GetSystemTime();
8911 }
8912 return E_MVD_RET_OK;
8913 }
8914 }
8915
8916 #if 0
8917 printf("[%d]%d,%d,%d,%d,%d,%d,%d,%d\n",__FUNCTION__,
8918 (MS_U32)MsOS_GetSystemTime(),
8919 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DECODEDONE_COUNT, sizeof(MS_U32))),
8920 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHBUF_COUNT, sizeof(MS_U32))),
8921 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHCODE_COUNT, sizeof(MS_U32))),
8922 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PREBUF_COUNT, sizeof(MS_U32))),
8923 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_VFIFOBUF_COUNT, sizeof(MS_U32))),
8924 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHHEADER_COUNT, sizeof(MS_U32))),
8925 (MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_FLASHPATTERN_COUNT, sizeof(MS_U32))));
8926 #endif
8927
8928 //check count to vertify alive
8929 if((pAliveInfo->u32decode_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DECODEDONE_COUNT, sizeof(MS_U32))))||
8930 (pAliveInfo->u32searchbuf_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHBUF_COUNT, sizeof(MS_U32))))||
8931 (pAliveInfo->u32searchcode_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHCODE_COUNT, sizeof(MS_U32))))||
8932 (pAliveInfo->u32prebuf_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PREBUF_COUNT, sizeof(MS_U32))))||
8933 (pAliveInfo->u32vfifobuf_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_VFIFOBUF_COUNT, sizeof(MS_U32))))||
8934 (pAliveInfo->u32searchheader_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHHEADER_COUNT, sizeof(MS_U32))))||
8935 (pAliveInfo->u32flashpattern_count!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_FLASHPATTERN_COUNT, sizeof(MS_U32))))||
8936 (pAliveInfo->u32IdleCount!=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_IDLE_COUNT, sizeof(MS_U32)))))
8937 {
8938 pAliveInfo->u32decode_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_DECODEDONE_COUNT, sizeof(MS_U32)));
8939 pAliveInfo->u32searchbuf_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHBUF_COUNT, sizeof(MS_U32)));
8940 pAliveInfo->u32searchcode_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHCODE_COUNT, sizeof(MS_U32)));
8941 pAliveInfo->u32prebuf_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PREBUF_COUNT, sizeof(MS_U32)));
8942 pAliveInfo->u32vfifobuf_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_VFIFOBUF_COUNT, sizeof(MS_U32)));
8943 pAliveInfo->u32searchheader_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_SEARCHHEADER_COUNT, sizeof(MS_U32)));
8944 pAliveInfo->u32flashpattern_count=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_FLASHPATTERN_COUNT, sizeof(MS_U32)));
8945 pAliveInfo->u32IdleCount=(MS_U32)(MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_IDLE_COUNT, sizeof(MS_U32)));
8946 pMVDHalContext->u32LastAliveTime[u8Idx] = MsOS_GetSystemTime();
8947 return E_MVD_RET_OK;
8948 }
8949 else
8950 {
8951 pMVDHalContext->u32LastAliveTime[u8Idx] = MsOS_GetSystemTime();
8952 return E_MVD_RET_FAIL;
8953 }
8954
8955 }
8956
HAL_MVD_Set_Err_Tolerance(MS_U8 u8Idx,MS_U16 u16Para)8957 E_MVD_Result HAL_MVD_Set_Err_Tolerance(MS_U8 u8Idx, MS_U16 u16Para)
8958 {
8959 MVD_CmdArg mvdcmd;
8960 SETUP_CMDARG(mvdcmd);
8961 mvdcmd.Arg0 = u16Para & 0xFF; //enable or disable
8962 mvdcmd.Arg1 = u16Para >> 8; // err rate 0~100%
8963 if(mvdcmd.Arg1 >= 100)
8964 mvdcmd.Arg1 = 100;
8965
8966 SET_DECNUM(mvdcmd, u8Idx);
8967 if (HAL_MVD_MVDCommand(CMD_DECODE_ERROR_TOLERANCE, &mvdcmd) == FALSE)
8968 {
8969 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DECODE_ERROR_TOLERANCE ) );
8970 return E_MVD_RET_FAIL;
8971 }
8972 return E_MVD_RET_OK;
8973
8974 }
8975
HAL_MVD_EnableAutoInsertDummyPattern(MS_U8 u8Idx,MS_BOOL bEnable)8976 void HAL_MVD_EnableAutoInsertDummyPattern(MS_U8 u8Idx, MS_BOOL bEnable)
8977 {
8978 pMVDHalContext->bAutoInsertDummyPattern[u8Idx] = bEnable;
8979 }
8980
HAL_MVD_Drop_One_PTS(MS_U8 u8Idx)8981 void HAL_MVD_Drop_One_PTS(MS_U8 u8Idx)
8982 {
8983 pMVDHalContext->bDropOnePTS[u8Idx] = TRUE;
8984 }
8985
HAL_MVD_PVR_Seamless_mode(MS_U8 u8Idx,MS_U8 u8Arg)8986 E_MVD_Result HAL_MVD_PVR_Seamless_mode(MS_U8 u8Idx, MS_U8 u8Arg)
8987 {
8988 #define STOP_TIMEOUT 500 //ms
8989 MVD_CmdArg mvdcmd;
8990 E_MVD_Result ret = E_MVD_RET_OK;
8991 MS_U32 u32StartTime;
8992 MS_U32 u32SeamlessStatus = 0;
8993 MS_U32 u32BufStart = 0;
8994 MS_U32* temp = 0;
8995
8996 if(u8Arg != 2)
8997 {
8998 // clear handshake dram
8999 u32BufStart = GET_FRMINFO_BUFFADD(u8Idx);
9000 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,u32BufStart,u32BufStart);
9001 temp = (MS_U32*)MsOS_PA2KSEG1(u32BufStart+OFFSET_PVR_SEAMLESS_STATUS);
9002 *temp = 0;
9003 MsOS_FlushMemory();
9004 }
9005
9006 SETUP_CMDARG(mvdcmd);
9007 mvdcmd.Arg0 = u8Arg;
9008 MVD_DEBUGINFO(printf("%s: arg=%d\n", __FUNCTION__, (unsigned int)u8Arg));
9009 SET_DECNUM(mvdcmd, u8Idx);
9010
9011 if (HAL_MVD_MVDCommand(CMD_PVR_SEAMLESS_MODE, &mvdcmd) == FALSE)
9012 {
9013 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_PVR_SEAMLESS_MODE ) );
9014 return E_MVD_RET_FAIL;
9015 }
9016
9017
9018 u32StartTime = HAL_MVD_GetTime();
9019
9020 if(u8Arg == 1)
9021 {
9022 pMVDHalContext->stFwCfg[u8Idx].eSrcMode = E_MVD_TS_FILE_MODE;
9023 while(1)
9024 {
9025 u32SeamlessStatus = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PVR_SEAMLESS_STATUS, sizeof(MS_U32));
9026 if(u32SeamlessStatus&1) // bit0 , pause done
9027 {
9028 break;
9029 }
9030
9031 if((HAL_MVD_GetTime()-u32StartTime)>STOP_TIMEOUT)
9032 {
9033 MVD_DEBUGERROR(printf("PVR seamless pause timeout\n" ) );
9034 ret = E_MVD_RET_FAIL;
9035 break;
9036 }
9037 }
9038 }
9039 else if(u8Arg == 2)
9040 {
9041 while(1)
9042 {
9043 u32SeamlessStatus = MVD_GetFWBuffData(u8Idx, FW_BUFF_FRMINFO, OFFSET_PVR_SEAMLESS_STATUS, sizeof(MS_U32));
9044 if(u32SeamlessStatus&4) // bit2, hw reset done
9045 {
9046 break;
9047 }
9048
9049 if((HAL_MVD_GetTime()-u32StartTime)>STOP_TIMEOUT)
9050 {
9051 MVD_DEBUGERROR(printf("PVR seamless hw reset timeout\n" ) );
9052 ret = E_MVD_RET_FAIL;
9053 break;
9054 }
9055 }
9056 }
9057
9058 return ret;
9059 }
9060
HAL_MVD_SetDVXCShmAddr(MS_U8 u8Idx,MS_PHY u32FWBaseAddr,MS_PHY u32DVXCShmAddr)9061 E_MVD_Result HAL_MVD_SetDVXCShmAddr(MS_U8 u8Idx, MS_PHY u32FWBaseAddr, MS_PHY u32DVXCShmAddr)
9062 {
9063 E_MVD_Result ret = E_MVD_RET_OK;
9064
9065 MS_U8 u8XCShmMiuSel;
9066 MS_U32 u32XCShmStartOffset;
9067 MS_U8 u8FWBaseMiuSel;
9068 MS_U32 u32FWBaseOffset;
9069 MVD_CmdArg mvdcmd;
9070 MS_U32 u32temp = 0;
9071
9072 _phy_to_miu_offset(u8FWBaseMiuSel, u32FWBaseOffset, u32FWBaseAddr);
9073 _phy_to_miu_offset(u8XCShmMiuSel, u32XCShmStartOffset, u32DVXCShmAddr);
9074
9075 if (u8FWBaseMiuSel != u8XCShmMiuSel)
9076 {
9077 MVD_DEBUGERROR(printf("[ERROR] XC share memory and VDEC Code base MIU selections are different\n"));
9078 return E_MVD_RET_FAIL;
9079 }
9080
9081 u32temp = u32XCShmStartOffset - u32FWBaseOffset;
9082
9083 SETUP_CMDARG(mvdcmd);
9084
9085 mvdcmd.Arg0 = L_WORD(u32temp);
9086 mvdcmd.Arg1 = H_WORD(u32temp);
9087 mvdcmd.Arg2 = L_DWORD(u32temp);
9088 mvdcmd.Arg3 = H_DWORD(u32temp);
9089
9090 MVD_DEBUGINFO(printf("%s: arg=%x\n", __FUNCTION__, (unsigned int)u32temp));
9091
9092 SET_DECNUM(mvdcmd, u8Idx);
9093
9094 if (HAL_MVD_MVDCommand(CMD_SET_DV_XC_SHM_ADDR, &mvdcmd) == FALSE)
9095 {
9096 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SET_DV_XC_SHM_ADDR ) );
9097 return E_MVD_RET_FAIL;
9098 }
9099
9100 return ret;
9101 }
9102
9103
HAL_MVD_SetDisplayFinishMode(MS_U8 u8Idx,MS_U8 u8Mode)9104 E_MVD_Result HAL_MVD_SetDisplayFinishMode(MS_U8 u8Idx, MS_U8 u8Mode)
9105 {
9106 MVD_CmdArg mvdcmd;
9107
9108 SETUP_CMDARG(mvdcmd);
9109 mvdcmd.Arg0 = u8Mode;
9110
9111 SET_DECNUM(mvdcmd, u8Idx);
9112
9113 MVD_DEBUGINFO(printf("%s CMD_ENABLE_LAST_FRAME_QUALIFIER arg0=%x\n", __FUNCTION__, u8Mode));
9114 if (HAL_MVD_MVDCommand(CMD_ENABLE_LAST_FRAME_QUALIFIER, &mvdcmd)== FALSE)
9115 {
9116 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_ENABLE_LAST_FRAME_QUALIFIER) );
9117 return E_MVD_RET_FAIL;
9118 }
9119
9120 return E_MVD_RET_OK;
9121 }
HAL_MVD_Set_SlowSyncParam(MS_U8 u8Idx,MS_U8 u8RepeatPeriod,MS_U8 u8DropPeriod)9122 E_MVD_Result HAL_MVD_Set_SlowSyncParam(MS_U8 u8Idx, MS_U8 u8RepeatPeriod,MS_U8 u8DropPeriod)
9123 {
9124 MVD_CmdArg mvdcmd;
9125 SETUP_CMDARG(mvdcmd);
9126
9127 mvdcmd.Arg0 = u8RepeatPeriod;
9128
9129 SET_DECNUM(mvdcmd, u8Idx);
9130 if (HAL_MVD_MVDCommand(CMD_SLOW_SYNC_REPEAT, &mvdcmd) == FALSE)
9131 {
9132 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLOW_SYNC_REPEAT ) );
9133 return E_MVD_RET_FAIL;
9134 }
9135
9136
9137 mvdcmd.Arg0 = u8DropPeriod;
9138
9139 SET_DECNUM(mvdcmd, u8Idx);
9140 if (HAL_MVD_MVDCommand(CMD_SLOW_SYNC_SKIP, &mvdcmd) == FALSE)
9141 {
9142 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_SLOW_SYNC_SKIP ) );
9143 return E_MVD_RET_FAIL;
9144 }
9145
9146
9147 return E_MVD_RET_OK;
9148
9149 }
9150
HAL_MVD_VariableFrameRate(MS_U8 u8Idx)9151 MS_BOOL HAL_MVD_VariableFrameRate(MS_U8 u8Idx)
9152 {
9153 MVD_CmdArg mvdcmd;
9154 SETUP_CMDARG(mvdcmd);
9155 mvdcmd.Arg0 = 1;
9156 SET_DECNUM(mvdcmd, u8Idx);
9157 if (HAL_MVD_MVDCommand(CMD_VARIABLE_FRAMERATE, &mvdcmd)== FALSE)
9158 {
9159 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_VARIABLE_FRAMERATE) );
9160 return FALSE;
9161 }
9162 return TRUE;
9163 }
9164
9165 //------------------------------------------------------------------------------
9166 /// Set FRC Only Show TopField
9167 /// @return -TRUE for success; FALSE for failure.
9168 //------------------------------------------------------------------------------
HAL_MVD_FRC_OnlyShowTopField(MS_U8 u8Idx,MS_BOOL bEnable)9169 MS_BOOL HAL_MVD_FRC_OnlyShowTopField(MS_U8 u8Idx, MS_BOOL bEnable)
9170 {
9171 MVD_CmdArg mvdcmd;
9172
9173 SETUP_CMDARG(mvdcmd);
9174 mvdcmd.Arg0 = bEnable; //1 -> show Only Show TopField. 0 -> normal case.
9175 SET_DECNUM(mvdcmd, u8Idx);
9176 SET_CMD_RET_FALSE(CMD_FRC_ONLY_SHOW_TOP_FIELD, &mvdcmd);
9177 return TRUE;
9178 }
9179
HAL_MVD_DisableESFullStop(MS_U8 u8Idx,MS_BOOL bDisable)9180 MS_BOOL HAL_MVD_DisableESFullStop(MS_U8 u8Idx, MS_BOOL bDisable)
9181 {
9182 MVD_CmdArg mvdcmd;
9183 SETUP_CMDARG(mvdcmd);
9184 mvdcmd.Arg0 = bDisable;
9185 SET_DECNUM(mvdcmd, u8Idx);
9186 if (HAL_MVD_MVDCommand( CMD_ES_FULL_STOP, &mvdcmd ) == FALSE)
9187 {
9188 printf( "Command: 0x%x fail!!\r\n", CMD_ES_FULL_STOP);
9189 return FALSE;
9190 }
9191 return TRUE;
9192 }
9193
HAL_MVD_PUSI_Control(MS_U8 u8Idx,MS_BOOL bEnable)9194 MS_BOOL HAL_MVD_PUSI_Control(MS_U8 u8Idx, MS_BOOL bEnable)
9195 {
9196 MVD_CmdArg mvdcmd;
9197 SETUP_CMDARG(mvdcmd);
9198 mvdcmd.Arg0 = bEnable;
9199 SET_DECNUM(mvdcmd, u8Idx);
9200 if (HAL_MVD_MVDCommand( CMD_PUSI_CONTROL, &mvdcmd ) == FALSE)
9201 {
9202 MVD_PRINT( "Command: 0x%x fail!!\r\n", CMD_PUSI_CONTROL);
9203 return FALSE;
9204 }
9205 return TRUE;
9206 }
9207
9208
HAL_MVD_GetVBBUTableAddr(MS_U8 u8Idx)9209 MS_VIRT HAL_MVD_GetVBBUTableAddr(MS_U8 u8Idx)
9210 {
9211 return pMVDHalContext->stFWBuff[(u8Idx)].u32VBBUTableAdd;
9212 }
9213
HAL_MVD_SetDmxFrameRate(MS_U8 u8HalIdx,MS_U32 u32Value)9214 void HAL_MVD_SetDmxFrameRate(MS_U8 u8HalIdx,MS_U32 u32Value)
9215 {
9216 pMVDHalContext->u32DmxFrameRate[u8HalIdx] = u32Value;
9217 }
9218
HAL_MVD_SetDmxFrameRateBase(MS_U8 u8HalIdx,MS_U32 u32Value)9219 void HAL_MVD_SetDmxFrameRateBase(MS_U8 u8HalIdx,MS_U32 u32Value)
9220 {
9221 pMVDHalContext->u32DmxFrameRateBase[u8HalIdx] = u32Value;
9222 }
9223
HAL_MVD_TrickPlay2xAVSync(MS_U8 u8Idx,MS_BOOL bEnable)9224 void HAL_MVD_TrickPlay2xAVSync(MS_U8 u8Idx,MS_BOOL bEnable)
9225 {
9226 pMVDHalContext->bTrickPlay2xAVSync[u8Idx] = bEnable;
9227 }
9228
HAL_MVD_SetAVSyncDispAutoDrop(MS_U8 u8Idx,MS_BOOL bEnable)9229 MS_BOOL HAL_MVD_SetAVSyncDispAutoDrop(MS_U8 u8Idx, MS_BOOL bEnable)
9230 {
9231 MVD_CmdArg mvdcmd;
9232
9233 SETUP_CMDARG(mvdcmd);
9234 mvdcmd.Arg0 = bEnable;
9235
9236 SET_DECNUM(mvdcmd, u8Idx);
9237
9238 MVD_DEBUGINFO(printf("%s CMD_AUTO_DROP_FRAME_IN_DECODE arg0=%x\n", __FUNCTION__, bEnable));
9239 if (HAL_MVD_MVDCommand(CMD_AUTO_DROP_FRAME_IN_DECODE, &mvdcmd)== FALSE)
9240 {
9241 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_AUTO_DROP_FRAME_IN_DECODE) );
9242 return FALSE;
9243 }
9244
9245 return TRUE;
9246 }
9247
HAL_MVD_SetDynmcDispPath(MS_U8 u8Idx,MS_BOOL bConnect,MVD_DISPLAY_PATH eValue,MS_BOOL bPreSet)9248 MS_BOOL HAL_MVD_SetDynmcDispPath(MS_U8 u8Idx,MS_BOOL bConnect,MVD_DISPLAY_PATH eValue,MS_BOOL bPreSet)
9249 {
9250 MS_U32 u32TimeCnt = 0;
9251 MVD_CmdArg mvdcmd;
9252
9253 HAL_MVD_ResetHandShake(u8Idx, MVD_HANDSHAKE_VSYNC_CONTROL);
9254
9255 SETUP_CMDARG(mvdcmd);
9256 mvdcmd.Arg0 = bConnect;
9257 mvdcmd.Arg1 = eValue;
9258 mvdcmd.Arg2 = bPreSet;
9259
9260 SET_DECNUM(mvdcmd, u8Idx);
9261
9262 MVD_DEBUGINFO(printf("%s CMD_DYNAMIC_MVOP_CONNECT arg0=%x, arg1=%x\n", __FUNCTION__, bConnect,eValue));
9263 if (HAL_MVD_MVDCommand(CMD_DYNAMIC_MVOP_CONNECT, &mvdcmd)== FALSE)
9264 {
9265 MVD_DEBUGERROR( printf( "Command: 0x%x fail!!\r\n", CMD_DYNAMIC_MVOP_CONNECT) );
9266 return FALSE;
9267 }
9268
9269 if(bConnect == FALSE) // disconnect, need to do handshake with fw
9270 {
9271 u32TimeCnt = HAL_MVD_GetTime();
9272 while ((HAL_MVD_GetTime() - u32TimeCnt) < CMD_TIMEOUT_MS)
9273 {
9274 if (HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_VSYNC_CONTROL))
9275 {
9276 MVD_DEBUGINFO(printf("\n vsync control finished!\n"));
9277 break;
9278 }
9279 }
9280
9281 MVD_DEBUGINFO(printf("====> %s (t1=%u t2=%u diff=%u)\n", __FUNCTION__,u32TimeCnt, HAL_MVD_GetTime(), (HAL_MVD_GetTime() - u32TimeCnt)));
9282
9283 if (TRUE != HAL_MVD_IsCmdFinished(u8Idx, MVD_HANDSHAKE_VSYNC_CONTROL))
9284 {
9285 MVD_DEBUGINFO(printf("\n***** vsync control timeout *****\n\n"));
9286 return FALSE;
9287 }
9288 }
9289
9290 return TRUE;
9291 }
9292
HAL_MVD_PreConnectInputTsp(MS_U8 u8Idx,MS_BOOL bEnable,MVD_INPUT_TSP eInputTsp,MVD_Original_Stream eStream)9293 MS_BOOL HAL_MVD_PreConnectInputTsp(MS_U8 u8Idx, MS_BOOL bEnable, MVD_INPUT_TSP eInputTsp, MVD_Original_Stream eStream)
9294 {
9295 #ifdef CMD_PRESET_CONNET_INPUT_TSP
9296
9297 MVD_SrcMode curSrcMode = HAL_MVD_GetSrcMode(u8Idx);
9298
9299 if (curSrcMode == E_MVD_TS_MODE)
9300 {
9301 MVD_CmdArg mvdcmd;
9302 MS_U8 u8Input = E_CTL_INPUT_TSP_NONE;
9303
9304 if (bEnable)
9305 {
9306 u8Input = (MS_U8)eInputTsp;
9307 VPRINTF("[NDec][%d] MVD preset tsp, eInputTsp %d\n", u8Idx, eInputTsp);
9308 }
9309 else
9310 {
9311 switch (eStream)
9312 {
9313 case E_MVD_ORIGINAL_MAIN_STREAM:
9314 u8Input = E_CTL_INPUT_TSP_0;
9315 break;
9316 case E_MVD_ORIGINAL_SUB_STREAM:
9317 u8Input = E_CTL_INPUT_TSP_1;
9318 break;
9319 case E_MVD_ORIGINAL_N_STREAM:
9320 default:
9321 u8Input = E_CTL_INPUT_TSP_NONE;
9322 break;
9323 }
9324 VPRINTF("[NDec][%d] MVD no preset tsp, input %d\n", u8Idx, u8Input);
9325 }
9326
9327 SETUP_CMDARG(mvdcmd);
9328 mvdcmd.Arg0 = u8Input;
9329 SET_DECNUM(mvdcmd, u8Idx);
9330
9331 MVD_DEBUGINFO(printf("%s CMD_PRESET_CONNET_INPUT_TSP arg0=%x\n", __FUNCTION__, u8Input));
9332 if (HAL_MVD_MVDCommand(CMD_PRESET_CONNET_INPUT_TSP, &mvdcmd)== FALSE)
9333 {
9334 MVD_DEBUGERROR(printf("Command: 0x%x fail!!\r\n", CMD_PRESET_CONNET_INPUT_TSP));
9335 return FALSE;
9336 }
9337 }
9338 else
9339 {
9340 VPRINTF("[NDec][%d] MVD not TSP input, ignore PRESET_CONNECT_INPUT_TSP\n", u8Idx);
9341 }
9342
9343 return TRUE;
9344
9345 #else
9346
9347 return FALSE;
9348
9349 #endif
9350 }
9351
HAL_MVD_SetCMAInformation(void * cmaInitParam)9352 void HAL_MVD_SetCMAInformation(void* cmaInitParam)
9353 {
9354 pMVDHalContext->bCMAUsed = TRUE;
9355 memcpy((void*)(&pMVDHalContext->cmaInitParam),cmaInitParam,sizeof(struct CMA_Pool_Init_Param));
9356 }
9357
HAL_MVD_GetCMAInformation(MS_U8 u8HalIdx,MS_U64 * u64Addr,MS_SIZE * u64Size,MS_BOOL * bAllocDone)9358 void HAL_MVD_GetCMAInformation(MS_U8 u8HalIdx,MS_U64* u64Addr,MS_SIZE* u64Size,MS_BOOL* bAllocDone)
9359 {
9360 FW_VOL_INFO gvolInfo;
9361 MS_U32 u32VolAddr;
9362
9363 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,GET_VOL_BUFFADD(u8HalIdx),u32VolAddr);
9364
9365 gvolInfo = (*(volatile FW_VOL_INFO*)(MsOS_PA2KSEG1(u32VolAddr)));
9366
9367 *u64Addr = (MS_U64)gvolInfo.CMA_FB_Address;
9368 *u64Size = (MS_SIZE)gvolInfo.CMA_FB_Size;
9369 *bAllocDone = gvolInfo.CMA_AllocDone;
9370
9371 MsOS_ReadMemory();
9372 MsOS_FlushMemory();
9373 }
9374
HAL_MVD_SetCMAAllocateDone(MS_U8 u8HalIdx)9375 void HAL_MVD_SetCMAAllocateDone(MS_U8 u8HalIdx)
9376 {
9377 MS_U8* temp;
9378 MS_VIRT u32VolAddr;
9379
9380 _miu_offset_to_phy(pMVDHalContext->stMiuCfg.u8FWMiuSel,GET_VOL_BUFFADD(u8HalIdx),u32VolAddr);
9381
9382 temp = (MS_U8*)(MsOS_PA2KSEG1(u32VolAddr+OFFSET_CMA_ALLOCDONE));
9383
9384 *temp = 1;
9385
9386 MsOS_ReadMemory();
9387 MsOS_FlushMemory();
9388 }
9389
HAL_MVD_SetFrameBufferMiu(MS_U8 u8HalIdx,MS_U8 u8MiuIdx)9390 void HAL_MVD_SetFrameBufferMiu(MS_U8 u8HalIdx,MS_U8 u8MiuIdx)
9391 {
9392 //to do....
9393 }
9394
9395
9396 #ifdef VDEC3
HAL_MVD_IsDisplayCommand(MS_U8 u8Cmd)9397 MS_BOOL HAL_MVD_IsDisplayCommand(MS_U8 u8Cmd)
9398 {
9399
9400 #if 1 // to do.
9401 UNUSED(u8Cmd);
9402 return TRUE;
9403 #else
9404 MS_BOOL ret;
9405 switch(u8Cmd)
9406 {
9407 case CMD_PLAY:
9408 case CMD_STOP:
9409 case CMD_DISPLAY_PAUSE:
9410 case CMD_PAUSE:
9411 case CMD_FLUSH_DISP_QUEUE:
9412 case CMD_VC1_HW_SLQ_RESET:
9413 case CMD_FAST_SLOW:
9414 case CMD_FLIP_RELEASE_FRAME:
9415 case CMD_FD_MASK_DELAY_CNT:
9416 case CMD_PVR_SEAMLESS_MODE:
9417 case CMD_SW_RESET:
9418 case CMD_CODEC_INFO:
9419 case CMD_CODE_OFFSET:
9420 case CMD_VOL_INFO_BUF:
9421 case CMD_FRAME_INFO_BUF:
9422 case CMD_HEADER_INFO_BUF:
9423 case CMD_USER_BUF_START:
9424 case CMD_USER_BUF_SIZE:
9425 case CMD_PTS_TBL_START:
9426 case CMD_DEC_FRAME_INFO_BUF:
9427 case CMD_SLQ_TBL_BUF_END:
9428 case CMD_SLQ_TBL_BUF_START:
9429 case CMD_STREAM_BUF_START:
9430 case CMD_STREAM_BUF_END:
9431 case CMD_FB_BASE:
9432 case CMD_IAP_BUF_START:
9433 case CMD_DP_BUF_START:
9434 case CMD_MV_BUF_START:
9435 case CMD_FB_NUM:
9436 case CMD_DISPLAY_CTL:
9437 case CMD_REPEAT_MODE:
9438 case CMD_DS_VIRTUAL_BOX:
9439 case CMD_ENABLE_FILE_SYNC:
9440 case CMD_RVU_EN:
9441 case CMD_START_DEC_STRICT:
9442 case CMD_SYNC_ON:
9443 case CMD_SET_MST_MODE:
9444 case CMD_SET_MCU_MODE:
9445 ret = TRUE;
9446 break;
9447 default:
9448 ret = FALSE;
9449 break;
9450 }
9451
9452 return ret;
9453 #endif
9454 }
9455
HAL_MVD_IsNormalCommand(MS_U8 u8Cmd)9456 MS_BOOL HAL_MVD_IsNormalCommand(MS_U8 u8Cmd)
9457 {
9458 MS_BOOL ret;
9459
9460 switch(u8Cmd)
9461 {
9462
9463 case CMD_DISP_SPEED_CTRL:
9464 case CMD_STEP_DISP_DECODE_ONE:
9465 case CMD_ENABLE_LAST_FRAME_SHOW:
9466 case CMD_STEP_TO_PTS:
9467 case CMD_SKIP_DATA:
9468 case CMD_DIU_WIDTH_ALIGN:
9469 case CMD_SCALER_INFO_BASE:
9470 case CMD_DYNAMIC_SCALE_BASE:
9471 case CMD_ENABLE_DYNAMIC_SCALE:
9472 case CMD_FORCE_BLUE_SCREEN:
9473 case CMD_FREEZE_DISP:
9474 case CMD_FIXED_FRAME_BUFFER:
9475 case CMD_SEND_UNI_PTS:
9476 case CMD_ENABLE_FREEZE_PIC:
9477 case CMD_PTS_BASE:
9478 case CMD_SINGLE_STEP:
9479 case CMD_PARSE_M4V_PACKMD:
9480 case CMD_SLQ_END:
9481 case CMD_SLQ_START:
9482 case CMD_ENABLE_INT_STAT:
9483 case CMD_SHOW_ONE_FIELD:
9484 case CMD_FRC_OUPUT:
9485 case CMD_FRC_DROP_BEHAVIOR:
9486 case CMD_FORBID_RESOLUTION_CHANGE:
9487 case CMD_DUMP_BITSTREAM_BASE:
9488 case CMD_DUMP_BITSTREAM_LENGTH:
9489 case CMD_SYNC_OFFSET:
9490 case CMD_SYN_THRESHOLD:
9491 case CMD_AVSYNC_FREERUN_THRESHOLD:
9492 case CMD_MVD_FAST_INT:
9493 case CMD_DIVX_PATCH:
9494 case CMD_IDCT_SEL:
9495 case CMD_SLQ_UPDATE_TBL_WPTR:
9496 case CMD_DMA_OVFTH:
9497 case CMD_DMA_UNFTH:
9498 case CMD_UPDATE_FRAME:
9499 case CMD_PTS_TBL_RESET:
9500 case CMD_ENABLE_AUTO_MUTE:
9501 case CMD_FORCE_ALIGN_VSIZE:
9502 case CMD_SUSPEND_DS:
9503 case CMD_PUSH_FIRST_FRAME_DISP:
9504 case CMD_XC_LOW_DELAY_PARA:
9505 case CMD_FP_FILTER:
9506 case CMD_CC_ENABLE_EXTERNAL_BUFFER:
9507 case CMD_CLOSE_CC:
9508 case CMD_PREBUFFER_SIZE:
9509 case CMD_TIME_INCR_PREDICT:
9510 case CMD_ENABLE_VLD_TIMEOUT:
9511 case CMD_SMOOTH_REWIND:
9512 case CMD_DECODE_ERROR_TOLERANCE:
9513 case CMD_MVD_IDLE:
9514 case CMD_PARSER_READ_POSITION:
9515 case CMD_SLQ_GET_TBL_RPTR:
9516 case CMD_DECODE_STATUS:
9517 case CMD_GET_AFD:
9518 case CMD_GET_SYNC_STAT:
9519 case CMD_RD_USER_WP:
9520 case CMD_ENABLE_LAST_FRAME_QUALIFIER:
9521 //case CMD_RD_IO: // no need in V3
9522 //case CMD_WR_IO: // no need in V3
9523 ret = TRUE;
9524 break;
9525 default:
9526 ret = FALSE;
9527 break;
9528 }
9529
9530 return ret;
9531 }
9532
HAL_MVD_IsNeedResponseCommand(MS_U8 u8Cmd)9533 MS_BOOL HAL_MVD_IsNeedResponseCommand(MS_U8 u8Cmd)
9534 {
9535 MS_BOOL ret;
9536
9537 switch(u8Cmd)
9538 {
9539 case CMD_GET_AFD:
9540 case CMD_GET_SYNC_STAT:
9541 case CMD_RD_USER_WP:
9542 case CMD_DECODE_STATUS:
9543 case CMD_PARSER_READ_POSITION:
9544 case CMD_MVD_IDLE:
9545 ret = TRUE;
9546 break;
9547 default:
9548 ret = FALSE;
9549 break;
9550 }
9551
9552 return ret;
9553 }
9554 #endif
9555 #endif
9556