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