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 /// file drvMJPEG.c
98 /// @brief MJPEG Driver Interface
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102
103 #if !defined(MSOS_TYPE_NUTTX)
104
105 //-------------------------------------------------------------------------------------------------
106 // Include Files
107 //-------------------------------------------------------------------------------------------------
108 // Common Definition
109 #include <string.h>
110 #include "MsCommon.h"
111 #include "MsVersion.h"
112 #include "MsOS.h"
113 #include "halCHIP.h"
114 // Internal Definition
115 #include "drvMJPEG.h"
116 #include "VirtualhalMJPEG.h"
117 #include "halVPU_EX.h"
118 #include "fwHVD_if.h"
119
120 //-------------------------------------------------------------------------------------------------
121 // Driver Compiler Options
122 //-------------------------------------------------------------------------------------------------
123
124 //-------------------------------------------------------------------------------------------------
125 // Local Defines
126 //-------------------------------------------------------------------------------------------------
127 //MJPEG driver debug macro
128 #ifndef ANDROID
129 #define MJPEG_DEBUG_DRV_MSG(format, args...) do{if(u8MJPEG_DrvDbgLevel & E_MJPEG_DEBUG_DRV_MSG) printf(format, ##args);}while(0)
130 #define MJPEG_DEBUG_DRV_ERR(format, args...) do{if(u8MJPEG_DrvDbgLevel & E_MJPEG_DEBUG_DRV_ERR) printf(format, ##args);}while(0)
131 #else
132 #define LOG_TAG "DRV_JPD"
133 #include <cutils/log.h>
134 #ifndef LOGD
135 #define MJPEG_DEBUG_DRV_MSG(format, args...) do{if(u8MJPEG_DrvDbgLevel & E_MJPEG_DEBUG_DRV_MSG) ALOGI(format, ##args);}while(0)
136 #define MJPEG_DEBUG_DRV_ERR(format, args...) do{if(u8MJPEG_DrvDbgLevel & E_MJPEG_DEBUG_DRV_ERR) ALOGE(format, ##args);}while(0)
137 #else
138 #define MJPEG_DEBUG_DRV_MSG(format, args...) do{if(u8MJPEG_DrvDbgLevel & E_MJPEG_DEBUG_DRV_MSG) LOGI(format, ##args);}while(0)
139 #define MJPEG_DEBUG_DRV_ERR(format, args...) do{if(u8MJPEG_DrvDbgLevel & E_MJPEG_DEBUG_DRV_ERR) LOGE(format, ##args);}while(0)
140 #endif
141
142 #endif
143
144 #define HVD_FW_MEM_OFFSET 0x100000UL // 1M
145
146 #if ENABLE_INC_BUILD
147
148 static MS_U8 u8MJPEG_DrvDbgLevel = E_MJPEG_DEBUG_DRV_NONE;
149
150 static MS_U32 __u32FwAddr = 0xFFFFFFFF;
151
152 static MS_BOOL bDisplayOutSideMode[E_MJPEG_MJPEG_TOTAL] = {0, 0};
153 static MS_U32 u32FrameBuffStAddr[E_MJPEG_MJPEG_TOTAL] = {0, 0};
154 static MS_U32 u32FrameBuffUnitSize[E_MJPEG_MJPEG_TOTAL] = {0, 0};
155 static MS_U32 u32FrameBuffTotalNum[E_MJPEG_MJPEG_TOTAL] = {0, 0};
156 static MS_U16 u16Width[E_MJPEG_MJPEG_TOTAL] = {0, 0};
157 static MS_U16 u16Height[E_MJPEG_MJPEG_TOTAL] = {0, 0};
158 static MS_U16 u16Pitch[E_MJPEG_MJPEG_TOTAL] = {0, 0};
159 static MS_U32 u32FrameCnt[E_MJPEG_MJPEG_TOTAL] = {0, 0};
160
161 /********************************************************************/
162 ///Set MJPEG Debug level
163 ///@para MS_U8 u8DbgLevel \b IN The MJPEG debug level
164 ///@return none
165 /********************************************************************/
MDrv_MJPEG_SetDbgLevel(MS_U8 u8DbgLevel)166 void MDrv_MJPEG_SetDbgLevel(MS_U8 u8DbgLevel)
167 {
168 u8MJPEG_DrvDbgLevel = u8DbgLevel;
169 }
170
171 /* =============================== MJPEG =====================================*/
172
MDrv_MJPEG_GetDrvId(MS_U32 u32Id)173 MS_U8 MDrv_MJPEG_GetDrvId(MS_U32 u32Id)
174 {
175 return (0xFF & (u32Id >> 16));
176 }
177 /******************************************************************************/
178 /// Stop VPU
179 /******************************************************************************/
MDrv_MJPEG_StopVPU(void)180 void MDrv_MJPEG_StopVPU(void)
181 {
182 VirtualHal_MJPEG_StopVPU();
183 }
184
185
186 /******************************************************************************/
187 /// Release VPU
188 /******************************************************************************/
MDrv_MJPEG_ReleaseVPU(void)189 void MDrv_MJPEG_ReleaseVPU(void)
190 {
191 VirtualHal_MJPEG_ReleaseVPU();
192 }
193
194 /******************************************************************************/
195 ///Check if MJPEG firmware ready or not
196 ///@return TRUE or FALSE
197 /******************************************************************************/
MDrv_MJPEG_IsFirmwareReady(void)198 MS_BOOL MDrv_MJPEG_IsFirmwareReady(void)
199 {
200 MS_U32 u32FirmVer = 0, u32Timeout = 50000;
201
202 // read VPU_RISC_MBOX0 to get firmware version
203 while(u32Timeout)
204 {
205 if(VirtualHal_MJPEG_IsVPUMBoxReady(VPU_RISC_MBOX0))
206 {
207 VirtualHal_MJPEG_ReadVPUMBox(VPU_RISC_MBOX0, (MS_U32 *)&u32FirmVer);
208 VirtualHal_MJPEG_ClearVPUMBox(VPU_RISC_MBOX0);
209 break;
210 }
211 u32Timeout--;
212 }
213 if(u32Timeout > 0)
214 {
215 MJPEG_DEBUG_DRV_MSG("MJPEG firmware version 0x%lx\n", u32FirmVer);
216 }
217 else
218 {
219 MJPEG_DEBUG_DRV_ERR("Cannot get MJPEG firmware version !! \n");
220 return FALSE;
221 }
222
223 return TRUE;
224 }
225
226 /******************************************************************************/
227 ///Set VPU Command
228 ///@return TRUE or FALSE
229 ///@param u8Cmd \b IN: VPU Command
230 /// - MJPEG_CMD_SET_FRAME_BUFF_ADDR, Set frame buffer address
231 /// - MJPEG_CMD_SET_FRAME_BUFF_SIZE, Set frame buffer size
232 /******************************************************************************/
MDrv_MJPEG_SetVPUCmd(MS_U32 u32Id,MS_U32 u32Cmd)233 static MS_BOOL MDrv_MJPEG_SetVPUCmd(MS_U32 u32Id, MS_U32 u32Cmd)
234 {
235 //currently we only use VPU_HI_MBOX0 to send command.
236 //MS_U32 u32TimeOut = MsOS_GetSystemTime() + _u32FrameTime;
237 MS_U32 u32TimeOut = 200000;
238 MS_BOOL bResult = FALSE;
239
240 MJPEG_DEBUG_DRV_MSG("Send CMD 0x%lx to MJPEG firmware\n", u32Cmd);
241 //while(MsOS_GetSystemTime() < u32TimeOut)
242 while(u32TimeOut)
243 {
244 if(VirtualHal_MJPEG_IsVPUMBoxReady(VPU_HI_MBOX0))
245 {
246 bResult = VirtualHal_MJPEG_SendVPUMBox(u32Id, VPU_HI_MBOX0, u32Cmd);
247 break;
248 }
249 u32TimeOut--;
250 }
251 if(u32TimeOut <= 0)
252 {
253 MJPEG_DEBUG_DRV_ERR("MJPEG send command timeout !!....pc=0x%lx \n", HAL_VPU_EX_GetProgCnt());
254 bResult = FALSE;
255 }
256
257 return bResult;
258 }
259
260 /******************************************************************************/
261 ///Set VPU command argument
262 ///@return TRUE or FALSE
263 ///@param u32Arg \b IN: VPU command argument
264 /******************************************************************************/
MDrv_MJPEG_SetVPUCmdArg(MS_U32 u32Arg)265 static MS_BOOL MDrv_MJPEG_SetVPUCmdArg(MS_U32 u32Arg)
266 {
267 // we use VPU_HI_MBOX1 to send command argument
268 //U16 u16TimeOut = 0xFFFF;
269 MS_U32 u32TimeOut = 200000;
270 MS_BOOL bResult = FALSE;
271
272 MJPEG_DEBUG_DRV_MSG("Send argument 0x%lx to VPU \n", u32Arg);
273 while(--u32TimeOut)
274 {
275 if( VirtualHal_MJPEG_IsVPUMBoxReady(VPU_HI_MBOX0)&& VirtualHal_MJPEG_IsVPUMBoxReady(VPU_HI_MBOX1))
276 {
277 // the argument to be sent doesn't need to add task information in prefix
278 bResult = VirtualHal_MJPEG_SendVPUMBox(0, VPU_HI_MBOX1, u32Arg);
279 break;
280 }
281 }
282 if(u32TimeOut <= 0)
283 {
284 MJPEG_DEBUG_DRV_ERR("MJPEG send command argument timeout !! \n");
285 bResult = FALSE;
286 }
287
288 return bResult;
289 }
290
291 /******************************************************************************/
292 ///Check VPU status
293 ///@param in \b IN in parameter
294 ///@param out \b OUT out parameter
295 ///@return status
296 /******************************************************************************/
MDrv_MJPEG_CheckVPUStatus(MS_U32 u32Id,MS_U32 u32Cmd)297 static MS_U32 MDrv_MJPEG_CheckVPUStatus(MS_U32 u32Id, MS_U32 u32Cmd)
298 {
299 // MS_BOOL bResult = FALSE;
300 MS_U32 u32Status = 0, u32Timeout = 200000;
301
302 MJPEG_DEBUG_DRV_MSG("Firmware status check: CMD 0x%lX\n", u32Cmd);
303 while (u32Timeout) // Need timeout protection
304 {
305 if(VirtualHal_MJPEG_IsVPUMBoxReady(VPU_HI_MBOX0))
306 {
307 // bResult = VirtualHal_MJPEG_SendVPUMBox(VPU_HI_MBOX0, u32Cmd);
308 VirtualHal_MJPEG_SendVPUMBox(u32Id, VPU_HI_MBOX0, u32Cmd);
309 break;
310 }
311 u32Timeout--;
312 }
313 if(u32Timeout <= 0)
314 {
315 MJPEG_DEBUG_DRV_ERR("u32Cmd=0x%lX MJPEG check vpu status 1 timeout !! \n", u32Cmd);
316 }
317
318 // Get firmware return value
319 u32Timeout = 200000;
320 while(u32Timeout)
321 {
322 if(VirtualHal_MJPEG_IsVPUMBoxReady(VPU_RISC_MBOX0))
323 {
324 VirtualHal_MJPEG_ReadVPUMBox(VPU_RISC_MBOX0, (MS_U32 *)&u32Status);
325 VirtualHal_MJPEG_ClearVPUMBox(VPU_RISC_MBOX0);
326 break;
327 }
328 u32Timeout--;
329 }
330 if(u32Timeout <= 0)
331 {
332 MJPEG_DEBUG_DRV_ERR("u32Cmd=0x%lX MJPEG check vpu status 2 timeout !! \n", u32Cmd);
333 }
334
335 MJPEG_DEBUG_DRV_MSG("Firmware status : 0x%lX\n", u32Status);
336 return u32Status;
337 }
338
339 /******************************************************************************/
340 ///Set VPU command argument
341 ///@return TRUE or FALSE
342 ///@param u32Arg \b IN: VPU command argument
343 /******************************************************************************/
MDrv_MJPEG_SendVPUCommand(MS_U32 u32Id,MJPEG_User_Cmd eCmd,MS_U32 u32Arg)344 MS_U32 MDrv_MJPEG_SendVPUCommand(MS_U32 u32Id, MJPEG_User_Cmd eCmd, MS_U32 u32Arg)
345 {
346 MS_U32 u32Ret = 0;
347
348 MS_U32 idx = 0;
349 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
350
351 if (bDisplayOutSideMode[u8DrvId])
352 {
353 volatile HVD_ShareMem *pShareMem = NULL;
354 MsOS_ReadMemory();
355 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
356 if((MS_U32)pShareMem==0xFFFFFFFF)
357 {
358 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!![%d]\n", __LINE__);
359 return 0xFFFFFFFF;
360 }
361
362 switch (eCmd)
363 {
364 case E_MJPEG_CMD_SET_FRAME_BUFF_START_ADDR:
365 u32FrameBuffStAddr[u8DrvId] = u32Arg;
366 pShareMem->DispQueue[0].u32LumaAddr = u32FrameBuffStAddr[u8DrvId];
367 pShareMem->DispQueue[0].u32Status = E_HVD_DISPQ_STATUS_FREE;
368 MsOS_FlushMemory();
369 break;
370
371 case E_MJPEG_CMD_SET_FRAME_BUFF_UNIT_SIZE:
372 u32FrameBuffUnitSize[u8DrvId] = u32Arg;
373 break;
374
375 case E_MJPEG_CMD_SET_FRAME_BUFF_TOTAL_NUM:
376 if (u32FrameBuffTotalNum[u8DrvId] > HVD_DISP_QUEUE_MAX_SIZE)
377 u32FrameBuffTotalNum[u8DrvId] = HVD_DISP_QUEUE_MAX_SIZE;
378 else
379 u32FrameBuffTotalNum[u8DrvId] = u32Arg;
380
381 pShareMem->u16DispQSize = u32FrameBuffTotalNum[u8DrvId];
382
383 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]-1; idx++)
384 {
385 if (u32FrameBuffUnitSize[u8DrvId] != 0)
386 {
387 pShareMem->DispQueue[idx+1].u32LumaAddr = pShareMem->DispQueue[idx].u32LumaAddr + u32FrameBuffUnitSize[u8DrvId];
388 pShareMem->DispQueue[idx+1].u32Status = E_HVD_DISPQ_STATUS_FREE;
389 }
390 }
391 MsOS_FlushMemory();
392 break;
393
394 case E_MJPEG_CMD_GET_NEXT_FREE_FRAME_BUFF_IDX:
395 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
396 {
397 if (pShareMem->DispQueue[idx].u32Status == E_HVD_DISPQ_STATUS_FREE)
398 {
399 return idx;
400 }
401 }
402 return (0xFFFFFFFF);
403 break;
404
405 case E_MJPEG_CMD_SET_FRAME_BUFF_IDX:
406 if (u32Arg < u32FrameBuffTotalNum[u8DrvId])
407 {
408 pShareMem->DispQueue[u32Arg].u32Status = E_HVD_DISPQ_STATUS_NONE;
409 pShareMem->u32MJPEG_NextFrameBuffIdx = 0xFFFF;
410 MsOS_FlushMemory();
411 }
412 break;
413
414 case E_MJPEG_CMD_PUSH_QUEUE_PARA_SETTING:
415
416 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32Status = E_HVD_DISPQ_STATUS_NONE;
417 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32TimeStamp = pShareMem->u32MJPEGTimeStamp;
418 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32ID_L = pShareMem->u32MJPEGID_L;
419 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32ID_H = pShareMem->u32MJPEGID_H;
420 MsOS_FlushMemory();
421 break;
422
423 case E_MJPEG_CMD_SET_DISPLAY_OUTSIDE_MODE:
424
425 if(u32Arg==0)
426 {
427 bDisplayOutSideMode[u8DrvId] = FALSE;
428 }
429 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
430 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_DISPLAY_OUTSIDE_MODE);
431 break;
432
433 case E_MJPEG_CMD_SET_FRAME_BUFF_IDX_READY:
434 if (u32Arg < u32FrameBuffTotalNum[u8DrvId])
435 {
436 u32FrameCnt[u8DrvId]++;
437 pShareMem->DispQueue[u32Arg].u32Status = E_HVD_DISPQ_STATUS_INIT;
438 pShareMem->DispQueue[u32Arg].u32ChromaAddr = pShareMem->DispQueue[u32Arg].u32LumaAddr;
439 pShareMem->DispQueue[u32Arg].u16Width = u16Width[u8DrvId];
440 pShareMem->DispQueue[u32Arg].u16Height = u16Height[u8DrvId];
441 pShareMem->DispQueue[u32Arg].u16Pitch = u16Pitch[u8DrvId];
442 pShareMem->DispQueue[u32Arg].u32PrivateData = u32FrameCnt[u8DrvId];
443
444 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
445 {
446 if (pShareMem->DispQueue[idx].u32Status == E_HVD_DISPQ_STATUS_FREE)
447 {
448 pShareMem->u32MJPEG_NextFrameBuffIdx = idx;
449 break;
450 }
451 else
452 {
453 pShareMem->u32MJPEG_NextFrameBuffIdx = 0xFFFF;
454 }
455 }
456 }
457 MsOS_FlushMemory();
458 break;
459
460 case E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID:
461 if (u32Arg < u32FrameBuffTotalNum[u8DrvId])
462 {
463 pShareMem->DispQueue[u32Arg].u32Status = E_HVD_DISPQ_STATUS_FREE;
464 MsOS_FlushMemory();
465 }
466 break;
467
468 case E_MJPEG_CMD_FLUSH_DISP_QUEUE:
469
470 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
471 {
472 if (pShareMem->DispQueue[idx].u32Status != E_HVD_DISPQ_STATUS_VIEW)
473 {
474 pShareMem->DispQueue[idx].u32Status = E_HVD_DISPQ_STATUS_FREE;
475 pShareMem->DispQueue[idx].u32TimeStamp = 0;
476 pShareMem->DispQueue[idx].u32ID_L = 0xFFFFFFFF;
477 pShareMem->DispQueue[idx].u32ID_H = 0xFFFFFFFF;
478 }
479 }
480 pShareMem->u8MJPEG_bFlushQueue = 0;
481 u32Ret = TRUE;
482 MsOS_FlushMemory();
483 break;
484
485 case E_MJPEG_CMD_IS_DISPLAY_QUEUE_FULL:
486 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
487 {
488 if (pShareMem->DispQueue[idx].u32Status == E_HVD_DISPQ_STATUS_FREE)
489 {
490 return 0;
491 }
492 }
493 MJPEG_DEBUG_DRV_MSG("Display Q is full[%d]\n", __LINE__);
494 // return full
495 return 1;
496 break;
497
498 case E_MJPEG_CMD_SET_WIDTH:
499 u16Width[u8DrvId] = (MS_U16)u32Arg;
500 break;
501
502 case E_MJPEG_CMD_SET_HEIGHT:
503 u16Height[u8DrvId] = (MS_U16)u32Arg;
504 break;
505
506 case E_MJPEG_CMD_SET_PITCH:
507 u16Pitch[u8DrvId] = (MS_U16)u32Arg;
508 break;
509
510 case E_MJPEG_CMD_IS_DISP_FINISH:
511 u32Ret = TRUE;
512 break;
513
514 case E_MJPEG_CMD_SET_FRAME_ID_L:
515 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32ID_L = u32Arg;
516 MsOS_FlushMemory();
517 break;
518
519 case E_MJPEG_CMD_SET_FRAME_ID_H:
520 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32ID_H = u32Arg;
521 MsOS_FlushMemory();
522 break;
523
524 case E_MJPEG_CMD_SET_TIMESTAMP:
525 pShareMem->DispQueue[pShareMem->u32MJPEGFrameBuffIdx].u32TimeStamp = u32Arg;
526 MsOS_FlushMemory();
527 break;
528 case E_MJPEG_CMD_GO:
529 case E_MJPEG_CMD_SET_FRAMERATE:
530 case E_MJPEG_CMD_SET_FRAMERATE_BASE:
531 case E_MJPEG_CMD_SET_CHIP_ID:
532 case E_MJPEG_CMD_PLAY:
533 case E_MJPEG_CMD_PAUSE:
534 case E_MJPEG_CMD_RESUME:
535 case E_MJPEG_CMD_STEP_PLAY:
536 case E_MJPEG_CMD_SET_SPEED_TYPE:
537 case E_MJPEG_CMD_SET_SPEED:
538 case E_MJPEG_CMD_FREEZE_DISP:
539 case E_MJPEG_CMD_ENABLE_AVSYNC:
540 case E_MJPEG_CMD_SET_AVSYNC_DELAY:
541 case E_MJPEG_CMD_SET_AVSYNC_TOLERENCE:
542 case E_MJPEG_CMD_SET_PTS_BASE:
543 case E_MJPEG_CMD_SET_STC_BASE:
544 case E_MJPEG_CMD_SET_BLUE_SCREEN:
545 case E_MJPEG_CMD_COMPENSATE_PTS:
546 case E_MJPEG_CMD_ENABLE_DISP_CMD_QUEUE:
547 case E_MJPEG_CMD_PUSH_DISP_CMD:
548 case E_MJPEG_CMD_GET_DISP_CMD_Q_VACANCY:
549 case E_MJPEG_CMD_IS_STEP_PLAY_DONE:
550 case E_MJPEG_CMD_IS_PLAYING:
551 case E_MJPEG_CMD_IS_AVSYNC_ON:
552 case E_MJPEG_CMD_IS_REACH_AVSYNC:
553 case E_MJPEG_CMD_IS_FLUSH_DONE:
554 MJPEG_DEBUG_DRV_MSG(" Unused MJPEG Command[0x%x] in display outside mode\n", eCmd);
555 u32Ret = 0xFFFFFFFF;
556 break;
557
558 default:
559 MJPEG_DEBUG_DRV_MSG(" !!! Unknown MJPEG Command[0x%x] !!!\n", eCmd);
560 u32Ret = 0xFFFFFFFF;
561 break;
562 }
563
564 return u32Ret;
565 }
566
567 switch (eCmd)
568 {
569 case E_MJPEG_CMD_GO:
570 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_GO);
571 break;
572
573 case E_MJPEG_CMD_SET_FRAME_BUFF_START_ADDR:
574 u32FrameBuffStAddr[u8DrvId] = u32Arg;
575 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
576 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_START_ADDR);
577 break;
578
579 case E_MJPEG_CMD_SET_FRAME_BUFF_UNIT_SIZE:
580 u32FrameBuffUnitSize[u8DrvId] = u32Arg;
581 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
582 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_UNIT_SIZE);
583 break;
584
585 case E_MJPEG_CMD_SET_FRAME_BUFF_TOTAL_NUM:
586 if (u32FrameBuffTotalNum[u8DrvId] > HVD_DISP_QUEUE_MAX_SIZE)
587 u32FrameBuffTotalNum[u8DrvId] = HVD_DISP_QUEUE_MAX_SIZE;
588 else
589 u32FrameBuffTotalNum[u8DrvId] = u32Arg;
590 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
591 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_TOTAL_NUM);
592 break;
593
594 case E_MJPEG_CMD_SET_FRAME_BUFF_IDX:
595 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
596 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_IDX);
597 break;
598
599 case E_MJPEG_CMD_SET_FRAME_BUFF_IDX_READY:
600 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
601 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_IDX_READY);
602 break;
603
604 case E_MJPEG_CMD_SET_WIDTH:
605 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
606 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_WIDTH);
607 break;
608
609 case E_MJPEG_CMD_SET_HEIGHT:
610 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
611 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_HEIGHT);
612 break;
613
614 case E_MJPEG_CMD_SET_PITCH:
615 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
616 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_PITCH);
617 break;
618
619 case E_MJPEG_CMD_SET_FRAME_ID_L:
620 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
621 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_ID_L);
622 break;
623
624 case E_MJPEG_CMD_SET_FRAME_ID_H:
625 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
626 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_ID_H);
627 break;
628
629 case E_MJPEG_CMD_SET_TIMESTAMP:
630 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
631 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_TIMESTAMP);
632 break;
633
634 case E_MJPEG_CMD_SET_FRAMERATE:
635 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
636 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAMERATE);
637 break;
638
639 case E_MJPEG_CMD_SET_FRAMERATE_BASE:
640 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
641 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAMERATE_BASE);
642 break;
643
644 case E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID:
645 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
646 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_IDX_VALID);
647 break;
648
649 case E_MJPEG_CMD_SET_CHIP_ID:
650 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
651 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_CHIP_ID);
652 break;
653
654 case E_MJPEG_CMD_PLAY:
655 u32Ret = (MS_U32)MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_PLAY);
656 break;
657
658 case E_MJPEG_CMD_PAUSE:
659 u32Ret = (MS_U32)MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_PAUSE);
660 break;
661
662 case E_MJPEG_CMD_RESUME:
663 u32Ret = (MS_U32)MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_RESUME);
664 break;
665
666 case E_MJPEG_CMD_STEP_PLAY:
667 u32Ret = (MS_U32)MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_STEP_PLAY);
668 break;
669
670 case E_MJPEG_CMD_SET_SPEED_TYPE:
671 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
672 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_SPEED_TYPE);
673 break;
674
675 case E_MJPEG_CMD_SET_SPEED:
676 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
677 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_SPEED);
678 break;
679
680 case E_MJPEG_CMD_FLUSH_DISP_QUEUE:
681 u32Ret = (MS_U32)MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_FLUSH_DISP_QUEUE);
682 break;
683
684 case E_MJPEG_CMD_FREEZE_DISP:
685 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
686 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_FREEZE_DISP);
687 break;
688
689 case E_MJPEG_CMD_ENABLE_AVSYNC:
690 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
691 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_ENABLE_AVSYNC);
692 break;
693
694 case E_MJPEG_CMD_SET_AVSYNC_DELAY:
695 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
696 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_AVSYNC_DELAY);
697 break;
698
699 case E_MJPEG_CMD_SET_AVSYNC_TOLERENCE:
700 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
701 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_AVSYNC_TOLERENCE);
702 break;
703
704 case E_MJPEG_CMD_SET_PTS_BASE:
705 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
706 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_PTS_BASE);
707 break;
708
709 case E_MJPEG_CMD_SET_STC_BASE:
710 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_STC_BASE);
711 break;
712
713 case E_MJPEG_CMD_SET_BLUE_SCREEN:
714 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
715 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_BLUE_SCREEN);
716 break;
717
718 case E_MJPEG_CMD_PUSH_QUEUE_PARA_SETTING:
719 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_PUSH_QUEUE_PARA_SETTING);
720 break;
721
722 case E_MJPEG_CMD_SET_DISPLAY_OUTSIDE_MODE:
723
724 if(u32Arg)
725 {
726 bDisplayOutSideMode[u8DrvId] = TRUE;
727 }
728 if (bDisplayOutSideMode[u8DrvId])
729 {
730 // set E_JPD_CMD_SET_FRAME_BUFF_TOTAL_NUM to 0 previent F/W write share mem
731 MDrv_MJPEG_SetVPUCmdArg(0);
732 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_FRAME_BUFF_TOTAL_NUM);
733 MDrv_MJPEG_SetVPUCmdArg(0);
734 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_ENABLE_DISP_CMD_QUEUE);
735
736 MsOS_DelayTaskUs(10* 1000);
737 u32FrameCnt[u8DrvId] = 0;
738
739 volatile HVD_ShareMem *pShareMem = NULL;
740 MsOS_ReadMemory();
741 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
742 if((MS_U32)pShareMem==0xFFFFFFFF)
743 {
744 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!![%d]\n", __LINE__);
745 return 0xFFFFFFFF;
746 }
747
748 pShareMem->DispQueue[0].u32LumaAddr = u32FrameBuffStAddr[u8DrvId];
749 pShareMem->DispQueue[0].u32Status = E_HVD_DISPQ_STATUS_FREE;
750 pShareMem->u16DispQSize = u32FrameBuffTotalNum[u8DrvId];
751
752 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]-1; idx++)
753 {
754 if (u32FrameBuffUnitSize[u8DrvId] != 0)
755 {
756 pShareMem->DispQueue[idx+1].u32LumaAddr = pShareMem->DispQueue[idx].u32LumaAddr + u32FrameBuffUnitSize[u8DrvId];
757 pShareMem->DispQueue[idx+1].u32Status = E_HVD_DISPQ_STATUS_FREE;
758 }
759 }
760
761 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
762 {
763 MJPEG_DEBUG_DRV_MSG("pShareMem->DispQueue[idx].u32Status : 0x%lX %ld\n", pShareMem->DispQueue[idx].u32Status, idx);
764 }
765 MsOS_FlushMemory();
766 }
767 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
768 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_SET_DISPLAY_OUTSIDE_MODE);
769 break;
770
771 case E_MJPEG_CMD_GET_NEXT_FREE_FRAME_BUFF_IDX:
772 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_GET_NEXT_FREE_FRAME_BUFF_IDX);
773 break;
774
775 case E_MJPEG_CMD_COMPENSATE_PTS:
776 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
777 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_COMPENSATE_PTS);
778 break;
779
780 // Display Command Queue -- BEGIN
781 case E_MJPEG_CMD_ENABLE_DISP_CMD_QUEUE:
782 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
783 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_ENABLE_DISP_CMD_QUEUE);
784 break;
785
786 case E_MJPEG_CMD_PUSH_DISP_CMD:
787 MDrv_MJPEG_SetVPUCmdArg(u32Arg);
788 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_PUSH_DISP_CMD);
789 break;
790
791 case E_MJPEG_CMD_GET_DISP_CMD_Q_VACANCY:
792 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_GET_DISP_CMD_Q_VACANCY);
793 break;
794 // Display Command Queue -- END
795
796 case E_MJPEG_CMD_IS_STEP_PLAY_DONE:
797 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_STEP_PLAY_DONE);
798 break;
799
800 case E_MJPEG_CMD_IS_DISP_FINISH:
801 #if USE_MJPEG_SHAREMEMORY
802 MDrv_MJPEG_Init_IsDispFinish(u32Id);
803 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_IS_DISP_FINISH);
804 u32Ret = (MS_U32) MDrv_MJPEG_IsDispFinish(u32Id);
805 #else
806 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_DISP_FINISH);
807 #endif
808 break;
809
810 case E_MJPEG_CMD_IS_PLAYING:
811 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_PLAYING);
812 break;
813
814 case E_MJPEG_CMD_IS_DISPLAY_QUEUE_FULL:
815 #if USE_MJPEG_SHAREMEMORY
816 MDrv_MJPEG_Init_IsQueueFull(u32Id);
817 MDrv_MJPEG_SetVPUCmd(u32Id, E_JPD_CMD_IS_DISPLAY_QUEUE_FULL);
818 u32Ret = (MS_U32) MDrv_MJPEG_IsQueueFull(u32Id);
819 #else
820 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_DISPLAY_QUEUE_FULL);
821 #endif
822 break;
823
824 case E_MJPEG_CMD_IS_AVSYNC_ON:
825 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_AVSYNC_ON);
826 break;
827
828 case E_MJPEG_CMD_IS_REACH_AVSYNC:
829 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_REACH_AVSYNC);
830 break;
831
832 case E_MJPEG_CMD_IS_FLUSH_DONE:
833 u32Ret = MDrv_MJPEG_CheckVPUStatus(u32Id, E_JPD_CMD_IS_FLUSH_DONE);
834 break;
835
836 default:
837 MJPEG_DEBUG_DRV_MSG(" !!! Unknown MJPEG Command !!!\n");
838 u32Ret = 0xFFFFFFFF;
839 break;
840 }
841
842
843 return u32Ret;
844 }
845
846 #if 0
847 /******************************************************************************/
848 ///
849 ///@param value \b IN
850 ///@param value \b OUT
851 ///@return status
852 /******************************************************************************/
853 MS_BOOL MDrv_MJPEG_IsVPUOnMiu1(void)
854 {
855 return VirtualHal_MJPEG_IsVPUOnMiu1();
856 }
857
858 /******************************************************************************/
859 ///
860 ///@param value \b IN
861 ///@param value \b OUT
862 ///@return status
863 /******************************************************************************/
864 MS_U32 MDrv_MJPEG_GetMiuBase(void)
865 {
866 return VirtualHal_MJPEG_GetMiuBase();
867 }
868 #endif
869
870 /******************************************************************************/
871 ///Get ShareMemory address
872 ///@param u32Value \b IN new PTS value
873 /******************************************************************************/
MDrv_MJPEG_GetShareMemAddr(MS_U32 u32Id)874 MS_U32 MDrv_MJPEG_GetShareMemAddr(MS_U32 u32Id)
875 {
876 MS_U32 u32ShareMemAddr = 0xFFFFFFFF;
877
878 if (__u32FwAddr != 0xFFFFFFFF)
879 u32ShareMemAddr = __u32FwAddr +(HAL_VPU_EX_GetTaskId(u32Id) * HVD_FW_MEM_OFFSET) + HVD_SHARE_MEM_ST_OFFSET;
880 else
881 return 0xFFFFFFFF;
882
883 u32ShareMemAddr = MS_PA2KSEG1((MS_U32)u32ShareMemAddr); //PhysicalAddr to VirtualAddr
884
885 return u32ShareMemAddr;
886 }
887
888 /******************************************************************************/
889 ///Description
890 ///@param in \b IN in parameter
891 ///@param out \b OUT out parameter
892 ///@return status
893 /******************************************************************************/
MDrv_MJPEG_ClearShareMemory(MS_U32 u32Id)894 void MDrv_MJPEG_ClearShareMemory(MS_U32 u32Id)
895 {
896 MS_U32 u32Idx = 0, u32Size;
897 volatile MS_U8 *u8Ptr = 0;
898
899 u8Ptr = (volatile MS_U8 *)MDrv_MJPEG_GetShareMemAddr(u32Id);
900 if((MS_U32)u8Ptr==0xFFFFFFFF)
901 {
902 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
903 return;
904 }
905 u32Size = sizeof(HVD_ShareMem);
906
907 for (u32Idx = 0; u32Idx < u32Size; u32Idx++)
908 {
909 *u8Ptr = 0;
910 u8Ptr++;
911 }
912 return;
913 }
914
915 /******************************************************************************/
916 ///Get PTS table address
917 ///@param u32Value \b IN new PTS value
918 /******************************************************************************/
MDrv_MJPEG_GetPtsTableAddr(MS_U32 u32Id)919 MS_U32 MDrv_MJPEG_GetPtsTableAddr(MS_U32 u32Id)
920 {
921 MS_U32 u32PtsAddr = 0xFFFFFFFF;
922 #if defined(SUPPORT_NEW_MEM_LAYOUT)
923 volatile HVD_ShareMem *pShareMem = NULL;
924 MsOS_ReadMemory();
925 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
926 MS_U32 u32HVD_PTS_TABLE_ST_OFFSET = pShareMem->u32HVD_PTS_TABLE_ST_OFFSET - HAL_VPU_EX_GetTaskId(u32Id) * HVD_FW_MEM_OFFSET;
927 #else
928 MS_U32 u32HVD_PTS_TABLE_ST_OFFSET = HVD_PTS_TABLE_ST_OFFSET;
929 #endif
930
931 if (__u32FwAddr != 0xFFFFFFFF)
932 u32PtsAddr = __u32FwAddr + u32HVD_PTS_TABLE_ST_OFFSET;
933 else
934 return 0xFFFFFFFF;
935
936 u32PtsAddr = MS_PA2KSEG1((MS_U32)u32PtsAddr); //PhysicalAddr to VirtualAddr
937
938 return u32PtsAddr;
939 }
940
941 /******************************************************************************/
942 ///Reset PTS value
943 ///@param u32Value \b IN new PTS value
944 /******************************************************************************/
MDrv_MJPEG_ResetPTS(MS_U32 u32Id,MS_U32 u32PtsBase)945 MS_BOOL MDrv_MJPEG_ResetPTS(MS_U32 u32Id, MS_U32 u32PtsBase)
946 {
947
948 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_PTS_BASE, u32PtsBase);
949
950 return TRUE;
951 }
952
953 /******************************************************************************/
954 ///Return PTS of current displayed frame
955 ///@return PTS
956 /******************************************************************************/
MDrv_MJPEG_GetPTS(MS_U32 u32Id)957 MS_U32 MDrv_MJPEG_GetPTS(MS_U32 u32Id)
958 {
959 volatile HVD_ShareMem *pShareMem = NULL;
960 MsOS_ReadMemory();
961
962 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
963 if((MS_U32)pShareMem==0xFFFFFFFF)
964 {
965 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
966 return NULL;
967 }
968
969 return pShareMem->DispFrmInfo.u32TimeStamp;
970 }
971
972 /******************************************************************************/
973 ///Description
974 ///@param in \b IN in parameter
975 ///@param out \b OUT out parameter
976 ///@return status
977 /******************************************************************************/
MDrv_MJPEG_DispFrame(MS_U32 u32Id,MS_U32 u32DispIdx)978 void MDrv_MJPEG_DispFrame(MS_U32 u32Id, MS_U32 u32DispIdx)
979 {
980 volatile HVD_ShareMem *pShareMem = NULL;
981 MsOS_ReadMemory();
982 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
983 if((MS_U32)pShareMem==0xFFFFFFFF)
984 {
985 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
986 return;
987 }
988
989 if (pShareMem->DispQueue[u32DispIdx].u32Status == E_HVD_DISPQ_STATUS_VIEW)
990 {
991 pShareMem->DispQueue[u32DispIdx].u32Status = E_HVD_DISPQ_STATUS_DISP;
992 }
993 MsOS_FlushMemory();
994 }
995
996 /******************************************************************************/
997 ///Description
998 ///@param in \b IN in parameter
999 ///@param out \b OUT out parameter
1000 ///@return status
1001 /******************************************************************************/
MDrv_MJPEG_FreeFrame(MS_U32 u32Id,MS_U32 u32DispIdx)1002 void MDrv_MJPEG_FreeFrame(MS_U32 u32Id, MS_U32 u32DispIdx)
1003 {
1004 volatile HVD_ShareMem *pShareMem = NULL;
1005 MsOS_ReadMemory();
1006 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1007 if((MS_U32)pShareMem==0xFFFFFFFF)
1008 {
1009 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1010 return;
1011 }
1012
1013 if (pShareMem->DispQueue[u32DispIdx].u32Status == E_HVD_DISPQ_STATUS_VIEW)
1014 {
1015 pShareMem->DispQueue[u32DispIdx].u32Status = E_HVD_DISPQ_STATUS_FREE;
1016 }
1017 MsOS_FlushMemory();
1018 }
1019
1020 /******************************************************************************/
1021 ///Description
1022 ///@param in \b IN in parameter
1023 ///@param out \b OUT out parameter
1024 ///@return status
1025 /******************************************************************************/
1026 #define MJPEG_DISPQ_PREFETCH_COUNT 2
1027
1028 static MS_U16 _u16DispQPtr[E_MJPEG_MJPEG_TOTAL] = {0, 0};
MDrv_MJPEG_GetNextDispFrame(MS_U32 u32Id)1029 void* MDrv_MJPEG_GetNextDispFrame(MS_U32 u32Id)
1030 {
1031 volatile HVD_ShareMem *pShareMem = NULL;
1032 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1033 MsOS_ReadMemory();
1034 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1035 if((MS_U32)pShareMem==0xFFFFFFFF)
1036 {
1037 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1038 return NULL;
1039 }
1040
1041 HVD_Frm_Information *pFrm;
1042
1043 if (bDisplayOutSideMode[u8DrvId])
1044 {
1045 MS_U32 idx = 0;
1046 MS_S32 found = -1;
1047
1048 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
1049 {
1050 if (pShareMem->DispQueue[idx].u32Status == E_HVD_DISPQ_STATUS_INIT)
1051 {
1052 MJPEG_DEBUG_DRV_MSG("MDrv_MJPEG_GetNextDispFrame, pShareMem->DispQueue[%ld].u32PrivateData = %ld", idx, pShareMem->DispQueue[idx].u32PrivateData);
1053
1054 if (found >= 0)
1055 {
1056 // find the older one
1057 if (pShareMem->DispQueue[idx].u32PrivateData < pShareMem->DispQueue[found].u32PrivateData)
1058 found = idx;
1059 }
1060 else
1061 {
1062 found = idx;
1063 }
1064 }
1065 }
1066
1067 if (found >= 0)
1068 {
1069 pFrm = (HVD_Frm_Information *)(MS_U32)&(pShareMem->DispQueue[found]);
1070 _u16DispQPtr[u8DrvId] = found;
1071 pFrm->u32Status = E_HVD_DISPQ_STATUS_VIEW;
1072 MsOS_FlushMemory();
1073 MJPEG_DEBUG_DRV_MSG("bDisplayOutSideMode-->FrameDone: %ld, pFrm=0x%lx, timestamp=%ld\n", idx, (MS_U32)pFrm, pFrm->u32TimeStamp);
1074 return pFrm;
1075 }
1076 else
1077 {
1078 MJPEG_DEBUG_DRV_MSG("MDrv_MJPEG_GetNextDispFrame return NULL!!!\n");
1079 return NULL;
1080 }
1081 }
1082 else
1083 {
1084
1085 MS_U16 u16QNum = pShareMem->u16DispQNumb;
1086 MS_U16 u16QPtr = pShareMem->u16DispQPtr;
1087
1088 #if 0
1089 if (u16QNum > MJPEG_DISPQ_PREFETCH_COUNT) u16QNum = MJPEG_DISPQ_PREFETCH_COUNT;
1090 #endif
1091
1092 while (u16QNum != 0)
1093 {
1094 pFrm = (HVD_Frm_Information*)(MS_U32)&(pShareMem->DispQueue[u16QPtr]);
1095
1096 if (pFrm->u32Status == E_HVD_DISPQ_STATUS_INIT)
1097 {
1098 _u16DispQPtr[u8DrvId] = u16QPtr;
1099 pFrm->u32Status = E_HVD_DISPQ_STATUS_VIEW; /////Change its state!!
1100 MJPEG_DEBUG_DRV_MSG("FrameDone: %d, pFrm=0x%lx, timestamp=%ld\n", u16QPtr, (MS_U32)pFrm, pFrm->u32TimeStamp);
1101 return pFrm;
1102 }
1103 u16QNum--;
1104 u16QPtr++;
1105 if (u16QPtr == pShareMem->u16DispQSize) u16QPtr = 0; //wrap to the begin
1106 }
1107 MsOS_FlushMemory();
1108 return NULL;
1109 }
1110 }
1111
MDrv_MJPEG_GetDispFrameNum(MS_U32 u32Id)1112 MS_U32 MDrv_MJPEG_GetDispFrameNum(MS_U32 u32Id)
1113 {
1114 volatile HVD_ShareMem *pShareMem = NULL;
1115 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1116
1117 MsOS_ReadMemory();
1118 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1119 if((MS_U32)pShareMem==0xFFFFFFFF)
1120 {
1121 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1122 return NULL;
1123 }
1124
1125 HVD_Frm_Information *pFrm;
1126 MS_U32 u32DispFrmNum = 0;
1127
1128 if (bDisplayOutSideMode[u8DrvId])
1129 {
1130 MS_U32 idx = 0;
1131 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
1132 {
1133 pFrm = (HVD_Frm_Information *)(MS_U32)&(pShareMem->DispQueue[idx]);
1134
1135 if (pFrm->u32Status == E_HVD_DISPQ_STATUS_INIT)
1136 {
1137 u32DispFrmNum++;
1138 }
1139 }
1140 return u32DispFrmNum;
1141 }
1142 else
1143 {
1144 MS_U16 u16QNum = pShareMem->u16DispQNumb;
1145 MS_U16 u16QPtr = pShareMem->u16DispQPtr;
1146
1147 while (u16QNum != 0)
1148 {
1149 pFrm = (HVD_Frm_Information *)(MS_U32)&(pShareMem->DispQueue[u16QPtr]);
1150
1151 if (pFrm->u32Status == E_HVD_DISPQ_STATUS_INIT)
1152 {
1153 u32DispFrmNum++;
1154 }
1155 u16QNum--;
1156 u16QPtr++;
1157 if (u16QPtr == pShareMem->u16DispQSize)
1158 {
1159 u16QPtr = 0; //wrap to the begin
1160 }
1161 }
1162 return u32DispFrmNum;
1163 }
1164 }
1165
1166 /******************************************************************************/
1167 ///Description
1168 ///@param in \b IN in parameter
1169 ///@param out \b OUT out parameter
1170 ///@return status
1171 /******************************************************************************/
MDrv_MJPEG_GetNextDispQPtr(MS_U32 u32Id)1172 MS_U32 MDrv_MJPEG_GetNextDispQPtr(MS_U32 u32Id)
1173 {
1174 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1175 return _u16DispQPtr[u8DrvId];
1176 }
1177
1178 /******************************************************************************/
1179 ///Description
1180 ///@param in \b IN in parameter
1181 ///@param out \b OUT out parameter
1182 ///@return status
1183 /******************************************************************************/
MDrv_MJPEG_GetDispFrameInfo(MS_U32 u32Id,void * pInfo)1184 void MDrv_MJPEG_GetDispFrameInfo(MS_U32 u32Id, void *pInfo)
1185 {
1186 MJPEG_DRV_FrameInfo *pFrmInfo = (MJPEG_DRV_FrameInfo *)pInfo;
1187
1188 volatile HVD_ShareMem *pShareMem = NULL;
1189 MsOS_ReadMemory();
1190 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1191 if((MS_U32)pShareMem==0xFFFFFFFF)
1192 {
1193 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1194 return;
1195 }
1196
1197 pFrmInfo->u32LumaAddr = pShareMem->DispFrmInfo.u32LumaAddr;
1198 pFrmInfo->u32ChromaAddr = pShareMem->DispFrmInfo.u32ChromaAddr;
1199 pFrmInfo->u32TimeStamp = pShareMem->DispFrmInfo.u32TimeStamp;
1200 pFrmInfo->u32ID_L = pShareMem->DispFrmInfo.u32ID_L;
1201 pFrmInfo->u32ID_H = pShareMem->DispFrmInfo.u32ID_H;
1202 }
1203
MDrv_MJPEG_EnableTurboFWMode(MS_BOOL bEnable)1204 void MDrv_MJPEG_EnableTurboFWMode(MS_BOOL bEnable)
1205 {
1206 // gbEnableTurboFWMode = bEnable;
1207 HAL_VPU_EX_SetFWReload(!bEnable);
1208 }
1209
MDrv_MJPEG_InitFw(MS_U32 u32Id,MS_U32 u32Size,MS_PHYADDR u32Addr,MS_U32 u32BinSize,MS_PHYADDR u32BinAddr,MS_U8 u8FwSrcType)1210 MJPEG_Return MDrv_MJPEG_InitFw(MS_U32 u32Id, MS_U32 u32Size, MS_PHYADDR u32Addr, MS_U32 u32BinSize, MS_PHYADDR u32BinAddr, MS_U8 u8FwSrcType)
1211 {
1212 __u32FwAddr = u32Addr;
1213
1214 MJPEG_DEBUG_DRV_MSG("MDrv_MJPEG_InitFw u32Size = 0x%lx, u32Addr = 0x%lx, u32BinSize = 0x%lx, u32BinAddr = 0x%lx, u8FwSrcType = %d\n", u32Size, u32Addr, u32BinSize, u32BinAddr, u8FwSrcType);
1215 // for wb
1216 //MDrv_MJPEG_ClearShareMemory(u32Id);
1217
1218 bDisplayOutSideMode[MDrv_MJPEG_GetDrvId(u32Id)] = FALSE;
1219
1220 // Set Codec Type for HVD Firmware
1221 volatile HVD_ShareMem *pHVDShareMem = NULL;
1222 pHVDShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1223 if((MS_U32)pHVDShareMem==0xFFFFFFFF)
1224 {
1225 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1226 return E_MJPEG_FAILED;
1227 }
1228 pHVDShareMem->u32CodecType = E_HVD_Codec_MJPEG;
1229 // u16ChipID is set in HAL_HVD_EX_InitShareMem()
1230 //pHVDShareMem->u16ChipID = E_MSTAR_CHIP_J2;
1231 MsOS_FlushMemory();
1232
1233 // Create Task
1234 VPU_EX_FWCodeCfg stVpuFWCfg;
1235 VPU_EX_TaskInfo stTaskInfo;
1236 VPU_EX_VLCTblCfg stVlcCfg;
1237 VPU_EX_NDecInitPara stVpuInitPara;
1238
1239 memset(&stVpuFWCfg, 0, sizeof(VPU_EX_FWCodeCfg));
1240 memset(&stTaskInfo, 0, sizeof(VPU_EX_TaskInfo));
1241 memset(&stVlcCfg, 0, sizeof(VPU_EX_VLCTblCfg));
1242 memset(&stVpuInitPara, 0, sizeof(VPU_EX_NDecInitPara));
1243
1244 stVpuInitPara.pFWCodeCfg = &stVpuFWCfg;
1245 stVpuInitPara.pTaskInfo = &stTaskInfo;
1246
1247 stVpuFWCfg.u32DstAddr = MsOS_PA2KSEG1(u32Addr);
1248 stVpuFWCfg.u32DstSize = u32Size;
1249 stVpuFWCfg.u32BinAddr = MsOS_PA2KSEG1(u32BinAddr);
1250 stVpuFWCfg.u32BinSize = u32BinSize;
1251 stVpuFWCfg.u8SrcType = u8FwSrcType;
1252
1253
1254 stTaskInfo.u32Id = u32Id;
1255 stTaskInfo.eDecType = E_VPU_EX_DECODER_HVD;
1256 stTaskInfo.eVpuId = (HAL_VPU_StreamId) (0xFF & u32Id);
1257 stTaskInfo.eSrcType = E_VPU_EX_INPUT_FILE;
1258
1259 HAL_VPU_EX_TaskCreate(u32Id, &stVpuInitPara);
1260
1261 return E_MJPEG_OK;
1262 }
1263
MDrv_MJPEG_Get_Chip_ID(void)1264 MJPEG_MSTAR_CHIP_ID MDrv_MJPEG_Get_Chip_ID(void)
1265 {
1266 return VirtualHal_MJPEG_Get_Chip_ID();
1267 }
1268
MDrv_MJPEG_GetFreeStream(MS_U32 * pu32Id,MJPEG_DRV_StreamType eStreamType)1269 MJPEG_Return MDrv_MJPEG_GetFreeStream(MS_U32 *pu32Id, MJPEG_DRV_StreamType eStreamType)
1270 {
1271 MJPEG_Return eRet = E_MJPEG_INVALID_PARAM;
1272 MS_U8 i = 0xff;
1273 MS_U32 u32VPUStreamId = 0;
1274 MS_U32 u32MJPEGStreamId = 0;
1275
1276 MJPEG_DEBUG_DRV_MSG("%20s:%30s: Id=0x%lX\n", __FILE__, __FUNCTION__, (*pu32Id));
1277
1278 switch(eStreamType)
1279 {
1280 case(E_MJPEG_DRV_MAIN_STREAM):
1281 i = 0;
1282 break;
1283 case(E_MJPEG_DRV_SUB_STREAM):
1284 i = 1;
1285 break;
1286 case(E_MJPEG_DRV_STREAM_NONE):
1287 default:
1288 i = 0xff;
1289 break;
1290 }
1291
1292 if ( i == 0xff )
1293 {
1294 return E_MJPEG_FAILED;
1295 }
1296
1297 if (E_MJPEG_DRV_MAIN_STREAM == eStreamType)
1298 {
1299 u32VPUStreamId = (MS_U32) HAL_VPU_EX_GetFreeStream(E_HAL_VPU_MAIN_STREAM);
1300 u32MJPEGStreamId = (MS_U32) VirtualHal_MJPEG_GetFreeStream(E_HAL_MJPEG_MAIN_STREAM);
1301
1302 if (u32VPUStreamId && u32MJPEGStreamId)
1303 {
1304 *pu32Id = (i << 16 | u32MJPEGStreamId << 8 | u32VPUStreamId);
1305 eRet = E_MJPEG_OK;
1306 }
1307 }
1308 else //if (E_MJPEG_DRV_SUB_STREAM== eStreamType)
1309 {
1310 u32VPUStreamId = (MS_U32) HAL_VPU_EX_GetFreeStream(E_HAL_VPU_SUB_STREAM);
1311 u32MJPEGStreamId = (MS_U32) VirtualHal_MJPEG_GetFreeStream(E_HAL_MJPEG_SUB_STREAM);
1312
1313 if (u32VPUStreamId && u32MJPEGStreamId)
1314 {
1315 *pu32Id = (i << 16 | u32MJPEGStreamId << 8 | u32VPUStreamId);
1316 eRet = E_MJPEG_OK;
1317 }
1318 }
1319
1320
1321 MJPEG_DEBUG_DRV_MSG("%20s:%30s: Id=0x%lX\n", __FILE__, __FUNCTION__, (*pu32Id));
1322
1323 return eRet;
1324 }
1325
MDrv_MJPEG_DeInit(MS_U32 u32Id)1326 MJPEG_Return MDrv_MJPEG_DeInit(MS_U32 u32Id)
1327 {
1328 MJPEG_Return eRet = E_MJPEG_INVALID_PARAM;
1329
1330 VPU_EX_FWCodeCfg stVpuFWCfg;
1331 VPU_EX_TaskInfo stTaskInfo;
1332 VPU_EX_NDecInitPara stVpuInitPara;
1333
1334 stVpuInitPara.pFWCodeCfg = &stVpuFWCfg;
1335 stVpuInitPara.pTaskInfo = &stTaskInfo;
1336
1337 stVpuFWCfg.u32DstAddr = MsOS_PA2KSEG1(__u32FwAddr);
1338 stVpuFWCfg.u8SrcType = E_HVD_FW_INPUT_SOURCE_NONE;
1339
1340 stTaskInfo.u32Id = u32Id;
1341 stTaskInfo.eDecType = E_VPU_EX_DECODER_HVD;
1342 stTaskInfo.eVpuId = (HAL_VPU_StreamId) (0xFF & u32Id);
1343 stTaskInfo.eSrcType = E_VPU_EX_INPUT_FILE;
1344
1345 if ( HAL_VPU_EX_TaskDelete(u32Id, &stVpuInitPara) ) eRet = E_MJPEG_OK;
1346
1347 return eRet;
1348 }
1349
MDrv_MJPEG_InitRegBase(MS_U32 u32RegBase)1350 void MDrv_MJPEG_InitRegBase(MS_U32 u32RegBase)
1351 {
1352 HAL_VPU_EX_InitRegBase(u32RegBase);
1353 }
1354
MDrv_MJPEG_SetPushQPara(MS_U32 u32Id,MS_U32 u32TimeStamp,MS_U32 u32ID_L,MS_U32 u32ID_H,MS_U32 u32NextFrameBuffIdx)1355 void MDrv_MJPEG_SetPushQPara(MS_U32 u32Id, MS_U32 u32TimeStamp, MS_U32 u32ID_L, MS_U32 u32ID_H, MS_U32 u32NextFrameBuffIdx)
1356 {
1357 volatile HVD_ShareMem *pShareMem = NULL;
1358 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1359 if((MS_U32)pShareMem==0xFFFFFFFF)
1360 {
1361 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1362 return;
1363 }
1364
1365 pShareMem->u32MJPEGFrameBuffIdx = u32NextFrameBuffIdx;
1366 pShareMem->u32MJPEGTimeStamp = u32TimeStamp;
1367 pShareMem->u32MJPEGID_L = u32ID_L;
1368 pShareMem->u32MJPEGID_H = u32ID_H;
1369 pShareMem->u32MJPEG_NextFrameBuffIdx = 0xffff;
1370 MsOS_FlushMemory();
1371
1372 }
1373
1374
MDrv_MJPEG_SetStepDispPara(MS_U32 u32Id)1375 void MDrv_MJPEG_SetStepDispPara(MS_U32 u32Id)
1376 {
1377 volatile HVD_ShareMem *pShareMem = NULL;
1378 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1379 if((MS_U32)pShareMem==0xFFFFFFFF)
1380 {
1381 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1382 return;
1383 }
1384 pShareMem->u8MJPEG_bStepPlay = TRUE;
1385 MsOS_FlushMemory();
1386
1387 }
1388
1389
MDrv_MJPEG_PrintShareInfo(MS_U32 u32Id)1390 void MDrv_MJPEG_PrintShareInfo(MS_U32 u32Id)
1391 {
1392 volatile HVD_ShareMem *pShareMem = NULL;
1393 MsOS_ReadMemory();
1394 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1395 if((MS_U32)pShareMem==0xFFFFFFFF)
1396 {
1397 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1398 return;
1399 }
1400
1401 MJPEG_DEBUG_DRV_MSG("0x%08x, r:%d, w:%d, sys=%ld, v_pts=%ld, s/r=%ld(%c)\n",
1402 (int)pShareMem->u32MJPEGDbg_DispStatus,
1403 pShareMem->u8MJPEGDbg_ReadFbIdx, pShareMem->u8MJPEGDbg_WriteFbIdx,
1404 pShareMem->u32MJPEGDbg_SysTime, pShareMem->u32MJPEGDbg_VideoPts,
1405 pShareMem->u32MJPEGDbg_SkipRepeatTime, pShareMem->u8MJPEGDbg_SkipRepeat
1406 );
1407 }
1408
MDrv_MJPEG_GetNextFrameBufferIdx(MS_U32 u32Id)1409 MS_U32 MDrv_MJPEG_GetNextFrameBufferIdx(MS_U32 u32Id)
1410 {
1411 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1412 volatile HVD_ShareMem *pShareMem = NULL;
1413 MsOS_ReadMemory();
1414 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1415 if((MS_U32)pShareMem==0xFFFFFFFF)
1416 {
1417 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1418 return NULL;
1419 }
1420
1421 if (bDisplayOutSideMode[u8DrvId])
1422 {
1423 MS_U32 idx = 0;
1424 for (idx = 0; idx < u32FrameBuffTotalNum[u8DrvId]; idx++)
1425 {
1426 if (pShareMem->DispQueue[idx].u32Status == E_HVD_DISPQ_STATUS_FREE) return idx;
1427 }
1428 MJPEG_DEBUG_DRV_ERR("MDrv_MJPEG_GetNextFrameBufferIdx is full!!!\n");
1429 return (0xFFFFFFFF);
1430 }
1431 else
1432 {
1433 return pShareMem->u32MJPEG_NextFrameBuffIdx;
1434 }
1435 }
1436
MDrv_MJPEG_IsStepPlayDone(MS_U32 u32Id)1437 MS_BOOL MDrv_MJPEG_IsStepPlayDone(MS_U32 u32Id)
1438 {
1439 volatile HVD_ShareMem *pShareMem = NULL;
1440 MsOS_ReadMemory();
1441 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1442 if((MS_U32)pShareMem==0xFFFFFFFF)
1443 {
1444 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1445 return FALSE;
1446 }
1447 return (MS_BOOL)pShareMem->u8MJPEG_bStepPlay;
1448 }
1449
MDrv_MJPEG_IsPlaying(MS_U32 u32Id)1450 MS_BOOL MDrv_MJPEG_IsPlaying(MS_U32 u32Id)
1451 {
1452 volatile HVD_ShareMem *pShareMem = NULL;
1453 MsOS_ReadMemory();
1454 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1455 if((MS_U32)pShareMem==0xFFFFFFFF)
1456 {
1457 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1458 return FALSE;
1459 }
1460 return (MS_BOOL)pShareMem->u8MJPEG_bPlaying;
1461 }
1462
MDrv_MJPEG_IsAVSyncOn(MS_U32 u32Id)1463 MS_BOOL MDrv_MJPEG_IsAVSyncOn(MS_U32 u32Id)
1464 {
1465 volatile HVD_ShareMem *pShareMem = NULL;
1466 MsOS_ReadMemory();
1467 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1468 if((MS_U32)pShareMem==0xFFFFFFFF)
1469 {
1470 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1471 return FALSE;
1472 }
1473 return (MS_BOOL)pShareMem->u8MJPEG_bIsAVSyncOn;
1474 }
1475
MDrv_MJPEG_IsReachAVSync(MS_U32 u32Id)1476 MS_BOOL MDrv_MJPEG_IsReachAVSync(MS_U32 u32Id)
1477 {
1478 volatile HVD_ShareMem *pShareMem = NULL;
1479 MsOS_ReadMemory();
1480 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1481 if((MS_U32)pShareMem==0xFFFFFFFF)
1482 {
1483 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1484 return FALSE;
1485 }
1486 return (MS_BOOL)pShareMem->u8MJPEG_bIsReachAVSync;
1487 }
1488
MDrv_MJPEG_IsFlushDone(MS_U32 u32Id)1489 MS_BOOL MDrv_MJPEG_IsFlushDone(MS_U32 u32Id)
1490 {
1491 volatile HVD_ShareMem *pShareMem = NULL;
1492 MsOS_ReadMemory();
1493 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1494 if((MS_U32)pShareMem==0xFFFFFFFF)
1495 {
1496 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1497 return FALSE;
1498 }
1499 return (MS_BOOL)(!pShareMem->u8MJPEG_bFlushQueue);
1500 }
1501
MDrv_MJPEG_InitFlush(MS_U32 u32Id)1502 void MDrv_MJPEG_InitFlush(MS_U32 u32Id)
1503 {
1504 volatile HVD_ShareMem *pShareMem = NULL;
1505 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1506 if((MS_U32)pShareMem==0xFFFFFFFF)
1507 {
1508 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1509 return;
1510 }
1511 pShareMem->u8MJPEG_bFlushQueue = 1;
1512 MsOS_FlushMemory();
1513 }
1514
1515
MDrv_MJPEG_Init_IsDispFinish(MS_U32 u32Id)1516 void MDrv_MJPEG_Init_IsDispFinish(MS_U32 u32Id)
1517 {
1518 volatile HVD_ShareMem *pShareMem = NULL;
1519 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1520 if((MS_U32)pShareMem==0xFFFFFFFF)
1521 {
1522 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1523 return;
1524 }
1525 pShareMem->u8MJPEG_bIsDispFinish = 0xff;
1526 MsOS_FlushMemory();
1527 }
1528
MDrv_MJPEG_IsDispFinish(MS_U32 u32Id)1529 MS_BOOL MDrv_MJPEG_IsDispFinish(MS_U32 u32Id)
1530 {
1531 volatile HVD_ShareMem *pShareMem = NULL;
1532 MsOS_ReadMemory();
1533 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1534 if((MS_U32)pShareMem==0xFFFFFFFF)
1535 {
1536 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1537 return FALSE;
1538 }
1539 MS_U32 u32Timer;
1540
1541 u32Timer = MsOS_GetSystemTime();
1542 while(1)
1543 {
1544 if (MsOS_GetSystemTime()-u32Timer > 30)
1545 {
1546 MJPEG_DEBUG_DRV_ERR("MDrv_MJPEG_IsDispFinish() timeout...\n");
1547 break;
1548 }
1549 if(pShareMem->u8MJPEG_bIsDispFinish!=0xff)
1550 break;
1551 }
1552 return (MS_BOOL)(pShareMem->u8MJPEG_bIsDispFinish);
1553 }
1554
1555
MDrv_MJPEG_Init_IsQueueFull(MS_U32 u32Id)1556 void MDrv_MJPEG_Init_IsQueueFull(MS_U32 u32Id)
1557 {
1558 volatile HVD_ShareMem *pShareMem = NULL;
1559 MsOS_ReadMemory();
1560 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1561 if((MS_U32)pShareMem==0xFFFFFFFF)
1562 {
1563 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1564 return;
1565 }
1566 pShareMem->u8MJPEG_bQueueFull = 0xff;
1567 }
1568
MDrv_MJPEG_IsQueueFull(MS_U32 u32Id)1569 MS_BOOL MDrv_MJPEG_IsQueueFull(MS_U32 u32Id)
1570 {
1571 volatile HVD_ShareMem *pShareMem = NULL;
1572 MsOS_ReadMemory();
1573 pShareMem = (HVD_ShareMem *)MDrv_MJPEG_GetShareMemAddr(u32Id);
1574 if((MS_U32)pShareMem==0xFFFFFFFF)
1575 {
1576 MJPEG_DEBUG_DRV_ERR("Cannot get pShareMem correctly!!!\n");
1577 return FALSE;
1578 }
1579 MS_U32 u32Timer;
1580
1581 u32Timer = MsOS_GetSystemTime();
1582 while(1)
1583 {
1584 if (MsOS_GetSystemTime()-u32Timer > 1000)
1585 {
1586 MJPEG_DEBUG_DRV_ERR("MDrv_MJPEG_IsQueueFull() timeout...\n");
1587 break;
1588 }
1589 MsOS_ReadMemory();
1590 if(pShareMem->u8MJPEG_bQueueFull!=0xff)
1591 {
1592 MJPEG_DEBUG_DRV_ERR("[%ld]ms\n", MsOS_GetSystemTime()-u32Timer);
1593 break;
1594 }
1595 }
1596 return (MS_BOOL)(pShareMem->u8MJPEG_bQueueFull);
1597
1598 }
1599 #endif
1600 #endif
1601
1602