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 // Internal Definition
104 #include "regCHIP.h"
105 #include "regAUDIO.h"
106 #include "halAUDIO.h"
107 #include "halAUR2.h"
108 #include "r2_shm_comm.h"
109 #include"decR2_shm.h"
110 #if ASND_R2_SUPPORT
111 #include"sndR2_shm.h"
112 #endif
113 #include <string.h>
114
115 #define code
116 #define BYTE MS_U8
117
118 //-------------------------------------------------------------------------------------------------
119 // Driver Compiler Options
120 //-------------------------------------------------------------------------------------------------
121 #define AUR2_ERRMSG(msg) MS_CRITICAL_MSG(msg)
122 #define AUR2_DBGMSG(msg) MS_DEBUG_MSG(msg)
123
124 //-------------------------------------------------------------------------------------------------
125 // Local Defines
126 //-------------------------------------------------------------------------------------------------
127 #define HINIBBLE(u8Data) ((u8Data) >> 4)
128 #define LONIBBLE(u8Data) ((u8Data) << 4)
129
130 #define R2_0_DDR_BASE (HAL_AUDIO_GetDspMadBaseAddr(2)+ADEC__R2_DDR_SIZE) //SND_R2 base
131 #define REG_R2_0_CTRL_BASE 0x112900
132 #define REG_R2_0_MAILBOX_BASE 0x112E00
133 #define REG_R2_0_CTRL REG_R2_0_CTRL_BASE+0x80
134 #define REG_R2_0_PARAM_TYPE REG_R2_0_MAILBOX_BASE+0x80
135 #define REG_R2_0_ID_SELECT REG_R2_0_MAILBOX_BASE+0x82
136 #define REG_R2_0_PARAM_VAL1 REG_R2_0_MAILBOX_BASE+0x84
137 #define REG_R2_0_PARAM_VAL2 REG_R2_0_MAILBOX_BASE+0x86
138 #define REG_R2_0_CMD_TOKEN REG_R2_0_MAILBOX_BASE+0xA3
139 #define REG_R2_0_INFO1 REG_R2_0_MAILBOX_BASE+0xA4
140 #define REG_R2_0_INFO2 REG_R2_0_MAILBOX_BASE+0xA6
141
142 #define R2_1_DDR_BASE (HAL_AUDIO_GetDspMadBaseAddr(2)) //DEC_R2 base
143 #define REG_R2_1_CTRL_BASE 0x163000
144 #define REG_R2_1_MAILBOX_BASE 0x160300
145 #define REG_R2_1_CTRL REG_R2_1_CTRL_BASE+0x80
146 #define REG_R2_1_PARAM_TYPE REG_R2_1_MAILBOX_BASE+0x80
147 #define REG_R2_1_ID_SELECT REG_R2_1_MAILBOX_BASE+0x82
148 #define REG_R2_1_PARAM_VAL1 REG_R2_1_MAILBOX_BASE+0x84
149 #define REG_R2_1_PARAM_VAL2 REG_R2_1_MAILBOX_BASE+0x86
150 #define REG_R2_1_CMD_TOKEN REG_R2_1_MAILBOX_BASE+0xA3
151 #define REG_R2_1_INFO1 REG_R2_1_MAILBOX_BASE+0xA4
152 #define REG_R2_1_INFO2 REG_R2_1_MAILBOX_BASE+0xA6
153
154 #define AUR2_DEBUG_PRINT(x) //x
155
156 #define DEC_R2_COMMON_INFO_COUNTER 500
157 #define SND_R2_COMMON_INFO_COUNTER 500
158
159 //-------------------------------------------------------------------------------------------------
160 // Local Structures
161 //-------------------------------------------------------------------------------------------------
162
163 //-------------------------------------------------------------------------------------------------
164 // Global Variables
165 //-------------------------------------------------------------------------------------------------
166 extern MS_VIRT _gMIO_MapBase;
167 extern MS_S32 _s32AUDIOMutexIDMA;
168
169 //-------------------------------------------------------------------------------------------------
170 // Local Variables
171 //-------------------------------------------------------------------------------------------------
172
173 //-------------------------------------------------------------------------------------------------
174 // Debug Functions
175 //-------------------------------------------------------------------------------------------------
176
177
178 //-------------------------------------------------------------------------------------------------
179 // Local Functions
180 //-------------------------------------------------------------------------------------------------
181
182 //-------------------------------------------------------------------------------------------------
183 // Global Functions
184 //-------------------------------------------------------------------------------------------------
185
186 /////////////`///////////////////////////////////////////////////////////////////
187 /// @brief \b Function \b Name: HAL_AUR2_ReadByte
188 /// @brief \b Function \b Description: read 1 Byte data
189 /// @param <IN> \b u32RegAddr: register address
190 /// @param <OUT> \b None :
191 /// @param <RET> \b MS_U8 : 8-bit register value
192 /// @param <GLOBAL> \b None :
193 ////////////////////////////////////////////////////////////////////////////////
HAL_AUR2_ReadByte(MS_U32 u32RegAddr)194 MS_U8 HAL_AUR2_ReadByte(MS_U32 u32RegAddr)
195 {
196 return HAL_AUDIO_AbsReadByte(u32RegAddr);
197 }
198
199 ////////////////////////////////////////////////////////////////////////////////
200 /// @brief \b Function \b Name: HAL_AUR2_ReadReg
201 /// @brief \b Function \b Description: read 2 Byte data
202 /// @param <IN> \b u32RegAddr: register address
203 /// @param <OUT> \b None :
204 /// @param <RET> \b MS_U16 : 16-bit register value
205 /// @param <GLOBAL> \b None :
206 ////////////////////////////////////////////////////////////////////////////////
HAL_AUR2_ReadReg(MS_U32 u32RegAddr)207 MS_U16 HAL_AUR2_ReadReg(MS_U32 u32RegAddr)
208 {
209 return HAL_AUDIO_AbsReadReg(u32RegAddr); // Add audio bank offset
210 }
211
212 ////////////////////////////////////////////////////////////////////////////////
213 /// @brief \b Function \b Name: HAL_AUR2_WriteByte
214 /// @param <IN> \b u32RegAddr: register address
215 /// @param <IN> \b u16Val : 8-bit data
216 /// @param <OUT> \b None :
217 /// @param <RET> \b None :
218 /// @param <GLOBAL> \b None :
219 ////////////////////////////////////////////////////////////////////////////////
HAL_AUR2_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)220 void HAL_AUR2_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
221 {
222 HAL_AUDIO_AbsWriteByte(u32RegAddr, u8Val);
223 }
224
225 ////////////////////////////////////////////////////////////////////////////////
226 /// @brief \b Function \b Name: HAL_AUR2_WriteReg
227 /// @param <IN> \b u32RegAddr: register address
228 /// @param <IN> \b u16Val : 16-bit data
229 /// @param <OUT> \b None :
230 /// @param <RET> \b None :
231 /// @param <GLOBAL> \b None :
232 ////////////////////////////////////////////////////////////////////////////////
HAL_AUR2_WriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)233 void HAL_AUR2_WriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
234 {
235 HAL_AUDIO_AbsWriteReg(u32RegAddr, u16Val);
236 }
237
238 ////////////////////////////////////////////////////////////////////////////////
239 /// @brief \b Function \b Name: HAL_AUR2_WriteMaskByte
240 /// @brief \b Function \b Description: Mask write 8-bit data
241 /// @param <IN> \b u32RegAddr: register address
242 /// @param <IN> \b u16Val : 8-bit data
243 /// @param <OUT> \b None :
244 /// @param <RET> \b None :
245 /// @param <GLOBAL> \b None :
246 ////////////////////////////////////////////////////////////////////////////////
HAL_AUR2_WriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)247 void HAL_AUR2_WriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
248 {
249 HAL_AUDIO_AbsWriteMaskByte(u32RegAddr, u8Mask, u8Val);
250 }
251
252 ////////////////////////////////////////////////////////////////////////////////
253 /// @brief \b Function \b Name: HAL_AUR2_WriteMaskReg
254 /// @brief \b Function \b Description: Mask write 16-bit data
255 /// @param <IN> \b u32RegAddr: register address
256 /// @param <IN> \b u16Val : 16-bit data
257 /// @param <OUT> \b None :
258 /// @param <RET> \b None :
259 /// @param <GLOBAL> \b None :
260 ////////////////////////////////////////////////////////////////////////////////
HAL_AUR2_WriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)261 void HAL_AUR2_WriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
262 {
263 HAL_AUDIO_AbsWriteMaskReg(u32RegAddr, u16Mask, u16Val);
264 }
265
266
267 ////////////////////////////////////////////////////////////////////////////////
268 /// @brief \b Function \b Name: HAL_SND_R2_EnableR2() / HAL_DEC_R2_EnableR2()
269 /// @brief \b Function \b Description: This routine load Audio R2 code
270 /// @param <IN> \b NONE :
271 /// @param <OUT> \b NONE :
272 /// @param <RET> \b NONE : (OK) TRUE / (FAIL) FALE
273 /// @param <GLOBAL> \b NONE :
274 ////////////////////////////////////////////////////////////////////////////////
HAL_SND_R2_EnableR2(MS_BOOL bEnable)275 void HAL_SND_R2_EnableR2( MS_BOOL bEnable)
276 {
277 if (bEnable)
278 {
279 HAL_AUR2_WriteMaskByte(REG_R2_0_CTRL, 0xFF, 0x27);
280 HAL_AUR2_WriteMaskByte(0x112940, 0xFF, 0x10);
281 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x01, 0x01); //BANK 1129 control by R2
282 }
283 else
284 {
285 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x01, 0x00); //BANK 1129 control by RIU
286 HAL_AUR2_WriteMaskByte(REG_R2_0_CTRL, 0xFF, 0x00);
287 }
288 }
289
HAL_DEC_R2_EnableR2(MS_BOOL bEnable)290 void HAL_DEC_R2_EnableR2(MS_BOOL bEnable )
291 {
292 if (bEnable)
293 {
294 HAL_AUR2_WriteMaskByte(REG_R2_1_CTRL, 0xFF, 0x27);
295 HAL_AUR2_WriteMaskByte(0x163040, 0xFF, 0x10);
296 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x02, 0x02); //BANK 1630 control by R2
297 }
298 else
299 {
300 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x02, 0x00); //BANK 1630 control by MIU
301 HAL_AUR2_WriteMaskByte(REG_R2_1_CTRL, 0xFF, 0x00);
302 }
303 }
304
HAL_DEC_R2_init_SHM_param(void)305 void HAL_DEC_R2_init_SHM_param( void )
306 {
307 MS_S32 dec_id;
308 DEC_R2_SHARE_MEM *p_shm = (DEC_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_1_DDR_BASE+DEC_R2_SHM_DDR_OFFSET));
309 AUR2_ADEC_PARAM_SHM *p_shm_param;
310
311 memset(p_shm, 0, sizeof(DEC_R2_SHARE_MEM));
312
313 for (dec_id = 0; dec_id < MAX_ADEC; dec_id++ )
314 {
315 AUR2_DOLBY_PARAM *pDolby;
316 AUR2_DTS_PARAM *pDTS;
317 AUR2_MPEG_PARAM *pMPEG;
318
319 p_shm_param = &p_shm->adec_param_shm[dec_id];
320
321 pDolby = &p_shm_param->dolby_param;
322 pDTS = &p_shm_param->dts_param;
323 pMPEG = &p_shm_param->mpeg_param;
324
325 //MsOS_Dcache_Flush((MS_VIRT) &(p_shm_param->bootMagicID), sizeof(MS_U32));
326 //if (p_shm_param->bootMagicID != SHM_PARAM_BOOT_MAGIC_ID)
327 {
328 memset(p_shm_param, 0, sizeof(AUR2_ADEC_PARAM_SHM));
329
330 p_shm_param->dtv_mpg_avDelay = MPG_AV_DEFAULT_DELAY;
331 p_shm_param->dtv_ac3_avDelay = AC3_AV_DEFAULT_DELAY;
332 p_shm_param->dtv_aac_avDelay = AAC_AV_DEFAULT_DELAY;
333
334 p_shm_param->dtv_asoc_mpg_avDelay = MPG_AV_DEFAULT_DELAY;
335 p_shm_param->dtv_asoc_ac3_avDelay = AC3_AV_DEFAULT_DELAY;
336 p_shm_param->dtv_asoc_aac_avDelay = AAC_AV_DEFAULT_DELAY;
337
338 p_shm_param->adMix_mainVol = 0x60; //0 dB
339 p_shm_param->adMix_asocVol = 0x60; //0 dB
340
341 p_shm_param->mmTs_ctrl_flag = 0;
342 p_shm_param->mmUni_needDecodeFrmCnt = 1;
343 p_shm_param->OMX_SPDIF_Ctrl = 0;
344 p_shm_param->OMX_SPDIF_PCM_Level = 0x1200;
345
346 p_shm_param->mmFileReqSize = 0;
347 p_shm_param->bootMagicID = SHM_PARAM_BOOT_MAGIC_ID;
348 p_shm_param->decCtrl = 0;
349 p_shm_param->hashKey = 0;
350
351 p_shm_param->extSynthsizer_en = 0;
352 p_shm_param->extSynthsizer_value = 0x11940000;
353 p_shm_param->fast_forward = 0;
354
355 p_shm_param->ES_Limiter_EN = 0;
356 p_shm_param->ES_Limiter_Threshold= 0x2000;
357 p_shm_param->PCM_Limiter_EN = 0;
358 p_shm_param->PCM_Limiter_Threshold = 0x4B00;
359
360 /* init Dolby param */
361 pDolby->high_cut = 100;
362 pDolby->low_boost = 100;
363 pDolby->dmxMode = 0;
364 pDolby->drcMode = 1;
365 pDolby->gain = 0x7FFFFFFF;
366 pDolby->mul_frame_header = 0;
367 pDolby->TB11_enable = 1;
368
369 /* init DTS param */
370 pDTS->drcMode = 0;
371 pDTS->dmxLfeEnable = 0;
372 pDTS->dialnormEnable = 0;
373 pDTS->certMode = 0;
374 pDTS->dmxMode = 0;
375
376 /* init MPEG param */
377 pMPEG->MPEG_soundMode = 0;
378 pMPEG->gain = 0x7FFFFFFF;
379
380 printf("[======= initialize DEC-R2[%d] SHM =======]\n", (int)dec_id);
381 }
382 }
383
384 MsOS_Dcache_Flush((MS_VIRT)p_shm, sizeof(DEC_R2_SHARE_MEM));
385
386 }
387
388 ///////////////////////////////////////////////////////////////////////////////
389 /// @brief \b Function \b Name: HAL_sndR2_SetCommInfo() / HAL_decR2_SetCommInfo()
390 /// @brief \b Function \b Description: This routine set different paramter to audio decoder
391 /// @param <IN> \b AudioR2_COMM_infoType : common audio parameter type
392 /// @param <IN> \b MS_U32 : common audio parameter 1
393 /// @param <IN> \b MS_U32 : common audio parameter 2
394 /// @param <OUT> \b NONE :
395 /// @param <RET> \b MS_BOOL : TRUE ( SUCCESS ) / FALSE (FAIL)
396 /// @param <GLOBAL> \b NONE :
397 ////////////////////////////////////////////////////////////////////////////////
HAL_SND_R2_SetCommInfo(R2_AudioParamType infoType,Audio_id id,MS_U16 param1,MS_U16 param2)398 void HAL_SND_R2_SetCommInfo(R2_AudioParamType infoType, Audio_id id, MS_U16 param1, MS_U16 param2)
399 {
400 MS_U16 tmpVal, token, i=0;
401
402 OS_OBTAIN_MUTEX(_s32AUDIOMutexIDMA, MSOS_WAIT_FOREVER);
403
404 token = HAL_AUR2_ReadByte( REG_R2_0_CMD_TOKEN );
405
406 tmpVal = (id&0xFF) | 0x100;
407 HAL_AUR2_WriteReg( REG_R2_0_PARAM_VAL1, param1 );
408 HAL_AUR2_WriteReg( REG_R2_0_PARAM_VAL2, param2 );
409 HAL_AUR2_WriteReg( REG_R2_0_ID_SELECT, tmpVal );
410 HAL_AUR2_WriteReg( REG_R2_0_PARAM_TYPE, infoType );
411
412 while( i < SND_R2_COMMON_INFO_COUNTER )
413 {
414 if (token != HAL_AUR2_ReadByte( REG_R2_0_CMD_TOKEN ))
415 break;
416
417 i++;
418 AUDIO_DELAY1US(20);
419 }
420
421 OS_RELEASE_MUTEX(_s32AUDIOMutexIDMA);
422
423 AUR2_DEBUG_PRINT(printf("[%s] infoType:%x, id:%x, param: [%04x, %04x]\n", __FUNCTION__, infoType, id, param1, param2));
424 }
425
HAL_DEC_R2_SetCommInfo(R2_AudioParamType infoType,Audio_id id,MS_U16 param1,MS_U16 param2)426 void HAL_DEC_R2_SetCommInfo(R2_AudioParamType infoType, Audio_id id, MS_U16 param1, MS_U16 param2)
427 {
428 MS_U16 tmpVal, token, i=0;
429
430 OS_OBTAIN_MUTEX(_s32AUDIOMutexIDMA, MSOS_WAIT_FOREVER);
431
432 token = HAL_AUR2_ReadByte( REG_R2_1_CMD_TOKEN );
433
434 tmpVal = (id&0xFF) | 0x100;
435 HAL_AUR2_WriteReg( REG_R2_1_PARAM_VAL1, param1 );
436 HAL_AUR2_WriteReg( REG_R2_1_PARAM_VAL2, param2 );
437 HAL_AUR2_WriteReg( REG_R2_1_ID_SELECT, tmpVal );
438 HAL_AUR2_WriteReg( REG_R2_1_PARAM_TYPE, infoType );
439
440 while( i < DEC_R2_COMMON_INFO_COUNTER )
441 {
442 if (token != HAL_AUR2_ReadByte( REG_R2_1_CMD_TOKEN ))
443 break;
444
445 i++;
446 AUDIO_DELAY1US(20);
447 }
448
449 #if 0
450 if (i >= DEC_R2_COMMON_INFO_COUNTER)
451 {
452 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x02, 0x00); //BANK 1630 control by MIU
453 printf("R2 PC:");
454 for( i=0; i<10; i++)
455 {
456 MS_U16 tmp_H, tmp_L;
457 tmp_H = HAL_AUR2_ReadReg(0x163012);
458 tmp_L = HAL_AUR2_ReadReg(0x163010);
459 printf("[%04x%04x],", tmp_H, tmp_L);
460 }
461
462 HALAUDIO_PRINT("\n[%s] infoType:%x, id:%x, param: [%04x, %04x] fail\n", __FUNCTION__, infoType, id, param1, param2);
463 }
464 #endif
465
466 OS_RELEASE_MUTEX(_s32AUDIOMutexIDMA);
467
468 AUR2_DEBUG_PRINT(printf("[%s] infoType:%x, id:%x, param: [%04x, %04x]\n", __FUNCTION__, infoType, id, param1, param2));
469 }
470
471 ////////////////////////////////////////////////////////////////////////////////
472 /// @brief \b Function \b Name: HAL_SND_R2_GetCommInfo() / HAL_DEC_R2_GetCommInfo()
473 /// @brief \b Function \b Description: This routine info of audio decoders
474 /// @param <IN> \b AudioR2_COMM_infoType : request info type of audio decoder
475 /// @param <OUT> \b NONE :
476 /// @param <RET> \b long long : return info
477 /// @param <GLOBAL> \b NONE :
478 ////////////////////////////////////////////////////////////////////////////////
HAL_SND_R2_GetCommInfo(R2_AudioInfoType infoType,Audio_id id,MS_U16 param1,MS_U16 param2)479 MS_U32 HAL_SND_R2_GetCommInfo(R2_AudioInfoType infoType, Audio_id id, MS_U16 param1, MS_U16 param2)
480 {
481 MS_U16 tmpVal, token, i=0;
482 MS_U32 ret_val;
483
484 token = HAL_AUR2_ReadByte( REG_R2_0_CMD_TOKEN );
485
486 tmpVal = (id&0xFF);
487 HAL_AUR2_WriteReg( REG_R2_0_PARAM_VAL1, param1 );
488 HAL_AUR2_WriteReg( REG_R2_0_PARAM_VAL2, param2 );
489 HAL_AUR2_WriteReg( REG_R2_0_ID_SELECT, tmpVal );
490 HAL_AUR2_WriteReg( REG_R2_0_PARAM_TYPE, infoType );
491
492 token = token + 0x01; //if send cmd successfully, token number should increase
493 while( i < SND_R2_COMMON_INFO_COUNTER )
494 {
495 if (token == HAL_AUR2_ReadByte( REG_R2_0_CMD_TOKEN ))
496 break;
497
498 i++;
499 AUDIO_DELAY1US(20);
500 }
501
502 if ( i >= SND_R2_COMMON_INFO_COUNTER )
503 {
504 printf("%s:%x, %x, %x, %x cmd fail\n",__FUNCTION__, infoType, id, param1, param2);
505 return 0;
506 }
507
508 ret_val = (HAL_AUR2_ReadReg(REG_R2_0_INFO1)<<16) + (HAL_AUR2_ReadReg(REG_R2_0_INFO2));
509
510 AUR2_DEBUG_PRINT(printf("[%s] infoType:%4x, id:%x, param: [%04x, %04x] ==> %lx\n", __FUNCTION__, infoType, id, param1, param2, ret_val));
511 return ret_val;
512 }
513
HAL_DEC_R2_GetCommInfo(R2_AudioInfoType infoType,Audio_id id,MS_U16 param1,MS_U16 param2)514 MS_U32 HAL_DEC_R2_GetCommInfo(R2_AudioInfoType infoType, Audio_id id, MS_U16 param1, MS_U16 param2)
515 {
516 MS_U16 tmpVal, token, i=0;
517 MS_U32 ret_val;
518
519 OS_OBTAIN_MUTEX(_s32AUDIOMutexIDMA, MSOS_WAIT_FOREVER);
520
521 token = HAL_AUR2_ReadByte( REG_R2_1_CMD_TOKEN );
522
523 tmpVal = (id&0xFF);
524 HAL_AUR2_WriteReg( REG_R2_1_PARAM_VAL1, param1 );
525 HAL_AUR2_WriteReg( REG_R2_1_PARAM_VAL2, param2 );
526 HAL_AUR2_WriteReg( REG_R2_1_ID_SELECT, tmpVal );
527 HAL_AUR2_WriteReg( REG_R2_1_PARAM_TYPE, infoType );
528
529 token = token + 0x01; //if send cmd successfully, token number should increase
530 while( i < DEC_R2_COMMON_INFO_COUNTER )
531 {
532 if (token == HAL_AUR2_ReadByte( REG_R2_1_CMD_TOKEN ))
533 break;
534
535 i++;
536 AUDIO_DELAY1US(20);
537 }
538
539 if ( i >= DEC_R2_COMMON_INFO_COUNTER )
540 {
541 printf("%s:%x, %x, %x, %x cmd fail\n",__FUNCTION__, infoType, id, param1, param2);
542 OS_RELEASE_MUTEX(_s32AUDIOMutexIDMA);
543 return 0;
544 }
545
546 ret_val = (HAL_AUR2_ReadReg(REG_R2_1_INFO1)<<16) + (HAL_AUR2_ReadReg(REG_R2_1_INFO2));
547 OS_RELEASE_MUTEX(_s32AUDIOMutexIDMA);
548
549 AUR2_DEBUG_PRINT(printf("[%s] infoType:%4x, id:%x, param: [%04x, %04x] ==> %lx\n", __FUNCTION__, infoType, id, param1, param2, ret_val));
550 return ret_val;
551 }
552
HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_TYPE decInfoType,MS_U8 dec_id)553 MS_U32 HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_TYPE decInfoType, MS_U8 dec_id )
554 {
555 MS_U32 ret_value = 0;
556
557 #if 0
558 volatile MS_U32 *ptr;
559 SND_R2_SHARE_MEM *p_shm = (SND_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_0_DDR_BASE+SND_R2_SHM_DDR_OFFSET));
560
561 switch( decInfoType )
562 {
563 default:
564 return 0;
565 }
566
567 //D-cache Invalidate
568 MsOS_Dcache_Flush((MS_VIRT) ptr, sizeof(MS_U32));
569 ret_value = *ptr;
570 #endif
571
572 AUR2_DEBUG_PRINT(printf("[%s] shmType:%4x, id:%x ==> %x\n", __FUNCTION__, decInfoType, dec_id, ret_value));
573
574 return ret_value;
575 }
576
577
578
HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TYPE decInfoType,MS_U8 dec_id)579 MS_U32 HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TYPE decInfoType, MS_U8 dec_id )
580 {
581 MS_U32 ret_value;
582 volatile MS_U32 *ptr;
583 DEC_R2_SHARE_MEM *p_shm = (DEC_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_1_DDR_BASE+DEC_R2_SHM_DDR_OFFSET));
584 AUR2_ADEC_INFO_SHM *p_shm_info = &p_shm->adec_info_shm[dec_id];
585
586 MS_U8 es_id = 0;
587 if (dec_id == 1)
588 es_id = 2;
589
590 AUR2_ADEC_ES_INFO_SHM *p_shm_esinfo = &p_shm->adec_esInfo_shm[es_id];
591 AUR2_ADEC_Ch_INFO_SHM *p_shm_chinfo = &p_shm->adec_chInfo_shm;
592
593 switch( decInfoType )
594 {
595 case R2_SHM_INFO_CAPABILITY: ptr = (volatile MS_U32 *) &p_shm_info->capability; break;
596 case R2_SHM_INFO_DEC_STAUS: ptr = (volatile MS_U32 *) &p_shm_info->decStatus; break;
597 case R2_SHM_INFO_DEC_ERROR_ID: ptr = (volatile MS_U32 *) &p_shm_info->dec_error_id; break;
598 case R2_SHM_INFO_SMP_RATE: ptr = (volatile MS_U32 *) &p_shm_info->smpRate; break;
599 case R2_SHM_INFO_BIT_RATE: ptr = (volatile MS_U32 *) &p_shm_info->bitRate; break;
600 case R2_SHM_INFO_SYNTH_RATE: ptr = (volatile MS_U32 *) &p_shm_info->synthRate; break;
601 case R2_SHM_INFO_DEC_CHANNEL_MODE: ptr = (volatile MS_U32 *) &p_shm_info->dec_ch_mode; break;
602 case R2_SHM_INFO_DEC_CHANNEL_MAPPING: ptr = (volatile MS_U32 *) &p_shm_info->dec_ch_mapping; break;
603
604 case R2_SHM_INFO_ES_LEVEL: ptr = (volatile MS_U32 *) &p_shm_esinfo->ES_Level; break;
605 case R2_SHM_INFO_PCM_LEVEL: ptr = (volatile MS_U32 *) &p_shm_info->PCM_Level; break;
606 case R2_SHM_INFO_PCM_DMX_LEVEL: ptr = (volatile MS_U32 *) &p_shm_info->PCM_DMX_Level; break;
607 case R2_SHM_INFO_ES_RD_PTR: ptr = (volatile MS_U32 *) &p_shm_esinfo->ES_rdPtr; break;
608
609 case R2_SHM_INFO_PCM_WR_PTR: ptr = (volatile MS_U32 *) &p_shm_info->PCM_wrPtr; break;
610 case R2_SHM_INFO_MM_FILE_REQ_SIZE: ptr = (volatile MS_U32 *) &p_shm_info->mmFileReqSize; break;
611
612 case R2_SHM_INFO_ACCUM_ES_BYTECNT: ptr = (volatile MS_U32 *) &p_shm_esinfo->ES_accumCnt; break;
613 case R2_SHM_INFO_WAIT_1STPTS_CNT: ptr = (volatile MS_U32 *) &p_shm_info->wait1stPtsCnt; break;
614 case R2_SHM_INFO_WAIT_STC_CNT: ptr = (volatile MS_U32 *) &p_shm_info->waitStcCnt; break;
615 case R2_SHM_INFO_SMP_FLUSH_CNT: ptr = (volatile MS_U32 *) &p_shm_info->smpFlushCnt; break;
616
617 case R2_SHM_INFO_AVSYNC_STATE: ptr = (volatile MS_U32 *) &p_shm_info->avSyncState; break;
618 case R2_SHM_INFO_AVSYNC_FREERUN_TYPE: ptr = (volatile MS_U32 *) &p_shm_info->freeRunType; break;
619 case R2_SHM_INFO_AVSYNC_OFFSET: ptr = (volatile MS_U32 *) &p_shm_info->avSyncOffset; break;
620
621 case R2_SHM_INFO_PTS_TAG_WR_IDX: ptr = (volatile MS_U32 *) &p_shm_info->ptsTagWRIdx; break;
622 case R2_SHM_INFO_PTS_TAG_RD_IDX: ptr = (volatile MS_U32 *) &p_shm_info->ptsTagRDIdx; break;
623
624 case R2_SHM_INFO_PLAY_STATE: ptr = (volatile MS_U32 *) &p_shm_info->playState; break;
625 case R2_SHM_INFO_DEC_TYPE: ptr = (volatile MS_U32 *) &p_shm_info->decType; break;
626 case R2_SHM_INFO_PLAYSMPFLAG: ptr = (volatile MS_U32 *) &p_shm_info->playSmpFlag; break;
627 case R2_SHM_INFO_DEC_CALLING_CNT: ptr = (volatile MS_U32 *) &p_shm_info->decCallingCnt; break;
628 case R2_SHM_INFO_RECEIVE_STOP_CNT: ptr = (volatile MS_U32 *) &p_shm_info->receiveStopCnt; break;
629
630 case R2_SHM_INFO_OK_FRMCNT: ptr = (volatile MS_U32 *) &p_shm_info->ok_frmCnt; break;
631 case R2_SHM_INFO_ERR_FRMCNT: ptr = (volatile MS_U32 *) &p_shm_info->err_frmCnt; break;
632 case R2_SHM_INFO_SKIP_FRMCNT: ptr = (volatile MS_U32 *) &p_shm_info->skip_frmCnt; break;
633 case R2_SHM_INFO_REPT_FRMCNT: ptr = (volatile MS_U32 *) &p_shm_info->rept_frmCnt; break;
634 case R2_SHM_INFO_SYNC_MISS_CNT: ptr = (volatile MS_U32 *) &p_shm_info->syncMiss_Cnt; break;
635 case R2_SHM_INFO_PCM_EMPTY_CNT: ptr = (volatile MS_U32 *) &p_shm_info->pcmBufEmptyCnt; break;
636
637 case R2_SHM_INFO_STC: ptr = (volatile MS_U32 *) &p_shm_info->STC; break;
638 case R2_SHM_INFO_PTS: ptr = (volatile MS_U32 *) &p_shm_info->PTS; break;
639 case R2_SHM_INFO_CURR_PTS: ptr = (volatile MS_U32 *) &p_shm_info->currPTS; break;
640 case R2_SHM_INFO_TD: ptr = (volatile MS_U32 *) &p_shm_info->Td; break;
641 case R2_SHM_INFO_PTS_LATENCY: ptr = (volatile MS_U32 *) &p_shm_info->pts_latency; break;
642
643 case R2_SHM_INFO_UNI_DECODE_DONE_CNT: ptr = (volatile MS_U32 *) &p_shm_info->uni_decDone_cnt; break;
644 case R2_SHM_INFO_UNI_DECODE_DONE_PCM_ADDR: ptr = (volatile MS_U32 *) &p_shm_info->uni_decDone_pcmAddr; break;
645 case R2_SHM_INFO_UNI_DECODE_DONE_PCM_SIZE: ptr = (volatile MS_U32 *) &p_shm_info->uni_decDone_pcmSize; break;
646
647 case R2_SHM_INFO_PCM_ADDR: ptr = (volatile MS_U32 *) &p_shm_info->pcmAddr; break;
648 case R2_SHM_INFO_PCM_SIZE: ptr = (volatile MS_U32 *) &p_shm_info->pcmSize; break;
649 case R2_SHM_INFO_spdifbuf_LEVEL: ptr = (volatile MS_U32 *) &p_shm_info->spdifbuf_Level; break;
650 case R2_SHM_INFO_spdifbuf_WR_PTR: ptr = (volatile MS_U32 *) &p_shm_info->encRawBuf_wrPtr; break;
651
652 case R2_SHM_INFO_DOLBY_DEC_TYPE: ptr = (volatile MS_U32 *) &p_shm_info->dolby_info.decType; break;
653 case R2_SHM_INFO_DOLBY_FRAME_SIZE: ptr = (volatile MS_U32 *) &p_shm_info->dolby_info.frameSize; break;
654 case R2_SHM_INFO_DOLBY_BS_MODE: ptr = (volatile MS_U32 *) &p_shm_info->dolby_info.bsMode; break;
655 case R2_SHM_INFO_DOLBY_AAC_TYPE: ptr = (volatile unsigned int *) &p_shm_info->dolby_info.aac_Type; break;
656 case R2_SHM_INFO_DOLBY_DDP_71_STREAM: ptr = (volatile MS_U32 *) &p_shm_info->dolby_info.DDP_71_stream; break;
657
658 case R2_SHM_INFO_DTS_CD_MODE: ptr = (volatile MS_U32 *) &p_shm_info->dts_info.cdMode; break;
659
660 case R2_SHM_INFO_MPEG_LAYER: ptr = (volatile MS_U32 *) &p_shm_info->mpeg_info.MPEG_Layer; break;
661 case R2_SHM_INFO_MPEG_STEREOMODE: ptr = (volatile MS_U32 *) &p_shm_info->mpeg_info.MPEG_stereoMode; break;
662 case R2_SHM_INFO_MPEG_HEADER: ptr = (volatile MS_U32 *) &p_shm_info->mpeg_info.MPEG_Header; break;
663 case R2_SHM_INFO_UNSUPPORT_TYPE: ptr = (volatile MS_U32 *) &p_shm_info->unsupport_type; break;
664 case R2_SHM_INFO_TRANSCODE_FLAG: ptr = (volatile MS_U32 *) &p_shm_info->common_info.spdif_info_flag; break;
665
666 case R2_SHM_INFO_SPDIFTx_SMP_RATE: ptr = (volatile MS_U32 *) &p_shm_info->spdifTx_smpRate; break;
667 case R2_SHM_INFO_HDMITx_SMP_RATE: ptr = (volatile MS_U32 *) &p_shm_info->hdmiTx_smpRate; break;
668
669 case R2_SHM_INFO_PCM_OUTPUT_CHANNEL: ptr = (volatile unsigned int *) &p_shm_info->dec_pcm_channel; break;
670 case R2_SHM_INFO_OMX_MCH_VALID: ptr = (volatile MS_U32 *) &p_shm_info->mch_valid; break;
671
672 /* channel output info */
673 case R2_SHM_INFO_CH_MPEG: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_MEPG; break;
674 case R2_SHM_INFO_CH_AC3: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_AC3; break;
675 case R2_SHM_INFO_CH_AAC: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_AAC; break;
676 case R2_SHM_INFO_CH_DTS: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_DTS; break;
677 case R2_SHM_INFO_CH_DTS_HD: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_DTS_HD; break;
678 case R2_SHM_INFO_CH_DTS_LBR: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_DTS_LBR; break;
679 case R2_SHM_INFO_CH_WMA: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_WMA; break;
680 case R2_SHM_INFO_CH_DRA: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_DRA; break;
681 case R2_SHM_INFO_CH_COOK: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_COOK; break;
682 case R2_SHM_INFO_CH_XPCM: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_XPCM; break;
683 case R2_SHM_INFO_CH_VORBIS: ptr = (volatile MS_U32 *) &p_shm_chinfo->ch_cap_VORBIS; break;
684 default:
685 //ret_value = 0;
686 return 0;
687 }
688
689 //D-cache Invalidate
690 MsOS_Dcache_Flush((MS_VIRT)p_shm_info, sizeof(AUR2_ADEC_INFO_SHM));
691 MsOS_Dcache_Flush((MS_VIRT)p_shm_esinfo, sizeof(AUR2_ADEC_ES_INFO_SHM));
692 MsOS_Dcache_Flush((MS_VIRT)p_shm_chinfo, sizeof(AUR2_ADEC_Ch_INFO_SHM));
693 ret_value = *ptr;
694
695 // HALAUDIO_PRINT("[%s] shmType:%4x, id:%x ==> %x\n", __FUNCTION__, decInfoType, dec_id, ret_value);
696
697 return ret_value;
698 }
699
HAL_SND_R2_Set_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType,MS_U8 dec_id,MS_U32 param,MS_U32 param2)700 MS_BOOL HAL_SND_R2_Set_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType, MS_U8 dec_id, MS_U32 param, MS_U32 param2 )
701 {
702 #if 0
703 volatile MS_U32 *ptr;
704 SND_R2_SHARE_MEM *p_shm = (SND_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_0_DDR_BASE+SND_R2_SHM_DDR_OFFSET));
705 MS_U32 offset_R2_to_DSP, offset_R2_to_CommDDR;
706
707 offset_R2_to_DSP = ASND__R2_DDR_SIZE;
708 offset_R2_to_CommDDR = ASND__R2_DDR_SIZE + ASND_DSP_DDR_SIZE;
709
710 switch( decParamType )
711 {
712 default:
713 break;
714 }
715 #endif
716
717 AUR2_DEBUG_PRINT(printf("[%s] shmType:%4x, id:%x, param: [%08lx, %08lx]\n", __FUNCTION__, decParamType, dec_id, param, param2));
718
719 return TRUE;
720 }
721
722
HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType,MS_U8 dec_id,MS_U32 param,MS_U32 param2)723 MS_BOOL HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType, MS_U8 dec_id, MS_U32 param, MS_U32 param2 )
724 {
725 MS_U32 ret_value;
726 volatile MS_U32 *ptr;
727 DEC_R2_SHARE_MEM *p_shm = (DEC_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_1_DDR_BASE+DEC_R2_SHM_DDR_OFFSET));
728 AUR2_ADEC_PARAM_SHM *p_shm_param = &p_shm->adec_param_shm[dec_id];
729 AUR2_ADEC_ES_PARAM_SHM *p_shm_esparam;
730 MS_U32 offset_R2_to_DSP, offset_R2_to_CommDDR;
731
732 offset_R2_to_DSP = ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE;
733 offset_R2_to_CommDDR = ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + ASND_DSP_DDR_SIZE;
734
735 if (dec_id == 0)
736 p_shm_esparam = &p_shm->adec_esParam_shm[0]; //dec0, use es0
737 else
738 p_shm_esparam = &p_shm->adec_esParam_shm[2]; //dec1, use es2
739
740 switch( decParamType )
741 {
742 case R2_SHM_PARAM_ES_WR_PTR:
743 ptr = (volatile MS_U32 *) &p_shm_esparam->ES_wrPtr;
744 *ptr = param; //(param + offset_R2_to_DSP + OFFSET_ES1_DRAM_ADDR;
745 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
746 HAL_DEC_R2_SetCommInfo(AUR2_CommParam_ADEC_updateEsWritePtr, dec_id, 0, 0);
747 break;
748 case R2_SHM_PARAM_EXT_SMPRATE_CTRL:
749 ptr = (volatile MS_U32 *) &p_shm_param->extSynthsizer_en; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4);
750 ptr = (volatile MS_U32 *) &p_shm_param->extSynthsizer_value; *ptr = param2; MsOS_Dcache_Flush((MS_VIRT)ptr,4);
751 break;
752
753 case R2_SHM_PARAM_MPG_AVOFFSET: ptr = (volatile MS_U32 *) &p_shm_param->dtv_mpg_avDelay; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
754 case R2_SHM_PARAM_AC3_AVOFFSET: ptr = (volatile MS_U32 *) &p_shm_param->dtv_ac3_avDelay; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
755 case R2_SHM_PARAM_AAC_AVOFFSET: ptr = (volatile MS_U32 *) &p_shm_param->dtv_aac_avDelay; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
756 case R2_SHM_PARAM_MM_FILE_REQ_SIZE: ptr = (volatile MS_U32 *) &p_shm_param->mmFileReqSize; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
757 case R2_SHM_PARAM_MM_INPUT_PTS:
758 ptr = (volatile MS_U32 *) &p_shm_esparam->MM_inputPTS;
759 *ptr = param;
760 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
761 HAL_DEC_R2_SetCommInfo(AUR2_CommParam_ADEC_PTS_input, dec_id, param>>16, param&0xFFFF);
762 break;
763
764 case R2_SHM_PARAM_UNI_SETUP_DECODE_FRMCNT: ptr = (volatile MS_U32 *) &p_shm_param->mmUni_needDecodeFrmCnt; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
765 case R2_SHM_PARAM_UNI_PCM_SET_OUTPUT_CNT:
766 HAL_DEC_R2_SetCommInfo(AUR2_CommParam_ADEC_UNI_setOutput, dec_id, param>>16, param&0xFFFF);
767 break;
768
769 case R2_SHM_PARAM_DOLBY_DRC_MODE:
770 case R2_SHM_PARAM_DOLBY_RF_MODE:
771 ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.drcMode;
772 *ptr = param;
773 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
774 break;
775
776 case R2_SHM_PARAM_DOLBY_DMX_MODE: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.dmxMode; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
777 case R2_SHM_PARAM_DOLBY_HIGH_CUT: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.high_cut; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
778 case R2_SHM_PARAM_DOLBY_LOW_BOOST: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.low_boost; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
779 case R2_SHM_PARAM_DOLBY_GAIN: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.gain; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
780 case R2_SHM_PARAM_DOLBY_MUL_FRAME_HEADER: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.mul_frame_header; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
781 case R2_SHM_PARAM_DOLBY_AAC_BYPASS: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.AAC_HDMI_bypass; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
782 case R2_SHM_PARAM_DOLBY_DDP_HDMI_BYPASS: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.DDP_HDMI_bypass; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
783 case R2_SHM_PARAM_DOLBY_TB11_ENABLE: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.TB11_enable; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
784 case R2_SHM_PARAM_DOLBY_MIXER_BALANCE:
785 {
786 MS_S32 temp = param - 32;
787
788 ptr = (volatile MS_U32 *)&p_shm_param->dolby_param.mixer_balance;
789 *ptr = temp;
790 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
791 break;
792 }
793
794 case R2_SHM_PARAM_STC_SELECT: //[10]
795 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
796 if (param)
797 *ptr |= 0x400;
798 else
799 *ptr &= 0xFFFFFBFF;
800 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
801 break;
802
803 case R2_SHM_PARAM_PARSER_SPEC: //[8]
804 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
805 if (param)
806 *ptr |= 0x100;
807 else
808 *ptr &= 0xFFFFFEFF;
809 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
810 break;
811
812 case R2_SHM_PARAM_PARSER_PES_BYPASS: //[7]
813 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
814 if (param)
815 *ptr |= 0x80;
816 else
817 *ptr &= 0xFFFFFF7F;
818 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
819 break;
820
821 case R2_SHM_PARAM_PARSER_PUSI_DISABLE: //[6]
822 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
823 if (param)
824 *ptr |= 0x40;
825 else
826 *ptr &= 0xFFFFFFBF;
827 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
828 break;
829
830 case R2_SHM_PARAM_REPORT_MM_TS_PTS_WITH_MSB: //[5]
831 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
832 if (param)
833 *ptr |= 0x20;
834 else
835 *ptr &= 0xFFFFFFDF;
836 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
837 break;
838 case R2_SHM_PARAM_MM_TS_SYNC_STC: //[4]
839 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
840 if (param)
841 *ptr |= 0x10;
842 else
843 *ptr &= 0xFFFFFFEF;
844 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
845 break;
846
847 case R2_SHM_PARAM_MM_FF2X: //[3]
848 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
849 if (param)
850 *ptr |= 0x8;
851 else
852 *ptr &= 0xFFFFFFF7;
853 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
854 break;
855
856 case R2_SHM_PARAM_DECODE_MUTE: //[2]
857 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
858 if (param)
859 *ptr |= 0x4;
860 else
861 *ptr &= 0xFFFFFFFB;
862 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
863 break;
864
865 case R2_SHM_PARAM_SOUND_MODE:
866 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl;
867 *ptr &= 0xFFFFFFFC;
868 *ptr |= (param&0x03);
869 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
870 break;
871
872 case R2_SHM_PARAM_MPEG_SOUNDMODE: ptr = (volatile MS_U32 *) &p_shm_param->mpeg_param.MPEG_soundMode; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
873 case R2_SHM_PARAM_MPEG_GAIN: ptr = (volatile MS_U32 *) &p_shm_param->mpeg_param.gain; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
874
875 case R2_SHM_PARAM_OMX_SPDIF_CTRL: ptr = (volatile MS_U32 *) &p_shm_param->OMX_SPDIF_Ctrl; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
876 case R2_SHM_PARAM_OMX_SPDIF_PCM_LEVEL: ptr = (volatile MS_U32 *) &p_shm_param->OMX_SPDIF_PCM_Level; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
877
878
879 case R2_SHM_PARAM_MAIN_VOLUME: ptr = (volatile MS_U32 *) &p_shm_param->adMix_mainVol; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
880 case R2_SHM_PARAM_MAIN_VOLUME_MUTE:
881 ptr = (volatile MS_U32 *) &p_shm_param->adMix_mainVol;
882 if(param)
883 *ptr |= 0x00000400;
884 else
885 *ptr &= 0x000003FF;
886 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
887 break;
888 case R2_SHM_PARAM_AD_VOLUME: ptr = (volatile MS_U32 *) &p_shm_param->adMix_asocVol; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
889 case R2_SHM_PARAM_AD_VOLUME_MUTE:
890 ptr = (volatile MS_U32 *) &p_shm_param->adMix_asocVol;
891 if(param)
892 *ptr |= 0x00000400;
893 else
894 *ptr &= 0x000003FF;
895 MsOS_Dcache_Flush((MS_VIRT)ptr,4);
896 break;
897
898 case R2_SHM_PARAM_COOK_NUMCODECS:
899 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.mNumCodecs; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
900 case R2_SHM_PARAM_COOK_SAMPLES:
901 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.mSamples; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
902 case R2_SHM_PARAM_COOK_SAMPLERATES:
903 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.mSampleRate; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
904 case R2_SHM_PARAM_COOK_CHANNELS:
905 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.Channels[param2]; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
906 case R2_SHM_PARAM_COOK_REGIONS:
907 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.Regions[param2]; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
908 case R2_SHM_PARAM_COOK_CPLSTART:
909 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.cplStart[param2]; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
910 case R2_SHM_PARAM_COOK_CPLQBITS:
911 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.cplQbits[param2]; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
912 case R2_SHM_PARAM_COOK_FRAMESIZE:
913 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.FrameSize[param2]; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
914
915 case R2_SHM_PARAM_DTS_DMX_LFE_ENABLE:
916 ptr = (volatile MS_U32 *) &p_shm_param->dts_param.dmxLfeEnable; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
917 case R2_SHM_PARAM_DTS_DMX_MODE:
918 ptr = (volatile MS_U32 *) &p_shm_param->dts_param.dmxMode; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
919
920 case R2_SHM_PARAM_ASF_VERSION:
921 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.asf_version; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
922 case R2_SHM_PARAM_ASF_CHANNELS:
923 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.nChannels; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
924 case R2_SHM_PARAM_ASF_SAMPLERATE:
925 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.smpRate; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
926 case R2_SHM_PARAM_ASF_BYTERATE:
927 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.byteRate; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
928 case R2_SHM_PARAM_ASF_BLOCKALIGN:
929 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.blockAlign; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
930 case R2_SHM_PARAM_ASF_ENCOPT:
931 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.encOpt; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
932 case R2_SHM_PARAM_ASF_PARSINGBYAPP:
933 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.parsingByApp; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
934 case R2_SHM_PARAM_ASF_BITS_PER_SAMPLE:
935 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.bitsPerSmp; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
936 case R2_SHM_PARAM_ASF_CHANNELMASK:
937 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.channelMask; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
938 case R2_SHM_PARAM_ASF_DRC_PARAM_EXIST:
939 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.drcParamExist; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
940 case R2_SHM_PARAM_ASF_DRC_RMS_AMP_REF:
941 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.drcRmsAmpRef; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
942 case R2_SHM_PARAM_ASF_DRC_RMS_AMP_TARGET:
943 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.drcRmsAmpTarget; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
944 case R2_SHM_PARAM_ASF_DRC_PEAK_AMP_REF:
945 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.drcPeakAmpRef; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
946 case R2_SHM_PARAM_ASF_DRC_PEAK_AMP_TARGET:
947 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.drcPeakAmpTarget; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
948 case R2_SHM_PARAM_ASF_MAX_PACKET_SIZE:
949 ptr = (volatile MS_U32 *) &p_shm_param->asf_param.maxPacketSize; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
950
951 case R2_SHM_PARAM_XPCM_TYPE:
952 ptr = (volatile MS_U32 *) &p_shm_param->xpcm_param.xPcmType; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
953 case R2_SHM_PARAM_XPCM_CHANNELS:
954 ptr = (volatile MS_U32 *) &p_shm_param->xpcm_param.nChannels; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
955 case R2_SHM_PARAM_XPCM_SAMPLERATES:
956 ptr = (volatile MS_U32 *) &p_shm_param->xpcm_param.smpRate; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
957 case R2_SHM_PARAM_XPCM_BITS_PER_SAMPLE:
958 ptr = (volatile MS_U32 *) &p_shm_param->xpcm_param.bitsPerSmp; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
959 case R2_SHM_PARAM_XPCM_BLOCK_SIZE:
960 ptr = (volatile MS_U32 *) &p_shm_param->xpcm_param.blockSize; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
961 case R2_SHM_PARAM_XPCM_SAMPLE_PER_BLOCK:
962 ptr = (volatile MS_U32 *) &p_shm_param->xpcm_param.samplePerBlock; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
963
964 case R2_SHM_PARAM_SPDIF_TYPE:
965 ptr = (volatile MS_U32 *) &p_shm_param->spdif_type; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
966
967 case R2_SHM_PARAM_RFSIGNAL_TYPE:
968 ptr = (volatile MS_U32 *) &p_shm->RfSignalType; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
969
970 case R2_SHM_PARAM_VORBIS_HEADER_SIZE:
971 ptr = (volatile MS_U32 *) &p_shm_param->vorbis_header_size; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
972
973 case R2_SHM_PARAM_TTS_EN:
974 ptr = (volatile MS_U32 *) &p_shm_param->TTS_On_flag; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
975
976 case R2_SHM_PARAM_DAP_EN:
977 ptr = (volatile MS_U32 *) &p_shm_param->DAP_enable; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
978
979 case R2_SHM_PARAM_SPEAKER_EN:
980 ptr = (volatile MS_U32 *) &p_shm_param->speaker_enable; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
981
982 case R2_SHM_PARAM_DDP_ENCODE_EN:
983 ptr = (volatile MS_U32 *) &p_shm_param->DDP_encode_enable; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
984
985 case R2_SHM_PARAM_ES_Limiter_EN:
986 ptr = (volatile MS_U32 *) &p_shm_param->ES_Limiter_EN; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
987
988 case R2_SHM_PARAM_ES_Limiter_Threshold:
989 ptr = (volatile MS_U32 *) &p_shm_param->ES_Limiter_Threshold; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
990
991 case R2_SHM_PARAM_PCM_Limiter_EN:
992 ptr = (volatile MS_U32 *) &p_shm_param->PCM_Limiter_EN; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
993
994 case R2_SHM_PARAM_PCM_Limiter_Threshold:
995 ptr = (volatile MS_U32 *) &p_shm_param->PCM_Limiter_Threshold; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
996
997 case R2_SHM_PARAM_MULTI_CHANNEL:
998 ptr = (volatile MS_U32 *) &p_shm_param->force_mmuni_mch_pcm; *ptr = param; MsOS_Dcache_Flush((MS_VIRT)ptr,4); break;
999
1000 case R2_SHM_PARAM_ES_PassThrough_DelaySmp:
1001 ptr = (volatile unsigned int *) &p_shm->esPassThrough_delaySmp; *ptr = param; MsOS_Dcache_Flush((unsigned int)ptr,4); break;
1002
1003 case R2_SHM_PARAM_ES_PassThrough_PcmSamRate:
1004 ptr = (volatile unsigned int *) &p_shm->esPassThrough_pcmSmpRate; *ptr = param; MsOS_Dcache_Flush((unsigned int)ptr,4); break;
1005
1006 case R2_SHM_PARAM_ES_PassThrough_HdmiSmpRate:
1007 ptr = (volatile unsigned int *) &p_shm->esPassThrough_hdmiSmpRate; *ptr = param; MsOS_Dcache_Flush((unsigned int)ptr,4); break;
1008
1009
1010 default:
1011 ret_value = 0;
1012 break;
1013 }
1014
1015 // HALAUDIO_PRINT("[%s] shmType:%4x, id:%x, param: [%08lx, %08lx]\n", __FUNCTION__, decParamType, dec_id, param, param2);
1016 return TRUE;
1017 }
1018
HAL_sndR2_Get_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType,MS_U8 dec_id,MS_U32 param)1019 MS_U32 HAL_sndR2_Get_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType, MS_U8 dec_id, MS_U32 param )
1020 {
1021 MS_U32 ret_value = 0;
1022
1023 #if 0
1024 volatile MS_U32 *ptr;
1025 SND_R2_SHARE_MEM *p_shm = (SND_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_0_DDR_BASE+SND_R2_SHM_DDR_OFFSET));
1026 MS_U32 offset_R2_to_DSP, offset_R2_to_CommDDR;
1027
1028 offset_R2_to_DSP = ASND__R2_DDR_SIZE;
1029 offset_R2_to_CommDDR = ASND__R2_DDR_SIZE + ASND_DSP_DDR_SIZE;
1030
1031 switch( decParamType )
1032 {
1033 default:
1034 ret_value = 0;
1035 break;
1036 }
1037 #endif
1038
1039 AUR2_DEBUG_PRINT(printf("[%s] shmType:%4x, id:%x, param: [%08lx] ==> %x\n", __FUNCTION__, decParamType, dec_id, param, ret_value));
1040
1041 return ret_value;
1042 }
1043
1044
1045
HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType,MS_U8 dec_id,MS_U32 param)1046 MS_U32 HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_TYPE decParamType, MS_U8 dec_id, MS_U32 param )
1047 {
1048 MS_U32 ret_value = 0;
1049 volatile MS_U32 *ptr;
1050 DEC_R2_SHARE_MEM *p_shm = (DEC_R2_SHARE_MEM *)(MS_PA2KSEG1(R2_1_DDR_BASE+DEC_R2_SHM_DDR_OFFSET));
1051 AUR2_ADEC_PARAM_SHM *p_shm_param = &p_shm->adec_param_shm[dec_id];
1052 AUR2_ADEC_ES_PARAM_SHM *p_shm_esparam = &p_shm->adec_esParam_shm[dec_id];
1053 MS_U32 offset_R2_to_DSP, offset_R2_to_CommDDR;
1054
1055 offset_R2_to_DSP = ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE;
1056 offset_R2_to_CommDDR = ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE + ASND_DSP_DDR_SIZE;
1057
1058 #if 0 //debug usage
1059 tmp = 0x743E000;
1060 printf("&adec_info_shm[0] = %lx, &adec_info_shm[1] = %lx\n",
1061 tmp + sizeof(AUR2_ADEC_INFO_SHM)*0,
1062 tmp + sizeof(AUR2_ADEC_INFO_SHM)*1);
1063
1064 tmp += (sizeof(AUR2_ADEC_INFO_SHM)*2);
1065 printf("&adec_esInfo_shm[0] = %lx, &adec_esInfo_shm[1] = %lx, &adec_esInfo_shm[2] = %lx, &adec_esInfo_shm[3] = %lx\n",
1066 tmp + sizeof(AUR2_ADEC_ES_INFO_SHM)*0,
1067 tmp + sizeof(AUR2_ADEC_ES_INFO_SHM)*1,
1068 tmp + sizeof(AUR2_ADEC_ES_INFO_SHM)*2,
1069 tmp + sizeof(AUR2_ADEC_ES_INFO_SHM)*3);
1070
1071 tmp += (sizeof(AUR2_ADEC_ES_INFO_SHM)*4);
1072 printf("&adec_param_shm[0] = %lx, &adec_param_shm[1] = %lx\n",
1073 tmp + sizeof(AUR2_ADEC_PARAM_SHM)*0,
1074 tmp + sizeof(AUR2_ADEC_PARAM_SHM)*1);
1075
1076 tmp += (sizeof(AUR2_ADEC_PARAM_SHM)*2);
1077 printf("&adec_esParam_shm[0] = %lx, &adec_esParam_shm[1] = %lx, &adec_esParam_shm[2] = %lx, &adec_esParam_shm[3] = %lx\n",
1078 tmp + sizeof(AUR2_ADEC_ES_PARAM_SHM)*0,
1079 tmp + sizeof(AUR2_ADEC_ES_PARAM_SHM)*1,
1080 tmp + sizeof(AUR2_ADEC_ES_PARAM_SHM)*2,
1081 tmp + sizeof(AUR2_ADEC_ES_PARAM_SHM)*3);
1082 #endif
1083
1084 switch( decParamType )
1085 {
1086 case R2_SHM_PARAM_ES_WR_PTR:
1087 if (dec_id == 0)
1088 {
1089 ptr = (volatile MS_U32 *) &p_shm_esparam->ES_wrPtr; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1090 ret_value = *ptr;
1091 }
1092 else if (dec_id == 1)
1093 {
1094 ptr = (volatile MS_U32 *) &p_shm_esparam->ES_wrPtr; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1095 ret_value = *ptr;
1096 }
1097 break;
1098
1099 case R2_SHM_PARAM_MPG_AVOFFSET: ptr = (volatile MS_U32 *) &p_shm_param->dtv_mpg_avDelay; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1100 case R2_SHM_PARAM_AC3_AVOFFSET: ptr = (volatile MS_U32 *) &p_shm_param->dtv_ac3_avDelay; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1101 case R2_SHM_PARAM_AAC_AVOFFSET: ptr = (volatile MS_U32 *) &p_shm_param->dtv_aac_avDelay; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1102 case R2_SHM_PARAM_MM_FILE_REQ_SIZE: ptr = (volatile MS_U32 *) &p_shm_param->mmFileReqSize; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1103 case R2_SHM_PARAM_MM_INPUT_PTS: ptr = (volatile MS_U32 *) &p_shm_esparam->MM_inputPTS; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1104
1105
1106 case R2_SHM_PARAM_DOLBY_DRC_MODE:
1107 case R2_SHM_PARAM_DOLBY_RF_MODE:
1108 ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.drcMode;
1109 MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1110 ret_value = *ptr;
1111 break;
1112
1113 case R2_SHM_PARAM_DOLBY_DMX_MODE: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.dmxMode; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1114 case R2_SHM_PARAM_DOLBY_HIGH_CUT: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.high_cut; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1115 case R2_SHM_PARAM_DOLBY_LOW_BOOST: ptr = (volatile MS_U32 *) &p_shm_param->dolby_param.low_boost; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1116
1117 case R2_SHM_PARAM_UNI_SETUP_DECODE_FRMCNT: ptr = (volatile MS_U32 *) &p_shm_param->mmUni_needDecodeFrmCnt; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1118
1119 case R2_SHM_PARAM_OMX_SPDIF_CTRL:
1120 ptr = (volatile MS_U32 *) &p_shm_param->OMX_SPDIF_Ctrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1121
1122 case R2_SHM_PARAM_PARSER_SPEC: //[8]
1123 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1124 ret_value = *ptr;
1125 if (ret_value&0x100)
1126 ret_value = 1;
1127 else
1128 ret_value = 0;
1129 break;
1130
1131 case R2_SHM_PARAM_PARSER_PES_BYPASS: //[7]
1132 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1133 ret_value = *ptr;
1134 if (ret_value&0x80)
1135 ret_value = 1;
1136 else
1137 ret_value = 0;
1138 break;
1139
1140 case R2_SHM_PARAM_PARSER_PUSI_DISABLE: //[6]
1141 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1142 ret_value = *ptr;
1143 if (ret_value&0x40)
1144 ret_value = 1;
1145 else
1146 ret_value = 0;
1147 break;
1148
1149 case R2_SHM_PARAM_REPORT_MM_TS_PTS_WITH_MSB: //[5]
1150 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1151 ret_value = *ptr;
1152 if (ret_value&0x20)
1153 ret_value = 1;
1154 else
1155 ret_value = 0;
1156 break;
1157 case R2_SHM_PARAM_MM_TS_SYNC_STC: //[4]
1158 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1159 ret_value = *ptr;
1160 if (ret_value&0x10)
1161 ret_value = 1;
1162 else
1163 ret_value = 0;
1164 break;
1165
1166 case R2_SHM_PARAM_MM_FF2X: //[3]
1167 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1168 ret_value = *ptr;
1169 if (ret_value&0x8)
1170 ret_value = 1;
1171 else
1172 ret_value = 0;
1173 break;
1174
1175 case R2_SHM_PARAM_DECODE_MUTE: //[2]
1176 ptr = (volatile MS_U32 *) &p_shm_param->decCtrl; MsOS_Dcache_Flush((MS_VIRT)ptr, 4);
1177 ret_value = *ptr;
1178 if (ret_value&0x4)
1179 ret_value = 1;
1180 else
1181 ret_value = 0;
1182 break;
1183
1184 case R2_SHM_PARAM_COOK_NUMCODECS:
1185 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.mNumCodecs; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1186 case R2_SHM_PARAM_COOK_SAMPLES:
1187 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.mSamples; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1188 case R2_SHM_PARAM_COOK_SAMPLERATES:
1189 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.mSampleRate; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1190 case R2_SHM_PARAM_COOK_CHANNELS:
1191 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.Channels[param]; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1192 case R2_SHM_PARAM_COOK_REGIONS:
1193 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.Regions[param]; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1194 case R2_SHM_PARAM_COOK_CPLSTART:
1195 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.cplStart[param]; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1196 case R2_SHM_PARAM_COOK_CPLQBITS:
1197 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.cplQbits[param]; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1198 case R2_SHM_PARAM_COOK_FRAMESIZE:
1199 ptr = (volatile MS_U32 *) &p_shm_param->cook_param.FrameSize[param]; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1200 case R2_SHM_PARAM_HASH_KEY:
1201 ptr = (volatile MS_U32 *) &p_shm_param->hashKey; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1202 case R2_SHM_PARAM_MULTI_CHANNEL:
1203 ptr = (volatile MS_U32 *) &p_shm_param->force_mmuni_mch_pcm; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1204 case R2_SHM_PARAM_DDP_ENCODE_EN:
1205 ptr = (volatile MS_U32 *) &p_shm_param->DDP_encode_enable; MsOS_Dcache_Flush((MS_VIRT)ptr, 4); ret_value = *ptr; break;
1206
1207 default:
1208 ret_value = 0;
1209 break;
1210 }
1211
1212 // HALAUDIO_PRINT("[%s] shmType:%4x, id:%x, param: [%08lx] ==> %x\n", __FUNCTION__, decParamType, dec_id, param, ret_value);
1213
1214 return ret_value;
1215 }