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