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 #include "MsCommon.h"
101 #include "MsIRQ.h"
102 #include "MsOS.h"
103 #ifdef MSOS_TYPE_LINUX_KERNEL
104 #include <linux/string.h>
105 #else
106 #include <string.h>
107 #endif
108
109 // Internal Definition
110 #include "regCHIP.h"
111 #include "drvAUDIO.h"
112 #include "regAUDIO.h"
113 #include "halAUDIO.h"
114 #include "halADVAUDIO.h"
115 #include "halMAD.h"
116 #include "halMAD2.h"
117 #include "halSOUND.h"
118 #include "halSIF.h"
119 #include "r2_shm_comm.h"
120 #include "decR2_shm.h"
121 #if ASND_R2_SUPPORT
122 #include "sndR2_shm.h"
123 #endif
124 #include "halAUR2.h"
125 #include "ddr_config.h"
126
127 #if (defined ANDROID)
128
129 #include <sys/mman.h>
130 #include <cutils/ashmem.h>
131 #include <cutils/log.h>
132
133 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
134 #define LOGI ALOGI
135 #endif
136
137 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
138 #define LOGE ALOGE
139 #endif
140
141 #define HALMAD_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
142 #define HALMAD_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
143
144 #else
145 #ifdef CONFIG_MBOOT //mboot Speed up
146 #define HALMAD_PRINT(fmt, args...)
147 #define HALMAD_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
148 #else
149 #define HALMAD_PRINT(fmt, args...) printf("[[utopia]] " fmt, ## args)
150 #define HALMAD_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
151 #endif
152 #endif
153
154
155 //-------------------------------------------------------------------------------------------------
156 // Driver Compiler Options
157 //-------------------------------------------------------------------------------------------------
158 #define OMX_AUDIO_DEBUG 0
159 #define DBG_MAD(msg) //msg
160 #define AUD_ERRMSG(msg) MS_CRITICAL_MSG(msg)
161 #define AUD_DBGMSG(msg) MS_DEBUG_MSG(msg)
162
163 #define HALMAD_CHECK_SHM_INIT \
164 do { \
165 if (g_AudioVars2 == NULL) \
166 { \
167 HALMAD_ERROR("%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
168 HALMAD_ERROR("%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
169 if (HAL_AUDIO_InitialVars() == FALSE) \
170 { \
171 MS_ASSERT(0);\
172 } \
173 } \
174 } while(0)
175
176 //-------------------------------------------------------------------------------------------------
177 // Local Defines
178 //-------------------------------------------------------------------------------------------------
179
180 #define H2BYTE(value) ((MS_U8)((value) / 0x10000))
181 #define HIBYTE(value) ((MS_U8)((value >>8) & 0x0000FF))
182 #define LOBYTE(value) ((MS_U8)((value) & 0x0000FF))
183
184 #ifndef UNUSED
185 #define UNUSED(x) ((x)=(x))
186 #endif
187
188 /* TVOS2.0 DTV */
189 #define STC_CLOCK_TICK 90
190 #define STC_BITS_MASK 0x1FFFFFFFF
191 #define STC_TICK_TO_NS(t) ((((t) & STC_BITS_MASK) * 1000LL) /STC_CLOCK_TICK)
192
193 //-------------------------------------------------------------------------------------------------
194 // Local Structures
195 //-------------------------------------------------------------------------------------------------
196
197 AES_INFO audio_aes_info[2];
198
199 //-------------------------------------------------------------------------------------------------
200 // Global Variables
201 //-------------------------------------------------------------------------------------------------
202 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit);
203 extern AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
204 extern MS_VIRT _gMIO_MapBase;
205 extern MS_U32 g_audioDumpInfo_interval;
206 extern AUDIO_SPDIF_OUTPUT_TYPE gSpdifOutputType;
207 extern HDMI_TX_OUTPUT_TYPE gHdmiOutputType;
208 extern MS_PHY g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2];
209 MS_U32 g_AudioDumpInfoCtrl = Audio_DumpInfo_Off;
210
211 extern MS_S32 _s32MutexLoadCode;
212 extern MS_S32 _s32AUDIOMutexIDMA;
213
214 //====== STAOS PIP START 2012/02/12 ========
215
216 extern pFuncPtr_SetAudioParam2 g_FuncPrt_Hal_SetAudioParam2;
217 extern pFuncPtr_GetAudioInfo2 g_FuncPrt_Hal_GetAudioInfo2;
218
219 //====== STAOS PIP END 2012/02/12 ========
220
221 //-------------------------------------------------------------------------------------------------
222 // Local Variables
223 //-------------------------------------------------------------------------------------------------
224 //static MS_BOOL EncodeInProcess;
225 //#define ENC_BUF_SIZE 6;
226 extern AUDIO_SHARED_VARS2 *g_AudioVars2;
227 #ifndef MSOS_TYPE_NUTTX
228 extern AUDIO_TEE_INFO_SHARE_MEM *pAudioTeeInfoShm;
229 extern MS_BOOL g_bAudioTeeEnabled, g_bAudioTeeMbxInitialized;
230 extern MS_BOOL g_bDecDspSecureTeeAccessed, g_bSndDspSecureTeeAccessed;
231 #endif
232 extern MS_BOOL (*g_FuncPtr_CheckCapability)(AUDIO_DEC_ID eDecId, AudioDecStatus_t * p_AudioDecStatus);
233
234 MS_U32 EncFrameIdx;
235 MS_U32 EncBuf_W_idx;
236 MS_U32 EncBuf_R_idx;
237 MS_U8 EncBuf_Count;
238 MS_U16 Reg_REG_SOUND_MAIN_SNDEFFECT = 0x0;
239 MS_U16 Reg_REG_SOUND_ADV_CFG0 = 0x0;
240 MS_BOOL Flag_MAIN_SNDEFFET_CHG = FALSE;
241
242 AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
243
244 MS_BOOL FLAG_HDMI_AC3_IN_SE = FALSE;
245
246 static MS_U32 g_ReadTargetAddr=0x2D00;
247 static MS_BOOL g_bR2Adec1AD = FALSE;
248 static MS_BOOL g_bR2Adec2AD = FALSE;
249
250 #define AUDIO_HASHKEY_DISABLE_AC3 0x1
251 #define AUDIO_HASHKEY_DISABLE_AC3P 0x2
252 #define AUDIO_HASHKEY_DISABLE_DDCO 0x4
253 #define AUDIO_HASHKEY_DISABLE_DTS 0x8
254 #define AUDIO_HASHKEY_DISABLE_DOLBY_MS10 0x10
255 #define AUDIO_HASHKEY_DISABLE_WMA 0x20
256 #define AUDIO_HASHKEY_DISABLE_DRA 0x40
257 #define AUDIO_HASHKEY_DISABLE_DTSLBR 0x80
258 #define AUDIO_HASHKEY_DISABLE_GAAC 0x100
259 #define AUDIO_HASHKEY_DISABLE_DOLBY_MS11 0x200
260 #define AUDIO_HASHKEY_DISABLE_DTSE 0x400
261 #define AUDIO_HASHKEY_DISABLE_DTS_NEO_ULTRA 0x800
262 #define AUDIO_HASHKEY_DEMO_MODE 0x1000
263 #define AUDIO_HASHKEY_DISABLE_SRS_TSHD 0x2000
264 #define AUDIO_HASHKEY_DISABLE_SRS_THEATERSOUND 0x4000
265 #define AUDIO_HASHKEY_DISABLE_DTS_STUDIO_SOUND_3D 0x8000
266 #define AUDIO_HASHKEY_DISABLE_COOK 0x10000
267 #define AUDIO_HASHKEY_DISABLE_DTS_XLL 0x20000
268 #define AUDIO_HASHKEY_DISABLE_MS12_LC_PROFILE 0x40000
269 #define AUDIO_HASHKEY_DISABLE_MS12_C_PROFILE 0x80000
270 #define AUDIO_HASHKEY_DISABLE_ABS_3D 0x100000
271 #define AUDIO_HASHKEY_DISABLE_MS12_B_PROFILE 0x200000
272
273 const MS_U16 MpegBitRateTable[6][16] =
274 {
275 // V1, L1
276 {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0},
277 // V1, L2
278 {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0},
279 // V1, L3
280 {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
281 // V2, L1
282 {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},
283 // V2, L2
284 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
285 // V2, L3
286 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
287 };
288
289
290 //-------------------------------------------------------------------------------------------------
291 // Debug Functions
292 //-------------------------------------------------------------------------------------------------
293
294 //-------------------------------------------------------------------------------------------------
295 // Local Functions
296 //-------------------------------------------------------------------------------------------------
_GetAudioCaps(AUDIO_DEC_ID eDecId)297 MMA_AudioType _GetAudioCaps(AUDIO_DEC_ID eDecId)
298 {
299 MMA_AudioType eAudioCaps = 0;
300
301 if ( eDecId == AU_DEC_ID1 )
302 {
303 if(g_AudioVars2->g_hbr_bypass_enable==true)
304 {
305 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
306 Audio_DEC_MP3 | Audio_DEC_AC3 |
307 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
308 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
309 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
310 Audio_DEC_WMA | Audio_DEC_WMAPRO |
311 Audio_DEC_XPCM | Audio_DEC_VORBIS |
312 Audio_DEC_DTS | Audio_DEC_FLAC |
313 Audio_DEC_DTSLBR | Audio_DEC_DRA |
314 Audio_DEC_DTS_HD_ADO_R2 | Audio_DEC_Dolby_TrueHD_Bypass_R2;
315 }
316 else
317 {
318 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
319 Audio_DEC_MP3 | Audio_DEC_AC3 |
320 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
321 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
322 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
323 Audio_DEC_WMA | Audio_DEC_WMAPRO |
324 Audio_DEC_XPCM | Audio_DEC_VORBIS |
325 Audio_DEC_DTS | Audio_DEC_FLAC |
326 Audio_DEC_DTSLBR | Audio_DEC_DRA | Audio_DEC_DTS_HD_ADO_R2;
327 }
328 }
329 else if ( eDecId == AU_DEC_ID2 )
330 {
331 eAudioCaps = 0;
332 }
333 else if ( eDecId == AU_DEC_ID3 )
334 {
335 if(g_AudioVars2->g_hbr_bypass_enable==true)
336 {
337 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
338 Audio_DEC_MP3 | Audio_DEC_AC3 |
339 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
340 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
341 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
342 Audio_DEC_WMA | Audio_DEC_WMAPRO |
343 Audio_DEC_XPCM | Audio_DEC_VORBIS |
344 Audio_DEC_DTS | Audio_DEC_FLAC |
345 Audio_DEC_DTSLBR | Audio_DEC_DRA |
346 Audio_DEC_DTS_HD_ADO_R2 | Audio_DEC_Dolby_TrueHD_Bypass_R2;
347 }
348 else
349 {
350 eAudioCaps = Audio_DEC_PCM | Audio_DEC_MPEG |
351 Audio_DEC_MP3 | Audio_DEC_AC3 |
352 Audio_DEC_AC3P | Audio_DEC_AAC_LC |
353 Audio_DEC_HEAAC_V1 | Audio_DEC_HEAAC_V2 |
354 Audio_DEC_DOLBYPULSE | Audio_DEC_RA8 |
355 Audio_DEC_WMA | Audio_DEC_WMAPRO |
356 Audio_DEC_XPCM | Audio_DEC_VORBIS |
357 Audio_DEC_DTS | Audio_DEC_FLAC |
358 Audio_DEC_DTSLBR | Audio_DEC_DRA | Audio_DEC_DTS_HD_ADO_R2;
359 }
360 }
361
362 return eAudioCaps;
363 }
364
365 ////////////////////////////////////////////////////////////////////////////////
366 /// @brief \b Function \b Name: HAL_MAD_GetAudioCapability()
367 /// @brief \b Function \b Description: This routine is used to get DSP capability
368 /// @param <IN> \b eDecId : Dec ID
369 /// @param <IN> \b p_AudioDecStatus : Audio Dec Status structure
370 /// @param <RET> \b value : 0-- eDecId not support
371 /// 1-- eDecId support
372 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetAudioCapability(AUDIO_DEC_ID eDecId,AudioDecStatus_t * p_AudioDecStatus)373 MS_BOOL HAL_MAD_GetAudioCapability(AUDIO_DEC_ID eDecId, AudioDecStatus_t * p_AudioDecStatus)
374 {
375 MS_BOOL ret = FALSE;
376
377 if (eDecId == AU_DEC_ID2)
378 {
379 return ret;
380 }
381
382 switch ((p_AudioDecStatus->eSourceType))
383 {
384 case E_AUDIO_INFO_HDMI_IN: // HDMI should decode in SE and DEC DSP, always return true
385 case E_AUDIO_INFO_ATV_IN:
386 ret = TRUE;
387 break;
388
389 case E_AUDIO_INFO_DTV_IN:
390 if ((p_AudioDecStatus->eGroup == E_CONNECT_MAIN) ||
391 (p_AudioDecStatus->eGroup == E_CONNECT_SUB))
392 {
393 ret = TRUE;
394 }
395 break;
396
397 case E_AUDIO_INFO_MM_IN:
398 case E_AUDIO_INFO_GAME_IN:
399 ret = TRUE;
400 break;
401
402 default:
403 if ((p_AudioDecStatus->eAudFormat) == (_GetAudioCaps(eDecId) & (p_AudioDecStatus->eAudFormat)))
404 {
405 ret = TRUE;
406 }
407 break;
408 }
409
410 return ret;
411 }
412 //-------------------------------------------------------------------------------------------------
413 // Global Functions
414 //-------------------------------------------------------------------------------------------------
415
416 ///-----------------------------------------------------------------------------
417 ////////////////////////////////////////////////////////////////////////////////
418 ////////////////////////////////////////////////////////////////////////////////
419 ///
420 /// AUDIO_MAD SYSETM Relational Hal Function
421 ///
422 ////////////////////////////////////////////////////////////////////////////////
423 ////////////////////////////////////////////////////////////////////////////////
424 ///-----------------------------------------------------------------------------
425 ////////////////////////////////////////////////////////////////////////////////
426 /// @brief \b Function \b Name: HAL_MAD_Read_DSP_sram()
427 /// @brief \b Function \b Description: This routine is used to Read DSP internal sram value by IDMA
428 /// @param <IN> \b dsp_addr : DSP internal sram address
429 /// @param <IN> \b dsp_memory_type : 0--DSP_MEM_TYPE_PM
430 /// 1--DSP_MEM_TYPE_DM
431 /// @param <OUT> \b NONE :
432 /// @param <RET> \b value : U32 sram value
433 /// @param <GLOBAL> \b NONE :
434 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Read_DSP_sram(MS_U16 u16Dsp_addr,AUDIO_DSP_MEMORY_TYPE dsp_memory_type)435 MS_U32 HAL_MAD_Read_DSP_sram(MS_U16 u16Dsp_addr,AUDIO_DSP_MEMORY_TYPE dsp_memory_type)
436 {
437 // Do nothing because no DEC-DSP in Monoco
438 UNUSED(u16Dsp_addr);
439 UNUSED(dsp_memory_type);
440
441 return 0;
442 }
443
444 ////////////////////////////////////////////////////////////////////////////////
445 /// @brief \b Function \b Name: HAL_MAD_Write_DSP_sram()
446 /// @brief \b Function \b Description: This routine is used to Write DSP internal sram value by IDMA
447 /// @param <IN> \b dsp_addr : DSP internal sram address
448 /// @param <IN> \b value : data want to write
449 /// @param <IN> \b dsp_memory_type : 0-- write to DSP_MEM_TYPE_PM
450 /// 1-- write to DSP_MEM_TYPE_DM
451 /// @param <OUT> \b NONE :
452 /// @param <RET> \b NONE : TRUE/FALSE
453 /// @param <GLOBAL> \b NONE :
454 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Write_DSP_sram(MS_U16 dsp_addr,MS_U32 value,AUDIO_DSP_MEMORY_TYPE dsp_memory_type)455 MS_BOOL HAL_MAD_Write_DSP_sram(MS_U16 dsp_addr, MS_U32 value, AUDIO_DSP_MEMORY_TYPE dsp_memory_type)
456 {
457 // Do nothing because no DEC-DSP in Monoco
458 UNUSED(dsp_addr);
459 UNUSED(value);
460 UNUSED(dsp_memory_type);
461
462 return TRUE;
463 }
464
465 ////////////////////////////////////////////////////////////////////////////////
466 /// @brief \b Function \b Name: HAL_MAD_Init()
467 /// @brief \b Function \b Description: This routine is the initialization for DVB module
468 /// @param <IN> \b NONE :
469 /// @param <OUT> \b NONE :
470 /// @param <RET> \b NONE :
471 /// @param <GLOBAL> \b NONE :
472 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Init(void)473 void HAL_MAD_Init(void)
474 {
475 //CarhyNeedReview
476
477 // to do : R2 init
478 HAL_MAD_LoadCode(AU_DVB_STANDARD_MPEG);
479
480 g_FuncPrt_Hal_SetAudioParam2 = HAL_MAD_SetAudioParam2;
481 g_FuncPrt_Hal_GetAudioInfo2 = HAL_MAD_GetAudioInfo2;
482 g_FuncPtr_CheckCapability = HAL_MAD_GetAudioCapability;
483 }
484
485 ////////////////////////////////////////////////////////////////////////////////
486 /// @brief \b Function \b Name: HAL_MAD_SetMemInfo()
487 /// @brief \b Function \b Description: This routine is used to set the DEC-DSP memory information
488 /// @param <IN> \b NONE :
489 /// @param <OUT> \b NONE :
490 /// @param <RET> \b NONE :
491 /// @param <GLOBAL> \b NONE :
492 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetMemInfo(void)493 void HAL_MAD_SetMemInfo(void)
494 {
495 // Remove all memory Info(SE-DSP & R2) to SetMemInfo2
496 return;
497 }
498
499 ////////////////////////////////////////////////////////////////////////////////
500 /// @brief \b Function \b Name: HAL_MAD_SetEncCmd()
501 /// @brief \b Function \b Description: This routine is to set encode command.
502 /// @param <IN> \b u8EncCmd :
503 /// 0--STOP
504 /// 1--START ENCODE
505 /// @param <OUT> \b NONE :
506 /// @param <RET> \b NONE :
507 /// @param <GLOBAL> \b NONE :
508 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetEncCmd(AU_DVB_ENCCMD u8EncCmd)509 void HAL_MAD_SetEncCmd(AU_DVB_ENCCMD u8EncCmd)
510 {
511 // not use, remove
512 }
513
514 ////////////////////////////////////////////////////////////////////////////////
515 /// @brief \b Function \b Name: HAL_MAD_EncodeInit() @@ function can be extended
516 /// @brief \b Function \b Description: This routine is to init encode parameter.
517 /// @param <IN> \b u8EncBr :
518 /// Encode Output Bitrate: 0:192kBps, 1:384kBps, 2:128kBps, 3:64kBps
519 /// \b
520 /// @param <OUT> \b NONE :
521 /// @param <RET> \b NONE :
522 /// @param <GLOBAL> \b NONE :
523 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_EncodeInit(AU_DVB_ENCBR u8EncBr,MS_U8 u8EncFrameNum)524 void HAL_MAD_EncodeInit(AU_DVB_ENCBR u8EncBr, MS_U8 u8EncFrameNum)
525 {
526 // not use, remove
527 }
528 ////////////////////////////////////////////////////////////////////////////////
529 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeFrameInfo() @@kochien added for PVR
530 /// @brief \b Function \b Description: This routine is used to get encoded frame information
531 /// @param <IN> \b u32Addr : encoded frame start address
532 /// @param <IN> \b u32Size : encoded frame data size
533 /// @param <IN> \b u64EncIdx : frame idx for PTS
534 /// @param <OUT> \b NONE :
535 /// @param <RET> \b NONE :
536 /// @param <GLOBAL> \b NONE :
537 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeFrameInfo(AU_DVB_ENC_FRAME_INFO * FrameInfo)538 void HAL_AUDIO_GetEncodeFrameInfo(AU_DVB_ENC_FRAME_INFO *FrameInfo)
539 {
540 // not use, remove
541 }
542
543
544 ////////////////////////////////////////////////////////////////////////////////
545 /// @brief \b Function \b Name: HAL_MAD_setDecCmd()
546 /// @brief \b Function \b Description: This routine is to set the DVB1 decode command.
547 /// @param <IN> \b u8DecCmd :
548 /// 0--STOP
549 /// 1--PLAY
550 /// 1--RESYNC
551 /// @param <OUT> \b NONE :
552 /// @param <RET> \b NONE :
553 /// @param <GLOBAL> \b NONE :
554 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDecCmd(AU_DVB_DECCMD u8DecCmd)555 void HAL_MAD_SetDecCmd(AU_DVB_DECCMD u8DecCmd)
556 {
557 MS_U8 FREERUN_STATE = 0;
558 MS_U16 u16_timeout = 0;
559 MS_U32 u32_r2_cmd = 0, u32_driver_cmd = 0;
560 DBG_MAD(printf("HAL_MAD_setDecCmd:(%x)\r\n",u8DecCmd));
561
562 if (u8DecCmd == AU_DVB_DECCMD_AVSYNC)
563 {
564 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, 0x00); // bit[15] = 0
565 }
566 else if (u8DecCmd == AU_DVB_DECCMD_FREERUN)
567 {
568 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, 0x80); // bit[15] = 1, AU_DEC_R2_CMD_FREERUN
569 }
570 else
571 {
572
573 switch(u8DecCmd)
574 {
575 case AU_DVB_DECCMD_STOP:
576 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, ADEC1, 0, 0);
577 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0, 0); //Set ES write pointer to start point.
578 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0xEF, AU_DEC_R2_CMD_STOP);
579 break;
580
581 case AU_DVB_DECCMD_PLAY:
582 if (g_AudioVars2->g_u8MADSkipResetFlag == TRUE)
583 {
584 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, ADEC1, 0, 0);
585 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0, 0); //Set ES write pointer to start point.
586 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0xFF, AU_DEC_R2_CMD_STOP);
587 g_AudioVars2->g_u8MADSkipResetFlag = FALSE;
588 }
589 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAY);
590 break;
591
592 case AU_DVB_DECCMD_PLAYFILETSP:
593 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAYFILETSP);
594 break;
595
596 case AU_DVB_DECCMD_PLAYFRAME_GS :
597 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAYUNI);
598 break;
599
600 case AU_DVB_DECCMD_PLAYFILE:
601 case AU_DVB_DECCMD_PLAYFILE2_PTS:
602 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x6F, AU_DEC_R2_CMD_PLAYFILE);
603 break;
604
605 case AU_DVB_DECCMD_PLAY_AD:
606 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x10, AU_DEC_R2_CMD_PLAY_AD);
607 break;
608
609 case AU_DVB_DECCMD_STOP_AD:
610 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x10, 0x00);
611 break;
612
613 case AU_DVB_DECCMD_PAUSE:
614 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x40, AU_DEC_R2_CMD_PAUSE);
615 break;
616
617 case AU_DVB_DECCMD_SKIP:
618 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x7F, AU_DEC_R2_CMD_SKIP);
619 g_AudioVars2->g_u8MADSkipResetFlag = TRUE;
620 break;
621
622 default:
623 break;
624 }
625
626 FREERUN_STATE = HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD)&0x80; // check free-run
627 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, FREERUN_STATE);
628
629 /* handshake scheme between R2 and Driver */
630 if((u8DecCmd == AU_DVB_DECCMD_PLAY)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILETSP)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE)
631 ||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_STAGE)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_GS)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE2_PTS))
632 {
633 u32_driver_cmd = R2_DECCMD_PLAY; //DEC_PLAYSTATE_PLAY
634 }
635 else if(u8DecCmd == AU_DVB_DECCMD_STOP)
636 {
637 u32_driver_cmd = R2_DECCMD_STOP; //DEC_PLAYSTATE_STOP
638 }
639 else if(u8DecCmd == AU_DVB_DECCMD_PAUSE)
640 {
641 u32_driver_cmd = R2_DECCMD_PAUSE; //DEC_PLAYSTATE_PAUSE
642 }
643 else
644 {
645 return;
646 }
647
648 /* wait command passing to r2 */
649 while(u16_timeout++ < 100)
650 {
651 u32_r2_cmd = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFFFF;
652 AUDIO_DELAY1MS(1);
653 if (u32_r2_cmd == u32_driver_cmd)
654 break;
655 }
656
657 if (u16_timeout >= 100 )
658 {
659 HALMAD_ERROR(" === HAL_MAD_SetDecCmd %d fail===\n",u8DecCmd);
660 }
661 }
662 }
663
HAL_MAD_SetDecCmd2(AUDIO_DEC_ID DecId,AU_DVB_DECCMD u8DecCmd)664 void HAL_MAD_SetDecCmd2(AUDIO_DEC_ID DecId, AU_DVB_DECCMD u8DecCmd)
665 {
666 if (AUDIO_DSP_ID_DEC == g_AudioVars2->AudioDecStatus[DecId].eDSPId)
667 {
668 // ADEC DSP
669 HAL_MAD_SetDecCmd(u8DecCmd);
670 }
671 else if (AUDIO_DSP_ID_SND == g_AudioVars2->AudioDecStatus[DecId].eDSPId)
672 {
673 // ASND DSP
674 HAL_MAD_SetDSP2DecCmd(u8DecCmd);
675 }
676 else
677 {
678 // AU_DEC_ID2 only for ATV SIF
679 // For other case should not use AU_DEC_ID2
680 return;
681 }
682
683 if(g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_DTV_IN)
684 {
685 switch(DecId)
686 {
687 case AU_DEC_ID1:
688 case AU_DEC_ID2:
689 {
690 switch(u8DecCmd)
691 {
692 case AU_DVB_DECCMD_PLAY_AD:
693 {
694 g_bR2Adec1AD = TRUE;
695 }
696 break;
697 case AU_DVB_DECCMD_STOP_AD:
698 {
699 g_bR2Adec1AD = FALSE;
700 }
701 break;
702 default:
703 break;
704 }
705 }
706 break;
707 case AU_DEC_ID3:
708 {
709 switch(u8DecCmd)
710 {
711 case AU_DVB_DECCMD_PLAY_AD:
712 {
713 g_bR2Adec2AD = TRUE;
714 }
715 break;
716 case AU_DVB_DECCMD_STOP_AD:
717 {
718 g_bR2Adec2AD = FALSE;
719 }
720 break;
721 default:
722 break;
723 }
724 }
725 break;
726 default:
727 break;
728 }
729 }
730
731 switch(DecId)
732 {
733 case AU_DEC_ID1:
734 case AU_DEC_ID2:
735 {
736 switch(g_bR2Adec1AD)
737 {
738 case TRUE:
739 {
740 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY_AD);
741 }
742 break;
743 case FALSE:
744 {
745 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP_AD);
746 }
747 break;
748 default:
749 break;
750 }
751 }
752 break;
753 case AU_DEC_ID3:
754 {
755 switch(g_bR2Adec2AD)
756 {
757 case TRUE:
758 {
759 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAY_AD);
760 }
761 break;
762 case FALSE:
763 {
764 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP_AD);
765 }
766 break;
767 default:
768 break;
769 }
770 }
771 break;
772 default:
773 break;
774 }
775 }
776
777
778
779 ////////////////////////////////////////////////////////////////////////////////
780 /// @brief \b Function \b Name: HAL_MAD_SetDSP2DecCmd()
781 /// @brief \b Function \b Description: This routine is to set the DVB3 decode command.
782 /// @param <IN> \b u8DecCmd :
783 /// 0--STOP
784 /// 1--PLAY
785 /// 1--RESYNC
786 /// @param <OUT> \b NONE :
787 /// @param <RET> \b NONE :
788 /// @param <GLOBAL> \b NONE :
789 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD u8DecCmd)790 void HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD u8DecCmd)
791 {
792 MS_U8 FREERUN_STATE = 0;
793 MS_U16 u16_timeout = 0;
794 MS_U32 u32_r2_cmd = 0, u32_driver_cmd = 0;
795 DBG_MAD(printf("HAL_MAD_SetDSP2DecCmd:(%x)\r\n", u8DecCmd));
796
797 if (u8DecCmd == AU_DVB_DECCMD_AVSYNC)
798 {
799 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x80, 0x00); // bit[15] = 0
800 }
801 else if (u8DecCmd == AU_DVB_DECCMD_FREERUN)
802 {
803 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x80, 0x80); // bit[15] = 1, AU_DEC_R2_CMD_FREERUN
804 }
805 else
806 {
807
808 switch(u8DecCmd)
809 {
810 case AU_DVB_DECCMD_STOP:
811 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, ADEC2, 0, 0);
812 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0, 0); //Set ES write pointer to start point.
813 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0xFF, AU_DEC_R2_CMD_STOP);
814 break;
815
816 case AU_DVB_DECCMD_PLAY:
817 if (g_AudioVars2->g_u8MAD2SkipResetFlag == TRUE)
818 {
819 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, ADEC2, 0, 0);
820 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0, 0); //Set ES write pointer to start point.
821 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_STOP);
822 g_AudioVars2->g_u8MAD2SkipResetFlag = FALSE;
823 AUDIO_DELAY1MS(20);
824 }
825 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAY);
826 break;
827
828 case AU_DVB_DECCMD_PLAYFILETSP:
829 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAYFILETSP);
830 break;
831
832 case AU_DVB_DECCMD_PLAYFRAME_GS :
833 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAYUNI);
834 break;
835
836 case AU_DVB_DECCMD_PLAYFILE:
837 case AU_DVB_DECCMD_PLAYFILE2_PTS:
838 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_PLAYFILE);
839 break;
840
841 case AU_DVB_DECCMD_PAUSE:
842 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x40, AU_DEC_R2_CMD_PAUSE);
843 break;
844
845 case AU_DVB_DECCMD_SKIP:
846 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x7F, AU_DEC_R2_CMD_SKIP);
847 g_AudioVars2->g_u8MAD2SkipResetFlag = TRUE;
848 break;
849
850 default:
851 break;
852 }
853
854 FREERUN_STATE = HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_CMD)&0x80; // check free-run
855 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE2_CMD, 0x80, FREERUN_STATE);
856 /* handshake scheme between R2 and Driver */
857 if((u8DecCmd == AU_DVB_DECCMD_PLAY)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILETSP)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE)
858 ||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_STAGE)||(u8DecCmd == AU_DVB_DECCMD_PLAYFRAME_GS)||(u8DecCmd == AU_DVB_DECCMD_PLAYFILE2_PTS))
859 {
860 u32_driver_cmd = R2_DECCMD_PLAY; //DEC_PLAYSTATE_PLAY
861 }
862 else if(u8DecCmd == AU_DVB_DECCMD_STOP)
863 {
864 u32_driver_cmd = R2_DECCMD_STOP; //DEC_PLAYSTATE_STOP
865 }
866 else if(u8DecCmd == AU_DVB_DECCMD_PAUSE)
867 {
868 u32_driver_cmd = R2_DECCMD_PAUSE; //DEC_PLAYSTATE_PAUSE
869 }
870 else
871 {
872 return;
873 }
874
875 /* wait command passing to r2 */
876 while(u16_timeout++ < 100)
877 {
878 u32_r2_cmd = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC2)&0x00FFFFFF;
879 AUDIO_DELAY1MS(1);
880 if (u32_r2_cmd == u32_driver_cmd)
881 break;
882 }
883
884 if (u16_timeout >= 100 )
885 {
886 HALMAD_ERROR(" === HAL_MAD_SetDSP2DecCmd %d fail===\n",u8DecCmd);
887 }
888 }
889 }
890
891 ////////////////////////////////////////////////////////////////////////////////
892 /// @brief \b Function \b Name: HAL_MAD_GetDecCmd()
893 /// @brief \b Function \b Description: This routine is to get the DVB1 decode command.
894 /// @param <OUT> \b AU_DVB_DECCMD :
895 // AU_DVB_DECCMD_STOP, //0
896 // AU_DVB_DECCMD_PLAY, //1
897 // AU_DVB_DECCMD_PLAYFILETSP = 2,
898 // AU_DVB_DECCMD_RESYNC,
899 // ....etc
900 /// @param <OUT> \b NONE :
901 /// @param <RET> \b NONE :
902 /// @param <GLOBAL> \b NONE :
903 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetDecCmd(En_DVB_AudioDecoder AdoDecoderNo)904 AU_DVB_DECCMD HAL_MAD_GetDecCmd(En_DVB_AudioDecoder AdoDecoderNo)
905 {
906 AU_DEC_R2_CMD r2cmd_status = AU_DEC_R2_CMD_STOP;
907 AU_DVB_DECCMD ret_deccmd = AU_DVB_DECCMD_STOP;
908
909 switch (AdoDecoderNo)
910 {
911 case DVB_Audio_Decoder1:
912 {
913 r2cmd_status = HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD);
914 r2cmd_status &= ~AU_DEC_R2_CMD_PLAY_AD; /* Discard AU_DEC_R2_CMD_PLAY_AD */
915 r2cmd_status &= ~AU_DEC_R2_CMD_FREERUN; /* Discard AU_DEC_R2_CMD_FREERUN */
916 break;
917 }
918
919 case DVB_Audio_Decoder2:
920 {
921 r2cmd_status = HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_CMD);
922 r2cmd_status = r2cmd_status & 0x7F;
923 break;
924 }
925
926 default:
927 break;
928 }
929
930 /*
931 need to report status cmd first (stauts cmd : free-run, pause, browse, play AD)
932 */
933
934 if((r2cmd_status & AU_DEC_R2_CMD_PAUSE) == AU_DEC_R2_CMD_PAUSE) // check pause
935 {
936 ret_deccmd = AU_DVB_DECCMD_PAUSE;
937 }
938 else if((r2cmd_status & AU_DEC_R2_CMD_STARTBROWSE) == AU_DEC_R2_CMD_STARTBROWSE) // check startbrowse
939 {
940 ret_deccmd = AU_DVB_DECCMD_STARTBROWSE;
941 }
942 else if((r2cmd_status & AU_DEC_R2_CMD_PLAY_AD) == AU_DEC_R2_CMD_PLAY_AD) // check play AD
943 {
944 ret_deccmd = AU_DVB_DECCMD_PLAY_AD;
945 }
946 else // others : not status cmd
947 {
948 switch(r2cmd_status)
949 {
950 case AU_DEC_R2_CMD_STOP:
951 ret_deccmd = AU_DVB_DECCMD_STOP;
952 break;
953
954 case AU_DEC_R2_CMD_PLAY:
955 ret_deccmd = AU_DVB_DECCMD_PLAY;
956 break;
957
958 case AU_DEC_R2_CMD_PLAYFILETSP:
959 ret_deccmd = AU_DVB_DECCMD_PLAYFILETSP;
960 break;
961
962 case AU_DEC_R2_CMD_PLAYUNI:
963 ret_deccmd = AU_DVB_DECCMD_PLAYFILE2_PTS;
964 break;
965
966 case AU_DEC_R2_CMD_PLAYFILE:
967 ret_deccmd = AU_DVB_DECCMD_PLAYFILE;
968 break;
969
970 default:
971 break;
972 }
973 }
974
975 return ret_deccmd;
976 }
977
978 ////////////////////////////////////////////////////////////////////////////////
979 /// @brief \b Function \b Name: HAL_MAD_setFreeRun()
980 /// @brief \b Function \b Description: This routine is to set the decoder in free run or AV-sync mode.
981 /// @param <IN> \b u8FreeRun : 0--normal AV sync
982 /// 1--free-run mode
983 /// @param <OUT> \b NONE :
984 /// @param <RET> \b NONE :
985 /// @param <GLOBAL> \b NONE :
986 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetFreeRun(MS_U8 u8FreeRun)987 void HAL_MAD_SetFreeRun( MS_U8 u8FreeRun )
988 {
989 DBG_MAD(printf("HAL_MAD_setFreeRun:(%x)\r\n",u8FreeRun));
990 if( u8FreeRun >= 2 ){
991 DBG_MAD(printf("Invalid mode\r\n"));
992 return;
993 }
994
995 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DECODE1_CMD, 0x80, (u8FreeRun << 7));
996 }
997
998
999 ////////////////////////////////////////////////////////////////////////////////
1000 /// @brief \b Function \b Name: HAL_MAD_DisEn_MIUREQ()
1001 /// @brief \b Function \b Description: This routine is to reset DVB1 MIU request command.
1002 /// @param <IN> \b NONE :
1003 /// @param <OUT> \b NONE :
1004 /// @param <RET> \b NONE :
1005 /// @param <GLOBAL> \b NONE :
1006 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_DisEn_MIUREQ(void)1007 void HAL_MAD_DisEn_MIUREQ(void)
1008 {
1009 // Disable MIU Request
1010 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0040 );
1011 AUDIO_DELAY1MS(1);
1012 // Enable MIU Request
1013 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0000 );
1014 }
1015
1016 ////////////////////////////////////////////////////////////////////////////////
1017 /// @brief \b Function \b Name: HAL_MAD_Dis_MIUREQ()
1018 /// @brief \b Function \b Description: This routine is to reset DVB1 MIU request command.
1019 /// @param <IN> \b NONE :
1020 /// @param <OUT> \b NONE :
1021 /// @param <RET> \b NONE :
1022 /// @param <GLOBAL> \b NONE :
1023 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Dis_MIUREQ(void)1024 void HAL_MAD_Dis_MIUREQ(void)
1025 {
1026 // Disable MIU Request
1027 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0040 ); // disable
1028 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0080, 0x0080 ); // reset MAD module
1029 }
1030
1031 ////////////////////////////////////////////////////////////////////////////////
1032 /// @brief \b Function \b Name: HAL_MAD_RSTMAD_DisEn_MIUREQ()
1033 /// @brief \b Function \b Description: This routine is to reset DVB1 MIU request command.
1034 /// @param <IN> \b NONE :
1035 /// @param <OUT> \b NONE :
1036 /// @param <RET> \b NONE :
1037 /// @param <GLOBAL> \b NONE :
1038 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_RSTMAD_DisEn_MIUREQ(void)1039 void HAL_MAD_RSTMAD_DisEn_MIUREQ(void)
1040 {
1041 // Disable MIU Request
1042 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0040 ); // disable
1043 // Reset MAD
1044 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0080, 0x0080 ); // reset MAD module
1045 AUDIO_DELAY1MS(1);
1046 // Set MAD
1047 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0080, 0x00 );
1048 // Enable MIU Request
1049 HAL_AUDIO_WriteMaskReg(REG_DEC_AUD_DTRL, 0x0040, 0x0000 );
1050 }
1051
1052 ////////////////////////////////////////////////////////////////////////////////
1053 /// @brief \b Function \b Name: HAL_MAD_DSPACK()
1054 /// @brief \b Function \b Description: This routine is to report DSP reload ACK cmd.
1055 /// @param <IN> \b NONE :
1056 /// @param <OUT> \b NONE :
1057 /// @param <RET> \b NONE :
1058 /// @param <GLOBAL> \b NONE :
1059 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetReloadCodeAck(void)1060 MS_U8 HAL_MAD_GetReloadCodeAck(void)
1061 {
1062 //NOT_DEFINE : to do
1063 return(HAL_AUDIO_ReadByte(REG_MB_DE_ACK2));
1064 }
1065
1066 ////////////////////////////////////////////////////////////////////////////////
1067 /// @brief \b Function \b Name: HAL_MAD_DSPACK()
1068 /// @brief \b Function \b Description: This routine is to report DSP reload ACK cmd.
1069 /// @param <IN> \b NONE :
1070 /// @param <OUT> \b NONE :
1071 /// @param <RET> \b NONE :
1072 /// @param <GLOBAL> \b NONE :
1073 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetLoadCodeAck(void)1074 MS_U8 HAL_MAD_GetLoadCodeAck(void)
1075 {
1076 //NOT_DEFINE : to do
1077 return(HAL_AUDIO_ReadByte(REG_MB_DE_ACK1));
1078 }
1079
1080 ////////////////////////////////////////////////////////////////////////////////
1081 /// @brief \b Function \b Name: HAL_MAD_Rpt_DTVES()
1082 /// @brief \b Function \b Description: This routine is used to report AC3/MPEG stream if exist or not.
1083 /// @param <IN> \b NONE :
1084 /// @param <OUT> \b NONE :
1085 /// @param <RET> \b MS_U8 : the decoder status
1086 /// @param <GLOBAL> \b NONE :
1087 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Rpt_DTVES(void)1088 MS_U8 HAL_MAD_Rpt_DTVES(void)
1089 {
1090 MS_U8 Rpt_DTVES_tmp;
1091 Rpt_DTVES_tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1);
1092
1093 return Rpt_DTVES_tmp;
1094 }
1095
1096 ////////////////////////////////////////////////////////////////////////////////
1097 /// @brief \b Function \b Name: HAL_MAD_SetStreamID_Mod()
1098 /// @brief \b Function \b Description: This routine is used to AC3 Stream ID mod.
1099 /// @param <IN> \b stream_id_mod :
1100 /// @param <OUT> \b NONE :
1101 /// @param <RET> \b NONE :
1102 /// @param <GLOBAL> \b NONE :
1103 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetStreamID_Mod(MS_U8 stream_id_mod)1104 void HAL_MAD_SetStreamID_Mod(MS_U8 stream_id_mod)
1105 {
1106 //NOT_DEFINE : not used, remove
1107 }
1108
1109 ////////////////////////////////////////////////////////////////////////////////
1110 /// @brief \b Function \b Name: HAL_MAD_ReadTimeStamp()
1111 /// @brief \b Function \b Description: This routine returns the stmestamp while decoding file format.
1112 /// @param <IN> \b NONE :
1113 /// @param <OUT> \b NONE :
1114 /// @param <RET> \b timestamp : time stamp value
1115 /// @param <GLOBAL> \b NONE :
1116 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_ReadTimeStamp(void)1117 MS_U32 HAL_MAD_ReadTimeStamp(void)
1118 {
1119 MS_U32 timestamp = 0;
1120 MS_U32 pts = 0;
1121
1122 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
1123 timestamp = pts/45;
1124
1125 return timestamp;
1126 }
1127
1128 ////////////////////////////////////////////////////////////////////////////////
1129 /// @brief \b Function \b Name: HAL_MAD__SetAdMixMode()
1130 /// @brief \b Function \b Description: This routine is used to set MPEG mixed with AD or AD mixed with MPEG or not.
1131 /// @param <IN> \b u8Mix_mode : 0--main mix to AD
1132 /// 1--AD mix to main
1133 /// @param <IN> \b bEnMix : 0--disable AD mix
1134 /// 1--enable AD mix
1135 /// @param <OUT> \b NONE :
1136 /// @param <RET> \b NONE :
1137 /// @param <GLOBAL> \b NONE :
1138 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAdMixMode(AD_MIX_MODE u8Mix_mode,MS_BOOL bEnMix)1139 void HAL_MAD_SetAdMixMode (AD_MIX_MODE u8Mix_mode, MS_BOOL bEnMix)
1140 {
1141 //NOT_DEFINE
1142 switch (u8Mix_mode)
1143 {
1144 case MAIN_MIX_AD:
1145 case AD_MIX_MAIN:
1146 HAL_AUDIO_WriteMaskReg(REG_MB_DEC3_CTRL, 0x8000, bEnMix<<15); // IO_100 [15]
1147 break;
1148
1149 default:
1150 break;
1151 }
1152 }
1153
1154 ////////////////////////////////////////////////////////////////////////////////
1155 /// @brief \b Function \b Name: HAL_MAD_SetMcuCmd()
1156 /// @brief \b Function \b Description: This routine is to write MCU cmd for PIO.
1157 /// @param <IN> \b NONE :
1158 /// @param <OUT> \b NONE :
1159 /// @param <RET> \b NONE :
1160 /// @param <GLOBAL> \b NONE :
1161 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetPIOCmd(MS_U8 cmd)1162 void HAL_MAD_SetPIOCmd(MS_U8 cmd)
1163 {
1164 HAL_AUDIO_WriteMaskReg(REG_MB_DEC_PIO_ID,0xFF00, cmd<<8);
1165 }
1166
1167 ////////////////////////////////////////////////////////////////////////////////
1168 /// @brief \b Function \b Name: HAL_MAD_SetMcuCmd()
1169 /// @brief \b Function \b Description: This routine is to write MCU cmd.
1170 /// @param <IN> \b NONE :
1171 /// @param <OUT> \b NONE :
1172 /// @param <RET> \b NONE :
1173 /// @param <GLOBAL> \b NONE :
1174 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetMcuCmd(MS_U8 cmd)1175 void HAL_MAD_SetMcuCmd(MS_U8 cmd)
1176 {
1177 //NOT_DEFINE : not used, remove
1178 }
1179
1180 ////////////////////////////////////////////////////////////////////////////////
1181 /// @brief \b Function \b Name: HAL_MAD_SetDspIDMA()
1182 /// @brief \b Function \b Description: This function is used to set DSP IDMA.
1183 /// @param <IN> \b NONE :
1184 /// @param <OUT> \b NONE :
1185 /// @param <RET> \b NONE :
1186 /// @param <GLOBAL> \b NONE :
1187 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDspIDMA(void)1188 void HAL_MAD_SetDspIDMA(void)
1189 {
1190 //NOT_DEFINE : not used, remove
1191 }
1192
1193 ////////////////////////////////////////////////////////////////////////////////
1194 /// @brief \b Function \b Name: HAL_MAD_TriggerPIO8()
1195 /// @brief \b Function \b Description: This function is used to trigger PIO8 init.
1196 /// @param <IN> \b NONE :
1197 /// @param <OUT> \b NONE :
1198 /// @param <RET> \b NONE :
1199 /// @param <GLOBAL> \b NONE :
1200 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_TriggerPIO8(void)1201 void HAL_MAD_TriggerPIO8(void)
1202 {
1203 //NOT_DEFINE : not used, remove
1204 }
1205
1206 ////////////////////////////////////////////////////////////////////////////////
1207 /// @brief \b Function \b Name: HAL_MAD_DvbFLockSynthesizer_En()
1208 /// @brief \b Function \b Description: This function is used to set DSP IDMA.
1209 /// @param <IN> \b NONE :
1210 /// @param <OUT> \b NONE :
1211 /// @param <RET> \b NONE :
1212 /// @param <GLOBAL> \b NONE :
1213 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_DvbFLockSynthesizer_En(void)1214 void HAL_MAD_DvbFLockSynthesizer_En(void)
1215 {
1216 // enable force lock current DVB SYNC synthesizer freq
1217 // SIF only in SE DSP
1218 HAL_AUDIO_WriteMaskReg(REG_AUDIO_INPUT_CFG, 0x0040, 0x0040 );
1219 }
1220
1221 ////////////////////////////////////////////////////////////////////////////////
1222 /// @brief \b Function \b Name: HAL_AUDIO_SetCertMode()
1223 /// @brief \b Function \b Description:
1224 /// @param CertType \b : AUDIO_DOLBY_DD_Cert,
1225 /// @param CertType \b : AUDIO_DOLBY_DDP_Cert,
1226 /// @param CertType \b : AUDIO_DOLBY_PULSE_Cert,
1227 /// @param CertType \b : AUDIO_DOLBY_MS10_Cert,
1228 /// @param CertType \b : AUDIO_DTS_DMP_Cert,
1229 /// @param CertType \b : AUDIO_DTS_BC_Cert,
1230 /// @param CertType \b : AUDIO_DTS_PremiumTV_Cert,
1231 /// @param CertType \b : AUDIO_SRS_XT_Cert,
1232 /// @param enable \b : AUDIO_CERT_Enable / AUDIO_CERT_Disable
1233 ///
1234 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetCertMode(Audio_CertMode CertType,Audio_CertEnable enCert)1235 MS_BOOL HAL_AUDIO_SetCertMode( Audio_CertMode CertType,Audio_CertEnable enCert )
1236 {
1237 switch(CertType)
1238 {
1239 case AUDIO_DOLBY_DD_Cert:
1240 case AUDIO_DOLBY_DDP_Cert:
1241 case AUDIO_DOLBY_PULSE_Cert:
1242 case AUDIO_DOLBY_MS10_Cert:
1243 case AUDIO_DTS_DMP_Cert:
1244 case AUDIO_DTS_BC_Cert:
1245 // sound effect bypass setting
1246 break;
1247
1248 case AUDIO_DOLBY_DDCO_Cert:
1249 break;
1250
1251 case AUDIO_DTS_SYMMETRY_Cert:
1252 break;
1253
1254 case AUDIO_DTS_ENVELO_Cert:
1255 break;
1256
1257 case AUDIO_SRS_XT_Cert:
1258 break;
1259
1260 default:
1261 break;
1262 }
1263 return(true);
1264 }
1265
1266
1267 ////////////////////////////////////////////////////////////////////////////////
1268 /// @brief \b Function \b Name: HAL_MAD_MM2_initAesInfo()
1269 /// @brief \b Function \b Description : Initialize AES info
1270 /// @param <IN> \b dec_id : Decoder ID
1271 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
1272 /// @param <GLOBAL> \b NONE :
1273 ////////////////////////////////////////////////////////////////////////////////
1274 static MS_U32 prv_PTS = 0, prv_PTS1 = 0;
1275 static MS_U32 accum_ES = 0, prv_accum_ES = 0, accum_ES1 = 0, prv_accum_ES1 = 0;
HAL_MAD_MM2_initAesInfo(AUDIO_DEC_ID dec_id)1276 MS_BOOL HAL_MAD_MM2_initAesInfo( AUDIO_DEC_ID dec_id )
1277 {
1278 if ( dec_id == AU_DEC_ID1 )
1279 {
1280 audio_aes_info[0].aes_base_addr = OFFSET_ES1_DRAM_ADDR;
1281 audio_aes_info[0].aes_BufSize = ES1_DRAM_SIZE;
1282 audio_aes_info[0].aes_end_addr = audio_aes_info[0].aes_base_addr + audio_aes_info[0].aes_BufSize;
1283 audio_aes_info[0].aes_write_addr = audio_aes_info[0].aes_base_addr;
1284 audio_aes_info[0].aes_freeSpace = audio_aes_info[0].aes_BufSize - (BYTES_IN_MIU_LINE*2);
1285 audio_aes_info[0].aes_level = 0;
1286 audio_aes_info[0].aes_lastPTS = 0;
1287 audio_aes_info[0].aes_ptsCnt = 0;
1288
1289 prv_PTS = 0;
1290 accum_ES = 0;
1291 prv_accum_ES = 0;
1292
1293 /* Set ES write pointer to DSP */
1294 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, 0, 0); //Set ES write pointer to start point.
1295
1296 DBG_MAD(printf("ID1: HAL_AUDIO_MM2_init end !!\r\n"));
1297 return TRUE;
1298 }
1299 else if( dec_id == AU_DEC_ID3 )
1300 {
1301 audio_aes_info[1].aes_base_addr = OFFSET_ES3_DRAM_ADDR;
1302 audio_aes_info[1].aes_BufSize = ES3_DRAM_SIZE;
1303 audio_aes_info[1].aes_end_addr = audio_aes_info[1].aes_base_addr + audio_aes_info[1].aes_BufSize;
1304 audio_aes_info[1].aes_write_addr = audio_aes_info[1].aes_base_addr;
1305 audio_aes_info[1].aes_freeSpace = audio_aes_info[1].aes_BufSize - (BYTES_IN_MIU_LINE*2);
1306 audio_aes_info[1].aes_level = 0;
1307 audio_aes_info[1].aes_lastPTS = 0;
1308 audio_aes_info[1].aes_ptsCnt = 0;
1309
1310 prv_PTS1 = 0;
1311 accum_ES1 = 0;
1312 prv_accum_ES1 = 0;
1313
1314 /* Set ES write pointer to DSP */
1315 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, 0, 0); //Set ES write pointer to start point.
1316
1317 DBG_MAD(printf("ID3: HAL_AUDIO_MM2_init end !!\r\n"));
1318 return TRUE;
1319 }
1320 else
1321 return FALSE;
1322 }
1323
1324 ////////////////////////////////////////////////////////////////////////////////
1325 /// @brief \b Function \b Name: HAL_MAD_MM2_checkAesInfo()
1326 /// @brief \b Function \b Description : Get AES info from audio decoder
1327 /// @param <IN> \b dec_id : Decoder ID
1328 /// @param <IN> \b aes_info : AES info structure pointer
1329 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
1330 /// @param <GLOBAL> \b NONE :
1331 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MM2_checkAesInfo(AUDIO_DEC_ID dec_id,AES_INFO * aes_info)1332 MS_BOOL HAL_MAD_MM2_checkAesInfo( AUDIO_DEC_ID dec_id, AES_INFO *aes_info )
1333 {
1334 if ( dec_id == AU_DEC_ID1 )
1335 {
1336 MS_U32 tmp1, tmp2;
1337
1338 /* es level */
1339 audio_aes_info[0].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1340
1341 /* calculate free space for next data input */
1342 tmp1 = audio_aes_info[0].aes_end_addr - audio_aes_info[0].aes_write_addr;
1343 tmp2 = audio_aes_info[0].aes_BufSize - audio_aes_info[0].aes_level;
1344
1345 if ( tmp2 < audio_aes_info[0].aes_BufSize/2)
1346 tmp2 = 0;
1347 else
1348 tmp2 -= (audio_aes_info[0].aes_BufSize/2);
1349
1350 if (tmp2 > (audio_aes_info[0].aes_BufSize/4))
1351 tmp2 = audio_aes_info[0].aes_BufSize/4;
1352
1353 audio_aes_info[0].aes_freeSpace = (tmp1 > tmp2)?tmp2:tmp1;
1354 audio_aes_info[0].aes_read_addr = OFFSET_ES1_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, ADEC1 );
1355
1356 memcpy( (void *)aes_info, (void *)&audio_aes_info[0], sizeof(AES_INFO));
1357 DBG_MAD(printf("[ID1:HAL_MAD_MM2_checkAesInfo] Ptr[w:%x,r:%x] LvL:%x, FreeSpace:%x, tmpFree:%x \n",
1358 audio_aes_info[0].aes_write_addr,
1359 audio_aes_info[0].aes_read_addr,
1360 audio_aes_info[0].aes_level,
1361 audio_aes_info[0].aes_BufSize - audio_aes_info[0].aes_level,
1362 audio_aes_info[0].aes_freeSpace));
1363
1364 return TRUE;
1365 }
1366 else if( dec_id == AU_DEC_ID3 )
1367 {
1368 MS_U32 tmp1, tmp2;
1369
1370 /* es level */
1371 audio_aes_info[1].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1372
1373 /* calculate free space for next data input */
1374 tmp1 = audio_aes_info[1].aes_end_addr - audio_aes_info[1].aes_write_addr;
1375 tmp2 = audio_aes_info[1].aes_BufSize - audio_aes_info[1].aes_level;
1376
1377 if ( tmp2 < audio_aes_info[1].aes_BufSize/2)
1378 tmp2 = 0;
1379 else
1380 tmp2 -= (audio_aes_info[1].aes_BufSize/2);
1381
1382 if (tmp2 > (audio_aes_info[1].aes_BufSize/4))
1383 tmp2 = audio_aes_info[1].aes_BufSize/4;
1384
1385 audio_aes_info[1].aes_freeSpace = (tmp1 > tmp2)?tmp2:tmp1;
1386 audio_aes_info[1].aes_read_addr = OFFSET_ES3_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, ADEC2 );
1387
1388 memcpy( (void *)aes_info, (void *)&audio_aes_info[1], sizeof(AES_INFO));
1389 DBG_MAD(printf("[ID3:HAL_MAD_MM2_checkAesInfo] Ptr[w:%x,r:%x] LvL:%x, FreeSpace:%x, tmpFree:%x \n",
1390 audio_aes_info[1].aes_write_addr,
1391 audio_aes_info[1].aes_read_addr,
1392 audio_aes_info[1].aes_level,
1393 audio_aes_info[1].aes_BufSize - audio_aes_info[1].aes_level,
1394 audio_aes_info[1].aes_freeSpace));
1395
1396 return TRUE;
1397 }
1398 else
1399 {
1400 return FALSE;
1401 }
1402 }
1403
1404 ////////////////////////////////////////////////////////////////////////////////
1405 /// @brief \b Function \b Name: HAL_MAD_MM2_inputAesFinished()
1406 /// @brief \b Function \b Description : Inform DSP how much ES data is sent
1407 /// @param <IN> \b dec_id : Decoder ID
1408 /// @param <IN> \b es_size : Size of ES data
1409 /// @param <IN> \b ptsExist : Whether ES data contains PTS or not
1410 /// @param <IN> \b pts : PTS
1411 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
1412 /// @param <GLOBAL> \b NONE :
1413 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MM2_inputAesFinished(AUDIO_DEC_ID dec_id,MS_U32 es_size,MS_BOOL ptsExist,MS_U64 pts)1414 MS_BOOL HAL_MAD_MM2_inputAesFinished( AUDIO_DEC_ID dec_id, MS_U32 es_size, MS_BOOL ptsExist, MS_U64 pts )
1415 {
1416 MS_U32 es_writeLineOffset;
1417 MS_U32 tmp1, tmp2;
1418
1419 if (es_size == 0)
1420 return FALSE;
1421
1422 if ( dec_id == AU_DEC_ID1 )
1423 {
1424 /* es level */
1425 audio_aes_info[0].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1426
1427 /* calculate free space for next data input */
1428 tmp1 = audio_aes_info[0].aes_end_addr - audio_aes_info[0].aes_write_addr;
1429 tmp2 = audio_aes_info[0].aes_BufSize - audio_aes_info[0].aes_level;
1430
1431 audio_aes_info[0].aes_freeSpace = (tmp1 - tmp2)?tmp2:tmp1;
1432
1433 if ( es_size > audio_aes_info[0].aes_freeSpace )
1434 {
1435 printf("ID1:==> Error, input AES size(0x%x) is larger than current Free space(0x%x)\r\n", es_size, audio_aes_info[0].aes_freeSpace );
1436 return FALSE;
1437 }
1438
1439 DBG_MAD(printf("[ID1:HAL_MAD_MM2_inputAesFinished] wPtr:%08x => ", audio_aes_info[0].aes_write_addr));
1440
1441 /* update write pointer */
1442 audio_aes_info[0].aes_write_addr += es_size;
1443
1444 if ( audio_aes_info[0].aes_write_addr >= audio_aes_info[0].aes_end_addr )
1445 audio_aes_info[0].aes_write_addr -= audio_aes_info[0].aes_BufSize;
1446
1447 DBG_MAD(printf("%08x, size=%08x,isPtsExist:%d,PTS=%09lld",
1448 audio_aes_info[0].aes_write_addr,
1449 es_size,
1450 ptsExist,
1451 pts/90));
1452
1453 if (ptsExist)
1454 {
1455 if (prv_PTS != 0)
1456 {
1457 DBG_MAD(printf(",PTS_diff=%08lld,accum_ES = %08x,ES_diff= %08d, ES PTS diff=%08d\n",
1458 (pts - prv_PTS)/90,
1459 accum_ES,
1460 accum_ES - prv_accum_ES,
1461 (accum_ES - prv_accum_ES)*32/1536));
1462 }
1463 else
1464 {
1465 DBG_MAD(printf(", PTS_diff=%08x, accum_ES = %08x\n", 0, 0));
1466 }
1467
1468 prv_PTS = pts;
1469 prv_accum_ES = accum_ES;
1470 }
1471 else
1472 {
1473 DBG_MAD(printf("\n"));
1474 }
1475
1476 accum_ES += es_size;
1477
1478 es_writeLineOffset = audio_aes_info[0].aes_write_addr - audio_aes_info[0].aes_base_addr;
1479
1480 if (ptsExist)
1481 {
1482 if ((audio_aes_info[0].aes_lastPTS == pts)&&(audio_aes_info[0].aes_ptsCnt != 0))
1483 printf(" ======== Error PTS is same !! =============\n");
1484 else
1485 {
1486 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_INPUT_PTS, dec_id, (pts >> 1), 0);
1487 audio_aes_info[0].aes_ptsCnt++;
1488 audio_aes_info[0].aes_lastPTS = pts;
1489 AUDIO_DELAY1US(500);
1490 }
1491 }
1492
1493 /* Set ES write pointer to DSP */
1494 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, es_writeLineOffset, 0);
1495 AUDIO_DELAY1US(250); //Since DSP timer update ES_MEM_CNT at each 125us, need this delay to keep
1496 }
1497 else if (dec_id == AU_DEC_ID3)
1498 {
1499 /* es level */
1500 audio_aes_info[1].aes_level = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, dec_id);
1501
1502 /* calculate free space for next data input */
1503 tmp1 = audio_aes_info[1].aes_end_addr - audio_aes_info[1].aes_write_addr;
1504 tmp2 = audio_aes_info[1].aes_BufSize - audio_aes_info[1].aes_level;
1505
1506 audio_aes_info[1].aes_freeSpace = (tmp1 - tmp2)?tmp2:tmp1;
1507
1508 if ( es_size > audio_aes_info[1].aes_freeSpace )
1509 {
1510 printf("ID3:==> Error, input AES size(0x%x) is larger than current Free space(0x%x)\r\n", es_size, audio_aes_info[1].aes_freeSpace );
1511 return FALSE;
1512 }
1513
1514 DBG_MAD(printf("[ID3:HAL_MAD_MM2_inputAesFinished] wPtr:%08x => ", audio_aes_info[1].aes_write_addr));
1515
1516 /* update write pointer */
1517 audio_aes_info[1].aes_write_addr += es_size;
1518
1519 if ( audio_aes_info[1].aes_write_addr >= audio_aes_info[1].aes_end_addr )
1520 audio_aes_info[1].aes_write_addr -= audio_aes_info[1].aes_BufSize;
1521
1522 DBG_MAD(printf("%08x, size=%08x,isPtsExist:%d,PTS=%09lld",
1523 audio_aes_info[1].aes_write_addr,
1524 es_size,
1525 ptsExist,
1526 pts/90));
1527
1528 if (ptsExist)
1529 {
1530 if (prv_PTS1 != 0)
1531 {
1532 DBG_MAD(printf(",PTS_diff=%08lld,accum_ES = %08x,ES_diff= %08d, ES PTS diff=%08d\n",
1533 (pts - prv_PTS1)/90,
1534 accum_ES1,
1535 accum_ES1 - prv_accum_ES1,
1536 (accum_ES1 - prv_accum_ES1)*32/1536));
1537 }
1538 else
1539 {
1540 DBG_MAD(printf(", PTS_diff=%08x, accum_ES = %08x\n", 0, 0));
1541 }
1542
1543 prv_PTS1 = pts;
1544 prv_accum_ES1 = accum_ES1;
1545 }
1546 else
1547 {
1548 DBG_MAD(printf("\n"));
1549 }
1550
1551 accum_ES1 += es_size;
1552
1553 es_writeLineOffset = audio_aes_info[1].aes_write_addr - audio_aes_info[1].aes_base_addr;
1554
1555 if (ptsExist)
1556 {
1557 if ((audio_aes_info[1].aes_lastPTS == pts)&&(audio_aes_info[1].aes_ptsCnt != 0))
1558 printf(" ======== Error PTS is same !! =============\n");
1559 else
1560 {
1561 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_INPUT_PTS, dec_id, (pts >> 1), 0);
1562 audio_aes_info[1].aes_ptsCnt++;
1563 audio_aes_info[1].aes_lastPTS = pts;
1564 AUDIO_DELAY1US(500);
1565 }
1566 }
1567
1568 /* Set ES write pointer to DSP */
1569 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, dec_id, es_writeLineOffset, 0);
1570 AUDIO_DELAY1US(250); //Since DSP timer update ES_MEM_CNT at each 125us, need this delay to keep
1571 }
1572 return TRUE;
1573 }
1574
1575
1576 ///-----------------------------------------------------------------------------
1577 ////////////////////////////////////////////////////////////////////////////////
1578 ////////////////////////////////////////////////////////////////////////////////
1579 ///
1580 /// AUDIO_MAD MPEG Relational Hal Function
1581 ///
1582 ////////////////////////////////////////////////////////////////////////////////
1583 ////////////////////////////////////////////////////////////////////////////////
1584 ///-----------------------------------------------------------------------------
1585 ////////////////////////////////////////////////////////////////////////////////
1586 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetHeaderInfo()
1587 /// @brief \b Function \b Description: This routine will return the 32bit mpeg header
1588 /// @param <IN> \b NONE :
1589 /// @param <OUT> \b NONE :
1590 /// @param <RET> \b U32 : mpeg header information
1591 /// @param <GLOBAL> \b NONE :
1592 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetHeaderInfo(void)1593 MS_U32 HAL_MAD_MPEG_GetHeaderInfo(void)
1594 {
1595 MS_U16 data;
1596
1597 data = (MS_U16)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MPEG_HEADER, ADEC1);
1598
1599 return (data & 0x0FFF);
1600 }
1601
1602 ////////////////////////////////////////////////////////////////////////////////
1603 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetSampleRate()
1604 /// @brief \b Function \b Description: This routine will return the 16bit mpeg samplerate
1605 /// @param <IN> \b NONE :
1606 /// @param <OUT> \b NONE :
1607 /// @param <RET> \b U16 : mpeg sampling rate
1608 /// @param <GLOBAL> \b NONE :
1609 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetSampleRate(void)1610 MS_U16 HAL_MAD_MPEG_GetSampleRate(void)
1611 {
1612 return (MS_U16)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
1613 }
1614
1615 ////////////////////////////////////////////////////////////////////////////////
1616 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetBitRate()
1617 /// @brief \b Function \b Description: This routine will return the 16-bit mpeg bit rate
1618 /// @param <IN> \b NONE :
1619 /// @param <OUT> \b NONE :
1620 /// @param <RET> \b U16 : mpeg bit rate
1621 /// @param <GLOBAL> \b NONE :
1622 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetBitRate(void)1623 MS_U16 HAL_MAD_MPEG_GetBitRate(void)
1624 {
1625 return (MS_U16) HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, ADEC1);
1626 }
1627
1628 ////////////////////////////////////////////////////////////////////////////////
1629 /// @brief \b Function \b Name: HAL_MAD_MPEG_GetSoundMode()
1630 /// @brief \b Function \b Description: This routine will return the 8bit mpeg sound mode
1631 /// @param <IN> \b NONE :
1632 /// @param <OUT> \b NONE :
1633 /// @param <RET> \b MPEG_SOUND_MODE :
1634 /// MPEG_SOUND_MODE_STEREO =0,
1635 /// MPEG_SOUND_MODE_JOINT_STEREO,
1636 /// MPEG_SOUND_MODE_DUAL_CHAN,
1637 /// MPEG_SOUND_MODE_MONO
1638 /// @param <GLOBAL> \b NONE :
1639 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_MPEG_GetSoundMode(void)1640 MPEG_SOUND_MODE HAL_MAD_MPEG_GetSoundMode(void)
1641 {
1642 return (MPEG_SOUND_MODE)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MPEG_STEREOMODE, ADEC1);
1643 }
1644
1645 ///-----------------------------------------------------------------------------
1646 ////////////////////////////////////////////////////////////////////////////////
1647 ////////////////////////////////////////////////////////////////////////////////
1648 ///
1649 /// AUDIO_MAD Dolby Relational Hal Function
1650 ///
1651 ////////////////////////////////////////////////////////////////////////////////
1652 ////////////////////////////////////////////////////////////////////////////////
1653 ///-----------------------------------------------------------------------------
1654 ///////////////////////////////////////////////////////////////////////////////
1655 /// @brief \b Function \b Name: HAL_MAD_Monitor_DDPlus_SPDIF_Rate()
1656 /// @brief \b Function \b Description: This routine is used to set reference ADC clock by DD+ dsp code
1657 /// @param <IN> \b NONE :
1658 /// @param <OUT> \b NONE :
1659 /// @param <RET> \b NONE :
1660 /// @param <GLOBAL> \b NONE :
1661 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Monitor_DDPlus_SPDIF_Rate(void)1662 void HAL_MAD_Monitor_DDPlus_SPDIF_Rate(void)
1663 {
1664 MS_U8 u8SpdifMode = SPDIF_OUT_PCM;
1665 MS_U8 eAudioSource = 0;
1666 MS_U8 u8MainDecodeId = 0;
1667 AUDIO_DSP_CODE_TYPE MainDspCodeType = AU_DVB_STANDARD_INVALID;
1668 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
1669 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
1670 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
1671 MS_BOOL retTx1, retTx2;
1672
1673 HALMAD_CHECK_SHM_INIT;
1674
1675 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
1676 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
1677
1678 eAudioSource = (MS_U8)g_AudioVars2->eAudioSource;
1679 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
1680 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
1681
1682 HAL_AUDIO_SPDIF_SetMode(gSpdifOutputType, eAudioSource);
1683 HAL_AUDIO_HDMI_TX_SetMode(gHdmiOutputType, eAudioSource);
1684
1685 u8SpdifMode = _HAL_AUDIO_SPDIF_GetMode();
1686
1687 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
1688 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
1689 if (retTx1 == FALSE || retTx2 == FALSE)
1690 {
1691 HALMAD_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
1692 }
1693
1694 switch(eAudioSource)
1695 {
1696 case E_AUDIO_INFO_DTV_IN:
1697 case E_AUDIO_INFO_MM_IN:
1698 case E_AUDIO_INFO_GAME_IN:
1699 {
1700 if (((eAudioSource == E_AUDIO_INFO_MM_IN) || (eAudioSource == E_AUDIO_INFO_GAME_IN)) &&
1701 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS))
1702 {
1703 MainDspCodeType = Dsp2CodeType;
1704 u8MainDecodeId = ADEC2;
1705 }
1706 else if ((eAudioSource == E_AUDIO_INFO_HDMI_IN) && (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1))
1707 {
1708 MainDspCodeType = Dsp2CodeType;
1709 u8MainDecodeId = ADEC2;
1710 }
1711 else
1712 {
1713 MainDspCodeType = Dsp1CodeType;
1714 u8MainDecodeId = ADEC1;
1715 }
1716
1717
1718 if (u8SpdifMode == SPDIF_OUT_PCM)
1719 {
1720 /* change SPDIF Tx 1&2 channel status --> 48KHz */
1721 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
1722 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
1723 }
1724 else
1725 {
1726 switch(HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, u8MainDecodeId))
1727 {
1728 case 44100:
1729 {
1730 /* change SPDIF Tx 1&2 channel status --> 44.1KHz */
1731 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
1732 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
1733 break;
1734 }
1735
1736 case 32000:
1737 {
1738 /* change SPDIF Tx 1&2 channel status --> 32KHz */
1739 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
1740 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
1741 break;
1742 }
1743
1744 default:
1745 {
1746 /* change SPDIF Tx 1&2 channel status --> 48KHz */
1747 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
1748 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
1749 break;
1750 }
1751 }
1752 }
1753
1754 if (g_AudioVars2->g_EdidOutViaArc == TRUE)
1755 {
1756 if (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20)
1757 {
1758 switch(HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, u8MainDecodeId))
1759 {
1760 case 19200:
1761 {
1762 /* change SPDIF Tx 2 channel status --> 192KHz */
1763 stDigitalChannelStatusTx2.u8SamplingRate = 0x70;
1764 break;
1765 }
1766
1767 case 17600:
1768 {
1769 /* change SPDIF Tx 2 channel status --> 176KHz */
1770 stDigitalChannelStatusTx2.u8SamplingRate = 0x30;
1771 break;
1772 }
1773
1774 case 9600:
1775 {
1776 /* change SPDIF Tx 2 channel status --> 96KHz */
1777 stDigitalChannelStatusTx2.u8SamplingRate = 0x50;
1778 break;
1779 }
1780
1781 case 8800:
1782 {
1783 /* change SPDIF Tx 2 channel status --> 88KHz */
1784 stDigitalChannelStatusTx2.u8SamplingRate = 0x10;
1785 break;
1786 }
1787
1788 case 44100:
1789 {
1790 /* change SPDIF Tx 2 channel status --> 44.1KHz */
1791 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
1792 break;
1793 }
1794
1795 case 32000:
1796 {
1797 /* change SPDIF Tx 2 channel status --> 32KHz */
1798 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
1799 break;
1800 }
1801
1802 default:
1803 {
1804 /* change SPDIF Tx 2 channel status --> 48KHz */
1805 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
1806 break;
1807 }
1808 }
1809 }
1810 else
1811 {
1812 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
1813 }
1814 }
1815 break;
1816 }
1817
1818 default:
1819 {
1820 /* change SPDIF Tx 1&2 channel status --> 48KHz */
1821 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
1822 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
1823 break;
1824 }
1825 }
1826
1827 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
1828 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
1829 }
1830
1831 ///-----------------------------------------------------------------------------
1832 ////////////////////////////////////////////////////////////////////////////////
1833 ////////////////////////////////////////////////////////////////////////////////
1834 ///
1835 /// AUDIO_MAD WMA Relational Hal Function
1836 ///
1837 ////////////////////////////////////////////////////////////////////////////////
1838 ////////////////////////////////////////////////////////////////////////////////
1839 ///-----------------------------------------------------------------------------
1840 ////////////////////////////////////////////////////////////////////////////////
1841 /// @brief \b Function \b Name: HAL_MAD_WMA_SetASFParm()
1842 /// @brief \b Function \b Description: This routine will set WMA ASF Paramaters.
1843 /// @param <IN> \b NONE : WMA_ASF_PARMTYPE, value
1844 /// @param <OUT> \b NONE :
1845 /// @param <RET> \b NONE :
1846 /// @param <GLOBAL> \b NONE :
1847 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_WMA_SetASFParm(WMA_ASF_PARMTYPE parm_type,MS_U32 value)1848 void HAL_MAD_WMA_SetASFParm(WMA_ASF_PARMTYPE parm_type, MS_U32 value)
1849 {
1850 switch ( parm_type )
1851 {
1852 case WMA_PARAMTYPE_VERSION:
1853 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_VERSION, ADEC1, value, 0);
1854 break;
1855 case WMA_PARAMTYPE_CHANNELS:
1856 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELS, ADEC1, value, 0);
1857 break;
1858 case WMA_PARAMTYPE_SAMPLERATE:
1859 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_SAMPLERATE, ADEC1, value, 0);
1860 break;
1861 case WMA_PARAMTYPE_BYTERATE:
1862 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BYTERATE, ADEC1, value, 0);
1863 break;
1864 case WMA_PARAMTYPE_BLOCKALIGN:
1865 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BLOCKALIGN, ADEC1, value, 0);
1866 break;
1867 case WMA_PARAMTYPE_ENCOPT:
1868 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_ENCOPT, ADEC1, value, 0);
1869 break;
1870 case WMA_PARAMTYPE_PARSINGBYAPP:
1871 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_PARSINGBYAPP, ADEC1, value, 0);
1872 break;
1873 case WMA_PARAMTYPE_BITS_PER_SAMPLE:
1874 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BITS_PER_SAMPLE, ADEC1, value, 0);
1875 break;
1876 case WMA_PARAMTYPE_CHANNELMASK:
1877 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELMASK, ADEC1, value, 0);
1878 break;
1879 case WMA_PARAMTYPE_DRC_PARAM_EXIST:
1880 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PARAM_EXIST, ADEC1, value, 0);
1881 break;
1882 case WMA_PARAMTYPE_DRC_RMS_AMP_REF:
1883 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_REF, ADEC1, value, 0);
1884 break;
1885 case WMA_PARAMTYPE_DRC_RMS_AMP_TARGET:
1886 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_TARGET, ADEC1, value, 0);
1887 break;
1888 case WMA_PARAMTYPE_DRC_PEAK_AMP_REF:
1889 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_REF, ADEC1, value, 0);
1890 break;
1891 case WMA_PARAMTYPE_DRC_PEAK_AMP_TARGET:
1892 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_TARGET, ADEC1, value, 0);
1893 break;
1894 case WMA_PARAMTYPE_MAX_PACKET_SIZE:
1895 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_MAX_PACKET_SIZE, ADEC1, value, 0);
1896 break;
1897 default:
1898 break;
1899 }
1900 }
1901
1902
1903 ///-----------------------------------------------------------------------------
1904 ////////////////////////////////////////////////////////////////////////////////
1905 ////////////////////////////////////////////////////////////////////////////////
1906 ///
1907 /// AUDIO_MAD OTHER Relational Hal Function
1908 ///
1909 ////////////////////////////////////////////////////////////////////////////////
1910 ////////////////////////////////////////////////////////////////////////////////
1911 ///-----------------------------------------------------------------------------
1912 ////////////////////////////////////////////////////////////////////////////////
1913 /// @brief \b Function \b Name: HAL_MAD_RA8_setParam()
1914 /// @brief \b Function \b Description: This routine configures necessary parameters when playing RA8 LBR data
1915 /// @param <IN> \b mNumCodecs : 1--stereo or mono
1916 /// 2~5-- multi channels
1917 /// @param <IN> \b mSamples : output samples--256, 512, 1024
1918 /// @param <IN> \b mSampleRate : 8, 11.025, 16, 22.05, 44.1, 48 (KHz)
1919 /// @param <IN> \b Channels : 1-- mono
1920 /// 2-- stereo
1921 /// @param <IN> \b cplStart : 0 ~ 51
1922 /// @param <IN> \b Regions : 0 ~ 31
1923 /// @param <IN> \b cplQbits : 0, 2, 3, 4, 5, 6
1924 /// @param <IN> \b FrameSize : bitstream size of every NumCodes (bytes)
1925 /// Range--0 ~ 65535
1926 /// @param <OUT> \b NONE :
1927 /// @param <RET> \b MS_U8 : TRUE--parameters are correct
1928 /// FALSE--parameters are incorrect
1929 /// @param <GLOBAL> \b NONE :
1930 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_RA8_setParam(MS_U16 mNumCodecs,MS_U16 mSamples,MS_U16 mSampleRate,MS_U16 * Channels,MS_U16 * Regions,MS_U16 * cplStart,MS_U16 * cplQbits,MS_U16 * FrameSize)1931 MS_U8 HAL_MAD_RA8_setParam(MS_U16 mNumCodecs, MS_U16 mSamples, MS_U16 mSampleRate,
1932 MS_U16* Channels, MS_U16* Regions, MS_U16* cplStart, MS_U16* cplQbits,
1933 MS_U16* FrameSize)
1934 {
1935
1936 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_NUMCODECS, ADEC1, mNumCodecs, 0 );
1937 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLES, ADEC1, mSamples, 0 );
1938 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLERATES, ADEC1, mSampleRate, 0 );
1939 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, Channels[0], 0 );
1940 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, Regions[0], 0 );
1941 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, cplStart[0], 0 );
1942 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, cplQbits[0], 0 );
1943 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, FrameSize[0], 0 );
1944
1945 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, Channels[1], 1 );
1946 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, Regions[1], 1 );
1947 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, cplStart[1], 1 );
1948 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, cplQbits[1], 1 );
1949 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, FrameSize[1], 1 );
1950
1951 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, Channels[2], 2 );
1952 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, Regions[2], 2 );
1953 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, cplStart[2], 2 );
1954 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, cplQbits[2], 2 );
1955 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, FrameSize[2], 2 );
1956
1957 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, Channels[3], 3 );
1958 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, Regions[3], 3 );
1959 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, cplStart[3], 3 );
1960 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, cplQbits[3], 3 );
1961 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, FrameSize[3], 3 );
1962
1963 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, Channels[4], 4 );
1964 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, Regions[4], 4 );
1965 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, cplStart[4], 4 );
1966 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, cplQbits[4], 4 );
1967 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, FrameSize[4], 4 );
1968
1969 return TRUE;
1970 }
1971
1972 ////////////////////////////////////////////////////////////////////////////////
1973 /// @brief \b Function \b Name: HAL_MAD_XPCM_GetParaBase()
1974 /// @brief \b Function \b Description: This routine is used to get the base address for XPCM parameter
1975 /// @param <IN> \b NONE :
1976 /// @param <OUT> \b NONE :
1977 /// @param <RET> \b MS_U16 : XPCM parameter base address in DSP
1978 /// @param <GLOBAL> \b NONE :
1979 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_XPCM_GetParaBase(void)1980 MS_U16 HAL_MAD_XPCM_GetParaBase(void)
1981 {
1982 //NOT_DEFINE : not used
1983 return 0;
1984 }
1985
1986 ////////////////////////////////////////////////////////////////////////////////
1987 /// @brief \b Function \b Name: HAL_MAD_RA8_GetParaBase()
1988 /// @brief \b Function \b Description: This routine is used to get the base address for Ra8 parameter
1989 /// @param <IN> \b NONE :
1990 /// @param <OUT> \b NONE :
1991 /// @param <RET> \b MS_U16 : Ra8 parameter base address in DSP
1992 /// @param <GLOBAL> \b NONE :
1993 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_Ra8_GetParaBase(void)1994 MS_U16 HAL_MAD_Ra8_GetParaBase(void)
1995 {
1996 //NOT_DEFINE : not used
1997 return 0;
1998 }
1999
2000 ///////////////////////////////////////////////////////////////////////////////
2001 /// @brief \b Function \b Name: HAL_MAD_SetCommInfo()
2002 /// @brief \b Function \b Description: This routine set different paramter to audio decoder
2003 /// @param <IN> \b Audio_COMM_infoType : common audio parameter type
2004 /// @param <IN> \b MS_U32 : common audio parameter 1
2005 /// @param <IN> \b MS_U32 : common audio parameter 2
2006 /// @param <OUT> \b NONE :
2007 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
2008 /// @param <GLOBAL> \b NONE :
2009 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetCommInfo(Audio_COMM_infoType infoType,MS_VIRT param1,MS_VIRT param2)2010 MS_BOOL HAL_MAD_SetCommInfo( Audio_COMM_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
2011 {
2012 HALMAD_CHECK_SHM_INIT;
2013
2014 MS_BOOL retTx1, retTx2;
2015 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
2016 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
2017 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
2018
2019 switch(infoType)
2020 {
2021 /********************************************************************************
2022 * Other CMD
2023 ********************************************************************************/
2024 case Audio_Comm_infoType_Set_UNI_NEED_DECODE_FRMCNT:
2025 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_SETUP_DECODE_FRMCNT, ADEC1, param1, 0);
2026 break;
2027
2028 case Audio_Comm_infoType_Set_UNI_ES_Wptr:
2029 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, param1, 0);
2030 break;
2031
2032 case Audio_Comm_infoType_setBypassSPDIF_PAPB_chk: //HAL_MAD_SetDtsBypassFlag
2033 break;
2034
2035 case Audio_Comm_infoType_MMA_init:
2036 HAL_AUDIO_SetEntertainmentMode(AUDIO_ETMODE_GAME);
2037 HAL_SOUND_SetMixModeVolume(E_AUDIO_INFO_GAME_IN, GAME1_VOL, 0x12, 0x00); //DEC1 Vol
2038 HAL_SOUND_SetMixModeVolume(E_AUDIO_INFO_GAME_IN, GAME2_VOL, 0x12, 0x00); //DEC2 Vol
2039 HAL_SOUND_SetMixModeVolume(E_AUDIO_INFO_GAME_IN, PCM_VOL, 0x12, 0x00); //DEC3 Vol
2040 break;
2041
2042 case Audio_Comm_infoType_MMA_finish:
2043 HAL_AUDIO_SetEntertainmentMode(AUDIO_ETMODE_DTV);
2044 break;
2045
2046 case Audio_Comm_infoType_DMAReader_Command:
2047 if (param1)
2048 {
2049 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
2050 AUDIO_DELAY1MS(2);
2051 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
2052 }
2053 else
2054 {
2055 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0000);
2056 AUDIO_DELAY1MS(2);
2057 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0000);
2058 AUDIO_DELAY1MS(2);
2059 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0040, 0x0040); //read_init, clear dma reader data & pointer
2060 AUDIO_DELAY1MS(1);
2061 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0040, 0x0000);
2062 }
2063 break;
2064
2065 case Audio_Comm_infoType_CompressBin_LoadCode:
2066 g_AudioVars2->CompressInfo = param1;
2067 break;
2068
2069 case Audio_Comm_infoType_CompressBin_DDRAddress:
2070 g_AudioVars2->g_DSPDDRBinBaseAddress[param1] = param2;
2071 g_DSPDDRBinBaseAddress[param1] = param2;
2072 break;
2073
2074 case Audio_Comm_infoType_SetSCMS:
2075 {
2076 retTx1= HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
2077 retTx2= HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
2078
2079 if (retTx1 == FALSE || retTx2 == FALSE)
2080 {
2081 HALMAD_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
2082 break;
2083 }
2084
2085 if(param1)
2086 {
2087 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
2088 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
2089 }
2090 else
2091 {
2092 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
2093 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
2094 }
2095
2096 if(param2)
2097 {
2098 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
2099 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
2100 }
2101 else
2102 {
2103 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
2104 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
2105 }
2106
2107 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
2108 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
2109 }
2110 break;
2111
2112 case Audio_Comm_infoType_ADC_InputGain:
2113 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, (AUD_ADC_GAIN_TYPE)param1<<5);
2114 break;
2115
2116 case Audio_Comm_infoType_ADC1_InputGain:
2117 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0x1C, (AUD_ADC_GAIN_TYPE)param1<<2);
2118 break;
2119
2120 case Audio_Comm_infoType_KTV_SetType:
2121 switch((AUDIO_KTV_MODEL)param1)
2122 {
2123 case AUD_KTV_MODEL1: // iSing99
2124 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x00); // No this model in T12
2125 break;
2126 case AUD_KTV_MODEL2: // Multak
2127 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x21);
2128 break;
2129 case AUD_KTV_MODEL3: // ¹p¥Û
2130 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x02);
2131 break;
2132 case AUD_KTV_MODEL4: // Konka
2133 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x7F, 0x14);
2134 break;
2135 default:
2136 break;
2137 }
2138 break;
2139
2140 case Audio_Comm_infoType_syncSTC_in_mmTs:
2141 if ( param1 )
2142 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, ADEC1, 1, 0);
2143 else
2144 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, ADEC1, 0, 0);
2145 break;
2146
2147 case Audio_Comm_infoType_PUSI_disable_Info:
2148 if(param1)
2149 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, ADEC1, 1, 0);
2150 else
2151 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, ADEC1, 0, 0);
2152 break;
2153
2154 case Audio_Comm_infoType_Parser_Spec:
2155 if(param1)
2156 {
2157 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_SPEC, ADEC1, 1, 0);
2158 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, ADEC1, 1, 0);
2159 }
2160 else
2161 {
2162 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_SPEC, ADEC1, 0, 0);
2163 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_PARSER_PUSI_DISABLE, ADEC1, 0, 0);
2164 }
2165 break;
2166
2167 case Audio_Comm_infoType_setNR_Threshold:
2168 HAL_AUDIO_WriteByte(0x2D32, (MS_U8) param1);
2169 break;
2170
2171 case Audio_Comm_infoType_Set_CallBackFunc:
2172 if ( g_FuncPrt_Hal_SetAudioParam2 == NULL )
2173 {
2174 g_FuncPrt_Hal_SetAudioParam2 = HAL_MAD_SetAudioParam2;
2175 HALMAD_ERROR ("%s: g_FuncPrt_Hal_SetAudioParam2 hook OK !!\r\n", __FUNCTION__);
2176 }
2177 else
2178 {
2179 HALMAD_ERROR ("%s: g_FuncPrt_Hal_SetAudioParam2 already register !!\r\n", __FUNCTION__);
2180 }
2181 if ( g_FuncPrt_Hal_GetAudioInfo2 == NULL )
2182 {
2183 g_FuncPrt_Hal_GetAudioInfo2 = HAL_MAD_GetAudioInfo2;
2184 HALMAD_ERROR ("%s: g_FuncPrt_Hal_GetAudioInfo2 hook OK !!\r\n", __FUNCTION__);
2185 }
2186 else
2187 {
2188 HALMAD_ERROR ("%s: g_FuncPrt_Hal_GetAudioInfo2 already register !!\r\n", __FUNCTION__);
2189 }
2190 break;
2191
2192 case Audio_Comm_infoType_Set_DFS_PowerSave:
2193 {
2194 MS_BOOL mistake_case = FALSE;
2195 AUDIO_DSP_CODE_TYPE MainDspCodeType = g_AudioVars2->g_DspCodeType;
2196 if(param1)
2197 {
2198 if(((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20) == 0x20) ||
2199 ((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02) == 0x02))
2200 {
2201 if(param2<4)
2202 {
2203 HALMAD_ERROR("%s: When NonPCM case, audio fs can't set under level 4\n", __FUNCTION__ );
2204 mistake_case = TRUE;
2205 param2 = 4;
2206 }
2207 }
2208 else if(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD)!=0x0) //not_stop case
2209 {
2210 switch(MainDspCodeType)
2211 {
2212 case AU_DVB_STANDARD_AAC:
2213 case AU_DVB_STANDARD_MS10_DDT:
2214 case AU_DVB_STANDARD_DTS:
2215 case AU_DVB_STANDARD_DTSLBR:
2216 if(param2<3)
2217 {
2218 HALMAD_ERROR("%s: When playing AAC/DTS stream, audio fs can't set under level 3\n", __FUNCTION__ );
2219 mistake_case = TRUE;
2220 param2 = 3;
2221 }
2222 break;
2223
2224 default:
2225 if(param2<2)
2226 {
2227 HALMAD_ERROR("%s: When playing any stream except AAC/DTS, audio fs can't set under level 2\n", __FUNCTION__ );
2228 mistake_case = TRUE;
2229 param2 = 2;
2230 }
2231 break;
2232 }
2233 }
2234
2235 switch(param2)
2236 {
2237 case 1: //lowest speed
2238 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x0A); //DSP = 11/32 fs
2239 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2240 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x00); //R2 = 1/32 fs
2241 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2242 break;
2243 case 2:
2244 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x15); //DSP = 22/32 fs
2245 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2246 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x0A); //R2 = 11/32 fs
2247 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2248 break;
2249 case 3:
2250 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x1A); //DSP = 27/32 fs
2251 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2252 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x15); //R2 = 22/32 fs
2253 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2254 break;
2255 case 4: //full speed
2256 default:
2257 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x1F); //DSP = 1 fs
2258 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2259 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x1F); //R2 = 1 fs
2260 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2261 break;
2262 }
2263 }
2264 else //full speed
2265 {
2266 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1F, 0x1F); //DSP = 1 fs
2267 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
2268 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x1F, 0x1F); //R2 = 1 fs
2269 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x80);
2270 }
2271 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x00);
2272 HAL_AUDIO_AbsWriteMaskByte(REG_R2_DFS_REG, 0x80, 0x00);
2273
2274 if(mistake_case == TRUE)
2275 return FALSE;
2276 }
2277 break;
2278
2279 #if 0
2280 case Audio_Comm_infoType_HDMI_HWbypassmode:
2281 {
2282 if (param1)
2283 {
2284 HAL_AUDIO_WriteMaskByte(REG_AUDIO_HDMI_MATRIX0+1, 0x80, 0x80); //HDMI data bypass to TX without store to DDR
2285 HAL_AUDIO_WriteMaskByte(REG_AUDIO_NEW_MODE_CFG, 0x04, 0x00);
2286 }
2287 else
2288 {
2289 HAL_AUDIO_WriteMaskByte(REG_AUDIO_HDMI_MATRIX0+1, 0x80, 0x00); //HDMI data send to dsp
2290 HAL_AUDIO_WriteMaskByte(REG_AUDIO_NEW_MODE_CFG, 0x04, 0x00);
2291 }
2292 break;
2293 }
2294 #endif
2295 /********************************************************************************
2296 * DECODER 1
2297 ********************************************************************************/
2298 case Audio_Comm_infoType_ADEC1_Set_play_smpRate:
2299 {
2300 MS_U16 play_cmd;
2301 MS_U32 synth_H;
2302
2303 play_cmd = HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD) & 0xF;
2304 if (play_cmd != 0x02)
2305 printf("[%s : Audio_Comm_infoType_ADEC1_Set_play_smpRate]: audio play cmd is not Ts file Play !!\n", __FUNCTION__);
2306
2307 if (param1)
2308 {
2309 if ((param2 > 50000) ||(param2<6000))
2310 #if defined (__aarch64__)
2311 printf("[%s : Audio_Comm_infoType_ADEC1_Set_play_smpRate]: play rate [%ld] is invalid !!\n", __FUNCTION__, param2);
2312 #else
2313 printf("[%s : Audio_Comm_infoType_ADEC1_Set_play_smpRate]: play rate [%d] is invalid !!\n", __FUNCTION__, param2);
2314 #endif
2315 synth_H = 216000000 / param2;
2316 synth_H <<= 16;
2317 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_EXT_SMPRATE_CTRL, ADEC1, 1, synth_H);
2318 }
2319 else
2320 {
2321 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_EXT_SMPRATE_CTRL, ADEC1, 0, 0x11940000);
2322 }
2323 }
2324 break;
2325
2326 case Audio_Comm_infoType_ADEC1_soundmod:
2327 {
2328 MS_U8 value = 0;
2329
2330 switch((AUD_Dolby_SOUNDMODE)param1)
2331 {
2332 case AUD_Dolby_SOUNDMODE_LR: value = 0x0; break;
2333 case AUD_Dolby_SOUNDMODE_LL: value = 0x1; break;
2334 case AUD_Dolby_SOUNDMODE_RR: value = 0x2; break;
2335 default: value = 0x0; break;
2336 }
2337
2338 //NOT_DEFINE : to do
2339 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SOUND_MODE, ADEC1, value, 0);
2340 }
2341 break;
2342
2343 case Audio_Comm_infoType_SoundMode: //HAL_MAD_SetSoundMode
2344 HAL_AUDIO_SeWriteMaskByte(REG_MB_MODE_SELECT, 0x03, (AU_DVB_MODE) param1);
2345 break;
2346
2347 case Audio_Comm_infoType_ADEC1_reqDataSize:
2348 case Audio_Comm_infoType_MMFileSize: //HAL_MAD_SetMadFileSize
2349 {
2350 MS_U32 file_size_value = 0x800;
2351
2352 switch (param1)
2353 {
2354 case FILE_SIZE_1KB: file_size_value = 0x00400; break;
2355 case FILE_SIZE_2KB: file_size_value = 0x00800; break;
2356 case FILE_SIZE_4KB: file_size_value = 0x01000; break;
2357 case FILE_SIZE_8KB: file_size_value = 0x02000; break;
2358 case FILE_SIZE_16KB: file_size_value = 0x04000; break;
2359 case FILE_SIZE_32KB: file_size_value = 0x08000; break;
2360 case FILE_SIZE_64KB: file_size_value = 0x10000; break;
2361 default: break;
2362 }
2363 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, ADEC1, file_size_value, 0);
2364 }
2365 break;
2366
2367 case Audio_Comm_infoType_ADEC1_esBuf_informDataRdy:
2368 case Audio_Comm_infoType_DEC1_MMTag: //HAL_MAD_SetMMIntTag
2369 {
2370 MS_U32 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0);
2371 MS_U32 es_bufSz = ES1_DRAM_SIZE;
2372 MS_U32 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1);
2373 es_wrPtr += es_reqsz;
2374
2375 if ( es_wrPtr >= es_bufSz )
2376 es_wrPtr -= es_bufSz;
2377
2378 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, es_wrPtr, 0);
2379 }
2380 break;
2381
2382 case Audio_Comm_infoType_ADEC1_FF2X:
2383 case Audio_Comm_infoType_MM_FFx2: //HAL_MAD_SetMMFFx2Mode
2384 if ( param1 )
2385 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, ADEC1, 1, 0);
2386 else
2387 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, ADEC1, 0, 0);
2388 break;
2389
2390 case Audio_Comm_infoType_ADEC1_mute:
2391 if ( param1 )
2392 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, ADEC1, 1, 0);
2393 else
2394 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, ADEC1, 0, 0);
2395 break;
2396
2397 case Audio_Comm_infoType_ADEC1_play_wo_output:
2398 if (param1)
2399 HAL_AUDIO_DecWriteMaskByte(REG_MB_DEC_CTRL, 0x80, 0x80);
2400 else
2401 HAL_AUDIO_DecWriteMaskByte(REG_MB_DEC_CTRL, 0x80, 0x00);
2402 break;
2403
2404 case Audio_Comm_infoType_ADEC1_playControl:
2405 switch((MMA_AUDIO_CONTROL)param1)
2406 {
2407 case MMA_STOP:
2408 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
2409 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_AVSYNC);
2410 g_AudioVars2->g_bDecPlayFileFlag = FALSE;
2411 break;
2412
2413 case MMA_PLAY:
2414 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY);
2415 break;
2416
2417 case MMA_PLAY_FILETSP:
2418 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILETSP);
2419 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
2420 break;
2421
2422 case MMA_RESYNC:
2423 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_RESYNC);
2424 break;
2425
2426 case MMA_PLAY_FILE:
2427 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILE);
2428 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
2429 break;
2430
2431 case MMA_BROWSE:
2432 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STARTBROWSE);
2433 break;
2434
2435 case MMA_PAUSE:
2436 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PAUSE);
2437 break;
2438
2439 case MMA_PLAY_FRAME:
2440 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFRAME);
2441 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
2442 break;
2443
2444 default:
2445 break;
2446 }
2447 break;
2448
2449 case Audio_Comm_infoType_ADEC1_setDecParam:
2450 //NOT_DEFINE : remove
2451 break;
2452
2453 case Audio_Comm_infoType_ADEC1_UNI_PCMOutCnt:
2454 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_PCM_SET_OUTPUT_CNT, ADEC1, param1, 0);
2455 break;
2456
2457 case Audio_Comm_infoType_ADEC1_UNI_PCMInput_Addr: //assume UNI get data from PCM1.
2458 HAL_AUDIO_WriteReg(REG_DEC1_UNI_PCM3_WPTR, (MS_U16)((param1>>BYTES_IN_MIU_LINE_LOG2) - OFFSET_PCM1_DRAM_ADDR));
2459 break;
2460
2461 case Audio_Comm_infoType_DEC1_setBufferProcess:
2462 // Need Decoder Add delay support in DEC1-DSP
2463 break;
2464
2465 /********************************************************************************
2466 * DECODER 2
2467 ********************************************************************************/
2468 case Audio_Comm_infoType_ADEC2_soundmod:
2469 case Audio_Comm_infoType_ADEC2_reqDataSize:
2470 case Audio_Comm_infoType_ADEC2_FF2X:
2471 case Audio_Comm_infoType_ADEC2_mute:
2472 break;
2473
2474 case Audio_Comm_infoType_ADEC2_esBuf_informDataRdy:
2475 case Audio_Comm_infoType_DEC2_MMTag: //HAL_MAD2_SetMMIntTag
2476 {
2477 MS_U32 es_wrPtr, es_bufSz, es_reqsz;
2478 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0);
2479 es_bufSz = ES2_DRAM_SIZE;
2480 es_reqsz = param2;
2481 es_wrPtr += es_reqsz;
2482
2483 if ( es_wrPtr >= es_bufSz )
2484 es_wrPtr -= es_bufSz;
2485 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, es_wrPtr, 0);
2486 }
2487 break;
2488
2489 case Audio_Comm_infoType_ADEC2_playControl:
2490 {
2491 switch((MMA_AUDIO_CONTROL)param1)
2492 {
2493 case MMA_STOP:
2494 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP);
2495 g_AudioVars2->g_bSePlayFileFlag = FALSE;
2496 break;
2497
2498 case MMA_PLAY:
2499 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAY);
2500 break;
2501
2502 case MMA_PLAY_FILETSP:
2503 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAYFILETSP);
2504 break;
2505
2506 case MMA_RESYNC:
2507 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_RESYNC);
2508 break;
2509
2510 case MMA_PLAY_FILE:
2511 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAYFILE);
2512 break;
2513
2514 case MMA_BROWSE:
2515 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STARTBROWSE);
2516 break;
2517
2518 case MMA_PAUSE:
2519 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PAUSE);
2520 break;
2521
2522 case MMA_PLAY_FRAME:
2523 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_PLAYFRAME);
2524 break;
2525
2526 default:
2527 break;
2528 }
2529 }
2530 break;
2531
2532 case Audio_Comm_infoType_ADEC2_setDecParam:
2533 //NOT_DEFINE : remove
2534 break;
2535
2536 /********************************************************************************
2537 * OTHERS
2538 ********************************************************************************/
2539 case Audio_Comm_infoType_setSpdifDelay: // set spdif dealy time
2540 case Audio_Comm_infoType_setSpdif_BufferProcess:
2541 HAL_SOUND_SetSpdifAudioDelay((MS_U16)param1);
2542 break;
2543
2544 case Audio_Comm_infoType_setHdmiDelay: // set hdmi dealy time for CDI project
2545 HAL_SOUND_SetHdmiAudioDelay((MS_U16)param1);
2546 break;
2547
2548 case Audio_Comm_infoType_ReadByte: // For APP to read register value directly.
2549 g_ReadTargetAddr=param1;
2550 break;
2551
2552 case Audio_Comm_infoType_WriteByte: // For APP to write register value directly.
2553 HAL_AUDIO_AbsWriteMaskByte(param1,0xFF,(MS_U8)(param2&0xFF));
2554 break;
2555
2556 case Audio_Comm_infoType_PTS_info:
2557 HAL_AUDIO_PTS_info(param1);
2558 break;
2559
2560 case Audio_Comm_infoType_RTSP_Mem:
2561 {
2562 AUDIO_RTSP_INFO *ptmp = (AUDIO_RTSP_INFO *)param1;
2563 ptmp->Mem_addr = RTSP_MEM_ADDR;
2564 ptmp->Mem_size= RTSP_MEM_SIZE;
2565 }
2566 break;
2567
2568 case Audio_Comm_infoType_Dump_Dsp_Info:
2569 {
2570 g_AudioDumpInfoCtrl = param1;
2571
2572 if (param2 > 50 )
2573 g_audioDumpInfo_interval = param2;
2574 }
2575 break;
2576
2577 case Audio_Comm_infoType_Set_Video_STCPTS_DIFF:
2578 break;
2579
2580 case Audio_Comm_infoType_HDMI_Unstable_Protect:
2581 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_protect, param1);
2582 break;
2583
2584 case Audio_Comm_infoType_Vorbis_header_size:
2585 if ( param1 )
2586 {
2587 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_VORBIS_HEADER_SIZE, ADEC1, param2, 0);
2588 }
2589 else
2590 {
2591 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_VORBIS_HEADER_SIZE, ADEC1, param2, 0);
2592 }
2593 break;
2594
2595 case Audio_Comm_infoType_HDMI_Unstable_Threshold:
2596 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_threshold, param1);
2597 break;
2598
2599 case Audio_Comm_infoType_mainAudio_setBufferProcess:
2600 HAL_SOUND_SetCH1AudioDelay(param1);
2601 break;
2602
2603 case Audio_Comm_infoType_STC_Select:
2604 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECT, ADEC1, param1, 0);
2605 break;
2606
2607 #ifndef MSOS_TYPE_NUTTX
2608 case Audio_Comm_infoType_Set_TEE_Capibility:
2609 HALAUDIO_CHECK_TEE_INFO_SHM_INIT;
2610 switch ((Audio_TEE_Capability)param1)
2611 {
2612 case Audio_TEE_Setup:
2613 g_bAudioTeeEnabled = TRUE; audio_tee_enabled = TRUE;
2614 if (audio_tee_mbx_initialized == FALSE)
2615 {
2616 if (HAL_AUDIO_RegisterMBX() == TRUE)
2617 {
2618 g_bAudioTeeMbxInitialized = TRUE; audio_tee_mbx_initialized = TRUE;
2619 }
2620 }
2621 break;
2622
2623 case Audio_TEE_Setup_and_ALL_DSP_Secure_Accessed:
2624 g_bAudioTeeEnabled = TRUE; audio_tee_enabled = TRUE;
2625 if (audio_tee_mbx_initialized == FALSE)
2626 {
2627 if (HAL_AUDIO_RegisterMBX() == TRUE)
2628 {
2629 g_bAudioTeeMbxInitialized = TRUE; audio_tee_mbx_initialized = TRUE;
2630 g_bDecDspSecureTeeAccessed = TRUE; dec_dsp_secure_tee_accessed = TRUE;
2631 g_bSndDspSecureTeeAccessed = TRUE; snd_dsp_secure_tee_accessed = TRUE;
2632 }
2633 }
2634 break;
2635
2636 case Audio_TEE_Set_DSP_Secure_Accessed:
2637 if ((audio_tee_enabled == TRUE) && (audio_tee_mbx_initialized == TRUE))
2638 {
2639 if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_DEC)
2640 {
2641 g_bDecDspSecureTeeAccessed = TRUE; dec_dsp_secure_tee_accessed = TRUE;
2642 }
2643 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_SND)
2644 {
2645 g_bSndDspSecureTeeAccessed = TRUE; snd_dsp_secure_tee_accessed = TRUE;
2646 }
2647 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_ALL)
2648 {
2649 g_bDecDspSecureTeeAccessed = TRUE; dec_dsp_secure_tee_accessed = TRUE;
2650 g_bSndDspSecureTeeAccessed = TRUE; snd_dsp_secure_tee_accessed = TRUE;
2651 }
2652 }
2653 break;
2654
2655 case Audio_TEE_Set_DSP_Normal_Accessed:
2656 if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_DEC)
2657 {
2658 g_bDecDspSecureTeeAccessed = FALSE; dec_dsp_secure_tee_accessed = FALSE;
2659 }
2660 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_SND)
2661 {
2662 g_bSndDspSecureTeeAccessed = FALSE; snd_dsp_secure_tee_accessed = FALSE;
2663 }
2664 else if (((AUDIO_DSP_ID)param2) == AUDIO_DSP_ID_ALL)
2665 {
2666 g_bDecDspSecureTeeAccessed = FALSE; dec_dsp_secure_tee_accessed = FALSE;
2667 g_bSndDspSecureTeeAccessed = FALSE; snd_dsp_secure_tee_accessed = FALSE;
2668 }
2669 break;
2670
2671 default:
2672 break;
2673 }
2674 break;
2675 #endif
2676
2677 /* not supported cmd */
2678 default:
2679 #if defined (__aarch64__)
2680 printf("%s: infoType[0x%x,0x%lx,0x%lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
2681 #else
2682 printf("%s: infoType[0x%x,0x%x,0x%x] not Supported\n",__FUNCTION__, infoType, param1, param2);
2683 #endif
2684 break;
2685 }
2686
2687 return TRUE;
2688 }
2689
2690 ////////////////////////////////////////////////////////////////////////////////
2691 /// @brief \b Function \b Name: HAL_MAD_GetCommInfo()
2692 /// @brief \b Function \b Description: This routine info of audio decoders
2693 /// @param <IN> \b Audio_COMM_infoType : request info type of audio decoder
2694 /// @param <OUT> \b NONE :
2695 /// @param <RET> \b long long : info type
2696 /// @param <GLOBAL> \b NONE :
2697 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetCommInfo(Audio_COMM_infoType infoType)2698 MS_U64 HAL_MAD_GetCommInfo( Audio_COMM_infoType infoType )
2699 {
2700 MS_U64 result = 0;
2701
2702 HALMAD_CHECK_SHM_INIT;
2703
2704 switch(infoType)
2705 {
2706 /********************************************************************************
2707 * Common
2708 ********************************************************************************/
2709 case Audio_Comm_infoType_getHDMI_CopyRight_C_Bit:
2710 result = _AU_AbsReadByte(0x1027B4) & 0x20;
2711 break;
2712
2713 case Audio_Comm_infoType_getHDMI_CopyRight_L_Bit:
2714 result = _AU_AbsReadByte(0x1027B5) & 0x01;
2715 break;
2716
2717 case Audio_Comm_infoType_Get_UNI_ES_MEMCNT:
2718 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC1);
2719 break;
2720
2721 case Audio_Comm_infoType_Get_UNI_ES_Base:
2722 result = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES1_DRAM_ADDR;
2723 break;
2724
2725 case Audio_Comm_infoType_Get_UNI_ES_Size:
2726 result = ES1_DRAM_SIZE ;
2727 break;
2728
2729 case Audio_Comm_infoType_Get_UNI_PCM_Base:
2730 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_ADDR, ADEC1);
2731 break;
2732
2733 case Audio_Comm_infoType_Get_UNI_PCM_Size:
2734 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_SIZE, ADEC1);
2735 break;
2736
2737 case Audio_Comm_infoType_Get_AccumEsCnt:
2738 // result = HAL_MAD_Read_DSP_sram(REG_PTS_AccumEsCnt, DSP_MEM_TYPE_DM);
2739 result = 0;
2740 break;
2741
2742 case Audio_Comm_infoType_Is_Decoder_In_R2:
2743 result = 1;
2744 break;
2745
2746 case Audio_Comm_infoType_Is_Audio_Sync:
2747 {
2748 long long tmp = 0;
2749 MS_U32 i, no_sync_cnt = 0;
2750
2751 tmp = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_1ms_timeStamp);
2752 if (tmp == 0)
2753 {
2754 result = 0;
2755 break;
2756 }
2757
2758 tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
2759 if (tmp != 2)
2760 {
2761 result = 0;
2762 break;
2763 }
2764
2765 for (i = 0;i<3;i++)
2766 {
2767 tmp = HAL_MAD_GetCommInfo (Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
2768 if ((tmp >= (100*90))||(tmp <= (-100*90))) //100ms
2769 {
2770 no_sync_cnt ++;
2771 }
2772 }
2773
2774 if (no_sync_cnt == 0)
2775 {
2776 result = 1;
2777 }
2778 }
2779 break;
2780
2781 case Audio_Comm_infoType_Parser_Info:
2782 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PARSER_INFO, ADEC1);
2783 break;
2784 /********************************************************************************
2785 * hdmiTx
2786 ********************************************************************************/
2787 case Audio_Comm_infoType_hdmiTx_outType:
2788 {
2789 MS_U32 r2_hdmiTx_HBR = 0xFFFF;
2790
2791 if(HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20)
2792 {
2793 if(HAL_AUR2_ReadByte(REG_R2_HDMI_NONPCM_PATH) == ADEC1)
2794 {
2795 r2_hdmiTx_HBR = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMIbuf_HBR, ADEC1);
2796 }
2797 else
2798 {
2799 r2_hdmiTx_HBR = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMIbuf_HBR, ADEC2);
2800 }
2801
2802 if(r2_hdmiTx_HBR == 1)
2803 result = HDMI_OUT_8CH_NONPCM;
2804 else
2805 result = HDMI_OUT_NONPCM;
2806 }
2807 else
2808 result = HDMI_OUT_PCM;
2809 }
2810 break;
2811
2812 case Audio_Comm_infoType_hdmiTx_outFreq:
2813 {
2814 if(HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20)
2815 {
2816 MS_U32 r2_hdmiTx_smpRate = 0xFFFF;
2817
2818 if(HAL_AUR2_ReadByte(REG_R2_HDMI_NONPCM_PATH) == ADEC1)
2819 {
2820 if(g_AudioVars2->g_EdidOutViaArc == TRUE)
2821 r2_hdmiTx_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, ADEC1);
2822 else
2823 r2_hdmiTx_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ADEC1);
2824 }
2825 else
2826 {
2827 if(g_AudioVars2->g_EdidOutViaArc == TRUE)
2828 r2_hdmiTx_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, ADEC2);
2829 else
2830 r2_hdmiTx_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ADEC2);
2831 }
2832
2833 result = AUDIO_FS_NONE;
2834
2835 switch(r2_hdmiTx_smpRate)
2836 {
2837 case 32000: result = AUDIO_FS_32KHZ; break;
2838 case 44100: result = AUDIO_FS_44KHZ; break;
2839 case 48000: result = AUDIO_FS_48KHZ; break;
2840 case 64000: result = AUDIO_FS_64KHZ; break;
2841 case 88200: result = AUDIO_FS_88KHZ; break;
2842 case 96000: result = AUDIO_FS_96KHZ; break;
2843 case 176400: result = AUDIO_FS_176KHZ; break;
2844 case 192000: result = AUDIO_FS_192KHZ; break;
2845 default: result = AUDIO_FS_48KHZ; break;
2846 }
2847 }
2848 else
2849 {
2850 result = AUDIO_FS_48KHZ;
2851 }
2852 }
2853 break;
2854
2855 case Audio_Comm_infoType_HDMI_ChannelStatus_1st_64bits:
2856 {
2857 MS_U64 HDMI_value;
2858 HAL_AUDIO_AbsWriteMaskByte(REG_HDMI_STATUS_REG12, 0x30, 0x20);
2859 AUDIO_DELAY1MS(1);
2860 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG0);
2861 result = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG0);
2862 if (HDMI_value!=result)
2863 {
2864 result = 0;
2865 break;
2866 }
2867 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG1);
2868 result = result + (HDMI_value<<16);
2869 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG2);
2870 result = result + (HDMI_value<<32);
2871 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG3);
2872 result = result + (HDMI_value<<48);
2873 }
2874 break;
2875
2876 case Audio_Comm_infoType_HDMI_ChannelStatus_2nd_64bits:
2877 {
2878 MS_U64 HDMI_value;
2879 HAL_AUDIO_AbsWriteMaskByte(REG_HDMI_STATUS_REG12, 0x30, 0x20);
2880 result = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG4);
2881 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG5);
2882 result = result + (HDMI_value<<16);
2883 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG6);
2884 result = result + (HDMI_value<<32);
2885 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG7);
2886 result = result + (HDMI_value<<48);
2887 }
2888 break;
2889
2890 case Audio_Comm_infoType_HDMI_ChannelStatus_3rd_64bits:
2891 {
2892 MS_U64 HDMI_value;
2893 HAL_AUDIO_AbsWriteMaskByte(REG_HDMI_STATUS_REG12, 0x30, 0x20);
2894 result = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG8);
2895 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG9);
2896 result = result + (HDMI_value<<16);
2897 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG10);
2898 result = result + (HDMI_value<<32);
2899 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG11);
2900 result = result + (HDMI_value<<48);
2901 }
2902 break;
2903
2904 case Audio_Comm_infoType_HDMI_UserData_1st_64bits:
2905 {
2906 MS_U64 HDMI_value;
2907 HAL_AUDIO_AbsWriteMaskByte(REG_HDMI_STATUS_REG12, 0x30, 0x10);
2908 AUDIO_DELAY1MS(1);
2909 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG0);
2910 result = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG0);
2911 if (HDMI_value!=result)
2912 {
2913 result = 0;
2914 break;
2915 }
2916 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG1);
2917 result = result + (HDMI_value<<16);
2918 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG2);
2919 result = result + (HDMI_value<<32);
2920 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG3);
2921 result = result + (HDMI_value<<48);
2922 }
2923 break;
2924
2925 case Audio_Comm_infoType_HDMI_UserData_2nd_64bits:
2926 {
2927 MS_U64 HDMI_value;
2928 HAL_AUDIO_AbsWriteMaskByte(REG_HDMI_STATUS_REG12, 0x30, 0x10);
2929 result = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG4);
2930 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG5);
2931 result = result + (HDMI_value<<16);
2932 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG6);
2933 result = result + (HDMI_value<<32);
2934 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG7);
2935 result = result + (HDMI_value<<48);
2936 }
2937 break;
2938
2939 case Audio_Comm_infoType_HDMI_UserData_3rd_64bits:
2940 {
2941 MS_U64 HDMI_value;
2942 HAL_AUDIO_AbsWriteMaskByte(REG_HDMI_STATUS_REG12, 0x30, 0x10);
2943 result = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG8);
2944 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG9);
2945 result = result + (HDMI_value<<16);
2946 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG10);
2947 result = result + (HDMI_value<<32);
2948 HDMI_value = HAL_AUR2_ReadReg(REG_HDMI_STATUS_REG11);
2949 result = result + (HDMI_value<<48);
2950 }
2951 break;
2952 /********************************************************************************
2953 * DECODER 1
2954 ********************************************************************************/
2955 case Audio_Comm_infoType_ADEC1_capability:
2956 {
2957 MMA_AudioType audioType = Audio_DEC_NULL;
2958 audioType = _GetAudioCaps(AU_DEC_ID1);
2959 result = (long long)audioType;
2960 }
2961 break;
2962
2963 case Audio_Comm_infoType_ADEC1_currAudDecStatus:
2964 case Audio_Comm_infoType_DecStatus: //no change
2965 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1);
2966 break;
2967
2968 case Audio_Comm_infoType_ADEC1_AudioSyncStatus:
2969 if(HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD)&0x80)
2970 result = 0; // Free-run
2971 else
2972 result = 1; // AV-sync
2973 break;
2974
2975 case Audio_Comm_infoType_ADEC1_sampleRate:
2976 case Audio_Comm_infoType_SampleRate: //HAL_MAD_GetMadSamplingRate
2977 {
2978 MS_U32 r2_smpRate = 0xFFFF;
2979 r2_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
2980 result = AUDIO_FS_NONE;
2981
2982 switch(r2_smpRate)
2983 {
2984 case 8000: result = AUDIO_FS_8KHZ; break;
2985 case 11025: result = AUDIO_FS_11KHZ; break;
2986 case 12000: result = AUDIO_FS_12KHZ; break;
2987 case 16000: result = AUDIO_FS_16KHZ; break;
2988 case 22050: result = AUDIO_FS_22KHZ; break;
2989 case 24000: result = AUDIO_FS_24KHZ; break;
2990 case 32000: result = AUDIO_FS_32KHZ; break;
2991 case 44100: result = AUDIO_FS_44KHZ; break;
2992 case 48000: result = AUDIO_FS_48KHZ; break;
2993 case 65535: result = AUDIO_FS_NONE; break;
2994 case 64000: result = AUDIO_FS_64KHZ; break;
2995 case 88200: result = AUDIO_FS_88KHZ; break;
2996 case 96000: result = AUDIO_FS_96KHZ; break;
2997 case 176000: //result = AUDIO_FS_176KHZ; break;
2998 case 192000: //result = AUDIO_FS_192KHZ; break;
2999 default: result = AUDIO_FS_NONE; break;
3000 }
3001 }
3002 break;
3003
3004 case Audio_Comm_infoType_ADEC1_bitRate:
3005 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, ADEC1);
3006 break;
3007
3008 case Audio_Comm_infoType_ADEC1_acmod:
3009 case Audio_Comm_infoType_ChannelMode: //HAL_MAD_GetMadChannelMode
3010 {
3011 MS_U32 ac_mode = 0xFF;
3012 MS_U32 channel_mapping = 0x0;
3013 ac_mode = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC1);
3014 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC1);
3015
3016 switch(ac_mode)
3017 {
3018 case adec_ch_mono:
3019 result = AUD_CH_MODE_MONO;
3020 break;
3021
3022 case adec_ch_joint_stereo:
3023 result = AUD_CH_MODE_JOINT_STEREO;
3024 break;
3025
3026 case adec_ch_stereo:
3027 result = AUD_CH_MODE_STEREO;
3028 break;
3029
3030 case adec_ch_dual_mono:
3031 result = AUD_CH_MODE_DUAL_MONO;
3032 break;
3033
3034 case adec_ch_multi:
3035 {
3036 MS_U32 channel_mapping_mask_C_L_R, channel_mapping_mask_Ls_Rs =0x00;
3037 channel_mapping_mask_Ls_Rs = (channel_mapping&(ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS));
3038 channel_mapping_mask_C_L_R = (channel_mapping&(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R));
3039
3040 if(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3041 {
3042 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3043 result = AUD_CH_MODE_3_2_MODE;
3044 else if(channel_mapping_mask_Ls_Rs == ACMOD_CH_MASK_NULL)
3045 result = AUD_CH_MODE_3_0_MODE;
3046 else
3047 result = AUD_CH_MODE_3_1_MODE;
3048 }
3049 else if((channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L))||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3050 ||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_R)))
3051 {
3052 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3053 result = AUD_CH_MODE_2_2_MODE;
3054 else
3055 result = AUD_CH_MODE_2_1_MODE;
3056 }
3057 else //other multi-channel case, set it to AUD_CH_MODE_3_2_MODE
3058 {
3059 result = AUD_CH_MODE_3_2_MODE;
3060 }
3061 }
3062 break;
3063
3064 default:
3065 result = AUD_CH_MODE_NONE;
3066 break;
3067 }
3068 }
3069 break;
3070
3071 case Audio_Comm_infoType_ADEC1_soundmod:
3072 case Audio_Comm_infoType_SoundMode:
3073 result = HAL_AUDIO_ReadReg(REG_MB_MODE_SELECT)&0x3;
3074 break;
3075
3076 case Audio_Comm_infoType_ADEC1_okFrmCnt:
3077 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1);
3078 break;
3079
3080 case Audio_Comm_infoType_ADEC1_errFrmCnt:
3081 case Audio_Comm_infoType_DecodeErrorCnt: //HAL_MAD_Get_DecodeErrorCnt
3082 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1);
3083 break;
3084
3085 case Audio_Comm_infoType_ADEC1_1ms_timeStamp:
3086 case Audio_Comm_infoType_1ms_PTS: //no change
3087 {
3088 MS_U32 pts;
3089 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
3090 result = pts/45;
3091 }
3092 break;
3093
3094 case Audio_Comm_infoType_ADEC1_33bit_PTS:
3095 case Audio_Comm_infoType_33Bit_PTS: //HAL_MAD_GetMadPts
3096 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
3097 result <<= 1;
3098 break;
3099
3100 case Audio_Comm_infoType_ADEC1_getlatest_PTS:
3101 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, ADEC1);
3102 result <<= 1;
3103 break;
3104
3105 case Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF:
3106 case Audio_Comm_infoType_33Bit_STCPTS_DIFF: //HAL_MAD_GetMadPtsStcDelta
3107 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TD, ADEC1);
3108
3109 //sign ext
3110 result <<= 32;
3111 result >>= 31;
3112 break;
3113
3114 case Audio_Comm_infoType_ADEC1_Get_PTS_latency:
3115 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_LATENCY, ADEC1);
3116
3117 //sign ext
3118 result <<= 32;
3119 result >>= 31;
3120 break;
3121
3122 case Audio_Comm_infoType_ADEC1_Get_PCM_bufferEmpty:
3123 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_EMPTY_CNT, ADEC1);
3124 break;
3125
3126 case Audio_Comm_infoType_ADEC1_esBuf_reqFlag:
3127 {
3128 if (HAL_AUDIO_GetPlayFileFlag(DSP_DEC))
3129 result = 1;
3130 else
3131 result = 0;
3132 }
3133 break;
3134
3135 case Audio_Comm_infoType_DEC1_BufferAddr: //HAL_MAD_GetBufferAddr
3136 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0) + OFFSET_ES1_DRAM_ADDR;
3137 break;
3138
3139 case Audio_Comm_infoType_ADEC1_esBuf_reqAddr:
3140 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0) + OFFSET_ES1_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
3141 break;
3142
3143 case Audio_Comm_infoType_ADEC1_esBuf_reqSize:
3144 case Audio_Comm_infoType_DEC1_BufferSize: //HAL_MAD_GetBufferSize
3145 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1);
3146 break;
3147
3148 case Audio_Comm_infoType_ADEC1_esBuf_currLevel:
3149 case Audio_Comm_infoType_DEC1_ESBufferSize: //HAL_MAD_GetESBufferSize
3150 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC1);
3151 break;
3152
3153 case Audio_Comm_infoType_ADEC1_pcmBuf_currLevel:
3154 case Audio_Comm_infoType_DEC1_MMResidualPCM: //HAL_MAD_GetMMResidualPCM
3155 case Audio_Comm_infoType_DEC1_PCMBufferSize: //HAL_MAD_GetPCMBufferSize
3156 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, ADEC1);
3157 break;
3158
3159 case Audio_Comm_infoType_ADEC1_UNI_pcm_wptr:
3160 result = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR + HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_WR_PTR, 0);
3161 break;
3162
3163 case Audio_Comm_infoType_ADEC1_UNI_pcm_decSize:
3164 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_SIZE, ADEC1);
3165 break;
3166
3167 case Audio_Comm_infoType_ADEC1_UNI_OutPCMLevel:
3168 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, ADEC1);
3169 break;
3170
3171 case Audio_Comm_infoType_ADEC1_getDecInfo1:
3172 case Audio_Comm_infoType_ADEC1_getDecInfo2:
3173 case Audio_Comm_infoType_ADEC1_getDecInfo3:
3174 case Audio_Comm_infoType_ADEC1_getDecInfo4:
3175 case Audio_Comm_infoType_ADEC1_getDecInfo5:
3176 case Audio_Comm_infoType_ADEC1_getDecInfo6:
3177 case Audio_Comm_infoType_ADEC1_getDecInfo7:
3178 case Audio_Comm_infoType_ADEC1_getDecInfo8:
3179 {
3180 // not used, remove
3181 }
3182 break;
3183
3184 case Audio_Comm_infoType_DMAReader_BufferLevel:
3185 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
3186 result = ((MS_U32)HAL_AUDIO_ReadReg(0x2B8C)<<3); // 0x2B8C is line size
3187 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
3188 break;
3189
3190 case Audio_Comm_infoType_DMAReader_BufferSize:
3191 result = (DSP2_DMA_READER_DRAM_SIZE+1)*BYTES_IN_MIU_LINE;
3192 break;
3193
3194 case Audio_Comm_infoType_syncSTC_in_mmTs:
3195 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_MMTsSyncFlag, ADEC1);
3196 break;
3197
3198 case Audio_Comm_infoType_ADEC1_getDecChannelInfo:
3199 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC1);
3200 break;
3201
3202 case Audio_Comm_infoType_ADEC1_audio_unsupported:
3203 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNSUPPORT_TYPE, ADEC1);
3204 break;
3205
3206 /*******************************************************************************
3207 * DECODER 2
3208 *******************************************************************************/
3209 case Audio_Comm_infoType_ADEC2_capability:
3210 result = Audio_DEC_MP3;
3211 break;
3212
3213 case Audio_Comm_infoType_ADEC2_currAudDecStatus:
3214 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC2);
3215 break;
3216
3217 case Audio_Comm_infoType_ADEC2_sampleRate:
3218 {
3219 MS_U32 r2_smpRate = 0xFFFF;
3220 r2_smpRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC2);
3221 result = AUDIO_FS_NONE;
3222
3223 switch(r2_smpRate)
3224 {
3225 case 8000: result = AUDIO_FS_8KHZ; break;
3226 case 11025: result = AUDIO_FS_11KHZ; break;
3227 case 12000: result = AUDIO_FS_12KHZ; break;
3228 case 16000: result = AUDIO_FS_16KHZ; break;
3229 case 22050: result = AUDIO_FS_22KHZ; break;
3230 case 24000: result = AUDIO_FS_24KHZ; break;
3231 case 32000: result = AUDIO_FS_32KHZ; break;
3232 case 44100: result = AUDIO_FS_44KHZ; break;
3233 case 48000: result = AUDIO_FS_48KHZ; break;
3234 case 65535: result = AUDIO_FS_NONE; break;
3235 case 64000: result = AUDIO_FS_64KHZ; break;
3236 case 88200: result = AUDIO_FS_88KHZ; break;
3237 case 96000: result = AUDIO_FS_96KHZ; break;
3238 case 176000: //result = AUDIO_FS_176KHZ; break;
3239 case 192000: //result = AUDIO_FS_192KHZ; break;
3240 default: result = AUDIO_FS_NONE; break;
3241 }
3242 }
3243 break;
3244
3245 case Audio_Comm_infoType_ADEC2_bitRate:
3246 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, ADEC2);
3247 break;
3248
3249 case Audio_Comm_infoType_ADEC2_acmod:
3250 {
3251 MS_U32 ac_mode = 0xFF;
3252 MS_U32 channel_mapping = 0x0;
3253 ac_mode = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC2);
3254 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC2);
3255
3256 switch(ac_mode)
3257 {
3258 case adec_ch_mono:
3259 result = AUD_CH_MODE_MONO;
3260 break;
3261
3262 case adec_ch_joint_stereo:
3263 result = AUD_CH_MODE_JOINT_STEREO;
3264 break;
3265
3266 case adec_ch_stereo:
3267 result = AUD_CH_MODE_STEREO;
3268 break;
3269
3270 case adec_ch_dual_mono:
3271 result = AUD_CH_MODE_DUAL_MONO;
3272 break;
3273
3274 case adec_ch_multi:
3275 {
3276 MS_U32 channel_mapping_mask_C_L_R, channel_mapping_mask_Ls_Rs =0x00;
3277 channel_mapping_mask_Ls_Rs = (channel_mapping&(ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS));
3278 channel_mapping_mask_C_L_R = (channel_mapping&(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R));
3279
3280 if(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3281 {
3282 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3283 result = AUD_CH_MODE_3_2_MODE;
3284 else if(channel_mapping_mask_Ls_Rs == ACMOD_CH_MASK_NULL)
3285 result = AUD_CH_MODE_3_0_MODE;
3286 else
3287 result = AUD_CH_MODE_3_1_MODE;
3288 }
3289 else if((channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L))||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
3290 ||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_R)))
3291 {
3292 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
3293 result = AUD_CH_MODE_2_2_MODE;
3294 else
3295 result = AUD_CH_MODE_2_1_MODE;
3296 }
3297 else //other multi-channel case, set it to AUD_CH_MODE_3_2_MODE
3298 {
3299 result = AUD_CH_MODE_3_2_MODE;
3300 }
3301 }
3302 break;
3303
3304 default:
3305 result = AUD_CH_MODE_NONE;
3306 break;
3307 }
3308 }
3309 break;
3310
3311 case Audio_Comm_infoType_ADEC2_soundmod:
3312 case Audio_Comm_infoType_ADEC2_okFrmCnt:
3313 case Audio_Comm_infoType_ADEC2_errFrmCnt:
3314 break;
3315
3316 case Audio_Comm_infoType_ADEC2_1ms_timeStamp:
3317 {
3318 MS_U32 pts;
3319 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC2);
3320 result = pts/45;
3321 }
3322 break;
3323
3324 case Audio_Comm_infoType_ADEC2_33bit_PTS:
3325 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC2);
3326 result <<= 1;
3327 break;
3328
3329 case Audio_Comm_infoType_ADEC2_33bit_STCPTS_DIFF:
3330 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TD, ADEC2);
3331 //sign ext
3332 result <<= 32;
3333 result >>= 31;
3334 break;
3335
3336 case Audio_Comm_infoType_ADEC2_esBuf_reqFlag:
3337 {
3338 if (HAL_AUDIO_GetPlayFileFlag(DSP_SE))
3339 result = 1;
3340 else
3341 result = 0;
3342 }
3343 break;
3344
3345 case Audio_Comm_infoType_DEC2_BufferAddr: //HAL_MAD2_GetBufferAddr
3346 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0) + OFFSET_ES2_DRAM_ADDR;
3347 break;
3348
3349 case Audio_Comm_infoType_ADEC2_esBuf_reqAddr:
3350 result = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0) + OFFSET_ES2_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
3351 break;
3352
3353 case Audio_Comm_infoType_ADEC2_esBuf_reqSize:
3354 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC2);
3355 break;
3356
3357 case Audio_Comm_infoType_DEC2_BufferSize: //HAL_MAD2_GetBufferSize
3358 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC2);
3359 break;
3360
3361 case Audio_Comm_infoType_ADEC2_esBuf_currLevel:
3362 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC2);
3363 break;
3364
3365 case Audio_Comm_infoType_ADEC2_pcmBuf_currLevel:
3366 case Audio_Comm_infoType_DEC2_MMResidualPCM: //HAL_MAD2_GetMMResidualPCM
3367 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, ADEC2);
3368 break;
3369
3370 case Audio_Comm_infoType_ADEC2_syncSTC_in_mmTs:
3371 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_MMTsSyncFlag, ADEC2);
3372 break;
3373
3374 case Audio_Comm_infoType_ADEC2_getDecInfo1:
3375 case Audio_Comm_infoType_ADEC2_getDecInfo2:
3376 case Audio_Comm_infoType_ADEC2_getDecInfo3:
3377 case Audio_Comm_infoType_ADEC2_getDecInfo4:
3378 case Audio_Comm_infoType_ADEC2_getDecInfo5:
3379 case Audio_Comm_infoType_ADEC2_getDecInfo6:
3380 case Audio_Comm_infoType_ADEC2_getDecInfo7:
3381 case Audio_Comm_infoType_ADEC2_getDecInfo8:
3382 //{
3383 // MS_U8 param_offset = infoType - Audio_Comm_infoType_ADEC2_getDecInfo1;
3384 // result = HAL_MAD2_Read_DSP_sram(REG_DEC2_INFO_BASE+param_offset, DSP_MEM_TYPE_DM);
3385 //}
3386 break;
3387
3388 case Audio_Comm_infoType_ADEC2_getDecChannelInfo:
3389 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC2);
3390 break;
3391
3392 /********************************************************************************
3393 * DECODER 3
3394 ********************************************************************************/
3395 case Audio_Comm_infoType_ADEC3_capability:
3396 case Audio_Comm_infoType_ADEC3_currAudDecStatus:
3397 case Audio_Comm_infoType_ADEC3_sampleRate:
3398 case Audio_Comm_infoType_ADEC3_bitRate:
3399 case Audio_Comm_infoType_ADEC3_acmod:
3400 case Audio_Comm_infoType_ADEC3_soundmod:
3401 case Audio_Comm_infoType_ADEC3_reqDataSize:
3402 case Audio_Comm_infoType_ADEC3_okFrmCnt:
3403 case Audio_Comm_infoType_ADEC3_errFrmCnt:
3404 case Audio_Comm_infoType_ADEC3_1ms_timeStamp:
3405 case Audio_Comm_infoType_ADEC3_33bit_PTS:
3406 case Audio_Comm_infoType_ADEC3_33bit_STCPTS_DIFF:
3407 case Audio_Comm_infoType_ADEC3_esBuf_reqFlag:
3408 case Audio_Comm_infoType_ADEC3_esBuf_reqAddr:
3409 case Audio_Comm_infoType_ADEC3_esBuf_reqSize:
3410 case Audio_Comm_infoType_ADEC3_esBuf_currLevel:
3411 case Audio_Comm_infoType_ADEC3_pcmBuf_currLevel:
3412 case Audio_Comm_infoType_ADEC3_getDecInfo1:
3413 case Audio_Comm_infoType_ADEC3_getDecInfo2:
3414 case Audio_Comm_infoType_ADEC3_getDecInfo3:
3415 case Audio_Comm_infoType_ADEC3_getDecInfo4:
3416 case Audio_Comm_infoType_ADEC3_getDecInfo5:
3417 case Audio_Comm_infoType_ADEC3_getDecInfo6:
3418 case Audio_Comm_infoType_ADEC3_getDecInfo7:
3419 case Audio_Comm_infoType_ADEC3_getDecInfo8:
3420 case Audio_Comm_infoType_ADEC3_getDecChannelInfo:
3421 case Audio_Comm_infoType_ADEC3_getlatest_PTS:
3422 break;
3423
3424 case Audio_Comm_infoType_ReadByte:
3425 result = (MS_U64)HAL_AUDIO_AbsReadByte(g_ReadTargetAddr);
3426 break;
3427
3428 case Audio_Comm_infoType_getSignal_Energy:
3429 result = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_dec1_signal_energy);
3430 break;
3431
3432 case Audio_Comm_infoType_getNR_Status:
3433 result = (HAL_AUDIO_ReadByte(S2M_MBOX_NR_STATUS)& 0x01);
3434 break;
3435
3436 case Audio_Comm_infoType_HDMI_Unstable_Protect:
3437 result = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_protect);
3438 break;
3439
3440 case Audio_Comm_infoType_HDMI_Unstable_Threshold:
3441 result = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_hdmi_unstable_threshold);
3442 break;
3443
3444 case Audio_Comm_infoType_Get_MultiPlayer_Capability:
3445 result = 1;
3446 break;
3447
3448 case Audio_comm_infoType_Get_audio_crash_status:
3449 result = g_AudioVars2->g_u8AudioCrashFlag;
3450 break;
3451
3452 case Audio_Comm_infoType_Get_Parser_Architecture:
3453 result = E_AUD_4_PARSER_type2; // 4 AFIFO & 4 audio parser arch
3454 break;
3455
3456 case Audio_comm_infoType_Get_Main_Input_Source_Info:
3457 result = g_AudioVars2->eAudioSource;
3458 break;
3459
3460 case Audio_comm_infoType_Get_Sub_Input_Source_Info:
3461 result = HAL_AUDIO_ConvertInputType2SourceInfo(g_AudioVars2->eSubAudioSource);
3462 break;
3463
3464 case Audio_comm_infoType_Get_Main_Input_Type:
3465 result = g_AudioVars2->eMainAudioSource;
3466 break;
3467
3468 case Audio_comm_infoType_Get_Sub_Input_Type:
3469 result = g_AudioVars2->eSubAudioSource;
3470 break;
3471
3472 case Audio_Comm_infoType_Get_Dra_ChannelMode:
3473 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC1);
3474 break;
3475
3476 case Audio_Comm_infoType_LFE_Channel_Info:
3477 {
3478 MS_U32 channel_mapping = 0x0;
3479 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC1);
3480 if ((channel_mapping&ACMOD_CH_MASK_LFE)==0x20)
3481 {
3482 result = 0x1; // 1:LFE 0:no LFE
3483 }
3484 else
3485 {
3486 result = 0x0; // 1:LFE 0:no LFE
3487 }
3488 break;
3489 }
3490
3491 case Audio_Comm_infoType_Get_AD_Cabability:
3492 {
3493 #if AUDIO_AD_SUPPORT
3494 result = 1;
3495 #endif
3496 break;
3497 }
3498
3499 /* not support cmd */
3500 default:
3501 printf("%s: cmd not Supported\n", __FUNCTION__ );
3502 break;
3503 }
3504
3505 return result;
3506 }
3507
3508 ////////////////////////////////////////////////////////////////////////////////
3509 /// @brief \b Function \b Name: HAL_MAD_SetMpegInfo()
3510 /// @brief \b Function \b Description: This routine set different paramter to mpeg decoder
3511 /// @param <IN> \b Audio_MPEG_infoType : mpeg audio parameter type
3512 /// @param <IN> \b MS_U32 : common mpeg parameter 1
3513 /// @param <IN> \b MS_U32 : common mpeg parameter 2
3514 /// @param <OUT> \b NONE :
3515 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3516 /// @param <GLOBAL> \b NONE :
3517 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetMpegInfo(Audio_MPEG_infoType infoType,MS_VIRT param1,MS_VIRT param2)3518 MS_BOOL HAL_MAD_SetMpegInfo( Audio_MPEG_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3519 {
3520 switch(infoType)
3521 {
3522 case Audio_MPEG_infoType_SoundMode: //HAL_MAD_MPEG_SetSoundMode
3523 {
3524 MS_U8 value = 0; //default LL mode
3525
3526 switch((AUD_MPEG_SOUNDMODE)param1)
3527 {
3528 case AUD_MPEG_SOUNDMODE_LL: value = 0x4; break;
3529 case AUD_MPEG_SOUNDMODE_RR: value = 0x8; break;
3530 case AUD_MPEG_SOUNDMODE_LR: value = 0x0; break;
3531 case AUD_MPEG_SOUNDMODE_MIX_LR: value = 0xC; break;
3532 default: value = 0x0; break;
3533 }
3534 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPEG_SOUNDMODE, ADEC1, (MS_U32)value, 0);
3535 }
3536 break;
3537
3538 case Audio_MPEG_infoType_MMFileSize: //HAL_MAD_MPEG_SetFileSize
3539 HAL_MAD_SetCommInfo(Audio_Comm_infoType_MMFileSize, param1, param2);
3540 break;
3541
3542 case Audio_MPEG_DTV_AVSYNC_OFFSET:
3543 if ((param1<DELAY_LOWER_LIMIT)||(param1>DELAY_UPPER_LIMIT)) //delay offset range from 30ms ~ 300ms
3544 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPG_AVOFFSET, ADEC1, (MS_U32)MPG_AV_DEFAULT_DELAY, 0);
3545 else
3546 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPG_AVOFFSET, ADEC1, (MS_U32)param1, 0);
3547 break;
3548
3549 case Audio_MPEG_DTV_AVSYNC_DISABLE_SETTING:
3550 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MPG_AVOFFSET, ADEC1, (MS_U32)MPG_AV_DEFAULT_DELAY, 0);
3551 break;
3552
3553 default:
3554 #if defined (__aarch64__)
3555 printf("%s: infoType[0x%x,0x%08lx,0x%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
3556 #else
3557 printf("%s: infoType[0x%x,0x%08x,0x%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
3558 #endif
3559 break;
3560 }
3561
3562 return TRUE;
3563 }
3564
3565 ////////////////////////////////////////////////////////////////////////////////
3566 /// @brief \b Function \b Name: HAL_MAD_GetMpegInfo()
3567 /// @brief \b Function \b Description: This routine info of mpeg decoder
3568 /// @param <IN> \b Audio_MPEG_infoType : request info type of mpeg decoder
3569 /// @param <OUT> \b NONE :
3570 /// @param <RET> \b MS_U32 : info type
3571 /// @param <GLOBAL> \b NONE :
3572 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetMpegInfo(Audio_MPEG_infoType infoType)3573 MS_U32 HAL_MAD_GetMpegInfo( Audio_MPEG_infoType infoType )
3574 {
3575 MS_U32 result = 0;
3576
3577 switch(infoType)
3578 {
3579 case Audio_MPEG_infoType_DecStatus: //no change
3580 if (((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_mpeg) && (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1) & 0x0001))
3581 result = 1;
3582 else
3583 result = 0;
3584 break;
3585
3586 case Audio_MPEG_infoType_BitRate: //HAL_MAD_MPEG_GetBitRate
3587 result = HAL_MAD_MPEG_GetBitRate();
3588 break;
3589
3590 case Audio_MPEG_infoType_FrameNum: //HAL_MAD_MPEG_GetframeNum
3591 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1);
3592 break;
3593
3594 case Audio_MPEG_infoType_Layer: //HAL_MAD_MPEG_GetLayer
3595 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MPEG_LAYER, ADEC1);
3596 break;
3597
3598 case Audio_MPEG_infoType_SampleRate: //HAL_MAD_MPEG_GetSampleRate
3599 result = HAL_MAD_MPEG_GetSampleRate();
3600 break;
3601
3602 case Audio_MPEG_infoType_stereoMode: //HAL_MAD_MPEG_GetSoundMode
3603 result = HAL_MAD_MPEG_GetSoundMode();
3604 break;
3605
3606 case Audio_MPEG_infoType_Header: //HAL_MAD_MPEG_GetHeaderInfo
3607 result = HAL_MAD_MPEG_GetHeaderInfo();
3608 break;
3609
3610 default:
3611 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
3612 break;
3613 }
3614
3615 return result;
3616 }
3617
3618 ////////////////////////////////////////////////////////////////////////////////
3619 /// @brief \b Function \b Name: HAL_MAD_SetWmaInfo()
3620 /// @brief \b Function \b Description: This routine set different paramter to wma decoder
3621 /// @param <IN> \b Audio_WMA_infoType : wma audio parameter type
3622 /// @param <IN> \b MS_U32 : common wma parameter 1
3623 /// @param <IN> \b MS_U32 : common wma parameter 2
3624 /// @param <OUT> \b NONE :
3625 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3626 /// @param <GLOBAL> \b NONE :
3627 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetWmaInfo(Audio_WMA_infoType infoType,MS_VIRT param1,MS_VIRT param2)3628 MS_BOOL HAL_MAD_SetWmaInfo( Audio_WMA_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3629 {
3630 switch(infoType)
3631 {
3632 case Audio_WMA_infoType_Asf_Param:
3633 HAL_MAD_WMA_SetASFParm((WMA_ASF_PARMTYPE)param1, param2); //HAL_MAD_WMA_SetASFParm
3634 break;
3635
3636 case Audio_WMA_infoType_FFSpeed: //HAL_MAD_WMA_SetFastFowardSpeed
3637 printf("Currently, it is not used\n");
3638 break;
3639
3640 case Audio_WMA_infoType_MMFileSize:
3641 HAL_MAD_SetCommInfo(Audio_Comm_infoType_MMFileSize, param1, param2);
3642 break;
3643
3644 default:
3645 #if defined (__aarch64__)
3646 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
3647 #else
3648 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
3649 #endif
3650 break;
3651 }
3652
3653 return TRUE;
3654 }
3655
3656 ////////////////////////////////////////////////////////////////////////////////
3657 /// @brief \b Function \b Name: HAL_MAD_GetWmaInfo()
3658 /// @brief \b Function \b Description: This routine info of wma decoder
3659 /// @param <IN> \b Audio_WMA_infoType : request info type of wma decoder
3660 /// @param <OUT> \b NONE :
3661 /// @param <RET> \b MS_U32 : info type
3662 /// @param <GLOBAL> \b NONE :
3663 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetWmaInfo(Audio_WMA_infoType infoType)3664 MS_U32 HAL_MAD_GetWmaInfo( Audio_WMA_infoType infoType )
3665 {
3666 MS_U32 result = 0;
3667
3668 switch(infoType)
3669 {
3670 case Audio_WMA_infoType_BitRate: //HAL_MAD_WMA_GetBitRate
3671 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, ADEC1);
3672 break;
3673
3674 case Audio_WMA_infoType_SampleRate: //HAL_MAD_WMA_GetSampleRate
3675 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
3676 break;
3677
3678 default:
3679 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
3680 break;
3681 }
3682
3683 return result;
3684 }
3685
3686 ////////////////////////////////////////////////////////////////////////////////
3687 /// @brief \b Function \b Name: HAL_MAD_SetAC3PInfo()
3688 /// @brief \b Function \b Description: This routine set different parameter to ac3+ decoder
3689 /// @param <IN> \b Audio_AC3P_infoType : AC3+ parameter type
3690 /// @param <IN> \b MS_U32 : AC3+ parameter 1
3691 /// @param <IN> \b MS_U32 : AC3+ parameter 2
3692 /// @param <OUT> \b NONE :
3693 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3694 /// @param <GLOBAL> \b NONE :
3695 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType infoType,MS_VIRT param1,MS_VIRT param2)3696 MS_BOOL HAL_MAD_SetAC3PInfo( Audio_AC3P_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3697 {
3698 switch(infoType)
3699 {
3700 case Audio_AC3P_infoType_DownmixMode: //HAL_MAD_SetDolbyDownmixMode
3701 if((DOLBY_DOWNMIX_MODE)param1 == DOLBY_DOWNMIX_MODE_LORO)
3702 {
3703 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, ADEC1, 1, 0);
3704 }
3705 else if ((DOLBY_DOWNMIX_MODE)param1 == DOLBY_DOWNMIX_MODE_LTRT)
3706 {
3707 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, ADEC1, 0, 0);
3708 }
3709 else
3710 {
3711 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, ADEC1, 2, 0);
3712 }
3713 break;
3714
3715 case Audio_AC3P_infoType_DrcMode: //HAL_MAD_SetDolbyDrcMode
3716 if((DOLBY_DRC_MODE)param1 == RF_MODE)
3717 {
3718 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC1, 1, 0);
3719 }
3720 else
3721 {
3722 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC1, 0, 0);
3723 }
3724 break;
3725
3726 case Audio_AC3P_infoType_MMFileSize: //HAL_MAD_ac3p_setFileSize
3727 HAL_MAD_SetCommInfo(Audio_Comm_infoType_MMFileSize, param1, param2);
3728 break;
3729
3730 case Audio_AC3P_infoType_syncSTC_in_mmTs:
3731 HAL_MAD_SetCommInfo(Audio_Comm_infoType_syncSTC_in_mmTs, param1, param2);
3732 break;
3733
3734 case Audio_AC3P_infoType_hdmiTxBypass_enable:
3735 if(param1)
3736 {
3737 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_HDMI_BYPASS, param2, param1, 0);
3738 }
3739 else
3740 {
3741 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_HDMI_BYPASS, param2, param1, 0);
3742 }
3743
3744 // MS12_hashkey enable --> DDPE
3745 if((MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_B)||
3746 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_B_WO_AAC)||
3747 MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_D)||
3748 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_D_WO_AAC)))
3749 {
3750 if(param1)
3751 {
3752 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, param2, 1, 0);
3753 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x20, 0x20); //enable DDP encoder
3754 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, param2, 1, 0);
3755 }
3756 else
3757 {
3758 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, param2, 0, 0);
3759 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x20, 0x0); //disable DDP encoder
3760 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, param2, 0, 0);
3761 }
3762 }
3763 break;
3764
3765 case Audio_AC3P_infoType_BYTESWAP:
3766 if(param1 == 1)
3767 {
3768 HAL_AUDIO_WriteMaskByte(0x2C48, 0x10, 0x10);
3769 HAL_AUDIO_WriteMaskByte(0x2C49, 0x05, 0x05);
3770 }
3771 else
3772 {
3773 HAL_AUDIO_WriteMaskByte(0x2C48, 0x10, 0x00);
3774 HAL_AUDIO_WriteMaskByte(0x2C49, 0x05, 0x00);
3775 }
3776 break;
3777
3778 case Audio_AC3P_DTV_AVSYNC_OFFSET:
3779 if ((param1<DELAY_LOWER_LIMIT)||(param1>DELAY_UPPER_LIMIT))
3780 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AC3_AVOFFSET, ADEC1, AC3_AV_DEFAULT_DELAY, 0);
3781 else
3782 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AC3_AVOFFSET, ADEC1, param1, 0);
3783 break;
3784
3785 case Audio_AC3P_DTV_AVSYNC_DISABLE_SETTING:
3786 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AC3_AVOFFSET, ADEC1, AC3_AV_DEFAULT_DELAY, 0);
3787 break;
3788
3789 case Audio_AC3P_infoType_hdmiAC3inSE:
3790 if(param1 == TRUE)
3791 {
3792 FLAG_HDMI_AC3_IN_SE = TRUE;
3793 }
3794 else
3795 {
3796 FLAG_HDMI_AC3_IN_SE = FALSE;
3797 }
3798 break;
3799
3800 case Audio_AC3P_infoType_enableDolbyBulletin11:
3801 case Audio_AC3P_infoType_LoudnessMatching:
3802 if ( param1 )
3803 {
3804 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x80, 0x80);
3805 g_AudioVars2->g_dolbyLoudness_Enable = TRUE;
3806 }
3807 else
3808 {
3809 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x80, 0x00);
3810 g_AudioVars2->g_dolbyLoudness_Enable = FALSE;
3811 }
3812
3813 if ((g_AudioVars2->AudioSystemInfo.dtv_system == AUDIO_DTV_ATSC) || (g_AudioVars2->AudioSystemInfo.dtv_system == AUDIO_DTV_DMBT))
3814 {
3815 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x60, 0x40);
3816 g_AudioVars2->g_dolbyLoudness_DTVsystem = ATSC_MODE;
3817 }
3818 else if(g_AudioVars2->AudioSystemInfo.dtv_system == AUDIO_DTV_DVB)
3819 {
3820 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x60, 0x00);
3821 g_AudioVars2->g_dolbyLoudness_DTVsystem = DVB_MODE;
3822 }
3823 else
3824 {
3825 HAL_AUDIO_DecWriteMaskByte(REG_MB_DOLBY_LOUDNESS_INFO+1, 0x60, 0x20);
3826 g_AudioVars2->g_dolbyLoudness_DTVsystem = OTHER_MODE;
3827 }
3828
3829 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_RFSIGNAL_TYPE, ADEC1, g_AudioVars2->g_dolbyLoudness_DTVsystem, 0);
3830 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_TB11_ENABLE, ADEC1, g_AudioVars2->g_dolbyLoudness_Enable, 0);
3831 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_RFSIGNAL_TYPE, ADEC2, g_AudioVars2->g_dolbyLoudness_DTVsystem, 0);
3832 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_TB11_ENABLE, ADEC2, g_AudioVars2->g_dolbyLoudness_Enable, 0);
3833 break;
3834
3835 case Audio_AC3P_infoType_Drc_HighCutScale:
3836 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_HIGH_CUT, ADEC1, param1, 0);
3837 break;
3838
3839 case Audio_AC3P_infoType_Drc_LowBootScale:
3840 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_LOW_BOOST, ADEC1, param1, 0);
3841 break;
3842
3843 case Audio_AC3P_infoType_Mixer_Balance:
3844 case Audio_AC3P_infoType_AD_Mixer_Balance:
3845 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, ADEC1, param1, 0);
3846 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, ADEC2, param1, 0);
3847 break;
3848
3849 case Audio_AC3P_infoType_DDP_AD_Substream:
3850 if (param2==0)
3851 {
3852 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_AD_SUBSTREAM, ADEC1, param1, 0);
3853 }
3854 else
3855 {
3856 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_AD_SUBSTREAM, ADEC2, param1, 0);
3857 }
3858 break;
3859
3860 default:
3861 #if defined (__aarch64__)
3862 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
3863 #else
3864 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
3865 #endif
3866 break;
3867 }
3868
3869 return TRUE;
3870 }
3871
3872 ////////////////////////////////////////////////////////////////////////////////
3873 /// @brief \b Function \b Name: HAL_MAD_GetAC3PInfo()
3874 /// @brief \b Function \b Description: This routine return info type of ac3+ decoder
3875 /// @param <IN> \b Audio_AC3P_infoType : AC3+ parameter type
3876 /// @param <OUT> \b NONE :
3877 /// @param <RET> \b MS_U32 : AC3+ paramter info
3878 /// @param <GLOBAL> \b NONE :
3879 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType infoType)3880 MS_U32 HAL_MAD_GetAC3PInfo( Audio_AC3P_infoType infoType )
3881 {
3882 MS_U32 result = 0;
3883
3884 switch(infoType)
3885 {
3886 case Audio_AC3P_infoType_DecStatus:
3887 if ((((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3) ||
3888 ((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3p)) &&
3889 (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1)&0x0001))
3890 result = 1;
3891 else
3892 result = 0;
3893 break;
3894
3895 case Audio_AC3P_infoType_SampleRate:
3896 {
3897 MS_U32 SMP_RATE = 0;
3898
3899 SMP_RATE = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1); //DD+
3900 switch(SMP_RATE)
3901 {
3902 case 44100: result = SAMPLE_RATE_44100; break;
3903 case 32000: result = SAMPLE_RATE_32000; break;
3904 default:
3905 case 48000: result = SAMPLE_RATE_48000; break;
3906 }
3907 }
3908 break;
3909
3910 case Audio_AC3P_infoType_BitRate: //unit : kbps
3911 {
3912 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, ADEC1); //DD+
3913 }
3914 break;
3915
3916 case Audio_AC3P_infoType_Acmod:
3917 result = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod);
3918 break;
3919
3920 case Audio_AC3P_infoType_DrcMode:
3921 if (HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC1, 0) == 1)
3922 result = RF_MODE;
3923 else
3924 result = LINE_MODE;
3925 break;
3926
3927 case Audio_AC3P_infoType_DownmixMode:
3928 if (HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, ADEC1, 0) == 1)
3929 result = DOLBY_DOWNMIX_MODE_LORO;
3930 else
3931 result = DOLBY_DOWNMIX_MODE_LTRT;
3932 break;
3933
3934 case Audio_AC3P_infoType_AC3Type:
3935 if ((((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3) ||
3936 ((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3p)) &&
3937 (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1) & 0x0001))
3938 {
3939 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_DEC_TYPE, ADEC1);
3940 result += 1;
3941 }
3942 else
3943 {
3944 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_DEC_TYPE, ADEC1);
3945 }
3946 break;
3947
3948 case Audio_AC3P_infoType_FrameSize:
3949 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_FRAME_SIZE, ADEC1);
3950 break;
3951
3952 case Audio_AC3P_infoType_BSMode:
3953 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_BS_MODE, ADEC1);
3954 break;
3955
3956
3957 case Audio_AC3P_infoType_hdmiAC3inSE:
3958 if(FLAG_HDMI_AC3_IN_SE == TRUE)
3959 {
3960 result = 1;
3961 }
3962 else
3963 {
3964 result = 0;
3965 }
3966 break;
3967
3968 case Audio_AC3P_infoType_hdmi_in_support_DDP:
3969 result = 1;
3970 break;
3971
3972 case Audio_AC3P_infoType_ATMOS_support:
3973 result = ((g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DDP].support_SAD_byte3) & 0x1);
3974 break;
3975
3976 default:
3977 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
3978 break;
3979 }
3980
3981 return result;
3982 }
3983
3984 ////////////////////////////////////////////////////////////////////////////////
3985 /// @brief \b Function \b Name: HAL_MAD_SetAC3Info()
3986 /// @brief \b Function \b Description: This routine set different paramter to ac3 decoder
3987 /// @param <IN> \b Audio_WMA_infoType : ac3 audio parameter type
3988 /// @param <IN> \b MS_U32 : common ac3 parameter 1
3989 /// @param <IN> \b MS_U32 : common ac3 parameter 2
3990 /// @param <OUT> \b NONE :
3991 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
3992 /// @param <GLOBAL> \b NONE :
3993 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAC3Info(Audio_AC3_infoType infoType,MS_VIRT param1,MS_VIRT param2)3994 MS_BOOL HAL_MAD_SetAC3Info( Audio_AC3_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
3995 {
3996 switch(infoType)
3997 {
3998 case Audio_AC3_infoType_DownmixMode: //HAL_MAD_SetDolbyDownmixMode
3999 HAL_MAD_SetAC3PInfo( Audio_AC3P_infoType_DownmixMode, param1, param2);
4000 break;
4001
4002 case Audio_AC3_infoType_DrcMode: //HAL_MAD_SetDolbyDrcMode
4003 HAL_MAD_SetAC3PInfo( Audio_AC3P_infoType_DrcMode, param1, param2);
4004 break;
4005
4006 case Audio_AC3_infoType_AD_Mixer_Balance:
4007 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, ADEC1, param1, 0);
4008 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, ADEC2, param1, 0);
4009 break;
4010
4011 default:
4012 #if defined (__aarch64__)
4013 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
4014 #else
4015 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4016 #endif
4017 break;
4018 }
4019
4020 return TRUE;
4021 }
4022
4023 ////////////////////////////////////////////////////////////////////////////////
4024 /// @brief \b Function \b Name: HAL_MAD_GetAC3Info()
4025 /// @brief \b Function \b Description: This routine info of ac3 decoder
4026 /// @param <IN> \b Audio_AC3_infoType : request info type of ac3 decoder
4027 /// @param <OUT> \b NONE :
4028 /// @param <RET> \b MS_U32 : info type
4029 /// @param <GLOBAL> \b NONE :
4030 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetAC3Info(Audio_AC3_infoType infoType)4031 MS_U32 HAL_MAD_GetAC3Info( Audio_AC3_infoType infoType )
4032 {
4033 MS_U32 result = 0;
4034
4035 switch(infoType)
4036 {
4037 case Audio_AC3_infoType_DecStatus:
4038 if ((((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3) ||
4039 ((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_ac3p)) &&
4040 (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1) & 0x0001))
4041 result = 1;
4042 else
4043 result = 0;
4044 break;
4045
4046 case Audio_AC3_infoType_Acmod:
4047 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_Acmod);
4048 break;
4049
4050 case Audio_AC3_infoType_BitRate:
4051 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_BitRate);
4052 break;
4053
4054 case Audio_AC3_infoType_SampleRate:
4055 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_SampleRate);
4056 break;
4057
4058 case Audio_AC3_infoType_DownmixMode:
4059 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_DownmixMode);
4060 break;
4061
4062 case Audio_AC3_infoType_DrcMode:
4063 result = HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_DrcMode);
4064 break;
4065
4066 default:
4067 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4068 break;
4069 }
4070
4071 return result;
4072 }
4073
4074
4075 ////////////////////////////////////////////////////////////////////////////////
4076 /// @brief \b Function \b Name: HAL_MAD_SetDTSCommonCtrl()
4077 /// @brief \b Function \b Description: This routine set different control to DTS decoder
4078 /// @param <IN> \b Audio_DTS_infoType : DTS control type
4079 /// @param <IN> \b MS_U16 : DTS control value
4080 /// @param <OUT> \b NONE :
4081 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4082 /// @param <GLOBAL> \b NONE :
4083 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDTSCommonCtrl(Audio_DTS_infoType infoType,Audio_DTS_CtrlType ctrl_type)4084 MS_BOOL HAL_MAD_SetDTSCommonCtrl( Audio_DTS_infoType infoType, Audio_DTS_CtrlType ctrl_type )
4085 {
4086 switch(infoType)
4087 {
4088 case Audio_DTS_infoType_DMIX_LFE_EN:
4089 if (ctrl_type == Audio_DTS_Ctrl_DMIX_LFE_OFF)
4090 {
4091 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_LFE_ENABLE, ADEC1, 0, 0);
4092 }
4093 else
4094 {
4095 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_LFE_ENABLE, ADEC1, 1, 0);
4096 }
4097 break;
4098
4099 case Audio_DTS_infoType_Dialnorm_EN:
4100 // always enable
4101 break;
4102
4103 case Audio_DTS_infoType_DrcMode:
4104 // always disable in T3
4105 break;
4106
4107 case Audio_DTS_infoType_DownmixMode:
4108 if (ctrl_type == Audio_DTS_Ctrl_Downmix_LoRo)
4109 {
4110 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_MODE, ADEC1, 0, 0);
4111 }
4112 else
4113 {
4114 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_DMX_MODE, ADEC1, 1, 0);
4115 }
4116 break;
4117
4118 case Audio_DTS_infoType_ESDataServiceMode:
4119 //force Audio_DTS_Ctrl_INTRPTMode in T3
4120 break;
4121
4122 case Audio_DTS_infoType_ESData_ByteSwap:
4123 //Currently, it is not used;
4124 break;
4125
4126 case Audio_DTS_infoType_CertMode:
4127 //DTS Certification Mode, Need to disable Sound Eeffect
4128 if (ctrl_type == Audio_DTS_Ctrl_CertMode_ON)
4129 {
4130 Flag_MAIN_SNDEFFET_CHG = TRUE;
4131 Reg_REG_SOUND_MAIN_SNDEFFECT = HAL_AUDIO_ReadReg(REG_SOUND_MAIN_SNDEFFECT);
4132 HAL_AUDIO_WriteReg(REG_SOUND_MAIN_SNDEFFECT,0x0000);
4133 Reg_REG_SOUND_ADV_CFG0 = HAL_AUDIO_ReadReg(REG_SOUND_ADV_CFG0);
4134 HAL_AUDIO_WriteReg(REG_SOUND_ADV_CFG0,0x0000);
4135 }
4136 if (ctrl_type == Audio_DTS_Ctrl_CertMode_OFF)
4137 {
4138 if(Flag_MAIN_SNDEFFET_CHG)
4139 {
4140 HAL_AUDIO_WriteReg(REG_SOUND_MAIN_SNDEFFECT, Reg_REG_SOUND_MAIN_SNDEFFECT);
4141 HAL_AUDIO_WriteReg(REG_SOUND_ADV_CFG0, Reg_REG_SOUND_ADV_CFG0);
4142 Flag_MAIN_SNDEFFET_CHG = FALSE;
4143 }
4144 }
4145 break;
4146
4147 case Audio_DTS_infoType_DTSHD_HDMITxBypass_Enable:
4148 if(ctrl_type == Audio_DTS_Ctrl_DTSHDBypass_ON)
4149 {
4150 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, ADEC1, Audio_DTS_Ctrl_DTSHDBypass_ON, 0);
4151 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, ADEC2, Audio_DTS_Ctrl_DTSHDBypass_ON, 0);
4152 }
4153 else
4154 {
4155 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, ADEC1, Audio_DTS_Ctrl_DTSHDBypass_OFF, 0);
4156 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DTS_HD_HDMI_BYPASS, ADEC2, Audio_DTS_Ctrl_DTSHDBypass_OFF, 0);
4157 }
4158 break;
4159
4160 default:
4161 break;
4162 }
4163
4164 return TRUE;
4165 }
4166
4167 ////////////////////////////////////////////////////////////////////////////////
4168 /// @brief \b Function \b Name: HAL_MAD_GetDTSInfo()
4169 /// @brief \b Function \b Description: This routine return info type of DTS decoder
4170 /// @param <IN> \b Audio_DTS_infoType : DTS parameter type
4171 /// @param <OUT> \b NONE :
4172 /// @param <RET> \b MS_U32 : DTS paramter info
4173 /// @param <GLOBAL> \b NONE :
4174 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetDTSInfo(Audio_DTS_infoType infoType)4175 MS_U32 HAL_MAD_GetDTSInfo( Audio_DTS_infoType infoType )
4176 {
4177 MS_U32 result = 0;
4178
4179 switch(infoType)
4180 {
4181 case Audio_DTS_infoType_DecStatus:
4182 if (((HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask) == adec_type_dts) && (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, ADEC1)&0x0001))
4183 result = 1;
4184 else
4185 result = 0;
4186 break;
4187
4188 case Audio_DTS_infoType_KernelVersion:
4189 //Currently, it is not used;
4190 break;
4191
4192 case Audio_DTS_infoType_SampleRate: // Original FS from Header
4193 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
4194 break;
4195
4196 case Audio_DTS_infoType_BitRate:
4197 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_BIT_RATE, ADEC1);
4198 break;
4199
4200 case Audio_DTS_infoType_CD_MODE:
4201 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DTS_CD_MODE, ADEC1);
4202 break;
4203
4204 case Audio_DTS_infoType_Amode:
4205 {
4206 MS_U32 ac_mode = 0xFF;
4207 MS_U32 channel_mapping = 0x0;
4208 ac_mode = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC1);
4209 channel_mapping = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MAPPING, ADEC1);
4210
4211 switch(ac_mode)
4212 {
4213 case adec_ch_mono:
4214 result = AUD_CH_MODE_MONO;
4215 break;
4216
4217 case adec_ch_joint_stereo:
4218 result = AUD_CH_MODE_JOINT_STEREO;
4219 break;
4220
4221 case adec_ch_stereo:
4222 result = AUD_CH_MODE_STEREO;
4223 break;
4224
4225 case adec_ch_dual_mono:
4226 result = AUD_CH_MODE_DUAL_MONO;
4227 break;
4228
4229 case adec_ch_multi:
4230 {
4231 MS_U32 channel_mapping_mask_C_L_R, channel_mapping_mask_Ls_Rs =0x00;
4232 channel_mapping_mask_Ls_Rs = (channel_mapping&(ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS));
4233 channel_mapping_mask_C_L_R = (channel_mapping&(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R));
4234
4235 if(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
4236 {
4237 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
4238 result = AUD_CH_MODE_3_2_MODE;
4239 else if(channel_mapping_mask_Ls_Rs == ACMOD_CH_MASK_NULL)
4240 result = AUD_CH_MODE_3_0_MODE;
4241 else
4242 result = AUD_CH_MODE_3_1_MODE;
4243 }
4244 else if((channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_L))||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_L|ACMOD_CH_MASK_R))
4245 ||(channel_mapping_mask_C_L_R==(ACMOD_CH_MASK_C|ACMOD_CH_MASK_R)))
4246 {
4247 if(channel_mapping_mask_Ls_Rs == (ACMOD_CH_MASK_LS|ACMOD_CH_MASK_RS))
4248 result = AUD_CH_MODE_2_2_MODE;
4249 else
4250 result = AUD_CH_MODE_2_1_MODE;
4251 }
4252 else //other multi-channel case, set it to AUD_CH_MODE_3_2_MODE
4253 {
4254 result = AUD_CH_MODE_3_2_MODE;
4255 }
4256 }
4257 break;
4258
4259 default:
4260 result = AUD_CH_MODE_NONE;
4261 break;
4262 }
4263 }
4264 break;
4265
4266 case Audio_DTS_infoType_HDMI_DSP_SEL:
4267 result = 0x0; //0: in DEC DSP, 1: in SND DSP
4268 break;
4269
4270 default:
4271 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4272 break;
4273 }
4274
4275 return result;
4276 }
4277
4278
4279 ////////////////////////////////////////////////////////////////////////////////
4280 /// @brief \b Function \b Name: HAL_MAD_SetAACInfo()
4281 /// @brief \b Function \b Description: This routine set different paramter to aac decoder
4282 /// @param <IN> \b Audio_WMA_infoType : aac audio parameter type
4283 /// @param <IN> \b MS_U32 : common aac parameter 1
4284 /// @param <IN> \b MS_U32 : common aac parameter 2
4285 /// @param <OUT> \b NONE :
4286 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4287 /// @param <GLOBAL> \b NONE :
4288 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetAACInfo(Audio_AAC_infoType infoType,MS_VIRT param1,MS_VIRT param2)4289 MS_BOOL HAL_MAD_SetAACInfo( Audio_AAC_infoType infoType, MS_VIRT param1, MS_VIRT param2 )
4290 {
4291 switch(infoType)
4292 {
4293 case Audio_AAC_infoType_DownmixMode: //HAL_MAD_SetDolbyDownmixMode
4294 if((DOLBY_DOWNMIX_MODE)param1 == DOLBY_DOWNMIX_MODE_LORO)
4295 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, ADEC1, 1, 0);
4296 else
4297 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DMX_MODE, ADEC1, 0, 0);
4298 break;
4299
4300 case Audio_AAC_infoType_DrcMode: //HAL_MAD_SetDolbyDrcMode
4301 if((DOLBY_DRC_MODE)param1 == RF_MODE)
4302 {
4303 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC1, 1, 0);
4304 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC2, 1, 0);
4305 }
4306 else
4307 {
4308 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC1, 0, 0);
4309 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_RF_MODE, ADEC2, 0, 0);
4310 }
4311 break;
4312
4313 case Audio_AAC_DTV_AVSYNC_OFFSET:
4314 if ((param1<DELAY_LOWER_LIMIT)||(param1>DELAY_UPPER_LIMIT)) //delay offset range from 30ms ~ 300ms
4315 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AAC_AVOFFSET, ADEC1, AAC_AV_DEFAULT_DELAY, 0);
4316 else
4317 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AAC_AVOFFSET, ADEC1, param1, 0);
4318 break;
4319
4320 case Audio_AAC_mm_single_frame_mode:
4321 if (param1 > 0)
4322 {
4323 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER, ADEC1, 1, 0);
4324 }
4325 else
4326 {
4327 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER, ADEC1, 0, 0);
4328 }
4329 break;
4330
4331 case Audio_AAC_DTV_AVSYNC_DISABLE_SETTING:
4332 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AAC_AVOFFSET, ADEC1, AAC_AV_DEFAULT_DELAY, 0);
4333 break;
4334
4335 case Audio_AAC_AD_Mixer_Balance:
4336 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, ADEC1, param1, 0);
4337 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MIXER_BALANCE, ADEC2, param1, 0);
4338 break;
4339
4340 default:
4341 #if defined (__aarch64__)
4342 printf("%s: infoType[%x,%08lx,%08lx] not Supported\n",__FUNCTION__, infoType, param1, param2);
4343 #else
4344 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4345 #endif
4346 break;
4347 }
4348
4349 return TRUE;
4350 }
4351
4352 ////////////////////////////////////////////////////////////////////////////////
4353 /// @brief \b Function \b Name: HAL_MAD_GetAACInfo()
4354 /// @brief \b Function \b Description: This routine info of aac decoder
4355 /// @param <IN> \b Audio_AAC_infoType : request info type of aac decoder
4356 /// @param <OUT> \b NONE :
4357 /// @param <RET> \b MS_U32 : info type
4358 /// @param <GLOBAL> \b NONE :
4359 ////////////////////////////////////////////////////////////////////////////////
4360 #define DEC_UNSUPPORT_CNT 10
4361 #define AAC_UNSUPPORT_ADDR 0x3824
HAL_MAD_GetAACInfo(Audio_AAC_infoType infoType)4362 MS_U32 HAL_MAD_GetAACInfo( Audio_AAC_infoType infoType )
4363 {
4364 MS_U32 result=0;
4365 //MS_U32 result1=0, result2=0,
4366
4367 if((HAL_MAD_Rpt_DTVES() & 0xF0) != 0x50)
4368 return result;
4369
4370 switch(infoType)
4371 {
4372 case Audio_AAC_error_count:
4373 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1);
4374 break;
4375
4376 case Audio_AAC_dec_unsupported:
4377 //decode unsupported, threshold 10
4378 //Currently, it is not used;
4379 break;
4380
4381 case Audio_AAC_type:
4382 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DOLBY_AAC_TYPE, ADEC1);
4383 break;
4384
4385 default:
4386 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4387 break;
4388 }
4389 return result;
4390 }
4391
4392 ////////////////////////////////////////////////////////////////////////////////
4393 /// @brief \b Function \b Name: HAL_MAD_SetDtsInfo()
4394 /// @brief \b Function \b Description: This routine set different paramter to aac decoder
4395 /// @param <IN> \b Audio_WMA_infoType : aac audio parameter type
4396 /// @param <IN> \b MS_U32 : common aac parameter 1
4397 /// @param <IN> \b MS_U32 : common aac parameter 2
4398 /// @param <OUT> \b NONE :
4399 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4400 /// @param <GLOBAL> \b NONE :
4401 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetDtsInfo(Audio_DTS_infoType infoType,MS_U32 param1,MS_U32 param2)4402 MS_BOOL HAL_MAD_SetDtsInfo( Audio_DTS_infoType infoType, MS_U32 param1, MS_U32 param2 )
4403 {
4404 switch(infoType)
4405 {
4406 default:
4407 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4408 break;
4409 }
4410
4411 return TRUE;
4412 }
4413
4414 ////////////////////////////////////////////////////////////////////////////////
4415 /// @brief \b Function \b Name: HAL_MAD_GetAACInfo()
4416 /// @brief \b Function \b Description: This routine info of aac decoder
4417 /// @param <IN> \b Audio_AAC_infoType : request info type of aac decoder
4418 /// @param <OUT> \b NONE :
4419 /// @param <RET> \b MS_U32 : info type
4420 /// @param <GLOBAL> \b NONE :
4421 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetDtsInfo(Audio_DTS_infoType infoType)4422 MS_U32 HAL_MAD_GetDtsInfo( Audio_DTS_infoType infoType )
4423 {
4424 MS_U32 result = 0;
4425
4426 switch(infoType)
4427 {
4428 default:
4429 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4430 break;
4431 }
4432
4433 return result;
4434 }
4435
4436 ////////////////////////////////////////////////////////////////////////////////
4437 /// @brief \b Function \b Name: HAL_MAD_SetRA8LBRInfo()
4438 /// @brief \b Function \b Description: This routine set different paramter to ra8 lbr decoder
4439 /// @param <IN> \b Audio_RA8LBR_infoType : ra8 lbr audio parameter type
4440 /// @param <IN> \b MS_U32 : common ra8 lbr parameter 1
4441 /// @param <IN> \b MS_U32 : common ra8 lbr parameter 2
4442 /// @param <OUT> \b NONE :
4443 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
4444 /// @param <GLOBAL> \b NONE :
4445 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_SetRA8LBRInfo(Audio_RA8LBR_infoType infoType,MS_U32 param1,MS_U32 param2)4446 MS_BOOL HAL_MAD_SetRA8LBRInfo( Audio_RA8LBR_infoType infoType, MS_U32 param1, MS_U32 param2 )
4447 {
4448 switch ( infoType )
4449 {
4450 case Audio_RA8LBR_NumCodes:
4451 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_NUMCODECS, ADEC1, param1, 0 );
4452 break;
4453 case Audio_RA8LBR_Samples:
4454 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLES, ADEC1, param1, 0 );
4455 break;
4456 case Audio_RA8LBR_SampleRate:
4457 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLERATES, ADEC1, param1, 0 );
4458 break;
4459 case Audio_RA8LBR_Channels1:
4460 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, param1, 0 );
4461 break;
4462 case Audio_RA8LBR_Regions1:
4463 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, param1, 0 );
4464 break;
4465 case Audio_RA8LBR_cplStart1:
4466 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, param1, 0 );
4467 break;
4468 case Audio_RA8LBR_cplQbits1:
4469 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, param1, 0 );
4470 break;
4471 case Audio_RA8LBR_FrameSize1:
4472 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, param1, 0 );
4473 break;
4474 case Audio_RA8LBR_Channels2:
4475 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, param1, 1 );
4476 break;
4477 case Audio_RA8LBR_Regions2:
4478 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, param1, 1 );
4479 break;
4480 case Audio_RA8LBR_cplStart2:
4481 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, param1, 1 );
4482 break;
4483 case Audio_RA8LBR_cplQbits2:
4484 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, param1, 1 );
4485 break;
4486 case Audio_RA8LBR_FrameSize2:
4487 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, param1, 1 );
4488 break;
4489 case Audio_RA8LBR_Channels3:
4490 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, param1, 2 );
4491 break;
4492 case Audio_RA8LBR_Regions3:
4493 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, param1, 2 );
4494 break;
4495 case Audio_RA8LBR_cplStart3:
4496 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, param1, 2 );
4497 break;
4498 case Audio_RA8LBR_cplQbits3:
4499 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, param1, 2 );
4500 break;
4501 case Audio_RA8LBR_FrameSize3:
4502 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, param1, 2 );
4503 break;
4504 case Audio_RA8LBR_Channels4:
4505 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, param1, 3 );
4506 break;
4507 case Audio_RA8LBR_Regions4:
4508 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, param1, 3 );
4509 break;
4510 case Audio_RA8LBR_cplStart4:
4511 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, param1, 3 );
4512 break;
4513 case Audio_RA8LBR_cplQbits4:
4514 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, param1, 3 );
4515 break;
4516 case Audio_RA8LBR_FrameSize4:
4517 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, param1, 3 );
4518 break;
4519 case Audio_RA8LBR_Channels5:
4520 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, ADEC1, param1, 4 );
4521 break;
4522 case Audio_RA8LBR_Regions5:
4523 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, ADEC1, param1, 4 );
4524 break;
4525 case Audio_RA8LBR_cplStart5:
4526 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, ADEC1, param1, 4 );
4527 break;
4528 case Audio_RA8LBR_cplQbits5:
4529 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, ADEC1, param1, 4 );
4530 break;
4531 case Audio_RA8LBR_FrameSize5:
4532 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, ADEC1, param1, 4 );
4533 break;
4534 default:
4535 printf("%s: infoType[%x,%08x,%08x] not Supported\n",__FUNCTION__, infoType, param1, param2);
4536 break;
4537 }
4538
4539 return TRUE;
4540 }
4541
4542 ////////////////////////////////////////////////////////////////////////////////
4543 /// @brief \b Function \b Name: HAL_MAD_GetRA8LBRInfo()
4544 /// @brief \b Function \b Description: This routine info of ra8 lbr decoder
4545 /// @param <IN> \b Audio_RA8LBR_infoType : request info type of ra8 lbr decoder
4546 /// @param <OUT> \b NONE :
4547 /// @param <RET> \b MS_U32 : info type
4548 /// @param <GLOBAL> \b NONE :
4549 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_GetRA8LBRInfo(Audio_RA8LBR_infoType infoType)4550 MS_U32 HAL_MAD_GetRA8LBRInfo( Audio_RA8LBR_infoType infoType )
4551 {
4552 MS_U32 result = 0;
4553
4554 switch ( infoType )
4555 {
4556 default:
4557 printf("%s: infoType[%x] not Supported\n",__FUNCTION__, infoType);
4558 break;
4559 }
4560
4561 return result;
4562 }
4563
4564 ////////////////////////////////////////////////////////////////////////////////
4565 /// @brief \b Function \b Name: HAL_MAD_ReLoadCode()
4566 /// @brief \b Function \b Description: This routine is used to reload the DVB algorithm code
4567 /// @param u8Type1 \b type1 : algorithm1 type
4568 /// @return MS_BOOL \b TRUE --DSP reload code okay
4569 /// FALSE--DSP reload code fail
4570 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_ReLoadCode(AUDIO_DSP_CODE_TYPE u8Type1)4571 MS_BOOL HAL_MAD_ReLoadCode(AUDIO_DSP_CODE_TYPE u8Type1)
4572 {
4573 //AUDIO_ALG_INFO *pau_info, *pau_info2, tmp_info, tmp_info2;
4574 MS_BOOL ret_status = FALSE;
4575 AU_DVB_DECCMD deccmd_status;
4576 MS_U16 deccmd_status1;
4577
4578 #if (SIF_DSP_TYPE == 1)
4579 if(u8Type1 == AU_DVB_STANDARD_MPEG_EN)
4580 {
4581 return FALSE;
4582 }
4583 #endif
4584
4585 if(((u8Type1 & 0xF0) == 0x00)||((u8Type1 & 0xF0) == 0x10)||((u8Type1 & 0xF0) == 0xb0) )
4586 {
4587 if(HAL_AUDIO_GetDspCodeType() == u8Type1) // if type is the same, don't reload again
4588 {
4589 printf("Audio DSP1 code is same(0x%x), no need to reload\n", u8Type1);
4590 return TRUE;
4591 }
4592
4593 deccmd_status = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
4594 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
4595 MsOS_DisableInterrupt(E_INT_FIQ_SE_DSP2UP);
4596
4597 // Reset MAD module
4598 HAL_MAD_DisEn_MIUREQ();
4599
4600 // enable DVB fix-sync mode
4601 HAL_MAD_DvbFLockSynthesizer_En();
4602 ret_status = HAL_AUDIO_AlgReloadCode(u8Type1);
4603
4604 MsOS_EnableInterrupt(E_INT_FIQ_SE_DSP2UP);
4605 if ( ret_status == TRUE )
4606 {
4607 if(u8Type1 != AU_DVB_STANDARD_MPEG_AD)
4608 {
4609 HAL_AUDIO_SetDspCodeType(u8Type1, ret_status);
4610 }
4611 }
4612 HAL_MAD_SetDecCmd((AU_DVB_DECCMD)deccmd_status);
4613 return ret_status;
4614 }
4615 else if(((u8Type1 & 0xF0) == 0x30)||((u8Type1 & 0xF0) == 0x20)) // MPEG AD/MPEG EN/2nd decoder
4616 {
4617 deccmd_status1 = HAL_AUDIO_ReadReg(REG_R2_DECODE1_CMD);
4618 HAL_MAD2_SetDecCmd(AU_DVB2_DECCMD_STOP);
4619
4620 MsOS_DisableInterrupt(E_INT_FIQ_SE_DSP2UP);
4621
4622 // Reset MAD module
4623 //HAL_MAD_DisEn_MIUREQ();
4624
4625 // enable DVB fix-sync mode
4626 //HAL_MAD_DvbFLockSynthesizer_En();
4627 ret_status = HAL_AUDIO_AlgReloadCode(u8Type1);
4628
4629 MsOS_EnableInterrupt(E_INT_FIQ_SE_DSP2UP);
4630 HAL_AUDIO_SetDsp2CodeType(u8Type1, ret_status);
4631 HAL_MAD2_SetDecCmd((AU_DVB_DECCMD)deccmd_status1);
4632 return ret_status;
4633 }
4634 else
4635 {
4636 return FALSE;
4637 }
4638 }
4639
4640 ////////////////////////////////////////////////////////////////////////////////
4641 /// @brief \b Function \b Name: HAL_MAD_LoadCode()
4642 /// @brief \b Function \b Description: This routine is used to load the DVB algorithm code
4643 /// @param u8Type \b algorithm type
4644 /// @return MS_BOOL \b TRUE --DSP load code okay
4645 /// FALSE--DSP load code fail
4646 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_LoadCode(AUDIO_DSP_CODE_TYPE u8Type)4647 MS_BOOL HAL_MAD_LoadCode(AUDIO_DSP_CODE_TYPE u8Type)
4648 {
4649 //AUDIO_ALG_INFO *pau_info, *pau_info2, tmp_info, tmp_info2;
4650 MS_BOOL ret_status = FALSE;
4651
4652 if(((u8Type & 0xF0) == 0x00)||((u8Type & 0xF0) == 0x10)||((u8Type & 0xF0) == 0xb0)) //mad load code
4653 {
4654 AUD_DBGMSG(printf("HAL_MAD_LoadCode(type=dvb (%x))\r\n", u8Type));
4655
4656 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07, 0x00); // decoder1 Input --> DVB
4657
4658 ret_status = HAL_AUDSP_DspLoadCode(u8Type);
4659 HAL_AUDIO_SetDspCodeType(u8Type, ret_status);
4660 HAL_AUDIO_SetIsDtvFlag(TRUE);
4661 return TRUE;
4662 }
4663 else
4664 {
4665 AUD_DBGMSG(printf("HAL_MAD_SIF_LoadCode: type(%x) is invalid\r\n",u8Type));
4666 return FALSE;
4667 }
4668 }
4669
4670 ////////////////////////////////////////////////////////////////////////////////
4671 /// @brief \b Function \b Name: HAL_MAD_XPCM_setParam
4672 ////////////////////////////////////////////////////////////////////////////////
HAL_MAD_XPCM_setParam(XPCM_TYPE audioType,MS_U8 channels,MS_U16 sampleRate,MS_U8 bitsPerSample,MS_U16 blockSize,MS_U16 samplePerBlock)4673 MS_U8 HAL_MAD_XPCM_setParam(XPCM_TYPE audioType, MS_U8 channels, MS_U16 sampleRate,
4674 MS_U8 bitsPerSample, MS_U16 blockSize, MS_U16 samplePerBlock)
4675 {
4676 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_TYPE, ADEC1, audioType, 0 );
4677 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_CHANNELS, ADEC1, channels, 0 );
4678 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLERATES, ADEC1, sampleRate, 0 );
4679 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BITS_PER_SAMPLE, ADEC1, bitsPerSample, 0 );
4680 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BLOCK_SIZE, ADEC1, blockSize, 0 );
4681 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLE_PER_BLOCK, ADEC1, samplePerBlock, 0 );
4682
4683 return TRUE;
4684 }
4685
4686 //====== STAOS PIP START 2012/02/01 ========
4687
HAL_MAD_XPCM_setParam2(AUDIO_DEC_ID DecId,Audio_XPCM_Param * pParam)4688 MS_BOOL HAL_MAD_XPCM_setParam2( AUDIO_DEC_ID DecId, Audio_XPCM_Param * pParam )
4689 {
4690 Audio_XPCM_Param * pParamXPCM = pParam;
4691 Audio_id adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(DecId);
4692
4693 if ( adec_id < ADEC3 )
4694 {
4695 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_TYPE, adec_id, (MS_U32) pParamXPCM->audioType, 0 );
4696 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_CHANNELS, adec_id, (MS_U32) pParamXPCM->channels, 0 );
4697 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLERATES, adec_id, (MS_U32) pParamXPCM->sampleRate, 0 );
4698 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BITS_PER_SAMPLE, adec_id, (MS_U32) pParamXPCM->bitsPerSample, 0 );
4699 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_BLOCK_SIZE, adec_id, (MS_U32) pParamXPCM->blockSize, 0 );
4700 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_XPCM_SAMPLE_PER_BLOCK, adec_id, (MS_U32) pParamXPCM->samplePerBlock, 0 );
4701 return TRUE;
4702 }
4703 else
4704 {
4705 return FALSE;
4706 }
4707 }
4708
HAL_MAD_COOK_setParam2(AUDIO_DEC_ID DecId,Audio_COOK_Param * pParam)4709 MS_BOOL HAL_MAD_COOK_setParam2( AUDIO_DEC_ID DecId, Audio_COOK_Param * pParam )
4710 {
4711 Audio_COOK_Param * pParamCOOK = pParam;
4712 Audio_id adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(DecId);
4713
4714 if ( adec_id < ADEC3 )
4715 {
4716 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_NUMCODECS, adec_id, pParamCOOK->mNumCodecs, 0 );
4717 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLES, adec_id, pParamCOOK->mSamples, 0 );
4718 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_SAMPLERATES, adec_id, pParamCOOK->mSampleRate, 0 );
4719 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, adec_id, pParamCOOK->Channels[0], 0 );
4720 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, adec_id, pParamCOOK->Regions[0], 0 );
4721 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, adec_id, pParamCOOK->cplStart[0], 0 );
4722 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, adec_id, pParamCOOK->cplQbits[0], 0 );
4723 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, adec_id, pParamCOOK->FrameSize[0], 0 );
4724
4725 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, adec_id, pParamCOOK->Channels[1], 1 );
4726 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, adec_id, pParamCOOK->Regions[1], 1 );
4727 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, adec_id, pParamCOOK->cplStart[1], 1 );
4728 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, adec_id, pParamCOOK->cplQbits[1], 1 );
4729 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, adec_id, pParamCOOK->FrameSize[1], 1 );
4730
4731 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, adec_id, pParamCOOK->Channels[2], 2 );
4732 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, adec_id, pParamCOOK->Regions[2], 2 );
4733 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, adec_id, pParamCOOK->cplStart[2], 2 );
4734 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, adec_id, pParamCOOK->cplQbits[2], 2 );
4735 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, adec_id, pParamCOOK->FrameSize[2], 2 );
4736
4737 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, adec_id, pParamCOOK->Channels[3], 3 );
4738 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, adec_id, pParamCOOK->Regions[3], 3 );
4739 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, adec_id, pParamCOOK->cplStart[3], 3 );
4740 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, adec_id, pParamCOOK->cplQbits[3], 3 );
4741 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, adec_id, pParamCOOK->FrameSize[3], 3 );
4742
4743 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CHANNELS, adec_id, pParamCOOK->Channels[4], 4 );
4744 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_REGIONS, adec_id, pParamCOOK->Regions[4], 4 );
4745 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLSTART, adec_id, pParamCOOK->cplStart[4], 4 );
4746 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_CPLQBITS, adec_id, pParamCOOK->cplQbits[4], 4 );
4747 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_COOK_FRAMESIZE, adec_id, pParamCOOK->FrameSize[4], 4 );
4748
4749 return TRUE;
4750 }
4751 else
4752 {
4753 return FALSE;
4754 }
4755 }
4756
HAL_MAD_WMA_SetASFParm2(AUDIO_DEC_ID DecId,Audio_ASF_Param * pParam)4757 MS_BOOL HAL_MAD_WMA_SetASFParm2( AUDIO_DEC_ID DecId, Audio_ASF_Param * pParam )
4758 {
4759 Audio_id adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(DecId);
4760
4761 if ( adec_id < ADEC3 )
4762 {
4763 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_VERSION, adec_id, pParam->u32Version, 0);
4764 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELS, adec_id, pParam->u32Channels, 0);
4765 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_SAMPLERATE, adec_id, pParam->u32SampleRate, 0);
4766 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BYTERATE, adec_id, pParam->u32ByteRate, 0);
4767 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BLOCKALIGN, adec_id, pParam->u32BlockAlign, 0);
4768 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_ENCOPT, adec_id, pParam->u32Encopt, 0);
4769 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_PARSINGBYAPP, adec_id, pParam->u32ParsingByApp, 0);
4770 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_BITS_PER_SAMPLE, adec_id, pParam->u32BitsPerSample, 0);
4771 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_CHANNELMASK, adec_id, pParam->u32ChannelMask, 0);
4772 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PARAM_EXIST, adec_id, pParam->u32DrcParamExist, 0);
4773 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_REF, adec_id, pParam->u32DrcRmsAmpRef, 0);
4774 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_RMS_AMP_TARGET, adec_id, pParam->u32DrcRmsAmpTarget, 0);
4775 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_REF, adec_id, pParam->u32DrcPeakAmpRef, 0);
4776 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_DRC_PEAK_AMP_TARGET, adec_id, pParam->u32DrcPeakAmpTarget, 0);
4777 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ASF_MAX_PACKET_SIZE, adec_id, pParam->u32MaxPacketSize, 0);
4778 return TRUE;
4779 }
4780 else
4781 {
4782 return FALSE;
4783 }
4784 }
4785
HAL_MAD_SetAudioParam2(AUDIO_DEC_ID DecId,Audio_ParamType paramType,MS_VIRT Param)4786 MS_BOOL HAL_MAD_SetAudioParam2( AUDIO_DEC_ID DecId, Audio_ParamType paramType, MS_VIRT Param )
4787 {
4788 MS_BOOL bRet = TRUE;
4789 Audio_id adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(DecId);
4790
4791 HALMAD_CHECK_SHM_INIT;
4792
4793 switch ( paramType )
4794 {
4795 case Audio_ParamType_setAudioDecoder:
4796 {
4797 En_DVB_decSystemType eAudioFormat;
4798 switch ( (MMA_AudioType) Param )
4799 {
4800 case Audio_DEC_PCM:
4801 case Audio_DEC_XPCM: eAudioFormat = MSAPI_AUD_DVB_XPCM; break;
4802 case Audio_DEC_MPEG: eAudioFormat = MSAPI_AUD_DVB_MPEG; break;
4803 case Audio_DEC_MP3: eAudioFormat = MSAPI_AUD_DVB_MP3; break;
4804 case Audio_DEC_AC3: eAudioFormat = MSAPI_AUD_DVB_AC3; break;
4805 case Audio_DEC_AC3P: eAudioFormat = MSAPI_AUD_DVB_AC3P; break;
4806 case Audio_DEC_AAC_LC:
4807 case Audio_DEC_HEAAC_V1:
4808 case Audio_DEC_HEAAC_V2: eAudioFormat = MSAPI_AUD_DVB_AAC; break;
4809 case Audio_DEC_DOLBYPULSE: eAudioFormat = MSAPI_AUD_DVB_MS10_DDT; break;
4810 case Audio_DEC_WMA: eAudioFormat = MSAPI_AUD_DVB_WMA; break;
4811 case Audio_DEC_WMAPRO: eAudioFormat = MSAPI_AUD_DVB_WMA_PRO; break;
4812 case Audio_DEC_RA8: eAudioFormat = MSAPI_AUD_DVB_RA8LBR; break;
4813 case Audio_DEC_DTS: eAudioFormat = MSAPI_AUD_DVB_DTS; break;
4814 case Audio_DEC_FLAC: eAudioFormat = MSAPI_AUD_DVB_FLAC; break;
4815 case Audio_DEC_VORBIS: eAudioFormat = MSAPI_AUD_DVB_VORBIS; break;
4816 case Audio_DEC_AMR_NB: eAudioFormat = MSAPI_AUD_DVB_AMR_NB; break;
4817 case Audio_DEC_AMR_WB: eAudioFormat = MSAPI_AUD_DVB_AMR_WB; break;
4818 case Audio_DEC_DRA: eAudioFormat = MSAPI_AUD_DVB_DRA; break;
4819 case Audio_DEC_DTSLBR: eAudioFormat = MSAPI_AUD_DVB_DTSLBR; break;
4820 case Audio_DEC_KTV:
4821 case Audio_DEC_KTV2:
4822 case Audio_DEC_Dolby_TrueHD_Bypass_R2: eAudioFormat = MSAPI_AUD_DVB_DolbyTrueHDBypass; break;
4823 case Audio_DEC_DTS_HD_ADO_R2: eAudioFormat = MSAPI_AUD_DVB_DTSHDADO; break;
4824 default: eAudioFormat = MSAPI_AUD_DVB_INVALID; break;
4825 }
4826 bRet = HAL_AUDIO_SetSystem2(DecId, eAudioFormat);
4827 if ( bRet == TRUE )
4828 {
4829 g_AudioVars2->AudioDecStatus[DecId].bConnect= TRUE;
4830 g_AudioVars2->AudioDecStatus[DecId].eSourceType = E_AUDIO_INFO_MM_IN;
4831 g_AudioVars2->AudioDecStatus[DecId].eAudFormat = (En_DVB_decSystemType) eAudioFormat;
4832 }
4833 break;
4834 }
4835
4836 case Audio_ParamType_playControl:
4837 {
4838 if ( DecId == AU_DEC_ID3 )
4839 {
4840 switch ( (MMA_AUDIO_CONTROL) Param )
4841 {
4842 case MMA_STOP:
4843 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
4844 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
4845 {
4846 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_STOP);
4847 }
4848 g_AudioVars2->u16DecodeFrmCnt[DecId] = 0;
4849 g_AudioVars2->g_bSePlayFileFlag = FALSE;
4850 break;
4851
4852 case MMA_PLAY:
4853 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAY);
4854 break;
4855
4856 case MMA_PLAY_FILETSP:
4857 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFILETSP);
4858 break;
4859
4860 case MMA_RESYNC:
4861 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_RESYNC);
4862 break;
4863
4864 case MMA_PLAY_FILE:
4865 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFILE);
4866 break;
4867
4868 case MMA_BROWSE:
4869 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_STARTBROWSE);
4870 break;
4871
4872 case MMA_PAUSE:
4873 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PAUSE);
4874 break;
4875
4876 case MMA_PLAY_FRAME:
4877 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFRAME);
4878 break;
4879
4880 case MMA_PLAY_FRAME_GS:
4881 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
4882 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
4883 {
4884 HAL_MAD2_SetDecCmd2(AU_DVB_DECCMD_PLAYFRAME_GS);
4885 }
4886 break;
4887
4888 default:
4889 break;
4890 }
4891 }
4892 else
4893 {
4894 switch ( (MMA_AUDIO_CONTROL) Param )
4895 {
4896 case MMA_STOP:
4897 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
4898 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
4899 {
4900 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
4901 }
4902 else
4903 {
4904 HALMAD_ERROR ("%s: DecId %d NOT used by ANDROID MM, used by %d !!\r\n", __FUNCTION__, DecId, g_AudioVars2->AudioDecStatus[DecId].eSourceType );
4905 }
4906 g_AudioVars2->u16DecodeFrmCnt[DecId] = 0;
4907 g_AudioVars2->g_bDecPlayFileFlag = FALSE;
4908 break;
4909
4910 case MMA_PLAY:
4911 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAY);
4912 break;
4913
4914 case MMA_PLAY_FILETSP:
4915 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILETSP);
4916 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
4917 break;
4918
4919 case MMA_RESYNC:
4920 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_RESYNC);
4921 break;
4922
4923 case MMA_PLAY_FILE:
4924 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFILE);
4925 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
4926 break;
4927
4928 case MMA_BROWSE:
4929 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STARTBROWSE);
4930 break;
4931
4932 case MMA_PAUSE:
4933 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PAUSE);
4934 break;
4935
4936 case MMA_PLAY_FRAME:
4937 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFRAME);
4938 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_FREERUN);
4939 break;
4940
4941 case MMA_PLAY_FRAME_GS:
4942 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
4943 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
4944 {
4945 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_PLAYFRAME_GS);
4946 }
4947 break;
4948
4949 default:
4950 break;
4951 }
4952 }
4953 break;
4954 }
4955
4956 case Audio_ParamType_SoundMode: //HAL_MAD_SetSoundMode
4957 {
4958 HAL_AUDIO_SeWriteMaskByte(REG_MB_MODE_SELECT, 0x03, (AU_DVB_MODE) Param);
4959 break;
4960 }
4961
4962 case Audio_ParamType_PTS_info:
4963 {
4964 HAL_AUDIO_PTS_info(Param);
4965 break;
4966 }
4967
4968 case Audio_ParamType_syncSTC:
4969 {
4970 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, adec_id, Param, 0);
4971 break;
4972 }
4973
4974 case Audio_ParamType_acMode:
4975 {
4976 // DD, DDP, HEAAC
4977 switch ( (AUD_Dolby_SOUNDMODE) Param )
4978 {
4979 case AUD_Dolby_SOUNDMODE_LR: Param = 0x0; break;
4980 case AUD_Dolby_SOUNDMODE_LL: Param = 0x1; break;
4981 case AUD_Dolby_SOUNDMODE_RR: Param = 0x2; break;
4982 default: Param = 0x0; break;
4983 }
4984 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SOUND_MODE, ADEC1, Param, 0);
4985 break;
4986 }
4987
4988 case Audio_ParamType_reqDataSize:
4989 {
4990 if ( DecId == AU_DEC_ID3 )
4991 {
4992 if ( (HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD) & 0x7F) != 0 )
4993 {
4994 break;
4995 }
4996 }
4997 else
4998 {
4999 if ( (HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD) & 0x7F) != 0 )
5000 {
5001 break;
5002 }
5003 }
5004
5005 switch ( (FILE_SIZE) Param )
5006 {
5007 case FILE_SIZE_64: Param = 0x0004; break;
5008 case FILE_SIZE_128: Param = 0x0008; break;
5009 case FILE_SIZE_256: Param = 0x0010; break;
5010 case FILE_SIZE_512: Param = 0x0020; break;
5011 case FILE_SIZE_1KB: Param = 0x0040; break;
5012 case FILE_SIZE_2KB: Param = 0x0080; break;
5013 case FILE_SIZE_4KB: Param = 0x0100; break;
5014 case FILE_SIZE_8KB: Param = 0x0200; break;
5015 case FILE_SIZE_16KB: Param = 0x0400; break;
5016 case FILE_SIZE_32KB: Param = 0x0800; break;
5017 case FILE_SIZE_64KB: Param = 0x1000; break;
5018 default: Param = 0x0100; break; // default = 2KB
5019 }
5020
5021 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FILE_REQ_SIZE, adec_id, Param, 0);
5022 break;
5023 }
5024
5025 case Audio_ParamType_MM_FFx2:
5026 {
5027 if ( Param )
5028 {
5029 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, adec_id, 1, 0);
5030 }
5031 else
5032 {
5033 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MM_FF2X, adec_id, 0, 0);
5034 }
5035 break;
5036 }
5037
5038 case Audio_ParamType_mute:
5039 {
5040 if ( Param )
5041 {
5042 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, adec_id, 1, 0);
5043 }
5044 else
5045 {
5046 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DECODE_MUTE, adec_id, 0, 0);
5047 }
5048 break;
5049 }
5050
5051 case Audio_ParamType_predecode:
5052 //Currently, it is not used;
5053 break;
5054
5055
5056 case Audio_ParamType_esBuf_informDataRdy:
5057 if (adec_id == ADEC1)
5058 {
5059 MS_U32 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0);
5060 MS_U32 es_bufSz = ES1_DRAM_SIZE;
5061 MS_U32 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1);
5062 es_wrPtr += es_reqsz;
5063
5064 if ( es_wrPtr >= es_bufSz )
5065 es_wrPtr -= es_bufSz;
5066
5067 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, es_wrPtr, 0);
5068 }
5069 else if (adec_id == ADEC2)
5070 {
5071 MS_U32 es_wrPtr, es_bufSz, es_reqsz;
5072 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0);
5073 es_bufSz = ES3_DRAM_SIZE;
5074 es_reqsz = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC2);;
5075 es_wrPtr += es_reqsz;
5076
5077 if ( es_wrPtr >= es_bufSz )
5078 es_wrPtr -= es_bufSz;
5079 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, es_wrPtr, 0);
5080 }
5081 break;
5082
5083 case Audio_ParamType_setWMADecParam:
5084 bRet = HAL_MAD_WMA_SetASFParm2(DecId, (Audio_ASF_Param *) Param);
5085 break;
5086
5087 case Audio_ParamType_setCOOKDecParam:
5088 bRet = HAL_MAD_COOK_setParam2(DecId, (Audio_COOK_Param *) Param);
5089 break;
5090
5091 case Audio_ParamType_setXPCMDecParam:
5092 bRet = HAL_MAD_XPCM_setParam2(DecId, (Audio_XPCM_Param *) Param);
5093 break;
5094
5095 case Audio_ParamType_UNI_PCM3_Input_Addr:
5096 //Currently, it is not used;
5097 break;
5098
5099 case Audio_ParamType_UNI_NEED_DECODE_FRMCNT:
5100 HALMAD_PRINT("\r\n=====ID:%X Audio_ParamType_UNI_NEED_DECODE_FRMCNT =0x%X==========\r\n", (unsigned int)adec_id,(unsigned int)Param);
5101 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_SETUP_DECODE_FRMCNT, adec_id, Param, 0);
5102 break;
5103
5104 case Audio_ParamType_UNI_ES_Wptr: // OMX Wptr = offset to MAD start address
5105 if(adec_id == ADEC2) // ES For 2nd Decoder
5106 {
5107 Param = Param - (MS_U32)(ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + OFFSET_ES3_DRAM_ADDR);
5108 }
5109 else // ES For 1st Decoder
5110 {
5111 Param = Param - (MS_U32)(ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + OFFSET_ES1_DRAM_ADDR);
5112 }
5113 #if OMX_AUDIO_DEBUG
5114 HALMAD_PRINT("\r\n=====ID:%X Audio_ParamType_UNI_ES_Wptr =0x%X==========\r\n", (unsigned int)adec_id, (unsigned int)Param);
5115 #endif
5116 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, adec_id, Param, 0);
5117 break;
5118
5119 case Audio_ParamType_UNI_PCMOutCnt:
5120 {
5121 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_UNI_PCM_SET_OUTPUT_CNT, adec_id, Param, 0);
5122 break;
5123 }
5124
5125 case Audio_ParamType_AllocDecoder:
5126 {
5127 HALMAD_PRINT("\r\n=====DecID:%X Audio_ParamType_AllocDecoder =0x%X==========\r\n", (unsigned int)DecId, (unsigned int)Param);
5128 MMA_AudioType eAudioType = (MMA_AudioType) Param;
5129 MMA_AudioType eAudioCaps;
5130
5131 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
5132
5133 if ( g_AudioVars2->AudioDecStatus[DecId].bConnect == TRUE )
5134 {
5135 HALMAD_ERROR ("%s: DecId %d in Used !!\r\n", __FUNCTION__, DecId);
5136 bRet = FALSE;
5137
5138 OS_RELEASE_MUTEX(_s32MutexLoadCode);
5139
5140 break;
5141 }
5142
5143 eAudioCaps = _GetAudioCaps(DecId);
5144
5145 if ( (eAudioCaps & eAudioType) == eAudioType )
5146 {
5147 En_DVB_decSystemType eAudioFormat;
5148 switch ( eAudioType )
5149 {
5150 case Audio_DEC_PCM:
5151 case Audio_DEC_XPCM: eAudioFormat = MSAPI_AUD_DVB_XPCM; break;
5152 case Audio_DEC_MPEG: eAudioFormat = MSAPI_AUD_DVB_MPEG; break;
5153 case Audio_DEC_MP3: eAudioFormat = MSAPI_AUD_DVB_MP3; break;
5154 case Audio_DEC_AC3: eAudioFormat = MSAPI_AUD_DVB_AC3; break;
5155 case Audio_DEC_AC3P: eAudioFormat = MSAPI_AUD_DVB_AC3P; break;
5156 case Audio_DEC_AAC_LC:
5157 case Audio_DEC_HEAAC_V1:
5158 case Audio_DEC_HEAAC_V2: eAudioFormat = MSAPI_AUD_DVB_AAC; break;
5159 case Audio_DEC_DOLBYPULSE: eAudioFormat = MSAPI_AUD_DVB_MS10_DDT; break;
5160 case Audio_DEC_WMA: eAudioFormat = MSAPI_AUD_DVB_WMA; break;
5161 case Audio_DEC_WMAPRO: eAudioFormat = MSAPI_AUD_DVB_WMA_PRO; break;
5162 case Audio_DEC_RA8: eAudioFormat = MSAPI_AUD_DVB_RA8LBR; break;
5163 case Audio_DEC_DTS: eAudioFormat = MSAPI_AUD_DVB_DTS; break;
5164 case Audio_DEC_FLAC: eAudioFormat = MSAPI_AUD_DVB_FLAC; break;
5165 case Audio_DEC_VORBIS: eAudioFormat = MSAPI_AUD_DVB_VORBIS; break;
5166 case Audio_DEC_AMR_NB: eAudioFormat = MSAPI_AUD_DVB_AMR_NB; break;
5167 case Audio_DEC_AMR_WB: eAudioFormat = MSAPI_AUD_DVB_AMR_WB; break;
5168 case Audio_DEC_DRA: eAudioFormat = MSAPI_AUD_DVB_DRA; break;
5169 case Audio_DEC_DTSLBR: eAudioFormat = MSAPI_AUD_DVB_DTSLBR; break;
5170 case Audio_DEC_KTV:
5171 case Audio_DEC_KTV2:
5172 case Audio_DEC_Dolby_TrueHD_Bypass_R2: eAudioFormat = MSAPI_AUD_DVB_DolbyTrueHDBypass; break;
5173 case Audio_DEC_DTS_HD_ADO_R2: eAudioFormat = MSAPI_AUD_DVB_DTSHDADO; break;
5174 default: eAudioFormat = MSAPI_AUD_DVB_INVALID; break;
5175 }
5176 bRet = HAL_AUDIO_SetSystem2(DecId, eAudioFormat);
5177 if ( bRet == TRUE )
5178 {
5179 g_AudioVars2->AudioDecStatus[DecId].bConnect = TRUE;
5180 g_AudioVars2->AudioDecStatus[DecId].eSourceType = E_AUDIO_INFO_MM_IN;
5181 g_AudioVars2->AudioDecStatus[DecId].eAudFormat =(En_DVB_decSystemType) eAudioFormat;
5182
5183 /* expect used this path is OMX MM, so need to setup input source path to 0x82 */
5184 HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT, AUDIO_PATH_4);
5185 }
5186 }
5187 else
5188 {
5189 HALMAD_ERROR ("%s: DecId %d Audio Type (0x%08X) not Support !!\r\n", __FUNCTION__, DecId, g_AudioVars2->AudioDecStatus[DecId].eAudFormat );
5190 bRet = FALSE;
5191 }
5192
5193 OS_RELEASE_MUTEX(_s32MutexLoadCode);
5194
5195 break;
5196 }
5197
5198 case Audio_ParamType_FreeDecoder:
5199
5200 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
5201
5202 if ( g_AudioVars2->AudioDecStatus[DecId].bConnect == TRUE )
5203 {
5204 if ((g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_MM_IN) ||
5205 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_GAME_IN))
5206 {
5207 memset(&g_AudioVars2->AudioDecStatus[DecId], 0, sizeof(AudioDecStatus_t));
5208 if ( DecId == AU_DEC_ID1 )
5209 {
5210 g_AudioVars2->g_DspCodeType = AU_DVB_NONE;
5211 }
5212 else if ( DecId == AU_DEC_ID3 )
5213 {
5214 g_AudioVars2->g_DspCodeType = AU_DVB_NONE;
5215 }
5216 }
5217 else
5218 {
5219 HALMAD_ERROR ("%s: DecId %d NOT used by ANDROID MM, used by %d !!\r\n", __FUNCTION__, DecId, g_AudioVars2->AudioDecStatus[DecId].eSourceType);
5220 }
5221 }
5222 else
5223 {
5224 HALMAD_ERROR ("%s: DecId %d NOT in USED !!\r\n", __FUNCTION__, DecId);
5225 bRet = FALSE;
5226 }
5227
5228 OS_RELEASE_MUTEX(_s32MutexLoadCode);
5229
5230 break;
5231
5232 case Audio_ParamType_omx_spdif_mode:
5233
5234 if ( adec_id < ADEC3 )
5235 {
5236 MS_U32 u32SpdifParam;
5237 Audio_OMX_SPDIF_Param eMode;
5238 u32SpdifParam = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, adec_id, 0);
5239 eMode = (Audio_OMX_SPDIF_Param) Param;
5240 if ( eMode == Audio_OMX_SPDIF_ON )
5241 {
5242 u32SpdifParam |= 0x00000001;
5243 }
5244 else
5245 {
5246 u32SpdifParam &= 0xFFFFFFFE;
5247 }
5248 //HALMAD_ERROR ("%s: DecId %d SpdifParam 0x%08X !!\r\n", __FUNCTION__, DecId, u32SpdifParam);
5249 if ( (bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, adec_id, u32SpdifParam, 0)) != TRUE )
5250 {
5251 HALMAD_ERROR ("%s: DecId %d Fail to switch SPDIF mode to %s !!\r\n", __FUNCTION__, DecId, (eMode == Audio_OMX_SPDIF_ON ? "ON" : "OFF"));
5252 }
5253 }
5254 else
5255 {
5256 HALMAD_ERROR ("%s: Param Type %d DecId %d Un-Support Now !!\r\n", __FUNCTION__, Audio_ParamType_omx_spdif_mode, DecId);
5257 bRet = FALSE;
5258 }
5259 break;
5260
5261 case Audio_ParamType_omx_spdif_play:
5262
5263 if ( adec_id < ADEC3 )
5264 {
5265 MS_U32 u32SpdifParam;
5266 Audio_OMX_SPDIF_Param eMode;
5267 u32SpdifParam = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, adec_id, 0);
5268 eMode = (Audio_OMX_SPDIF_Param) Param;
5269 if ( eMode == Audio_OMX_SPDIF_PLAY )
5270 {
5271 u32SpdifParam |= 0x00000002;
5272 }
5273 else
5274 {
5275 u32SpdifParam &= 0xFFFFFFFD;
5276 }
5277 //HALMAD_ERROR ("%s: DecId %d SpdifParam 0x%08X !!\r\n", __FUNCTION__, DecId, u32SpdifParam);
5278 if ( (bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_CTRL, adec_id, u32SpdifParam, 0)) != TRUE )
5279 {
5280 HALMAD_ERROR ("%s: DecId %d Fail to switch SPDIF mode to %s !!\r\n", __FUNCTION__, DecId, (eMode == Audio_OMX_SPDIF_ON ? "ON" : "OFF"));
5281 }
5282 }
5283 else
5284 {
5285 HALMAD_ERROR ("%s: Param Type %d DecId %d Un-Support Now !!\r\n", __FUNCTION__, Audio_ParamType_omx_spdif_play, DecId);
5286 bRet = FALSE;
5287 }
5288 break;
5289
5290 case Audio_ParamType_omx_spdif_pcmLevel:
5291
5292 if ( adec_id < ADEC3 )
5293 {
5294 if ( (bRet = HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_OMX_SPDIF_PCM_LEVEL, adec_id, Param, 0)) != TRUE )
5295 {
5296 HALMAD_ERROR ("%s: DecId %d Fail to setup PCM Level !!\r\n", __FUNCTION__, DecId);
5297 }
5298 }
5299 else
5300 {
5301 HALMAD_ERROR ("%s: Param Type %d DecId %d Un-Support Now !!\r\n", __FUNCTION__, Audio_ParamType_omx_spdif_pcmLevel, DecId);
5302 bRet = FALSE;
5303 }
5304 break;
5305
5306 case Audio_ParamType_trueHD_bypass_enable:
5307 if(Param)
5308 g_AudioVars2->g_hbr_bypass_enable = true;
5309 else
5310 g_AudioVars2->g_hbr_bypass_enable = false;
5311 break;
5312
5313 /* TVOS2.0 DTV */
5314 case Audio_ParamType_tvos2_PCM_rdPtr:
5315 Param = Param - (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR);
5316 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TVOS2_PCM_RDPTR, adec_id, Param, 0);
5317 break;
5318
5319 case Audio_ParamType_tvos2_DTV_SyncType:
5320 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TVOS2_DTV_SYNCTYPE, adec_id, Param, 0);
5321 break;
5322
5323 case Audio_ParamType_Audio_AAC_mm_single_frame_mode:
5324 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER, adec_id, Param, 0);
5325 break;
5326
5327 case Audio_ParamType_Multi_Channel:
5328 {
5329 if ((Param == TRUE) || (Param == FALSE))
5330 {
5331 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_MULTI_CHANNEL, adec_id, Param, 0);
5332
5333 HALMAD_ERROR ("%s: DecId(%d) %s Multi-Channel\n", __FUNCTION__, adec_id, Param?"Enable":"disable");
5334 }
5335 else
5336 {
5337 HALMAD_ERROR ("%s: Error! Invalid value(%u) to enable/disable Multi-Channel\n", __FUNCTION__, Param);
5338 }
5339
5340 break;
5341 }
5342
5343 case Audio_ParamType_CommonCmd:
5344 HAL_MAD_CommonCmd((AUDIO_COMMON_CMD_t *)Param);
5345 break;
5346
5347 case Audio_ParamType_SetEDIDOutputInterface:
5348 {
5349 DIGITAL_OUTPUT_TYPE eEdidOutputInterfaceType = (DIGITAL_OUTPUT_TYPE)Param;
5350 MS_BOOL bHdmiMuteStatus = (((HAL_AUDIO_ReadByte(M2S_MBOX_HDMI_SETTING+1) & 0x80) > 0) ? TRUE : FALSE);
5351
5352 if (g_AudioVars2->g_EdidOutputInterfaceType == eEdidOutputInterfaceType)
5353 {
5354 //HALMAD_ERROR ("%s: same EDID Output Interface Type %u, so do nothing here\n", __FUNCTION__, eEdidOutputInterfaceType);
5355 break;
5356 }
5357
5358 g_AudioVars2->g_EdidOutputInterfaceType = eEdidOutputInterfaceType;
5359
5360 /* mute related output */
5361 HAL_SOUND_SetMute(AUDIO_T3_PATH_SPDIF, TRUE);
5362 HAL_SOUND_SetMute(AUDIO_T3_PATH_HDMI, TRUE);
5363
5364 /* apply settings */
5365 bRet = HAL_AUDIO_SetEDIDOutputInterface(eEdidOutputInterfaceType);
5366
5367 /*
5368 * Per STB's requirement :
5369 * 1. if HDMI output is configured as ARC, then SPDIF goes with ... ????
5370 * 2. if HDMI output is configure as regular TX, then SPDIF goes with ... ????
5371 */
5372 if (bRet == TRUE)
5373 {
5374 MS_BOOL bEdidOutViaArc = g_AudioVars2->g_EdidOutViaArc;
5375
5376 if (eEdidOutputInterfaceType == DIGITAL_HDMI_ARC_OUTPUT)
5377 {
5378 bEdidOutViaArc = TRUE;
5379 }
5380 else if (eEdidOutputInterfaceType == DIGITAL_HDMI_OUTPUT)
5381 {
5382 bEdidOutViaArc = FALSE;
5383 }
5384
5385 /* apply current settings if neccessary */
5386 if (g_AudioVars2->g_EdidOutViaArc != bEdidOutViaArc)
5387 {
5388 g_AudioVars2->g_EdidOutViaArc = bEdidOutViaArc;
5389 HAL_MAD_Monitor_DDPlus_SPDIF_Rate();
5390 }
5391 }
5392
5393 /* unmute related output */
5394 HAL_SOUND_SetMute(AUDIO_T3_PATH_SPDIF, g_AudioVars2->g_SPDIF_MuteStatus);
5395 HAL_SOUND_SetMute(AUDIO_T3_PATH_HDMI, bHdmiMuteStatus);
5396
5397 break;
5398 }
5399
5400 /* not supported cmd */
5401 default:
5402 HALMAD_ERROR ("%s: infoType[%x] not Supported\n", __FUNCTION__, paramType);
5403 bRet = FALSE;
5404 break;
5405 }
5406
5407 return bRet;
5408 }
5409
HAL_MAD_GetAudioInfo2(AUDIO_DEC_ID DecId,Audio_InfoType infoType,void * pInfo)5410 MS_BOOL HAL_MAD_GetAudioInfo2( AUDIO_DEC_ID DecId, Audio_InfoType infoType, void * pInfo )
5411 {
5412 MS_BOOL result = TRUE;
5413 Audio_id adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(DecId);
5414
5415 HALMAD_CHECK_SHM_INIT;
5416
5417 switch ( infoType )
5418 {
5419 case Audio_infoType_capability:
5420 {
5421 MMA_AudioType * pA_Type = (MMA_AudioType *) pInfo;
5422 *pA_Type = _GetAudioCaps(DecId);
5423 break;
5424 }
5425
5426 case Audio_infoType_DecStatus: //no change
5427 {
5428 MS_U8 * pResult = (MS_U8 *) pInfo;
5429 if ( HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_STAUS, adec_id) != 0 )
5430 {
5431 *pResult = 1;
5432 }
5433 else
5434 {
5435 *pResult = 0;
5436 }
5437 break;
5438 }
5439
5440 case Audio_infoType_AudioSyncStatus:
5441 {
5442 MS_U8 * pResult = (MS_U8 *) pInfo;
5443 if ( DecId == AU_DEC_ID3 )
5444 {
5445 if(HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_CMD)&0x80)
5446 *pResult = 0; // Free-run
5447 else
5448 *pResult = 1; // AV-sync
5449 }
5450 else
5451 {
5452 if(HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_CMD)&0x80)
5453 *pResult = 0; // Free-run
5454 else
5455 *pResult = 1; // AV-sync
5456 }
5457 break;
5458 }
5459
5460 case Audio_infoType_SampleRate: //HAL_MAD_GetMadSamplingRate
5461 {
5462 MS_U32 fs_type = 0xFFFFFFFF;
5463 AUDIO_FS_TYPE * pFS_Type = (AUDIO_FS_TYPE *) pInfo;
5464
5465 fs_type = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, adec_id);
5466
5467 *pFS_Type = AUDIO_FS_NONE;
5468
5469 switch ( fs_type )
5470 {
5471 case 8000: *pFS_Type = AUDIO_FS_8KHZ; break;
5472 case 11025: *pFS_Type = AUDIO_FS_11KHZ; break;
5473 case 12000: *pFS_Type = AUDIO_FS_12KHZ; break;
5474 case 16000: *pFS_Type = AUDIO_FS_16KHZ; break;
5475 case 22050: *pFS_Type = AUDIO_FS_22KHZ; break;
5476 case 24000: *pFS_Type = AUDIO_FS_24KHZ; break;
5477 case 32000: *pFS_Type = AUDIO_FS_32KHZ; break;
5478 case 44100: *pFS_Type = AUDIO_FS_44KHZ; break;
5479 case 48000: *pFS_Type = AUDIO_FS_48KHZ; break;
5480 case 64000: *pFS_Type = AUDIO_FS_64KHZ; break;
5481 case 88200: *pFS_Type = AUDIO_FS_88KHZ; break;
5482 case 96000: *pFS_Type = AUDIO_FS_96KHZ; break;
5483 default: *pFS_Type = AUDIO_FS_NONE; break;
5484 }
5485 break;
5486 }
5487
5488 case Audio_infoType_SoundMode:
5489 {
5490 MS_U16 * pRet = (MS_U16 *) pInfo;
5491 *pRet = HAL_AUDIO_ReadReg(REG_MB_MODE_SELECT) & 0x3;
5492
5493 break;
5494 }
5495
5496 case Audio_infoType_okFrmCnt:
5497 {
5498 MS_U32 * pRet = (MS_U32 *) pInfo;
5499 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, adec_id);
5500
5501 break;
5502 }
5503
5504 case Audio_infoType_errFrmCnt:
5505 {
5506 MS_U32 * pRet = (MS_U32 *) pInfo;
5507 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, adec_id);
5508
5509 break;
5510 }
5511
5512 case Audio_infoType_1ms_timeStamp:
5513 {
5514 MS_U32 * pRet = (MS_U32 *) pInfo;
5515
5516 MS_U32 pts;
5517 pts = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, adec_id);
5518 *pRet = pts/45;
5519
5520 break;
5521 }
5522
5523 case Audio_infoType_33bit_PTS:
5524 {
5525 MS_U64 * pRet = (MS_U64 *) pInfo;
5526
5527 if(adec_id >= MAX_ADEC) // SHM only has 2 mem
5528 {
5529 HALMAD_ERROR ("%s: DEC_ID not Supported\n", __FUNCTION__ );
5530 return FALSE;
5531 }
5532
5533 *pRet = ((MS_U64)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, adec_id))<<1;
5534 break;
5535 }
5536 #if 0
5537 case Audio_infoType_33bit_latestPTS:
5538 {
5539 MS_U64 * pRet = (MS_U64 *) pInfo;
5540
5541 if(adec_id >= MAX_ADEC) // SHM only has 2 mem
5542 {
5543 HALMAD_ERROR ("%s: DEC_ID not Supported\n", __FUNCTION__ );
5544 return FALSE;
5545 }
5546
5547 *pRet = ((MS_U64)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, adec_id))<<1;
5548 break;
5549 }
5550 #endif
5551 case Audio_infoType_BufferAddr:
5552 {
5553 MS_U32 * pRet = (MS_U32 *) pInfo;
5554 if ( DecId == AU_DEC_ID3 )
5555 {
5556 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0) + OFFSET_ES3_DRAM_ADDR;
5557 }
5558 else
5559 {
5560 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0) + OFFSET_ES1_DRAM_ADDR;
5561 }
5562
5563 break;
5564 }
5565
5566 case Audio_infoType_BufferSize:
5567 {
5568 MS_U32 * pRet = (MS_U32 *) pInfo;
5569 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, adec_id);
5570
5571 break;
5572 }
5573
5574 case Audio_infoType_esBuf_req:
5575 {
5576 MS_BOOL bFlag = FALSE;
5577
5578 if ( DecId == AU_DEC_ID3 )
5579 {
5580 bFlag = HAL_AUDIO_GetPlayFileFlag(DSP_SE);
5581 }
5582 else
5583 {
5584 bFlag = HAL_AUDIO_GetPlayFileFlag(DSP_DEC);
5585 }
5586
5587 if ( bFlag )
5588 {
5589 Audio_MM_Data_Request * pDataReq = (Audio_MM_Data_Request *) pInfo;
5590
5591 if ( DecId == AU_DEC_ID3 )
5592 {
5593 pDataReq->U32WrtBytes = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC2);
5594 pDataReq->U32WrtAddr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC2, 0) + OFFSET_ES3_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
5595 }
5596 else
5597 {
5598 pDataReq->U32WrtBytes = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1);
5599 pDataReq->U32WrtAddr = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_ES_WR_PTR, ADEC1, 0) + OFFSET_ES1_DRAM_ADDR + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE);
5600 }
5601
5602 result = TRUE;
5603 }
5604 else
5605 {
5606 result = FALSE;
5607 }
5608
5609 break;
5610 }
5611
5612 case Audio_infoType_esBuf_currLevel:
5613 {
5614 MS_U32 * pRet = (MS_U32 *) pInfo;
5615 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, adec_id);
5616
5617 break;
5618 }
5619
5620 case Audio_infoType_pcmBuf_currLevel:
5621 {
5622 MS_U32 * pRet = (MS_U32 *) pInfo;
5623 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, adec_id);
5624
5625 break;
5626 }
5627
5628 case Audio_infoType_get_audio_filter:
5629 {
5630 MS_U32 * pRet = (MS_U32 *) pInfo;
5631 if ( DecId == AU_DEC_ID3 )
5632 {
5633 *pRet = (MS_U32) FILTER_TYPE_AUDIO_2;
5634 }
5635 else if ( DecId == AU_DEC_ID1 )
5636 {
5637 *pRet = (MS_U32) FILTER_TYPE_AUDIO_1;
5638 }
5639 else
5640 {
5641 *pRet = (MS_U32) FILTER_TYPE_AUDIO_INVALID;
5642 }
5643
5644 break;
5645 }
5646
5647 case Audio_infoType_audio_unsupported:
5648 //Currently, it is not used;
5649 break;
5650
5651
5652 case Audio_infoType_UNI_PCM1_Info:
5653 {
5654 Audio_MM_PCM_Info * pPCMInfo = (Audio_MM_PCM_Info *) pInfo;
5655
5656 if ( HAL_AUDIO_GetUniDecodeFrameCnt(DecId) != g_AudioVars2->u16DecodeFrmCnt[DecId] )
5657 {
5658 g_AudioVars2->u16DecodeFrmCnt[DecId] = HAL_AUDIO_GetUniDecodeFrameCnt(DecId);
5659
5660 if ( DecId == AU_DEC_ID3 )
5661 {
5662 pPCMInfo->U32WrtAddr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM2_DRAM_ADDR+HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_ADDR, adec_id);
5663 }
5664 else
5665 {
5666 pPCMInfo->U32WrtAddr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR+ HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_ADDR, adec_id);
5667 }
5668 pPCMInfo->U32WrtBytes = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_UNI_DECODE_DONE_PCM_SIZE, adec_id);
5669 #if OMX_AUDIO_DEBUG
5670 HALMAD_PRINT("\r\n===DecId:%d Audio_infoType_UNI_PCM1_Info addr :0x%X size:0x%X DecodeFrame=0x%X==========\r\n", (MS_U32)DecId,(MS_U32)pPCMInfo->U32WrtAddr, (MS_U32)pPCMInfo->U32WrtBytes,(MS_U32)g_AudioVars2->u16DecodeFrmCnt[DecId]);
5671 #endif
5672 }
5673
5674 pPCMInfo->U32DecodeFrame = g_AudioVars2->u16DecodeFrmCnt[DecId];
5675 }
5676 break;
5677
5678 case Audio_infoType_UNI_PCM3_Level:
5679 {
5680 MS_U32 * pRet = (MS_U32 *) pInfo;
5681 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, adec_id);
5682 break;
5683 }
5684
5685 case Audio_infoType_UNI_ES_Level:
5686 {
5687 MS_U32 * pRet = (MS_U32 *) pInfo;
5688 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, adec_id);
5689 #if OMX_AUDIO_DEBUG
5690 HALMAD_PRINT("\r\n=====ID:%X Audio_infoType_UNI_ES_Level =0x%X==========\r\n", (MS_U32)adec_id, (MS_U32)*pRet);
5691 #endif
5692 break;
5693 }
5694
5695 case Audio_infoType_UNI_ES_Base:
5696 {
5697 MS_U32 * pRet = (MS_U32 *) pInfo;
5698
5699 if ( DecId == AU_DEC_ID3 )
5700 {
5701 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES3_DRAM_ADDR);
5702 }
5703 else
5704 {
5705 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + OFFSET_ES1_DRAM_ADDR);
5706 }
5707 break;
5708 }
5709
5710 case Audio_infoType_UNI_ES_Size:
5711 {
5712 MS_U32 * pRet = (MS_U32 *) pInfo;
5713 if ( DecId == AU_DEC_ID3 )
5714 {
5715 *pRet = ES3_DRAM_SIZE;
5716 }
5717 else
5718 {
5719 *pRet = ES1_DRAM_SIZE;
5720 }
5721 break;
5722 }
5723
5724 case Audio_infoType_UNI_PCM_Base:
5725 {
5726 MS_U32 * pRet = (MS_U32 *) pInfo;
5727 if ( DecId == AU_DEC_ID3 )
5728 {
5729 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM2_DRAM_ADDR);
5730 }
5731 else
5732 {
5733 *pRet = (MS_U32) (HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR);
5734 }
5735 break;
5736 }
5737
5738 case Audio_infoType_UNI_PCM_Size:
5739 {
5740 MS_U32 * pRet = (MS_U32 *) pInfo;
5741 if ( DecId == AU_DEC_ID3 )
5742 {
5743 *pRet = PCM2_DRAM_SIZE;
5744 }
5745 else
5746 {
5747 *pRet = PCM1_DRAM_SIZE;
5748 }
5749 break;
5750 }
5751
5752 case Audio_infoType_MadBaseAddr:
5753 {
5754 MS_U32 * pRet = (MS_U32 *) pInfo;
5755 if ( DecId == AU_DEC_ID3 )
5756 {
5757 *pRet = HAL_AUDIO_GetDspMadBaseAddr(DSP_ADV);
5758 }
5759 else
5760 {
5761 *pRet = HAL_AUDIO_GetDspMadBaseAddr(DSP_ADV);
5762 }
5763 break;
5764 }
5765
5766 case Audio_infoType_hashkey:
5767 {
5768 Audio_Hashkey_Info * pHashkeyInfo = (Audio_Hashkey_Info *) pInfo;
5769 MS_U32 audio_ipauth = HAL_MAD2_Read_DSP_sram(REG_DEC2_AUDIO_IPAUTH, DSP_MEM_TYPE_PM);
5770
5771 pHashkeyInfo->U32IsHashkeySupported = TRUE;
5772
5773 switch ( pHashkeyInfo->U32Name )
5774 {
5775 case Audio_DEC_AC3:
5776 {
5777 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_AC3)
5778 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_DOLBY_MS11)
5779 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_LC_PROFILE)
5780 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_C_PROFILE)
5781 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_B_PROFILE))
5782 {
5783 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5784 }
5785 break;
5786 }
5787
5788 case Audio_DEC_AC3P:
5789 {
5790 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_AC3P)
5791 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_DOLBY_MS11)
5792 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_LC_PROFILE)
5793 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_C_PROFILE)
5794 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_B_PROFILE))
5795 {
5796 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5797 }
5798 break;
5799 }
5800
5801 case Audio_DEC_AAC_LC:
5802 case Audio_DEC_HEAAC_V1:
5803 case Audio_DEC_HEAAC_V2:
5804 case Audio_DEC_DOLBYPULSE:
5805 {
5806 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_DOLBY_MS10)
5807 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_GAAC)
5808 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_DOLBY_MS11)
5809 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_C_PROFILE)
5810 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_MS12_B_PROFILE))
5811 {
5812 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5813 }
5814 break;
5815 }
5816
5817 case Audio_DEC_WMA:
5818 case Audio_DEC_WMAPRO:
5819 {
5820 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_WMA))
5821 {
5822 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5823 }
5824 break;
5825 }
5826
5827 case Audio_DEC_DTS:
5828 {
5829 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_DTS)
5830 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_DTS_XLL))
5831 {
5832 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5833 }
5834 break;
5835 }
5836
5837 case Audio_DEC_DTSLBR:
5838 {
5839 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_DTSLBR)
5840 && (audio_ipauth & AUDIO_HASHKEY_DISABLE_DTS_XLL))
5841 {
5842 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5843 }
5844 break;
5845 }
5846
5847 case Audio_DEC_DRA:
5848 {
5849 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_DRA))
5850 {
5851 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5852 }
5853 break;
5854 }
5855
5856 case Audio_DEC_RA8:
5857 {
5858 if ((audio_ipauth & AUDIO_HASHKEY_DISABLE_COOK))
5859 {
5860 pHashkeyInfo->U32IsHashkeySupported = FALSE;
5861 }
5862 break;
5863 }
5864
5865 default:
5866 break;
5867 }
5868
5869 break;
5870 }
5871
5872 case Audio_infoType_AccumEsCnt:
5873 {
5874 MS_U32 * pRet = (MS_U32 *) pInfo;
5875 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, adec_id);
5876 break;
5877 }
5878
5879
5880 case Audio_infoType_get_trueHD_bypass_enable:
5881 {
5882 MS_U8 * pRet = (MS_U8 *) pInfo;
5883 MS_U8 true_hd_support;
5884 true_hd_support = g_AudioVars2->stDigitalOutCodecCapability[1][CODEC_TRUEHD].support_codec;
5885
5886 if ((g_AudioVars2->g_hbr_bypass_enable) && (true_hd_support != 2))
5887 {
5888 *pRet = true;
5889 }
5890 else
5891 {
5892 *pRet = false;
5893 }
5894 break;
5895 }
5896
5897 case Audio_infoType_Decoder_Type:
5898 {
5899 AUDIO_DSP_CODE_TYPE eDecoder = AU_DVB_STANDARD_INVALID;
5900 MS_U32 u32DecoderType = 0;
5901 MS_U32 *pRet = (MS_U32 *)pInfo;
5902
5903 switch (adec_id)
5904 {
5905 case ADEC1:
5906 {
5907 eDecoder = g_AudioVars2->g_DspCodeType;
5908 break;
5909 }
5910
5911 case ADEC2:
5912 {
5913 eDecoder = g_AudioVars2->g_Dsp2CodeType;
5914 break;
5915 }
5916
5917 default:
5918 {
5919 HALMAD_ERROR ("%s: invalid ID (%d, %d)\n", __FUNCTION__, DecId, adec_id);
5920 result = FALSE;
5921 break;
5922 }
5923 }
5924
5925 if (result == TRUE)
5926 {
5927 switch (eDecoder)
5928 {
5929 case AU_DVB_STANDARD_DTS:
5930 case AU_DVB_STANDARD_DTSLBR:
5931 {
5932 u32DecoderType = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DTS_ES_TYPE, adec_id) & 0x00FFFFFF;
5933
5934 switch (u32DecoderType)
5935 {
5936 case DTS_TYPE_CORE:
5937 case DTS_TYPE_CORE_XLL:
5938 {
5939 *pRet = AUDIO_DTS_TYPE_CORE;
5940 break;
5941 }
5942
5943 case DTS_TYPE_LBR:
5944 {
5945 *pRet = AUDIO_DTS_TYPE_LBR;
5946 break;
5947 }
5948
5949 case DTS_TYPE_XLL:
5950 {
5951 *pRet = AUDIO_DTS_TYPE_HD;
5952 break;
5953 }
5954
5955 default:
5956 {
5957 result = FALSE;
5958 break;
5959 }
5960 }
5961 break;
5962 }
5963
5964 default:
5965 {
5966 HALMAD_ERROR ("%s: invalid ID (%d, %d)\n", __FUNCTION__, DecId, adec_id);
5967 result = FALSE;
5968 break;
5969 }
5970 }
5971 }
5972
5973 break;
5974 }
5975
5976 case Audio_infoType_syncSTC_in_mmTs:
5977 {
5978 MS_U32 * pRet = (MS_U32 *) pInfo;
5979 *pRet = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, adec_id, 0);
5980 break;
5981 }
5982
5983 #if 0
5984 /* TVOS2.0 DTV */
5985 case Audio_infoType_tvos2_PCM1_Info:
5986 {
5987 Audio_MM_PCM_Info * pPCMInfo = (Audio_MM_PCM_Info *) pInfo;
5988 MS_U64 u64cpts=0;
5989
5990 pPCMInfo->U32WriteAddr = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_PCM_WRPT, adec_id) + HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_PCM1_DRAM_ADDR;
5991 u64cpts = ((MS_U64)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_CPTS, adec_id))<<1;
5992 u64cpts = STC_TICK_TO_NS(u64cpts);
5993 pPCMInfo->S64CPTS = (MS_S64)u64cpts;
5994 pPCMInfo->U32FrameSize = (MS_U32)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_PCM_FRAMESIZE, adec_id);
5995 pPCMInfo->U32Channels = (MS_U32)HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TVOS2_PCM_CH, adec_id);
5996 pPCMInfo->U32Bps = 2;
5997 pPCMInfo->U32SampleRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, adec_id);
5998 break;
5999 }
6000 #endif
6001
6002 case Audio_infoType_get_parser_info:
6003 {
6004 MS_U32 * pRet = (MS_U32 *) pInfo;
6005 *pRet = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PARSER_INFO, adec_id);
6006 break;
6007 }
6008
6009 case Audio_infoType_Is_Audio_Sync:
6010 {
6011 if ( DecId == AU_DEC_ID3 )
6012 {
6013 long long tmp = 0;
6014 MS_U32 i, no_sync_cnt = 0;
6015
6016 tmp = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC2_1ms_timeStamp);
6017 if (tmp == 0)
6018 {
6019 result = FALSE;
6020 break;
6021 }
6022
6023 tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC2)&0x0F;
6024 if (tmp != 2)
6025 {
6026 result = FALSE;
6027 break;
6028 }
6029
6030 for (i = 0;i<3;i++)
6031 {
6032 tmp = HAL_MAD_GetCommInfo (Audio_Comm_infoType_ADEC2_33bit_STCPTS_DIFF);
6033 if ((tmp >= (100*90))||(tmp <= (-100*90))) //100ms
6034 {
6035 no_sync_cnt ++;
6036 }
6037 }
6038
6039 if (no_sync_cnt == 0)
6040 {
6041 result = TRUE;
6042 }
6043 }
6044 else
6045 {
6046 long long tmp = 0;
6047 MS_U32 i, no_sync_cnt = 0;
6048
6049 tmp = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_1ms_timeStamp);
6050 if (tmp == 0)
6051 {
6052 result = FALSE;
6053 break;
6054 }
6055
6056 tmp = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
6057 if (tmp != 2)
6058 {
6059 result = FALSE;
6060 break;
6061 }
6062
6063 for (i = 0;i<3;i++)
6064 {
6065 tmp = HAL_MAD_GetCommInfo (Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
6066 if ((tmp >= (100*90))||(tmp <= (-100*90))) //100ms
6067 {
6068 no_sync_cnt ++;
6069 }
6070 }
6071
6072 if (no_sync_cnt == 0)
6073 {
6074 result = TRUE;
6075 }
6076 }
6077 break;
6078 }
6079
6080 /* not support cmd */
6081 default:
6082 HALMAD_ERROR ("%s: cmd not Supported\n", __FUNCTION__ );
6083 result = FALSE;
6084 break;
6085 }
6086
6087 return result;
6088 }
6089
6090 //====== STAOS PIP END 2012/02/01 ========
6091
HAL_MAD_CommonCmd_TrasferData(void * pSrc,MS_U32 u32SrcSize,void * pDst,MS_U32 u32DstSzie)6092 MS_S32 HAL_MAD_CommonCmd_TrasferData(void *pSrc, MS_U32 u32SrcSize, void *pDst, MS_U32 u32DstSzie)
6093 {
6094 MS_S32 s32Ret = 0;
6095 MS_U32 u32TransferSize = 0;
6096
6097 if (pSrc == NULL)
6098 {
6099 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pSrc should not be NULL!\n", __FUNCTION__);
6100 return -A_EFAULT;
6101 }
6102
6103 if (u32SrcSize == 0)
6104 {
6105 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32SrcSize should not be zero!\n", __FUNCTION__);
6106 return -A_EINVAL;
6107 }
6108
6109 if (pDst == NULL)
6110 {
6111 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pDst should not be NULL!\n", __FUNCTION__);
6112 return -A_EFAULT;
6113 }
6114
6115 if (u32DstSzie == 0)
6116 {
6117 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32DstSzie should not be zero!\n", __FUNCTION__);
6118 return -A_EINVAL;
6119 }
6120
6121 u32TransferSize = (u32SrcSize < u32DstSzie) ? u32SrcSize : u32DstSzie;
6122 memcpy(((MS_U8 *)pDst + 8), ((MS_U8 *)pSrc + 8),(u32TransferSize - 8));
6123 if(u32SrcSize < u32DstSzie)
6124 {
6125 memset(((MS_U8 *)pDst + u32TransferSize), 0x00, (u32DstSzie - u32SrcSize));
6126 }
6127
6128 return s32Ret;
6129 }
6130
HAL_MAD_SetAudioOutputDeviceSelection(AUDIO_OUTPUT_DEVICE_SELECTION_t * pAudioOutputDeviceSelection)6131 MS_S32 HAL_MAD_SetAudioOutputDeviceSelection(AUDIO_OUTPUT_DEVICE_SELECTION_t * pAudioOutputDeviceSelection)
6132 {
6133 MS_S32 s32Ret = 0;
6134 MS_U32 u32UserStrucVer = 0;
6135 MS_U32 u32UserStrucSize = 0;
6136 MS_U32 u32DriverStrucVer = 0;
6137 MS_U32 u32DriverStrucSize = 0;
6138
6139 HALMAD_CHECK_SHM_INIT;
6140
6141 if (pAudioOutputDeviceSelection == NULL)
6142 {
6143 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pAudioOutputDeviceSelection should not be NULL!\n", __FUNCTION__);
6144 return -A_EFAULT;
6145 }
6146
6147 u32UserStrucVer = pAudioOutputDeviceSelection->u32StructVersion;
6148 u32DriverStrucVer = g_AudioVars2->g_AudioOutputDeviceSelection.u32StructVersion;
6149
6150 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (u32DriverStrucVer & AUDIO_MAJOR_VERSION_MASK))
6151 {
6152 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__,u32UserStrucVer,u32DriverStrucVer);
6153 return -A_EPERM;
6154 }
6155
6156 u32UserStrucSize = pAudioOutputDeviceSelection->u32StructSize;
6157 u32DriverStrucSize = g_AudioVars2->g_AudioOutputDeviceSelection.u32StructSize;
6158
6159 s32Ret = HAL_MAD_CommonCmd_TrasferData(pAudioOutputDeviceSelection, u32UserStrucSize, &g_AudioVars2->g_AudioOutputDeviceSelection, u32DriverStrucSize);
6160 if (s32Ret < 0)
6161 {
6162 return s32Ret;
6163 }
6164
6165 if ((g_AudioVars2->g_AudioOutputDeviceSelection.u32OutputDeviceSelection & AUDIO_OUTPUT_DEVICE_SPEAKER) == 0)
6166 {
6167 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC1, DISABLE, 0);
6168 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC2, DISABLE, 0);
6169
6170 HAL_ADVSOUND_SubProcessEnable(DOLBY_DAP_EN, FALSE);
6171 }
6172 else
6173 {
6174 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC1, ENABLE, 0);
6175 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPEAKER_EN, ADEC2, ENABLE, 0);
6176
6177 HAL_ADVSOUND_SubProcessEnable(DOLBY_DAP_EN, g_AudioVars2->g_DolbyDAPEnable);
6178 }
6179
6180 return s32Ret;
6181 }
6182
HAL_MAD_SpecifyDigitalOutputCodec(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t * pAudioSpecifiedDigitalOutput,DIGITAL_OUTPUT_TYPE u32DigitalOutputType)6183 MS_S32 HAL_MAD_SpecifyDigitalOutputCodec(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t * pAudioSpecifiedDigitalOutput, DIGITAL_OUTPUT_TYPE u32DigitalOutputType)
6184 {
6185 MS_S32 s32Ret = 0;
6186 MS_U32 u32UserStrucVer = 0;
6187 MS_U32 u32UserStrucSize = 0;
6188 MS_U32 u32DriverStrucVer = 0;
6189 MS_U32 u32DriverStrucSize = 0;
6190 AUDIO_SPECIFIED_DIGITAL_OUTPUT_t tSpecifiedDigitalOutput;
6191
6192 HALMAD_CHECK_SHM_INIT;
6193
6194 if (pAudioSpecifiedDigitalOutput == NULL)
6195 {
6196 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pAudioSpecifiedDigitalOutput should not be NULL!\n", __FUNCTION__);
6197 return -A_EFAULT;
6198 }
6199
6200 u32UserStrucVer = pAudioSpecifiedDigitalOutput->u32StructVersion;
6201 u32DriverStrucVer = g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32StructVersion;
6202
6203 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (u32DriverStrucVer & AUDIO_MAJOR_VERSION_MASK))
6204 {
6205 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__,u32UserStrucVer,u32DriverStrucVer);
6206 return -A_EPERM;
6207 }
6208
6209 u32UserStrucSize = pAudioSpecifiedDigitalOutput->u32StructSize;
6210 u32DriverStrucSize = g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32StructSize;
6211
6212 memset((void *)&tSpecifiedDigitalOutput, 0x00, sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t));
6213 tSpecifiedDigitalOutput.u32StructVersion = AUDIO_SPECIFIED_DIGITAL_OUTPUT_VERSION;
6214 tSpecifiedDigitalOutput.u32StructSize = sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t);
6215
6216 s32Ret = HAL_MAD_CommonCmd_TrasferData(pAudioSpecifiedDigitalOutput, u32UserStrucSize, &tSpecifiedDigitalOutput, u32DriverStrucSize);
6217 if (s32Ret < 0)
6218 {
6219 return s32Ret;
6220 }
6221
6222 switch (u32DigitalOutputType)
6223 {
6224 case DIGITAL_SPDIF_OUTPUT:
6225 {
6226 g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32SpdifOutputCodec = tSpecifiedDigitalOutput.u32SpdifOutputCodec;
6227 break;
6228 }
6229
6230 case DIGITAL_HDMI_ARC_OUTPUT:
6231 {
6232 g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32HdmiArcOutputCodec = tSpecifiedDigitalOutput.u32HdmiArcOutputCodec;
6233 break;
6234 }
6235
6236 case DIGITAL_HDMI_OUTPUT:
6237 {
6238 g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32HdmiTxOutputCodec = tSpecifiedDigitalOutput.u32HdmiTxOutputCodec;
6239 break;
6240 }
6241
6242 default:
6243 {
6244 memcpy((void *)&g_AudioVars2->g_AudioSpecifiedDigitalOutput, (void *)&tSpecifiedDigitalOutput, sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t));
6245 break;
6246 }
6247 }
6248
6249 return s32Ret;
6250 }
6251
HAL_MAD_DAP_Control(AUDIO_DAP_CONTROL_t * pDapControl)6252 MS_S32 HAL_MAD_DAP_Control(AUDIO_DAP_CONTROL_t * pDapControl)
6253 {
6254 MS_S32 s32Ret = 0;
6255 MS_U32 u32UserStrucVer = 0;
6256
6257 HALMAD_CHECK_SHM_INIT;
6258
6259 if (pDapControl == NULL)
6260 {
6261 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pDapControl should not be NULL!\n", __FUNCTION__);
6262 return -A_EFAULT;
6263 }
6264
6265 u32UserStrucVer = pDapControl->u32StructVersion;
6266
6267 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_DAP_CONTROL_VERSION & AUDIO_MAJOR_VERSION_MASK))
6268 {
6269 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__, u32UserStrucVer, AUDIO_DAP_CONTROL_VERSION);
6270 return -A_EPERM;
6271 }
6272
6273 if (pDapControl->u32McuCtrlEnable)
6274 {
6275 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x02, 0x02);
6276 }
6277 else
6278 {
6279 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x02, 0x00);
6280 }
6281
6282 if (pDapControl->u32MultiChannelEnable)
6283 {
6284 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x04, 0x04);
6285 }
6286 else
6287 {
6288 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x04, 0x00);
6289 }
6290
6291 return s32Ret;
6292 }
6293
HAL_MAD_GetDecoderInfo(AUDIO_DECODER_INFO_t * pDecoderInfo)6294 MS_S32 HAL_MAD_GetDecoderInfo(AUDIO_DECODER_INFO_t * pDecoderInfo)
6295 {
6296 MS_S32 s32Ret = 0;
6297 MS_U32 u32UserStrucVer = 0;
6298 MS_U32 u32UserStrucSize = 0;
6299 MS_U32 u32DriverStrucVer = 0;
6300 MS_U32 u32DriverStrucSize = 0;
6301 Audio_id adec_id = 0;
6302 AUDIO_DECODER_INFO_t tDecoderInfo;
6303
6304 if (pDecoderInfo == NULL)
6305 {
6306 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pChannelInfo should not be NULL!\n", __FUNCTION__);
6307 return -A_EFAULT;
6308 }
6309
6310 u32UserStrucVer = pDecoderInfo->u32StructVersion;
6311 u32DriverStrucVer = AUDIO_DECODER_INFO_VERSION;
6312
6313 if ((u32UserStrucVer & AUDIO_MAJOR_VERSION_MASK) != (u32DriverStrucVer & AUDIO_MAJOR_VERSION_MASK))
6314 {
6315 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): structure version is mismatch, user is 0x%08X, driver is 0x%08X!\n", __FUNCTION__, u32UserStrucVer, AUDIO_DECODER_INFO_VERSION);
6316 return -A_EPERM;
6317 }
6318
6319 u32UserStrucSize = pDecoderInfo->u32StructSize;
6320 u32DriverStrucSize = sizeof(AUDIO_DECODER_INFO_t);
6321 adec_id = HAL_AUDIO_Convert_DecId_to_ADECId(pDecoderInfo->u8DecId);
6322
6323 memset((void *)&tDecoderInfo, 0x00, sizeof(AUDIO_DECODER_INFO_t));
6324 tDecoderInfo.u32StructVersion = AUDIO_DECODER_INFO_VERSION;
6325 tDecoderInfo.u32StructSize = sizeof(AUDIO_DECODER_INFO_t);
6326 tDecoderInfo.u8DecId = pDecoderInfo->u8DecId;
6327 tDecoderInfo.bForceMchOutput = TRUE;
6328 tDecoderInfo.u32PcmOutputType = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OMX_MCH_VALID, adec_id);
6329
6330 s32Ret = HAL_MAD_CommonCmd_TrasferData(&tDecoderInfo, u32DriverStrucSize, pDecoderInfo, u32UserStrucSize);
6331
6332 return s32Ret;
6333 }
6334
HAL_MAD_CommonCmd(AUDIO_COMMON_CMD_t * cmd)6335 MS_S32 HAL_MAD_CommonCmd(AUDIO_COMMON_CMD_t * cmd)
6336 {
6337 char *name = (char *)cmd->u8StrCmd;
6338 MS_S32 s32Ret = 0;
6339
6340 if (cmd == NULL)
6341 {
6342 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! cmd should not be NULL!\n", __FUNCTION__);
6343 return -A_EFAULT;
6344 }
6345
6346 if (!(strcmp(name, "SetAudioOutputDeviceSelection")))
6347 {
6348 s32Ret = HAL_MAD_SetAudioOutputDeviceSelection((AUDIO_OUTPUT_DEVICE_SELECTION_t *)cmd->pData);
6349 }
6350 else if (!(strcmp(name, "SpecifyDigitalOutputCodec")))
6351 {
6352 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_MAX_OUTPUT);
6353 }
6354 else if (!(strcmp(name, "SpecifyDigitalOutputCodec_Spdif")))
6355 {
6356 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_SPDIF_OUTPUT);
6357 }
6358 else if (!(strcmp(name, "SpecifyDigitalOutputCodec_HdmiArc")))
6359 {
6360 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_HDMI_ARC_OUTPUT);
6361 }
6362 else if (!(strcmp(name, "SpecifyDigitalOutputCodec_HdmiTx")))
6363 {
6364 s32Ret = HAL_MAD_SpecifyDigitalOutputCodec((AUDIO_SPECIFIED_DIGITAL_OUTPUT_t *)cmd->pData, DIGITAL_HDMI_OUTPUT);
6365 }
6366 else if (!(strcmp(name, "DAP_Control")))
6367 {
6368 s32Ret = HAL_MAD_DAP_Control((AUDIO_DAP_CONTROL_t *) cmd->pData);
6369 }
6370 else if (!(strcmp(name, "GetDecoderInfo")))
6371 {
6372 s32Ret = HAL_MAD_GetDecoderInfo((AUDIO_DECODER_INFO_t *) cmd->pData);
6373 }
6374 else
6375 {
6376 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s(): Error! Unsupportted Common Cmd (%s)!!\n", __FUNCTION__, cmd->u8StrCmd);
6377 s32Ret = -A_EINVAL;
6378 }
6379
6380 return s32Ret;
6381 }