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